@amistio/cli 0.1.22 → 0.1.24

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createHash as createHash7, randomUUID } from "node:crypto";
-import { writeFile as writeFile9 } from "node:fs/promises";
-import os7 from "node:os";
-import path15 from "node:path";
+import { createHash as createHash8, randomUUID } from "node:crypto";
+import { writeFile as writeFile10 } from "node:fs/promises";
+import os8 from "node:os";
+import path16 from "node:path";
 import { Command } from "commander";
 
 // ../shared/src/schemas.ts
@@ -2178,6 +2178,24 @@ async function readGitTopLevel(rootDir) {
 
 // src/api-client.ts
 import { z as z3 } from "zod";
+var AmistioApiError = class extends Error {
+  constructor(status, statusText, detail) {
+    super(`Amistio API request failed: ${status} ${statusText}${detail ? ` - ${detail}` : ""}`);
+    this.status = status;
+    this.statusText = statusText;
+    this.detail = detail;
+    this.name = "AmistioApiError";
+  }
+  status;
+  statusText;
+  detail;
+};
+function isRetryableApiError(error) {
+  if (error instanceof AmistioApiError) {
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+  }
+  return error instanceof TypeError;
+}
 var ApiClient = class {
   constructor(options) {
     this.options = options;
@@ -2519,7 +2537,7 @@ var ApiClient = class {
     });
     if (!response.ok) {
       const detail = await response.text().catch(() => "");
-      throw new Error(`Amistio API request failed: ${response.status} ${response.statusText}${detail ? ` - ${detail}` : ""}`);
+      throw new AmistioApiError(response.status, response.statusText, detail);
     }
     return schema.parse(await response.json());
   }
@@ -2554,8 +2572,8 @@ var toolSessionMutationSchema = z3.object({
 });
 function resolveApiUrl(apiUrl, urlPath) {
   const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
-  const path16 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
-  return new URL(`${base}${path16}`);
+  const path17 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path17}`);
 }
 
 // src/orchestrator.ts
@@ -2619,11 +2637,155 @@ async function writePromptFile(filePath, prompt) {
   return filePath;
 }
 
-// src/local-tool-runner.ts
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile as readFile3, rm, writeFile as writeFile4 } from "node:fs/promises";
+// src/result-finalization-outbox.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile3, rename, rm, writeFile as writeFile4 } from "node:fs/promises";
 import os2 from "node:os";
 import path5 from "node:path";
+import { z as z4 } from "zod";
+var brainGenerationResultMutationSchema = z4.discriminatedUnion("status", [
+  z4.object({
+    status: z4.literal("completed"),
+    runnerId: z4.string().min(1),
+    idempotencyKey: z4.string().min(1),
+    artifacts: z4.array(generatedBrainArtifactSchema).min(1),
+    tool: z4.string().min(1).optional(),
+    durationMs: z4.number().int().nonnegative().optional(),
+    sessionPolicy: sessionPolicySchema.optional(),
+    sessionGroupKey: z4.string().min(1).optional(),
+    toolSessionId: z4.string().min(1).optional(),
+    sessionDecision: sessionDecisionSchema.optional(),
+    sessionDecisionReason: z4.string().min(1).optional(),
+    message: z4.string().optional()
+  }),
+  z4.object({
+    status: z4.literal("failed"),
+    runnerId: z4.string().min(1),
+    idempotencyKey: z4.string().min(1),
+    tool: z4.string().min(1).optional(),
+    durationMs: z4.number().int().nonnegative().optional(),
+    sessionPolicy: sessionPolicySchema.optional(),
+    sessionGroupKey: z4.string().min(1).optional(),
+    toolSessionId: z4.string().min(1).optional(),
+    sessionDecision: sessionDecisionSchema.optional(),
+    sessionDecisionReason: z4.string().min(1).optional(),
+    message: z4.string().optional(),
+    error: z4.string().optional()
+  })
+]);
+var brainGenerationFinalizationEntrySchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("brainGenerationResult"),
+  status: z4.enum(["pending", "terminal"]),
+  accountId: z4.string().min(1),
+  projectId: z4.string().min(1),
+  repositoryLinkId: z4.string().min(1),
+  runnerId: z4.string().min(1),
+  workItemId: z4.string().min(1),
+  workKind: z4.enum(["brainGeneration", "planRevision"]),
+  attempt: z4.number().int().nonnegative(),
+  idempotencyKey: z4.string().min(1),
+  result: brainGenerationResultMutationSchema,
+  retryCount: z4.number().int().nonnegative(),
+  createdAt: z4.string().min(1),
+  updatedAt: z4.string().min(1),
+  lastError: z4.string().optional()
+});
+function defaultResultFinalizationOutboxDir() {
+  return path5.join(os2.homedir(), ".config", "amistio", "result-finalizations");
+}
+function createBrainGenerationFinalizationEntry(input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return brainGenerationFinalizationEntrySchema.parse({
+    schemaVersion: 1,
+    kind: "brainGenerationResult",
+    status: "pending",
+    accountId: input.accountId,
+    projectId: input.projectId,
+    repositoryLinkId: input.repositoryLinkId,
+    runnerId: input.runnerId,
+    workItemId: input.workItemId,
+    workKind: input.workKind,
+    attempt: input.attempt,
+    idempotencyKey: input.idempotencyKey,
+    result: input.result,
+    retryCount: 0,
+    createdAt: now,
+    updatedAt: now
+  });
+}
+async function upsertBrainGenerationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await mkdir5(outboxDir, { recursive: true });
+  const filePath = brainGenerationFinalizationEntryPath(entry, outboxDir);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile4(tempPath, `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+  await rename(tempPath, filePath);
+}
+async function listPendingBrainGenerationFinalizations(scope, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const entries = await readdir2(outboxDir, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  const pending = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = path5.join(outboxDir, entry.name);
+    let raw;
+    try {
+      raw = JSON.parse(await readFile3(filePath, "utf8"));
+    } catch {
+      continue;
+    }
+    const parsed = brainGenerationFinalizationEntrySchema.safeParse(raw);
+    if (!parsed.success) continue;
+    const value = parsed.data;
+    if (value.status !== "pending") continue;
+    if (value.accountId !== scope.accountId || value.projectId !== scope.projectId || value.repositoryLinkId !== scope.repositoryLinkId || value.runnerId !== scope.runnerId) continue;
+    pending.push(value);
+  }
+  return pending.sort((first, second) => Date.parse(first.createdAt) - Date.parse(second.createdAt));
+}
+async function markBrainGenerationFinalizationRetry(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = brainGenerationFinalizationEntrySchema.parse({
+    ...entry,
+    status: "pending",
+    retryCount: entry.retryCount + 1,
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertBrainGenerationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function markBrainGenerationFinalizationTerminal(entry, error, outboxDir = defaultResultFinalizationOutboxDir()) {
+  const updated = brainGenerationFinalizationEntrySchema.parse({
+    ...entry,
+    status: "terminal",
+    lastError: truncateLocalError(error),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await upsertBrainGenerationFinalizationEntry(updated, outboxDir);
+  return updated;
+}
+async function deleteBrainGenerationFinalizationEntry(entry, outboxDir = defaultResultFinalizationOutboxDir()) {
+  await rm(brainGenerationFinalizationEntryPath(entry, outboxDir), { force: true });
+}
+function brainGenerationFinalizationEntryPath(entry, outboxDir) {
+  return path5.join(outboxDir, `${brainGenerationFinalizationEntryKey(entry)}.json`);
+}
+function brainGenerationFinalizationEntryKey(entry) {
+  const hash = createHash2("sha256").update([entry.accountId, entry.projectId, entry.repositoryLinkId, entry.runnerId, entry.workItemId, String(entry.attempt), entry.idempotencyKey].join("\0")).digest("hex").slice(0, 32);
+  return `brain-generation-${hash}`;
+}
+function truncateLocalError(error) {
+  const trimmed = error.trim();
+  return trimmed.length > 600 ? `${trimmed.slice(0, 600)}...` : trimmed;
+}
+
+// src/local-tool-runner.ts
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import os3 from "node:os";
+import path6 from "node:path";
 var localToolNames = runnerToolNames;
 var allReasoningEfforts = ["auto", "low", "medium", "high", "xhigh"];
 var highReasoningEfforts = ["auto", "high", "xhigh"];
@@ -2830,9 +2992,9 @@ async function detectLocalTools() {
   );
 }
 async function runLocalTool(options) {
-  const promptTempDir = await mkdtemp(path5.join(os2.tmpdir(), "amistio-prompt-"));
-  const promptFilePath = path5.join(promptTempDir, "prompt.md");
-  await writeFile4(promptFilePath, options.prompt, "utf8");
+  const promptTempDir = await mkdtemp(path6.join(os3.tmpdir(), "amistio-prompt-"));
+  const promptFilePath = path6.join(promptTempDir, "prompt.md");
+  await writeFile5(promptFilePath, options.prompt, "utf8");
   const modelConfig = normalizeModelOptions(options);
   try {
     const runnerOptions = {
@@ -2864,11 +3026,11 @@ async function runLocalTool(options) {
       ...result
     };
   } finally {
-    await rm(promptTempDir, { recursive: true, force: true });
+    await rm2(promptTempDir, { recursive: true, force: true });
   }
 }
 async function createToolRunPreview(options) {
-  const promptFilePath = path5.join(os2.tmpdir(), "amistio-generated-prompt.md");
+  const promptFilePath = path6.join(os3.tmpdir(), "amistio-generated-prompt.md");
   const modelConfig = normalizeModelOptions(options);
   const runnerOptions = {
     rootDir: options.rootDir,
@@ -3061,13 +3223,13 @@ async function detectProviderCatalog(adapter) {
 }
 async function loadOpencodeProviderCatalog() {
   const configPaths = [
-    path5.join(os2.homedir(), ".config", "opencode", "opencode.json"),
-    path5.join(os2.homedir(), ".config", "opencode", "config.json"),
-    path5.join(process.cwd(), "opencode.json")
+    path6.join(os3.homedir(), ".config", "opencode", "opencode.json"),
+    path6.join(os3.homedir(), ".config", "opencode", "config.json"),
+    path6.join(process.cwd(), "opencode.json")
   ];
   for (const configPath of configPaths) {
     try {
-      const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+      const parsed = JSON.parse(await readFile4(configPath, "utf8"));
       const providerValue = isRecord(parsed) ? parsed.provider : void 0;
       const catalog = sanitizeProviderCatalog(providerValue);
       if (catalog) return catalog;
@@ -3439,16 +3601,16 @@ function shellQuote(value) {
 
 // src/runner-daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { openSync } from "node:fs";
-import { mkdir as mkdir5, readdir as readdir2, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
-import os3 from "node:os";
-import path6 from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile5, writeFile as writeFile6 } from "node:fs/promises";
+import os4 from "node:os";
+import path7 from "node:path";
 function currentRunnerMode() {
   return process.env.AMISTIO_RUNNER_MODE === "background" ? "background" : "foreground";
 }
 function defaultRunnerMetadataDir() {
-  return path6.join(os3.homedir(), ".config", "amistio", "runners");
+  return path7.join(os4.homedir(), ".config", "amistio", "runners");
 }
 function updatedCliRunnerLaunchOptions() {
   return { executablePath: "amistio", directExecutable: true };
@@ -3465,8 +3627,8 @@ async function startRunnerDaemon(input) {
   if (existing?.status === "running" && isProcessRunning(existing.pid)) {
     throw new Error(`Background runner ${existing.runnerId} is already running with PID ${existing.pid}.`);
   }
-  await mkdir5(metadataDir, { recursive: true });
-  const logPath = path6.join(metadataDir, `${runnerDaemonKey(input)}.log`);
+  await mkdir6(metadataDir, { recursive: true });
+  const logPath = path7.join(metadataDir, `${runnerDaemonKey(input)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args: input.args,
@@ -3493,13 +3655,13 @@ async function startRunnerDaemon(input) {
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path6.resolve(input.rootDir),
+    rootDir: path7.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     pid: child.pid,
     status: "running",
     startedAt: now,
     updatedAt: now,
-    hostname: os3.hostname(),
+    hostname: os4.hostname(),
     logPath
   };
   await writeRunnerDaemonMetadata(metadata, metadataDir);
@@ -3507,8 +3669,8 @@ async function startRunnerDaemon(input) {
 }
 async function restartRunnerDaemonProcess(metadata, args, input = {}) {
   const metadataDir = input.metadataDir ?? defaultRunnerMetadataDir();
-  await mkdir5(metadataDir, { recursive: true });
-  const logPath = metadata.logPath ?? path6.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
+  await mkdir6(metadataDir, { recursive: true });
+  const logPath = metadata.logPath ?? path7.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
   const logFd = openSync(logPath, "a");
   const launch = resolveRunnerDaemonLaunch({
     args,
@@ -3536,7 +3698,7 @@ async function restartRunnerDaemonProcess(metadata, args, input = {}) {
     status: "running",
     startedAt: now,
     updatedAt: now,
-    hostname: os3.hostname(),
+    hostname: os4.hostname(),
     logPath
   };
   await writeRunnerDaemonMetadata(replacement, metadataDir);
@@ -3545,12 +3707,12 @@ async function restartRunnerDaemonProcess(metadata, args, input = {}) {
 async function listRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   let entries;
   try {
-    entries = await readdir2(metadataDir);
+    entries = await readdir3(metadataDir);
   } catch {
     return [];
   }
   const records = await Promise.all(
-    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path6.join(metadataDir, entry)))
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path7.join(metadataDir, entry)))
   );
   return records.filter((record) => Boolean(record)).filter((record) => record.accountId === input.accountId && record.projectId === input.projectId && record.repositoryLinkId === input.repositoryLinkId).filter((record) => !input.runnerId || record.runnerId === input.runnerId).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
 }
@@ -3558,8 +3720,8 @@ async function readRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetada
   return readRunnerDaemonMetadataFile(runnerDaemonMetadataPath(input, metadataDir));
 }
 async function writeRunnerDaemonMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir5(metadataDir, { recursive: true });
-  await writeFile5(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir6(metadataDir, { recursive: true });
+  await writeFile6(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function markRunnerDaemonStopped(metadata, metadataDir = defaultRunnerMetadataDir()) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -3621,14 +3783,14 @@ function runnerDaemonUptime(metadata, now = Date.now()) {
   return `${seconds}s`;
 }
 function runnerDaemonMetadataPath(input, metadataDir) {
-  return path6.join(metadataDir, `${runnerDaemonKey(input)}.json`);
+  return path7.join(metadataDir, `${runnerDaemonKey(input)}.json`);
 }
 function runnerDaemonKey(input) {
-  return createHash2("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
+  return createHash3("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
 }
 async function readRunnerDaemonMetadataFile(filePath) {
   try {
-    const parsed = JSON.parse(await readFile4(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile5(filePath, "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.runnerId || !parsed.projectId || !parsed.repositoryLinkId) {
       return void 0;
     }
@@ -3640,10 +3802,10 @@ async function readRunnerDaemonMetadataFile(filePath) {
 
 // src/runner-service.ts
 import { spawn as spawn3 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile5, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
-import os4 from "node:os";
-import path7 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir7, readFile as readFile6, rm as rm3, writeFile as writeFile7 } from "node:fs/promises";
+import os5 from "node:os";
+import path8 from "node:path";
 function detectRunnerServicePlatform(platform = process.platform) {
   if (platform === "darwin") return "launchd";
   if (platform === "linux") return "systemd";
@@ -3654,19 +3816,19 @@ function createRunnerServiceDescriptor(input) {
   if (platform === "unsupported") {
     throw new Error("Startup services are supported for user-level launchd on macOS and systemd user services on Linux.");
   }
-  const homeDir = input.homeDir ?? os4.homedir();
+  const homeDir = input.homeDir ?? os5.homedir();
   const serviceName = runnerServiceName(input);
   const serviceFilePath = runnerServiceFilePath(platform, serviceName, homeDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const command = [input.executablePath ?? process.execPath, input.scriptPath ?? process.argv[1], ...input.args];
-  const logPath = path7.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
+  const logPath = path8.join(input.metadataDir ?? defaultRunnerMetadataDir(), `${runnerServiceKey(input)}.service.log`);
   const metadata = {
     schemaVersion: 1,
     accountId: input.accountId,
     projectId: input.projectId,
     repositoryLinkId: input.repositoryLinkId,
     runnerId: input.runnerId,
-    rootDir: path7.resolve(input.rootDir),
+    rootDir: path8.resolve(input.rootDir),
     apiUrl: input.apiUrl,
     serviceName,
     serviceFilePath,
@@ -3683,9 +3845,9 @@ function createRunnerServiceDescriptor(input) {
 }
 async function installRunnerService(input, options = {}) {
   const descriptor = createRunnerServiceDescriptor(input);
-  await mkdir6(path7.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
-  await mkdir6(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
-  await writeFile6(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
+  await mkdir7(path8.dirname(descriptor.metadata.serviceFilePath), { recursive: true });
+  await mkdir7(input.metadataDir ?? defaultRunnerMetadataDir(), { recursive: true });
+  await writeFile7(descriptor.metadata.serviceFilePath, descriptor.content, { encoding: "utf8", mode: 384 });
   await writeRunnerServiceMetadata(descriptor.metadata, input.metadataDir);
   if (options.activate !== false) {
     const activation = await activateRunnerService(descriptor.metadata);
@@ -3701,13 +3863,13 @@ async function removeRunnerService(input) {
     return void 0;
   }
   await deactivateRunnerService(metadata).catch(() => void 0);
-  await rm2(metadata.serviceFilePath, { force: true });
-  await rm2(runnerServiceMetadataPath(input, input.metadataDir ?? defaultRunnerMetadataDir()), { force: true });
+  await rm3(metadata.serviceFilePath, { force: true });
+  await rm3(runnerServiceMetadataPath(input, input.metadataDir ?? defaultRunnerMetadataDir()), { force: true });
   return { ...metadata, status: "removed", updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   try {
-    const parsed = JSON.parse(await readFile5(runnerServiceMetadataPath(input, metadataDir), "utf8"));
+    const parsed = JSON.parse(await readFile6(runnerServiceMetadataPath(input, metadataDir), "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.serviceName || !parsed.serviceFilePath) {
       return void 0;
     }
@@ -3717,8 +3879,8 @@ async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetad
   }
 }
 async function writeRunnerServiceMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
-  await mkdir6(metadataDir, { recursive: true });
-  await writeFile6(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+  await mkdir7(metadataDir, { recursive: true });
+  await writeFile7(runnerServiceMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
 }
 async function runnerServiceRuntimeStatus(metadata) {
   if (metadata.platform === "launchd") {
@@ -3801,18 +3963,18 @@ WantedBy=default.target
 }
 function runnerServiceFilePath(platform, serviceName, homeDir) {
   if (platform === "launchd") {
-    return path7.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
+    return path8.join(homeDir, "Library", "LaunchAgents", `${serviceName}.plist`);
   }
-  return path7.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
+  return path8.join(homeDir, ".config", "systemd", "user", `${serviceName}.service`);
 }
 function runnerServiceMetadataPath(input, metadataDir) {
-  return path7.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
+  return path8.join(metadataDir, `${runnerServiceKey(input)}.service.json`);
 }
 function runnerServiceName(input) {
   return `com.amistio.runner.${runnerServiceKey(input).slice(0, 20)}`;
 }
 function runnerServiceKey(input) {
-  return createHash3("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
+  return createHash4("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
 }
 function launchdDomain() {
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
@@ -3988,9 +4150,9 @@ function tokens(value) {
 
 // src/sync.ts
 import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir7, readdir as readdir3, readFile as readFile6, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
-import path8 from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir as mkdir8, readdir as readdir4, readFile as readFile7, stat as stat3, writeFile as writeFile8 } from "node:fs/promises";
+import path9 from "node:path";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync3 = promisify3(execFile3);
 var legacySyncRoots = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
@@ -4086,7 +4248,7 @@ async function readLocalSyncedDocuments(rootDir) {
   const documentFiles = await findBrainDocumentFiles(rootDir);
   const documents = [];
   for (const fullPath of documentFiles) {
-    const raw = await readFile6(fullPath, "utf8");
+    const raw = await readFile7(fullPath, "utf8");
     const repoPath = toRepoPath(rootDir, fullPath);
     const parsed = parseSyncedDocument(raw, repoPath);
     if (!parsed) {
@@ -4136,8 +4298,8 @@ async function materializeBrainDocuments(rootDir, documents, options = {}) {
       result.skipped.push(document.repoPath);
       continue;
     }
-    await mkdir7(path8.dirname(fullPath), { recursive: true });
-    await writeFile7(fullPath, createSyncedDocumentContent(document), "utf8");
+    await mkdir8(path9.dirname(fullPath), { recursive: true });
+    await writeFile8(fullPath, createSyncedDocumentContent(document), "utf8");
     result.written.push(document.repoPath);
   }
   return result;
@@ -4266,7 +4428,7 @@ function parseSyncedHtml(content) {
 }
 async function readExistingSyncedDocument(fullPath) {
   try {
-    const raw = await readFile6(fullPath, "utf8");
+    const raw = await readFile7(fullPath, "utf8");
     const parsed = parseSyncedDocument(raw, fullPath);
     if (!parsed) {
       return { exists: true };
@@ -4291,7 +4453,7 @@ async function readExistingSyncedDocument(fullPath) {
 async function findBrainDocumentFiles(rootDir) {
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot]) {
-    const fullRoot = path8.join(rootDir, syncRoot);
+    const fullRoot = path9.join(rootDir, syncRoot);
     if (!await exists2(fullRoot)) {
       continue;
     }
@@ -4300,8 +4462,8 @@ async function findBrainDocumentFiles(rootDir) {
   return files;
 }
 async function walkBrainDocumentFiles(directory, files) {
-  for (const entry of await readdir3(directory, { withFileTypes: true })) {
-    const fullPath = path8.join(directory, entry.name);
+  for (const entry of await readdir4(directory, { withFileTypes: true })) {
+    const fullPath = path9.join(directory, entry.name);
     if (entry.isDirectory()) {
       await walkBrainDocumentFiles(fullPath, files);
     } else if (entry.isFile() && /\.(md|mdx|html?)$/i.test(entry.name)) {
@@ -4310,23 +4472,23 @@ async function walkBrainDocumentFiles(directory, files) {
   }
 }
 function safeRepoPath(rootDir, repoPath) {
-  if (path8.isAbsolute(repoPath)) {
+  if (path9.isAbsolute(repoPath)) {
     throw new Error(`Refusing to use absolute repo path: ${repoPath}`);
   }
-  const normalized = path8.normalize(repoPath);
-  if (normalized === ".." || normalized.startsWith(`..${path8.sep}`)) {
+  const normalized = path9.normalize(repoPath);
+  if (normalized === ".." || normalized.startsWith(`..${path9.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
-  const root = path8.resolve(rootDir);
-  const fullPath = path8.resolve(root, normalized);
-  if (!fullPath.startsWith(`${root}${path8.sep}`)) {
+  const root = path9.resolve(rootDir);
+  const fullPath = path9.resolve(root, normalized);
+  if (!fullPath.startsWith(`${root}${path9.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
   return fullPath;
 }
 function isControlPlanePath(repoPath) {
-  const normalized = path8.normalize(repoPath);
-  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path8.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path8.sep}`);
+  const normalized = path9.normalize(repoPath);
+  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path9.sep}`)) || normalized === htmlSyncRoot || normalized.startsWith(`${htmlSyncRoot}${path9.sep}`);
 }
 function canonicalControlPlaneRepoPath(repoPath) {
   const normalized = repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -4337,16 +4499,16 @@ function canonicalControlPlaneRepoPath(repoPath) {
   return normalized;
 }
 function toRepoPath(rootDir, fullPath) {
-  return path8.relative(rootDir, fullPath).split(path8.sep).join("/");
+  return path9.relative(rootDir, fullPath).split(path9.sep).join("/");
 }
 function inferTitle(content, repoPath) {
   const heading = content.split("\n").find((line) => line.startsWith("# "))?.replace(/^#\s+/, "").trim();
   if (heading) return heading;
   const htmlHeading = content.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
-  return htmlHeading || path8.basename(repoPath, path8.extname(repoPath));
+  return htmlHeading || path9.basename(repoPath, path9.extname(repoPath));
 }
 async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingDocuments, options) {
-  const root = path8.resolve(rootDir);
+  const root = path9.resolve(rootDir);
   const maxBytes = (options.maxFileKb ?? defaultAutoSyncMaxFileKb) * 1024;
   const syncedAt = options.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const existingById = new Map(existingDocuments.map((document) => [document.documentId, document]));
@@ -4371,7 +4533,7 @@ async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingD
       skipped.push({ repoPath: normalizedRepoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile6(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile7(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
       continue;
@@ -4436,7 +4598,7 @@ async function listAutoSyncCandidatePaths(rootDir) {
   }
   const files = [];
   for (const syncRoot of [...syncRoots, htmlSyncRoot, ...legacySyncRoots]) {
-    const fullRoot = path8.join(rootDir, syncRoot);
+    const fullRoot = path9.join(rootDir, syncRoot);
     if (await exists2(fullRoot)) {
       await walkAutoSyncFiles(rootDir, fullRoot, files);
     }
@@ -4444,9 +4606,9 @@ async function listAutoSyncCandidatePaths(rootDir) {
   return uniqueSortedRepoPaths(files);
 }
 async function walkAutoSyncFiles(rootDir, directory, files) {
-  for (const entry of await readdir3(directory, { withFileTypes: true }).catch(() => [])) {
-    const fullPath = path8.join(directory, entry.name);
-    const repoPath = normalizeRepoPath3(path8.relative(rootDir, fullPath));
+  for (const entry of await readdir4(directory, { withFileTypes: true }).catch(() => [])) {
+    const fullPath = path9.join(directory, entry.name);
+    const repoPath = normalizeRepoPath3(path9.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!autoSyncExcludedDirectoryNames.has(entry.name)) {
         await walkAutoSyncFiles(rootDir, fullPath, files);
@@ -4480,7 +4642,7 @@ function legacyDocumentTypeForRepoPath(repoPath) {
   return root && root in documentTypeByRoot ? documentTypeByRoot[root] : void 0;
 }
 function stableExternalDocumentId(metadata, repoPath) {
-  return `doc_external_${createHash4("sha256").update(`${metadata.amistioAccountId}:${metadata.amistioProjectId}:${metadata.repositoryLinkId}:${repoPath}`).digest("hex").slice(0, 24)}`;
+  return `doc_external_${createHash5("sha256").update(`${metadata.amistioAccountId}:${metadata.amistioProjectId}:${metadata.repositoryLinkId}:${repoPath}`).digest("hex").slice(0, 24)}`;
 }
 function normalizeRepoPath3(repoPath) {
   return repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -4508,9 +4670,9 @@ async function exists2(filePath) {
 }
 
 // src/tool-session-store.ts
-import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
-import os5 from "node:os";
-import path9 from "node:path";
+import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
+import os6 from "node:os";
+import path10 from "node:path";
 var LocalToolSessionStore = class {
   constructor(filePath = defaultSessionStorePath()) {
     this.filePath = filePath;
@@ -4524,12 +4686,12 @@ var LocalToolSessionStore = class {
   async setProviderSessionId(toolSessionId, toolName, providerSessionId) {
     const data = await this.read();
     data[toolSessionId] = { toolName, providerSessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await mkdir8(path9.dirname(this.filePath), { recursive: true });
-    await writeFile8(this.filePath, JSON.stringify(data, null, 2), "utf8");
+    await mkdir9(path10.dirname(this.filePath), { recursive: true });
+    await writeFile9(this.filePath, JSON.stringify(data, null, 2), "utf8");
   }
   async read() {
     try {
-      return JSON.parse(await readFile7(this.filePath, "utf8"));
+      return JSON.parse(await readFile8(this.filePath, "utf8"));
     } catch {
       return {};
     }
@@ -4537,16 +4699,16 @@ var LocalToolSessionStore = class {
 };
 function defaultSessionStorePath() {
   if (process.platform === "darwin") {
-    return path9.join(os5.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
+    return path10.join(os6.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
   }
   if (process.platform === "win32") {
-    return path9.join(process.env.APPDATA ?? os5.homedir(), "Amistio", "tool-sessions.json");
+    return path10.join(process.env.APPDATA ?? os6.homedir(), "Amistio", "tool-sessions.json");
   }
-  return path9.join(process.env.XDG_STATE_HOME ?? path9.join(os5.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
+  return path10.join(process.env.XDG_STATE_HOME ?? path10.join(os6.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
 }
 
 // src/work-runner.ts
-import path10 from "node:path";
+import path11 from "node:path";
 var generationResultStart = "AMISTIO_BRAIN_GENERATION_RESULT_START";
 var generationResultEnd = "AMISTIO_BRAIN_GENERATION_RESULT_END";
 var assistantAnswerStart = "AMISTIO_ASSISTANT_ANSWER_START";
@@ -4570,6 +4732,14 @@ var projectContextTopLevelWarningMaxLength = 600;
 var validProjectContextSliceKinds = /* @__PURE__ */ new Set(["overview", "architecture", "domain", "data", "api", "frontend", "backend", "cli", "workflow", "operations", "security", "testing", "unknown"]);
 var validProjectContextEntityTypes = /* @__PURE__ */ new Set(["project", "system", "component", "domain", "tool", "decision", "feature", "risk", "team", "workflow", "unknown"]);
 var validProjectContextRelationTypes = /* @__PURE__ */ new Set(["uses", "depends_on", "decides", "supersedes", "touches", "blocks", "implements", "mentions"]);
+var canonicalProjectContextCitationSources = /* @__PURE__ */ new Map([
+  ["projectbrain", "projectBrain"],
+  ["approvedbrain", "projectBrain"],
+  ["approvedprojectbrain", "projectBrain"],
+  ["localsource", "localSource"],
+  ["runnerstate", "runnerState"],
+  ["mixed", "mixed"]
+]);
 function createImplementationVerificationPrompt(workItem) {
   return [
     "# Amistio Implementation Verification",
@@ -4727,6 +4897,7 @@ function createProjectContextRefreshPrompt(workItem, context) {
     "- Use only these exact singular slice kind values: overview, architecture, domain, data, api, frontend, backend, cli, workflow, operations, security, testing, unknown.",
     "- Capture entities and relations that explain how the app is put together and where future work should look first.",
     "- Prefer summaries, repository-relative paths, short citations, tags, and freshness status over raw source excerpts.",
+    "- Use only these exact citation source values: projectBrain, localSource, runnerState, mixed. Approved project-brain records use projectBrain, not approvedBrain.",
     "- Mark stale or missing areas explicitly instead of guessing.",
     "- Keep coverage.missingAreas entries concise noun phrases under 160 characters.",
     "- Keep coverage.warnings and verificationPlan entries under 300 characters; keep top-level warnings under 600 characters.",
@@ -5400,6 +5571,7 @@ function normalizeProjectContextCitationPaths(value, options) {
         return citation;
       }
       const normalizedCitation = { ...citation };
+      normalizedCitation.source = normalizeProjectContextCitationSource(normalizedCitation.source);
       if (typeof normalizedCitation.repoPath === "string") {
         normalizedCitation.repoPath = normalizeProjectContextRepoPath(normalizedCitation.repoPath, options);
       }
@@ -5408,20 +5580,27 @@ function normalizeProjectContextCitationPaths(value, options) {
   }
   return normalized;
 }
+function normalizeProjectContextCitationSource(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const sourceKey = value.trim().replace(/[\s_-]+/g, "").toLowerCase();
+  return canonicalProjectContextCitationSources.get(sourceKey) ?? value;
+}
 function normalizeProjectContextRepoPath(value, options) {
   const trimmed = value.trim();
   if (!trimmed || /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(trimmed) || /^file:/i.test(trimmed) || /^[A-Za-z]:($|[^\\/])/.test(trimmed)) {
     throwUnsafeProjectContextPath();
   }
-  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path10.isAbsolute(trimmed) || path10.win32.isAbsolute(trimmed);
+  const absolute = trimmed.startsWith("/") || trimmed.startsWith("\\\\") || path11.isAbsolute(trimmed) || path11.win32.isAbsolute(trimmed);
   if (!absolute) {
     return normalizeRelativeProjectContextPath(trimmed);
   }
   if (!options.repositoryRoot) {
     throwUnsafeProjectContextPath();
   }
-  const useWindowsPathRules = path10.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
-  const relativePath = useWindowsPathRules ? path10.win32.relative(path10.win32.resolve(options.repositoryRoot), path10.win32.resolve(trimmed)) : path10.relative(path10.resolve(options.repositoryRoot), path10.resolve(trimmed));
+  const useWindowsPathRules = path11.win32.isAbsolute(trimmed) && !trimmed.startsWith("/");
+  const relativePath = useWindowsPathRules ? path11.win32.relative(path11.win32.resolve(options.repositoryRoot), path11.win32.resolve(trimmed)) : path11.relative(path11.resolve(options.repositoryRoot), path11.resolve(trimmed));
   return normalizeRelativeProjectContextPath(relativePath);
 }
 function normalizeRelativeProjectContextPath(value) {
@@ -5473,7 +5652,7 @@ function stripJsonFence(value) {
 }
 
 // src/runner-status.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var watchStateReminderMs = 60 * 1e3;
 function formatWatchStartupContext(input) {
   return [
@@ -5500,20 +5679,20 @@ function watchStateKey(action) {
   return [action.kind, action.message, action.workItemId, action.documentId, action.runnerId].filter(Boolean).join(":");
 }
 function stableRunnerId(input) {
-  const digest = createHash5("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
+  const digest = createHash6("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
   return `runner_${digest}`;
 }
 
 // src/runner-resources.ts
-import os6 from "node:os";
+import os7 from "node:os";
 var defaultRuntime = {
   nowMs: () => Date.now(),
   memoryUsage: () => process.memoryUsage(),
   uptime: () => process.uptime(),
   cpuUsage: () => process.cpuUsage(),
-  totalmem: () => os6.totalmem(),
-  freemem: () => os6.freemem(),
-  loadavg: () => os6.loadavg()
+  totalmem: () => os7.totalmem(),
+  freemem: () => os7.freemem(),
+  loadavg: () => os7.loadavg()
 };
 var previousRunnerResourceSample;
 function sampleCurrentRunnerResourceUsage() {
@@ -5625,9 +5804,9 @@ function roundNumber(value, digits) {
 
 // src/importer.ts
 import { execFile as execFile4 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import { readdir as readdir4, readFile as readFile8, stat as stat4 } from "node:fs/promises";
-import path11 from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { readdir as readdir5, readFile as readFile9, stat as stat4 } from "node:fs/promises";
+import path12 from "node:path";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 var defaultMaxFileKb = 256;
@@ -5648,12 +5827,12 @@ var documentFolderByType = {
   workflow: "docs/workflows"
 };
 async function inspectLocalRepository(rootDir, defaultBranch) {
-  const requestedRoot = path11.resolve(rootDir);
+  const requestedRoot = path12.resolve(rootDir);
   const root = await runGit2(["-C", requestedRoot, "rev-parse", "--show-toplevel"]).catch(() => requestedRoot);
   const detectedBranch = await runGit2(["-C", root, "symbolic-ref", "--quiet", "--short", "HEAD"]).catch(() => defaultBranch);
   const originUrl = await runGit2(["-C", root, "remote", "get-url", "origin"]).catch(() => void 0);
   const parsedCloneUrl = originUrl ? parseOptionalOriginCloneUrl(originUrl) : void 0;
-  const repoName = (parsedCloneUrl?.repoName ?? path11.basename(root)) || "repository";
+  const repoName = (parsedCloneUrl?.repoName ?? path12.basename(root)) || "repository";
   const fingerprintSeed = parsedCloneUrl ? `origin:${parsedCloneUrl.normalizedKey}` : `repo:${repoName}:${detectedBranch || defaultBranch}`;
   return {
     rootDir: root,
@@ -5665,7 +5844,7 @@ async function inspectLocalRepository(rootDir, defaultBranch) {
   };
 }
 async function scanLegacyDocuments(options) {
-  const rootDir = path11.resolve(options.rootDir);
+  const rootDir = path12.resolve(options.rootDir);
   const maxBytes = (options.maxFileKb ?? defaultMaxFileKb) * 1024;
   const skipped = [];
   const candidates = [];
@@ -5685,7 +5864,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "excluded" });
       continue;
     }
-    const fullPath = path11.join(rootDir, ...repoPath.split("/"));
+    const fullPath = path12.join(rootDir, ...repoPath.split("/"));
     const fileStat = await stat4(fullPath).catch(() => void 0);
     if (!fileStat?.isFile()) {
       skipped.push({ repoPath, reason: "unreadable" });
@@ -5695,7 +5874,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile8(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile9(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath, reason: "unreadable" });
       continue;
@@ -5785,10 +5964,10 @@ async function listRepositoryPaths(rootDir) {
   return files;
 }
 async function walkRepository(rootDir, directory, files) {
-  const entries = await readdir4(directory, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir5(directory, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path11.join(directory, entry.name);
-    const repoPath = normalizeRepoPath4(path11.relative(rootDir, fullPath));
+    const fullPath = path12.join(directory, entry.name);
+    const repoPath = normalizeRepoPath4(path12.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!excludedDirectoryNames.has(entry.name)) {
         await walkRepository(rootDir, fullPath, files);
@@ -5856,9 +6035,9 @@ function uniqueDestinationPath(basePath, sourcePath, usedPaths) {
     usedPaths.add(basePath);
     return basePath;
   }
-  const extension = path11.posix.extname(basePath) || ".md";
-  const directory = path11.posix.dirname(basePath);
-  const basename = path11.posix.basename(basePath, extension);
+  const extension = path12.posix.extname(basePath) || ".md";
+  const directory = path12.posix.dirname(basePath);
+  const basename = path12.posix.basename(basePath, extension);
   const uniquePath = `${directory}/${basename}-${hashText(sourcePath, 8)}${extension}`;
   usedPaths.add(uniquePath);
   return uniquePath;
@@ -5931,7 +6110,7 @@ function inferTitle2(content, repoPath) {
   if (heading) return heading;
   const htmlHeading = body.match(/<h1\b[^>]*>([\s\S]*?)<\/h1>/i)?.[1]?.replace(/<[^>]+>/g, "").trim();
   if (htmlHeading) return htmlHeading;
-  const basename = path11.posix.basename(repoPath, path11.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
+  const basename = path12.posix.basename(repoPath, path12.posix.extname(repoPath)).replace(/[-_]+/g, " ").trim();
   return titleCase(basename || "Imported Document");
 }
 function stripFrontmatter(content) {
@@ -5953,7 +6132,7 @@ function stableImportDocumentId(accountId, projectId, repositoryLinkId, sourcePa
   return `doc_import_${hashText(`${accountId}\0${projectId}\0${repositoryLinkId}\0${sourcePath}`, 24)}`;
 }
 function hashText(value, length) {
-  return createHash6("sha256").update(value).digest("hex").slice(0, length);
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
 }
 function normalizeRepoPath4(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
@@ -5965,7 +6144,7 @@ async function runGit2(args) {
 
 // src/runner-actions.ts
 import { spawn as spawn4 } from "node:child_process";
-import path12 from "node:path";
+import path13 from "node:path";
 function buildBackgroundRunnerArgs(options) {
   const args = [
     "run",
@@ -5975,7 +6154,7 @@ function buildBackgroundRunnerArgs(options) {
     "--runner-id",
     options.runnerId,
     "--root",
-    path12.resolve(options.root),
+    path13.resolve(options.root),
     "--session",
     options.session,
     "--interval-seconds",
@@ -6092,8 +6271,8 @@ function truncateProcessOutput(value) {
 
 // src/git-worktree.ts
 import { execFile as execFile5 } from "node:child_process";
-import { mkdir as mkdir9, stat as stat5 } from "node:fs/promises";
-import path13 from "node:path";
+import { mkdir as mkdir10, stat as stat5 } from "node:fs/promises";
+import path14 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync5 = promisify5(execFile5);
 function needsGitWorktreeIsolation(workItem) {
@@ -6122,7 +6301,7 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
     await assertExistingWorktree(worktreePath, identity.branch);
     return { ...identity, baseRevision, worktreePath };
   }
-  await mkdir9(path13.dirname(worktreePath), { recursive: true });
+  await mkdir10(path14.dirname(worktreePath), { recursive: true });
   const branchExists = await gitCommandSucceeds(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${identity.branch}`]);
   const worktreeArgs = branchExists ? ["worktree", "add", worktreePath, identity.branch] : ["worktree", "add", "-b", identity.branch, worktreePath, baseRevision];
   await gitOutput(repoRoot, worktreeArgs).catch((error) => {
@@ -6131,9 +6310,9 @@ async function prepareGitWorktreeIsolation(rootDir, workItem) {
   return { ...identity, baseRevision, worktreePath };
 }
 function localWorktreePath(repoRoot, worktreeKey) {
-  const repoName = path13.basename(repoRoot);
+  const repoName = path14.basename(repoRoot);
   const worktreeSlug = worktreeKey.split("/").filter(Boolean).pop() ?? "work";
-  return path13.join(path13.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
+  return path14.join(path14.dirname(repoRoot), `${repoName}.worktrees`, worktreeSlug);
 }
 async function assertExistingWorktree(worktreePath, branch) {
   await gitOutput(worktreePath, ["rev-parse", "--is-inside-work-tree"]);
@@ -6180,7 +6359,7 @@ function errorMessage2(error) {
 
 // src/implementation-handoff.ts
 import { execFile as execFile6 } from "node:child_process";
-import path14 from "node:path";
+import path15 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync6 = promisify6(execFile6);
 async function completeImplementationHandoff(input) {
@@ -6266,7 +6445,7 @@ async function cleanupWorktree(run, input) {
     return { status: "failed", message: "Cleanup skipped because the worktree is not clean after PR handoff." };
   }
   try {
-    await gitOutput2(run, input.primaryRepoRoot || path14.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
+    await gitOutput2(run, input.primaryRepoRoot || path15.dirname(input.worktreePath), ["worktree", "remove", input.worktreePath]);
     return { status: "completed" };
   } catch (error) {
     return { status: "failed", message: `Cleanup failed: ${safeErrorMessage(error)}` };
@@ -6677,7 +6856,7 @@ work.command("prompt").description("Print or write an approved work prompt witho
   }
   const prompt = await createRunnerWorkPrompt(context.client, context.metadata.amistioProjectId, workItem);
   if (options.out) {
-    await writeFile9(options.out, prompt, "utf8");
+    await writeFile10(options.out, prompt, "utf8");
     console.log(`Wrote work prompt to ${options.out}.`);
   } else {
     console.log(prompt);
@@ -6755,7 +6934,7 @@ program.command("run").description("Claim and run approved Amistio work locally"
       projectId: context.metadata.amistioProjectId,
       repositoryLinkId: context.metadata.repositoryLinkId,
       runnerId,
-      rootDir: path15.resolve(options.root),
+      rootDir: path16.resolve(options.root),
       apiUrl: options.apiUrl,
       args: buildBackgroundRunnerArgs(resolvedOptions)
     });
@@ -6927,7 +7106,7 @@ runnerService.command("install").description("Install a user-level startup servi
     projectId: context.metadata.amistioProjectId,
     repositoryLinkId: context.metadata.repositoryLinkId,
     runnerId,
-    rootDir: path15.resolve(options.root),
+    rootDir: path16.resolve(options.root),
     apiUrl: options.apiUrl,
     args,
     platform
@@ -6998,6 +7177,18 @@ async function runWatchIteration({ command, context, options, runnerId }) {
         runnerId
       });
     }
+    if (!options.dryRun) {
+      const replayResult = await replayPendingBrainGenerationFinalizations({
+        accountId: context.metadata.amistioAccountId,
+        apiClient: context.client,
+        projectId: context.metadata.amistioProjectId,
+        repositoryLinkId: context.metadata.repositoryLinkId,
+        runnerId
+      });
+      if (replayResult) {
+        return replayResult;
+      }
+    }
     return await runNextWorkItem({
       apiClient: context.client,
       projectId: context.metadata.amistioProjectId,
@@ -7745,6 +7936,58 @@ function runnerCommandLabel(commandKind) {
   if (commandKind === "restart") return "restart";
   return "remove";
 }
+async function replayPendingBrainGenerationFinalizations({ accountId, apiClient, projectId, repositoryLinkId, runnerId }) {
+  const pendingEntries = await listPendingBrainGenerationFinalizations({ accountId, projectId, repositoryLinkId, runnerId });
+  if (!pendingEntries.length) {
+    return void 0;
+  }
+  let completedCount = 0;
+  for (const entry of pendingEntries) {
+    const replay = await submitBrainGenerationFinalizationEntry(apiClient, entry, { recordReplayTelemetry: true });
+    if (replay.status === "completed") {
+      completedCount += 1;
+      continue;
+    }
+    return { status: "failed", exitCode: 1, message: replay.message };
+  }
+  const message = `Replayed ${completedCount} pending brain generation finalization${completedCount === 1 ? "" : "s"}.`;
+  console.log(message);
+  return { status: "completed", exitCode: 0, message };
+}
+async function submitBrainGenerationFinalizationEntry(apiClient, entry, options = {}) {
+  let result;
+  try {
+    result = await apiClient.submitBrainGenerationResult(entry.projectId, entry.workItemId, entry.result);
+  } catch (error) {
+    const detail = truncateLogExcerpt(errorMessage3(error));
+    if (isRetryableApiError(error)) {
+      const updated = await markBrainGenerationFinalizationRetry(entry, detail);
+      const message2 = `Pending brain generation finalization ${entry.workItemId} could not be replayed yet (${updated.retryCount} attempt${updated.retryCount === 1 ? "" : "s"}): ${detail}`;
+      console.error(message2);
+      return { status: "failed", message: message2, retryable: true };
+    }
+    await markBrainGenerationFinalizationTerminal(entry, detail);
+    const message = `Pending brain generation finalization ${entry.workItemId} reached a terminal API failure: ${detail}`;
+    console.error(message);
+    return { status: "failed", message, retryable: false };
+  }
+  await deleteBrainGenerationFinalizationEntry(entry).catch((error) => {
+    console.error(`delete pending brain generation finalization ${entry.workItemId} failed: ${errorMessage3(error)}`);
+  });
+  if (options.recordReplayTelemetry) {
+    await recordRunnerMilestone(apiClient, entry.projectId, result.workItem, entry.runnerId, entry.repositoryLinkId, {
+      status: entry.result.status,
+      summary: entry.result.status === "completed" ? "Replayed pending brain generation result finalization." : "Replayed pending brain generation failure finalization.",
+      idempotencyKey: `runner_milestone_generation_replayed_${entry.workItemId}_${result.workItem.idempotencyKey}`,
+      metadata: { artifactCount: result.documents.length, replayedFinalization: true, workKind: entry.workKind }
+    });
+    await apiClient.sendRunnerHeartbeat(entry.projectId, entry.runnerId, entry.repositoryLinkId, "online", {
+      ...runnerHeartbeatMetadata(),
+      preferenceMessage: "Pending result finalization replayed."
+    }).catch(() => void 0);
+  }
+  return { status: "completed", workItem: result.workItem, documentCount: result.documents.length };
+}
 async function finalizeBrainGenerationWork({
   apiClient,
   durationMs,
@@ -7770,55 +8013,97 @@ ${toolResult.stderr}`);
     generationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
   }
   const finalStatus = artifacts ? "completed" : "failed";
-  const updatedToolSession = await finalizeToolSession({
-    apiClient,
-    projectId,
-    status: finalStatus,
-    runnerId,
-    workItemId: workItem.workItemId,
-    stdout: toolResult.stdout,
-    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
-    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
-    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
-    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
-    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
-  });
   const sessionTelemetry = {
     sessionPolicy: sessionContext.policy,
     sessionDecision: sessionContext.decision,
     sessionDecisionReason: sessionContext.reason,
-    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
-    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
+    ...sessionContext.toolSession ? { toolSessionId: sessionContext.toolSession.toolSessionId } : {},
+    ...sessionContext.toolSession?.sessionGroupKey ? { sessionGroupKey: sessionContext.toolSession.sessionGroupKey } : {}
   };
   if (artifacts) {
     const completionMessage = workItem.workKind === "planRevision" ? `${toolName} returned a revised plan for review.` : `${toolName} generated ${artifacts.length} brain artifact${artifacts.length === 1 ? "" : "s"}.`;
-    const result = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+    const resultMutation = {
       status: "completed",
       runnerId,
-      idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+      idempotencyKey: `generation_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`,
       artifacts,
       tool: toolName,
       durationMs,
       ...sessionTelemetry,
       message: completionMessage
+    };
+    const entry = createBrainGenerationFinalizationEntry({
+      accountId: workItem.accountId,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      workItemId: workItem.workItemId,
+      workKind: brainGenerationFinalizationWorkKind(workItem.workKind),
+      attempt: workItem.attempt,
+      idempotencyKey: resultMutation.idempotencyKey,
+      result: resultMutation
     });
+    await upsertBrainGenerationFinalizationEntry(entry);
+    const replay = await submitBrainGenerationFinalizationEntry(apiClient, entry);
+    if (replay.status === "failed") {
+      if (!replay.retryable) {
+        throw new Error(replay.message);
+      }
+      return { status: "failed", exitCode: 1 };
+    }
+    const toolSessionSettlement = await Promise.allSettled([
+      finalizeToolSession({
+        apiClient,
+        projectId,
+        status: finalStatus,
+        runnerId,
+        workItemId: workItem.workItemId,
+        stdout: toolResult.stdout,
+        ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+        ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+        ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+        ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+        ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+      })
+    ]);
+    logRejectedSettlements("finalize generation tool session", toolSessionSettlement);
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
       status: "completed",
       summary: completionMessage,
-      idempotencyKey: `runner_milestone_generation_completed_${workItem.workItemId}_${result.workItem.idempotencyKey}`,
-      metadata: { tool: toolName, durationMs, artifactCount: result.documents.length, verificationSummary: "Generated artifacts were accepted by the Amistio API for review." }
+      idempotencyKey: `runner_milestone_generation_completed_${workItem.workItemId}_${entry.idempotencyKey}`,
+      metadata: { tool: toolName, durationMs, artifactCount: replay.documentCount, verificationSummary: "Generated artifacts were accepted by the Amistio API for review." }
     });
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
-    console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `Generated ${result.documents.length} brain artifact${result.documents.length === 1 ? "" : "s"} for review.`);
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)).catch((error) => {
+      console.error(`send generation completion heartbeat failed: ${errorMessage3(error)}`);
+    });
+    console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `Generated ${replay.documentCount} brain artifact${replay.documentCount === 1 ? "" : "s"} for review.`);
     return { status: "completed", exitCode: 0 };
   }
+  const updatedToolSession = await finalizeToolSession({
+    apiClient,
+    projectId,
+    status: finalStatus,
+    runnerId,
+    workItemId: workItem.workItemId,
+    stdout: toolResult.stdout,
+    ...sessionContext.toolSession ? { session: sessionContext.toolSession } : {},
+    ...toolResult.messageCount !== void 0 ? { messageCount: toolResult.messageCount } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+  });
+  const failedSessionTelemetry = {
+    ...sessionTelemetry,
+    ...updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {},
+    ...updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}
+  };
   const failedResult = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
     status: "failed",
     runnerId,
     idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
     tool: toolName,
     durationMs,
-    ...sessionTelemetry,
+    ...failedSessionTelemetry,
     message: `${toolName} did not produce valid brain artifacts.`,
     ...generationError ? { error: generationError } : {}
   });
@@ -7832,6 +8117,9 @@ ${toolResult.stderr}`);
   console.error(generationError ?? "Local runner generation failed.");
   return { status: "failed", exitCode: toolResult.exitCode || 1 };
 }
+function brainGenerationFinalizationWorkKind(workKind) {
+  return workKind === "planRevision" ? "planRevision" : "brainGeneration";
+}
 async function finalizeAssistantQuestionWork({
   apiClient,
   durationMs,
@@ -8750,10 +9038,10 @@ function parseReasoningEffort(value) {
   throw new Error(`Expected reasoning effort auto, low, medium, high, or xhigh; received ${value}.`);
 }
 function inferRepoName(root) {
-  return path15.basename(path15.resolve(root)) || "repository";
+  return path16.basename(path16.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-  return createHash7("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+  return createHash8("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
 }
 function defaultApiUrl() {
   const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
@@ -9011,7 +9299,7 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
   return {
     version: CLI_VERSION,
     mode,
-    hostname: os7.hostname(),
+    hostname: os8.hostname(),
     ...runnerIsolationCapabilityMetadata(),
     resourceUsage: sampleCurrentRunnerResourceUsage(),
     ...toolConfig?.capabilities ? { capabilities: toolConfig.capabilities } : {},
@@ -9034,7 +9322,7 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
   };
 }
 function runnerMachineId() {
-  return createHash7("sha256").update(`${os7.hostname()}:${os7.platform()}:${os7.arch()}`).digest("hex").slice(0, 20);
+  return createHash8("sha256").update(`${os8.hostname()}:${os8.platform()}:${os8.arch()}`).digest("hex").slice(0, 20);
 }
 async function delay(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));