@almightygpt/core 0.9.2 → 0.10.1

package/src/auth/validator.ts

@@ -107,7 +107,7 @@ async function validateOpenAI(key: string): Promise<ValidationResult> {
       return {
         ok: false,
         statusCode: res.status,
-        error: normalizeOpenAIError(res.status, rawBody),
+        error: normalizeOpenAIError(res.status, rawBody, key),
         rawBody,
       };
     }
@@ -142,7 +142,7 @@ async function validateAnthropic(key: string): Promise<ValidationResult> {
       return {
         ok: false,
         statusCode: res.status,
-        error: normalizeAnthropicError(res.status, rawBody),
+        error: normalizeAnthropicError(res.status, rawBody, key),
         rawBody,
       };
     }
@@ -193,28 +193,36 @@ async function validateGoogle(key: string): Promise<ValidationResult> {
 // Never echo the raw key back even by accident (defense in depth: we
 // also redact anything that looks like the submitted key).
 
-function normalizeOpenAIError(status: number, rawBody: string): string {
+function normalizeOpenAIError(
+  status: number,
+  rawBody: string,
+  submittedKey: string,
+): string {
   // OpenAI shape: { "error": { "message": "...", "type": "...", "code": "..." } }
   try {
     const parsed = JSON.parse(rawBody) as {
       error?: { message?: string; type?: string; code?: string };
     };
     const msg = parsed.error?.message;
-    if (msg) return `[${status}] OpenAI: ${truncate(msg, 200)}`;
+    if (msg) return `[${status}] OpenAI: ${truncate(redactKey(msg, submittedKey), 200)}`;
   } catch {
     /* fall through */
   }
   return statusOnlyMessage("OpenAI", status);
 }
 
-function normalizeAnthropicError(status: number, rawBody: string): string {
+function normalizeAnthropicError(
+  status: number,
+  rawBody: string,
+  submittedKey: string,
+): string {
   // Anthropic shape: { "type": "error", "error": { "type": "...", "message": "..." } }
   try {
     const parsed = JSON.parse(rawBody) as {
       error?: { type?: string; message?: string };
     };
     const msg = parsed.error?.message;
-    if (msg) return `[${status}] Anthropic: ${truncate(msg, 200)}`;
+    if (msg) return `[${status}] Anthropic: ${truncate(redactKey(msg, submittedKey), 200)}`;
   } catch {
     /* fall through */
   }
@@ -231,20 +239,25 @@ function normalizeGoogleError(
     const parsed = JSON.parse(rawBody) as {
       error?: { code?: number; message?: string; status?: string };
     };
-    let msg = parsed.error?.message ?? "";
-    // Belt-and-braces redaction: Google sometimes echoes the key in
-    // error messages (e.g. "API key not valid. Pass a valid API key.")
-    // — we don't ship the actual key value if it ever ends up here.
-    if (submittedKey && msg.includes(submittedKey)) {
-      msg = msg.replace(submittedKey, "<redacted-key>");
-    }
-    if (msg) return `[${status}] Google: ${truncate(msg, 200)}`;
+    const msg = parsed.error?.message ?? "";
+    if (msg) return `[${status}] Google: ${truncate(redactKey(msg, submittedKey), 200)}`;
   } catch {
     /* fall through */
   }
   return statusOnlyMessage("Google", status);
 }
 
+/**
+ * Belt-and-braces: if a provider echoes the submitted key in its
+ * error body, redact before surfacing to the user. Codex's v0.8 P2 #6
+ * found this gap (originally Google-only); now applied to all three
+ * providers via this shared helper.
+ */
+function redactKey(msg: string, key: string): string {
+  if (!key || !msg.includes(key)) return msg;
+  return msg.split(key).join("<redacted-key>");
+}
+
 function statusOnlyMessage(provider: string, status: number): string {
   if (status === 401 || status === 403) {
     return `[${status}] ${provider} rejected the key (unauthorized).`;

package/src/index.ts

@@ -13,7 +13,7 @@
  *   - budget/     ✅ task #14 BudgetTracker + BudgetExceededError
  */
 
-export const VERSION = "0.9.2";
+export const VERSION = "0.10.1";
 
 // MCP server (v0.9.0+) — exposes AlmightyGPT's review surface as MCP tools.
 export { startMcpServer } from "./mcp/server.js";
@@ -143,6 +143,18 @@ export {
   type KeychainAdapter,
 } from "./auth/keychain.js";
 export { validateKey, type ValidationResult } from "./auth/validator.js";
+// Plan subsystem (v0.10.0+) — Worker plan + Reviewer plan-review
+export {
+  runWorkerPlan,
+  type PlanOptions,
+  type PlanResult,
+} from "./plan/run-plan.js";
+export {
+  runPlanReview,
+  type PlanReviewOptions,
+  type PlanReviewResult,
+} from "./plan/run-plan-review.js";
+
 export {
   AuthMissingError,
   PROVIDER_ENV_VARS,

package/src/plan/run-plan-review.ts

@@ -0,0 +1,302 @@
+/**
+ * `almightygpt review --plan <file>` — Reviewer AI critiques a PLAN
+ * doc (not a git diff). Same review primitives as runDiffReview but
+ * the input is the plan markdown and the framing tells the Reviewer
+ * to critique the plan's structure, completeness, and risks rather
+ * than line-by-line code.
+ *
+ * Output lands at `<reviewsDir>/plan-<topic>.md` (prefix distinguishes
+ * plan reviews from diff reviews when they share the same topic name).
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { loadConfig } from "../config/load.js";
+import { makeAdapter } from "../adapters/factory.js";
+import { AdapterError } from "../adapters/types.js";
+import { assembleMemory } from "../review/memory.js";
+import {
+  createRunFolder,
+  writeRunMetadata,
+  writeRunInput,
+  writeAgentOutput,
+  collectGitContext,
+} from "../runs/folder.js";
+import {
+  writeHumanReviewFile,
+  preflightReviewFileCollision,
+} from "../review/write.js";
+
+export interface PlanReviewOptions {
+  repoRoot: string;
+  topic: string;
+  /** Path (relative to repoRoot) to the plan markdown to review. */
+  planPath: string;
+  reviewer?: string;
+  force?: boolean;
+}
+
+export interface PlanReviewResult {
+  reviewPath: string;
+  reviewBytes: number;
+  reviewer: string;
+  provider: string;
+  modelUsed: string;
+  tokensIn: number;
+  cachedTokensIn: number;
+  tokensOut: number;
+  costUsd: number;
+  latencyMs: number;
+  memorySources: { path: string; bytes: number }[];
+  memoryMissing: string[];
+  runId: string;
+  runFolder: string;
+  shallowWarning?: string;
+}
+
+const PLAN_REVIEW_SYSTEM_FRAMING = [
+  "You are the Reviewer AI in an AlmightyGPT Plan-review stage.",
+  "",
+  "WHAT YOU ARE REVIEWING: the PLAN markdown supplied below. NOT a git",
+  "diff and NOT code — a plan that a Worker AI drafted in response to a",
+  "human's requirement. The plan has not been implemented yet. Your job",
+  "is to find what's WRONG with the plan: missing steps, hidden",
+  "dependencies, risks the Worker didn't surface, ambiguous decisions,",
+  "things that will break in production, edge cases the test plan misses.",
+  "",
+  "WHAT THE ORCHESTRATOR OWNS (do NOT include these in your response):",
+  "  - The H1 title (orchestrator prepends `# Plan Review: <topic>`).",
+  "  - The header block with model / tokens / cost.",
+  "  - The `## Cost and Latency` and `## Appendix: Raw Outputs` sections.",
+  "",
+  "WHAT YOU MUST PRODUCE — start with `## Decision Required` and emit",
+  "ONLY these sections in this order:",
+  "  ## Decision Required",
+  "  ## Highest-Risk Findings",
+  "  ## Concrete Weaknesses",
+  "  ## Worker Plan Summary",
+  "  ## Test Plan",
+  "  ## Human Decision",
+  "",
+  "ANTI-SYCOPHANCY (non-negotiable):",
+  "  - Find at least 3 concrete weaknesses with specific file / step / line",
+  "    references from the plan.",
+  "  - A finding without a specific anchor is too vague.",
+  "  - 'Looks good, minor suggestions' is a FAILED review — recalibrate.",
+  "",
+  "REVIEW LENS — focus on what plans commonly get wrong:",
+  "  - Steps assume capabilities that don't exist yet",
+  "  - Risks section underweights production blast radius",
+  "  - Test plan is generic ('add tests') instead of named cases",
+  "  - Open questions are missing things the human will actually need to",
+  "    decide before implementation",
+  "  - Affected modules list is incomplete (the plan touches more surfaces",
+  "    than it admits)",
+  "  - Migration / rollback story is missing or hand-wavy",
+].join("\n");
+
+function buildPlanReviewUserMessage(
+  topic: string,
+  planContent: string,
+): string {
+  return [
+    `# Plan-review request — topic: \`${topic}\``,
+    "",
+    "## The plan to review",
+    "",
+    "```markdown",
+    planContent.trim(),
+    "```",
+    "",
+    "## Your task",
+    "",
+    "Critique the plan above using the structure in your system prompt.",
+    "Start your response with `## Decision Required` (no H1, no preamble).",
+  ].join("\n");
+}
+
+export async function runPlanReview(
+  opts: PlanReviewOptions,
+): Promise<PlanReviewResult> {
+  const config = await loadConfig(opts.repoRoot);
+
+  const reviewerName = opts.reviewer ?? config.defaults.reviewer;
+  if (!reviewerName) {
+    throw new Error(
+      "No reviewer specified. Pass --reviewer <name> or set defaults.reviewer in .almightygpt/config.yaml.",
+    );
+  }
+  const agentConfig = config.agents[reviewerName];
+  if (!agentConfig) {
+    throw new Error(
+      `Reviewer "${reviewerName}" not found in .almightygpt/config.yaml agents map.`,
+    );
+  }
+  if (!agentConfig.enabled) {
+    throw new Error(`Reviewer "${reviewerName}" is disabled in .almightygpt/config.yaml.`);
+  }
+
+  const adapter = makeAdapter(reviewerName, agentConfig.provider);
+  if (!(await adapter.isAvailable())) {
+    throw new AdapterError(
+      `Adapter "${reviewerName}" (${agentConfig.provider}) is not available. Set the provider's API key.`,
+      reviewerName,
+    );
+  }
+
+  // Plan reviews land at <reviewsDir>/plan-<topic>.md so they don't
+  // collide with diff reviews on the same topic.
+  const planReviewTopic = `plan-${opts.topic}`;
+  await preflightReviewFileCollision(
+    opts.repoRoot,
+    config.reviewsDir,
+    planReviewTopic,
+    opts.force ?? false,
+  );
+
+  // Load the plan to review.
+  let planContent: string;
+  try {
+    planContent = await readFile(join(opts.repoRoot, opts.planPath), "utf8");
+  } catch (err) {
+    throw new Error(
+      `Could not read plan file at ${opts.planPath}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  const runFolder = await createRunFolder({
+    repoRoot: opts.repoRoot,
+    runsDir: config.runsDir,
+    topic: planReviewTopic,
+    type: "review-plan",
+  });
+  const createdAt = new Date().toISOString();
+
+  const memory = await assembleMemory(opts.repoRoot, agentConfig.memoryFile);
+  const systemPrompt = PLAN_REVIEW_SYSTEM_FRAMING + "\n\n" + memory.text;
+  const userMessage = buildPlanReviewUserMessage(opts.topic, planContent);
+
+  await writeRunInput(runFolder.absPath, userMessage);
+
+  const adapterOut = await adapter.execute({
+    role: "reviewer",
+    systemPrompt,
+    userMessage,
+  });
+
+  await writeAgentOutput(runFolder.absPath, "reviewer", adapterOut.content);
+
+  // Shallow detection: same rule as diff reviews — need N concrete
+  // weaknesses with anchors.
+  const shallowWarning = detectShallowPlanReview(
+    adapterOut.content,
+    config.review.requireConcreteWeaknesses,
+  );
+
+  const writeOpts: Parameters<typeof writeHumanReviewFile>[0] = {
+    repoRoot: opts.repoRoot,
+    reviewsDir: config.reviewsDir,
+    topic: planReviewTopic,
+    reviewerName,
+    reviewerProvider: adapter.provider,
+    modelUsed: adapterOut.modelUsed,
+    body: adapterOut.content,
+    metrics: {
+      tokensIn: adapterOut.tokensIn,
+      tokensOut: adapterOut.tokensOut,
+      costUsd: adapterOut.costUsd,
+      latencyMs: adapterOut.latencyMs,
+    },
+    runFolder: runFolder.relPath,
+  };
+  if (shallowWarning) writeOpts.shallowWarning = shallowWarning;
+  if (opts.force) writeOpts.force = opts.force;
+  const written = await writeHumanReviewFile(writeOpts);
+
+  const git = await collectGitContext(opts.repoRoot);
+  await writeRunMetadata(runFolder.absPath, {
+    id: runFolder.id,
+    type: "review-plan",
+    createdAt,
+    finishedAt: new Date().toISOString(),
+    workspacePath: opts.repoRoot,
+    topic: planReviewTopic,
+    git,
+    input: { source: "requirement-file", path: opts.planPath },
+    agents: [
+      {
+        name: reviewerName,
+        role: "reviewer",
+        provider: agentConfig.provider,
+        enabled: true,
+      },
+    ],
+    adapterVersions: [],
+    status: "completed",
+    metrics: [
+      {
+        agent: reviewerName,
+        role: "reviewer",
+        provider: adapter.provider,
+        model: adapterOut.modelUsed,
+        tokensIn: adapterOut.tokensIn,
+        cachedTokensIn: adapterOut.cachedTokensIn ?? 0,
+        tokensOut: adapterOut.tokensOut,
+        costUsd: adapterOut.costUsd,
+        latencyMs: adapterOut.latencyMs,
+      },
+    ],
+    totals: {
+      tokensIn: adapterOut.tokensIn,
+      tokensOut: adapterOut.tokensOut,
+      costUsd: adapterOut.costUsd,
+      latencyMs: adapterOut.latencyMs,
+    },
+    reviewPath: written.path,
+    budget: {
+      maxCostPerRunUsd: config.budget.maxCostPerRunUsd,
+      maxTokensPerRun: config.budget.maxTokensPerRun,
+    },
+  });
+
+  const result: PlanReviewResult = {
+    reviewPath: written.path,
+    reviewBytes: written.bytes,
+    reviewer: reviewerName,
+    provider: adapter.provider,
+    modelUsed: adapterOut.modelUsed,
+    tokensIn: adapterOut.tokensIn,
+    cachedTokensIn: adapterOut.cachedTokensIn ?? 0,
+    tokensOut: adapterOut.tokensOut,
+    costUsd: adapterOut.costUsd,
+    latencyMs: adapterOut.latencyMs,
+    memorySources: memory.sources,
+    memoryMissing: memory.missing,
+    runId: runFolder.id,
+    runFolder: runFolder.relPath,
+  };
+  if (shallowWarning) result.shallowWarning = shallowWarning;
+  return result;
+}
+
+/** Same shallow heuristic as diff reviews — count file/step/line anchors. */
+function detectShallowPlanReview(
+  content: string,
+  requireConcreteWeaknesses: number,
+): string | undefined {
+  const anchorPattern = /\b(?:file|step|line|section)[:\s][\w\-./]+/gi;
+  const anchors = content.match(anchorPattern) ?? [];
+  const weaknessesSection = content.match(
+    /## Concrete Weaknesses([\s\S]*?)(?=##|$)/i,
+  );
+  const weaknessBullets =
+    weaknessesSection?.[1]?.match(/^\s*[-*\d.]/gm)?.length ?? 0;
+
+  if (anchors.length === 0) {
+    return "Plan review has zero anchored references (file / step / line). The Reviewer may not have engaged with specifics — consider re-running.";
+  }
+  if (weaknessBullets < requireConcreteWeaknesses) {
+    return `Plan review listed ${weaknessBullets} concrete weaknesses, fewer than the configured minimum of ${requireConcreteWeaknesses}. Output may be shallow — consider re-running with a more rigorous Reviewer.`;
+  }
+  return undefined;
+}

package/src/plan/run-plan.ts

@@ -0,0 +1,247 @@
+/**
+ * `almightygpt plan` — Worker AI reads a free-text requirement +
+ * project memory, produces a structured plan markdown.
+ *
+ * Distinct from the review pipeline because the INPUT is a
+ * requirement (a sentence or paragraph from the user describing
+ * what they want), not a git diff. Output is a plan doc with
+ * required sections — same shape on every run so the Reviewer
+ * downstream knows what to expect.
+ *
+ * Plans land at `docs/<worker>-plans/<topic>.md`. The Reviewer step
+ * then runs against this plan via the `review --plan <file>` mode
+ * (see run-plan-review.ts).
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { loadConfig } from "../config/load.js";
+import { makeAdapter } from "../adapters/factory.js";
+import { AdapterError } from "../adapters/types.js";
+import { assembleMemory } from "../review/memory.js";
+import {
+  createRunFolder,
+  writeRunMetadata,
+  writeRunInput,
+  writeAgentOutput,
+  collectGitContext,
+} from "../runs/folder.js";
+import { assertSafeToWrite } from "../git/status.js";
+
+export interface PlanOptions {
+  repoRoot: string;
+  topic: string;
+  requirement: string;
+  worker?: string;
+  force?: boolean;
+}
+
+export interface PlanResult {
+  planPath: string;
+  planBytes: number;
+  worker: string;
+  provider: string;
+  modelUsed: string;
+  tokensIn: number;
+  cachedTokensIn: number;
+  tokensOut: number;
+  costUsd: number;
+  latencyMs: number;
+  memorySources: { path: string; bytes: number }[];
+  memoryMissing: string[];
+  runId: string;
+  runFolder: string;
+}
+
+const PLAN_SYSTEM_FRAMING = [
+  "You are the Worker AI in an AlmightyGPT Plan stage.",
+  "",
+  "WHAT YOU ARE DOING: turning a free-text requirement (the user message",
+  "below) into a structured plan markdown that a Reviewer AI will then",
+  "critique. You are NOT writing code — only the plan. The human will",
+  "approve / reject / refine the plan, and only then will implementation",
+  "happen (in a separate tool).",
+  "",
+  "WHAT THE ORCHESTRATOR OWNS (do NOT include these in your response):",
+  "  - The H1 title (the orchestrator prepends `# Plan: <topic>`).",
+  "  - The header block with model / tokens / cost.",
+  "",
+  "WHAT YOU MUST PRODUCE — emit exactly these sections in this order:",
+  "  ## Goal",
+  "  ## Affected modules / surfaces",
+  "  ## Step-by-step approach",
+  "  ## Risks",
+  "  ## Test plan",
+  "  ## Open questions",
+  "",
+  "STYLE:",
+  "  - Be concrete. Name specific files, classes, functions, env vars.",
+  "  - Write so the Reviewer can find concrete things to critique.",
+  "  - Open questions are not a weakness; they're the things you'd ask",
+  "    the human if you could. Surface them.",
+].join("\n");
+
+function buildPlanUserMessage(topic: string, requirement: string): string {
+  return [
+    `# Plan request — topic: \`${topic}\``,
+    "",
+    "## Requirement (from human)",
+    "",
+    requirement.trim(),
+    "",
+    "## Your task",
+    "",
+    "Produce the plan markdown using the structure in your system prompt.",
+    "Start your response with `## Goal` (no H1, no preamble).",
+  ].join("\n");
+}
+
+export async function runWorkerPlan(opts: PlanOptions): Promise<PlanResult> {
+  const config = await loadConfig(opts.repoRoot);
+
+  const workerName = opts.worker ?? config.defaults.worker;
+  if (!workerName) {
+    throw new Error(
+      "No worker specified. Pass --worker <name> or set defaults.worker in .almightygpt/config.yaml.",
+    );
+  }
+  const agentConfig = config.agents[workerName];
+  if (!agentConfig) {
+    throw new Error(
+      `Worker "${workerName}" not found in .almightygpt/config.yaml agents map.`,
+    );
+  }
+  if (!agentConfig.enabled) {
+    throw new Error(`Worker "${workerName}" is disabled in .almightygpt/config.yaml.`);
+  }
+
+  const adapter = makeAdapter(workerName, agentConfig.provider);
+  if (!(await adapter.isAvailable())) {
+    throw new AdapterError(
+      `Adapter "${workerName}" (${agentConfig.provider}) is not available. Set the provider's API key.`,
+      workerName,
+    );
+  }
+
+  // Plans land at docs/<worker>-plans/<topic>.md — symmetric with reviews.
+  const plansDir = `docs/${workerName}-plans`;
+  const planRel = `${plansDir}/${opts.topic}.md`;
+  await assertSafeToWrite(opts.repoRoot, planRel, opts.force ?? false);
+
+  const runFolder = await createRunFolder({
+    repoRoot: opts.repoRoot,
+    runsDir: config.runsDir,
+    topic: opts.topic,
+    type: "plan",
+  });
+  const createdAt = new Date().toISOString();
+
+  const memory = await assembleMemory(opts.repoRoot, agentConfig.memoryFile);
+  const systemPrompt = PLAN_SYSTEM_FRAMING + "\n\n" + memory.text;
+  const userMessage = buildPlanUserMessage(opts.topic, opts.requirement);
+
+  await writeRunInput(runFolder.absPath, userMessage);
+
+  const adapterOut = await adapter.execute({
+    role: "worker",
+    systemPrompt,
+    userMessage,
+  });
+
+  await writeAgentOutput(runFolder.absPath, "worker", adapterOut.content);
+
+  // Compose the final plan file: orchestrator-owned header + worker body.
+  const header = [
+    `# Plan: ${opts.topic}`,
+    "",
+    `> Worker: \`${workerName}\` (${adapter.provider}, ${adapterOut.modelUsed})`,
+    `> Generated: ${new Date().toISOString()}`,
+    `> Tokens: ${adapterOut.tokensIn} in / ${adapterOut.tokensOut} out`,
+    `> Cost: $${adapterOut.costUsd.toFixed(4)} USD`,
+    `> Run folder: \`${runFolder.relPath}\``,
+    "",
+  ].join("\n");
+
+  const footer = [
+    "",
+    "---",
+    "",
+    "## How this plan was produced",
+    "",
+    `The AlmightyGPT Plan stage produced this. Worker (\`${workerName}\`)`,
+    `read the requirement above + the project's memory files.`,
+    "",
+    "**Next stage:** cross-AI review with `almightygpt review --plan",
+    `${planRel} --reviewer codex --topic ${opts.topic}\` (Reviewer critiques`,
+    "this plan), then human approval, then implementation in your",
+    "preferred coding tool.",
+  ].join("\n");
+
+  const planContent = header + adapterOut.content.trim() + footer;
+  const planAbs = join(opts.repoRoot, planRel);
+  await mkdir(dirname(planAbs), { recursive: true });
+  await writeFile(planAbs, planContent, "utf8");
+
+  const gitContext = await collectGitContext(opts.repoRoot);
+  await writeRunMetadata(runFolder.absPath, {
+    id: runFolder.id,
+    type: "plan",
+    createdAt,
+    finishedAt: new Date().toISOString(),
+    workspacePath: opts.repoRoot,
+    topic: opts.topic,
+    git: gitContext,
+    input: { source: "requirement-file" },
+    agents: [
+      {
+        name: workerName,
+        role: "worker",
+        provider: agentConfig.provider,
+        enabled: true,
+      },
+    ],
+    adapterVersions: [],
+    status: "completed",
+    metrics: [
+      {
+        agent: workerName,
+        role: "worker",
+        provider: adapter.provider,
+        model: adapterOut.modelUsed,
+        tokensIn: adapterOut.tokensIn,
+        cachedTokensIn: adapterOut.cachedTokensIn ?? 0,
+        tokensOut: adapterOut.tokensOut,
+        costUsd: adapterOut.costUsd,
+        latencyMs: adapterOut.latencyMs,
+      },
+    ],
+    totals: {
+      tokensIn: adapterOut.tokensIn,
+      tokensOut: adapterOut.tokensOut,
+      costUsd: adapterOut.costUsd,
+      latencyMs: adapterOut.latencyMs,
+    },
+    reviewPath: planRel,
+    budget: {
+      maxCostPerRunUsd: config.budget.maxCostPerRunUsd,
+      maxTokensPerRun: config.budget.maxTokensPerRun,
+    },
+  });
+
+  return {
+    planPath: planRel,
+    planBytes: planContent.length,
+    worker: workerName,
+    provider: adapter.provider,
+    modelUsed: adapterOut.modelUsed,
+    tokensIn: adapterOut.tokensIn,
+    cachedTokensIn: adapterOut.cachedTokensIn ?? 0,
+    tokensOut: adapterOut.tokensOut,
+    costUsd: adapterOut.costUsd,
+    latencyMs: adapterOut.latencyMs,
+    memorySources: memory.sources,
+    memoryMissing: memory.missing,
+    runId: runFolder.id,
+    runFolder: runFolder.relPath,
+  };
+}

package/src/runs/types.ts

@@ -14,7 +14,9 @@ export type RunType =
   | "review-diff"
   | "review-path"
   | "review-requirement"
-  | "review-worker-reviewer";
+  | "review-worker-reviewer"
+  | "plan"
+  | "review-plan";
 
 export type RunStatus = "running" | "completed" | "failed" | "aborted_budget";