boot_report

Instructions

Implementation Reference

• src/tools/boot-report.ts:12-41 (handler)

  The tool handler logic: registers an MCP tool named 'boot_report' that takes identity_path, transcript_dir, and optional project, generates an orientation report via OrientationService, and returns it as formatted markdown.

  server.tool(
    "boot_report",
    "Generate an orientation report for session start. Reads identity document, scans memories, finds latest transcript, and detects gaps in what was loaded. Call this first thing every session.",
    {
      identity_path: z
        .string()
        .describe("Path to identity.md (e.g., .rekindle/identity.md)"),
      transcript_dir: z
        .string()
        .describe(
          "Path to transcripts directory (e.g., .rekindle/transcripts)"
        ),
      project: z
        .string()
        .optional()
        .describe("Active project name for scoped orientation"),
    },
    async ({ identity_path, transcript_dir, project }) => {
      const result = orientationService.generate({
        identityPath: identity_path,
        transcriptDir: transcript_dir,
        project,
      });
      const markdown = OrientationRenderer.toMarkdown(result);
  
      return {
        content: [{ type: "text" as const, text: markdown }],
      };
    }
  );

• src/tools/boot-report.ts:15-28 (schema)

  The input schema using Zod: three parameters (identity_path required, transcript_dir required, project optional).

  {
    identity_path: z
      .string()
      .describe("Path to identity.md (e.g., .rekindle/identity.md)"),
    transcript_dir: z
      .string()
      .describe(
        "Path to transcripts directory (e.g., .rekindle/transcripts)"
      ),
    project: z
      .string()
      .optional()
      .describe("Active project name for scoped orientation"),
  },

• src/tools/boot-report.ts:12-42 (registration)

  Registration via server.tool() call with name 'boot_report' and description.

    server.tool(
      "boot_report",
      "Generate an orientation report for session start. Reads identity document, scans memories, finds latest transcript, and detects gaps in what was loaded. Call this first thing every session.",
      {
        identity_path: z
          .string()
          .describe("Path to identity.md (e.g., .rekindle/identity.md)"),
        transcript_dir: z
          .string()
          .describe(
            "Path to transcripts directory (e.g., .rekindle/transcripts)"
          ),
        project: z
          .string()
          .optional()
          .describe("Active project name for scoped orientation"),
      },
      async ({ identity_path, transcript_dir, project }) => {
        const result = orientationService.generate({
          identityPath: identity_path,
          transcriptDir: transcript_dir,
          project,
        });
        const markdown = OrientationRenderer.toMarkdown(result);
  
        return {
          content: [{ type: "text" as const, text: markdown }],
        };
      }
    );
  }

• src/server.ts:23-24 (registration)

  Where registerBootReport is called to register the tool on the MCP server.

  registerBootReport(server, storage);
  registerEndSession(server, storage);

• src/orientation/OrientationService.ts:25-80 (helper)

  The OrientationService.generate() method called by the handler — reads identity, memory stats, checkpoint, latest transcript, then detects gaps and scores orientation readiness.

  export class OrientationService {
    constructor(private storage: RekindleStorage) {}
  
    generate(config: OrientationConfig): OrientationResult {
      let identityLoaded = false;
      let identityContent: string | undefined;
  
      if (existsSync(config.identityPath)) {
        const raw = readFileSync(config.identityPath, "utf-8");
        identityLoaded = raw.trim().length > 0;
        if (identityLoaded) identityContent = raw;
      }
  
      const stats = this.storage.stats();
      const checkpoint = this.storage.getLatestCheckpoint(config.project);
      const transcript = findLatestTranscript(config.transcriptDir);
      const hasTranscript = transcript !== null;
      const hasCheckpoint = checkpoint !== null;
  
      const gaps = detectGaps(stats, identityLoaded, hasTranscript, hasCheckpoint);
      const { score, breakdown } = calculateScore(
        identityLoaded,
        hasCheckpoint,
        hasTranscript,
        stats,
        config.project
      );
  
      const preview =
        transcript && transcript.content.length > 1500
          ? transcript.content.slice(0, 1500) + "\n\n[...truncated]"
          : transcript?.content;
  
      return {
        identity: {
          loaded: identityLoaded,
          path: config.identityPath,
          content: identityContent,
        },
        memoryStats: stats,
        checkpoint: {
          exists: hasCheckpoint,
          content: checkpoint?.content,
          created_at: checkpoint?.created_at,
        },
        transcript: {
          exists: hasTranscript,
          name: transcript?.name,
          preview,
        },
        gaps,
        score,
        scoreBreakdown: breakdown,
      };
    }
  }