@plannotator/opencode 0.27.10 → 0.27.11

package/dist/embedded.js

@@ -443,6 +443,13 @@ function resolveAnnotateHistory(config) {
   }
   return coerceConfigBoolean(config.annotateHistory, true);
 }
+function resolveFeedbackHistory(config) {
+  const envVal = process.env.PLANNOTATOR_FEEDBACK_HISTORY;
+  if (envVal !== undefined) {
+    return envVal === "1" || envVal.toLowerCase() === "true";
+  }
+  return coerceConfigBoolean(config.feedbackHistory, true);
+}
 function resolveGuideHistory(config) {
   const envVal = process.env.PLANNOTATOR_GUIDE_HISTORY;
   if (envVal !== undefined) {
@@ -2045,14 +2052,210 @@ var init_config2 = __esm(() => {
   init_config();
 });
 
-// ../../packages/shared/improvement-hooks.ts
+// ../../packages/shared/feedback-archive.ts
+import { appendFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
+function normalizeFeedbackProject(project2) {
+  if (!project2)
+    return "_unknown";
+  if (project2 === "_unknown")
+    return project2;
+  return sanitizeTag(project2) ?? "_unknown";
+}
+function deriveFeedbackProject(cwd) {
+  if (!cwd)
+    return "_unknown";
+  return extractDirName(cwd) ?? extractRepoName(cwd) ?? "_unknown";
+}
+function feedbackProjectDir(project2) {
+  return join7(getPlannotatorDataDir(), "feedback", normalizeFeedbackProject(project2));
+}
+function stamp(now) {
+  return now.toISOString().replace(/[:.]/g, "-");
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function normalizeAnnotation(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return {};
+  const a = raw;
+  const record = {};
+  const id = asString(a.id);
+  if (id)
+    record.id = id;
+  const type = asString(a.type);
+  if (type)
+    record.type = type;
+  const text = asString(a.text);
+  if (text)
+    record.text = text;
+  const originalText = asString(a.originalText) ?? asString(a.selectedText) ?? asString(a.tokenText);
+  if (originalText)
+    record.originalText = originalText;
+  const file = asString(a.filePath) ?? asString(a.file);
+  if (file)
+    record.file = file;
+  const lineStart = asNumber(a.lineStart);
+  if (lineStart !== undefined)
+    record.lineStart = lineStart;
+  const lineEnd = asNumber(a.lineEnd);
+  if (lineEnd !== undefined)
+    record.lineEnd = lineEnd;
+  const side = asString(a.side);
+  if (side)
+    record.side = side;
+  const blockId = asString(a.blockId);
+  if (blockId)
+    record.blockId = blockId;
+  const diffContext = asString(a.diffContext);
+  if (diffContext)
+    record.diffContext = diffContext;
+  const severity = asString(a.severity);
+  if (severity)
+    record.severity = severity;
+  const inReplyTo = asString(a.inReplyTo);
+  if (inReplyTo)
+    record.inReplyTo = inReplyTo;
+  const source = asString(a.source);
+  if (source)
+    record.source = source;
+  const author = asString(a.author);
+  if (author)
+    record.author = author;
+  if (Array.isArray(a.images) && a.images.length > 0)
+    record.images = a.images.length;
+  return record;
+}
+function renderFeedbackRecordMarkdown(record) {
+  const lines = [`# ${SURFACE_TITLES[record.surface] ?? "Feedback"}`, ""];
+  lines.push(`- Submitted: ${record.ts}`);
+  lines.push(`- Surface: ${record.surface}`);
+  lines.push(`- Decision: ${record.decision}`);
+  lines.push(`- Project: ${record.project}`);
+  if (record.origin)
+    lines.push(`- Origin: ${record.origin}`);
+  const target = record.target;
+  if (target?.filePath)
+    lines.push(`- File: ${target.filePath}`);
+  if (target?.url)
+    lines.push(`- URL: ${target.url}`);
+  if (target?.slug) {
+    lines.push(`- Plan: ${target.slug}${target.planVersion ? ` (version ${target.planVersion})` : ""}`);
+  }
+  if (target?.planVersionFile)
+    lines.push(`- Plan version file: ${target.planVersionFile}`);
+  const review = target?.review;
+  if (review) {
+    const bits = [review.diffType, review.base ? `base ${review.base}` : null, review.gitRef ? `ref ${review.gitRef}` : null].filter(Boolean).join(", ");
+    if (bits)
+      lines.push(`- Diff: ${bits}`);
+    if (review.cwd)
+      lines.push(`- Repository: ${review.cwd}`);
+    if (review.pr)
+      lines.push(`- Pull request: ${review.pr.provider} ${review.pr.repo}#${review.pr.number}`);
+  }
+  lines.push(`- Annotations: ${record.counts.annotations}${record.counts.external > 0 ? ` (${record.counts.external} external)` : ""}`);
+  lines.push("", "---", "");
+  lines.push(record.feedback && record.feedback.trim() ? record.feedback : "_No feedback text submitted._");
+  lines.push("");
+  return lines.join(`
+`);
+}
+function appendFeedbackRecord(input) {
+  try {
+    const now = input.now ?? new Date;
+    const project2 = normalizeFeedbackProject(input.project);
+    const feedback = typeof input.feedback === "string" ? input.feedback : "";
+    const rawAnnotations = Array.isArray(input.annotations) ? input.annotations : [];
+    const annotations = rawAnnotations.map(normalizeAnnotation);
+    const counts = {
+      annotations: annotations.length,
+      external: annotations.filter((a) => a.source !== undefined).length,
+      images: annotations.reduce((sum, a) => sum + (a.images ?? 0), 0)
+    };
+    const hasContent = feedback.trim().length > 0 || annotations.length > 0;
+    const record = {
+      v: FEEDBACK_RECORD_VERSION,
+      ts: now.toISOString(),
+      client: FEEDBACK_RECORD_CLIENT,
+      project: project2,
+      ...input.origin ? { origin: input.origin } : {},
+      surface: input.surface,
+      decision: input.decision,
+      ...input.target ? { target: input.target } : {},
+      ...feedback ? { feedback } : {},
+      ...annotations.length > 0 ? { annotations } : {},
+      counts
+    };
+    const projectDir = feedbackProjectDir(project2);
+    mkdirSync4(projectDir, { recursive: true });
+    if (hasContent) {
+      const recordsDir = join7(projectDir, "records");
+      mkdirSync4(recordsDir, { recursive: true });
+      const base = `${stamp(now)}-${input.surface}-${input.decision}`;
+      let name = `${base}.md`;
+      const body = renderFeedbackRecordMarkdown(record);
+      for (let n = 2;; n++) {
+        try {
+          writeFileSync3(join7(recordsDir, name), body, { encoding: "utf-8", flag: "wx" });
+          break;
+        } catch (err) {
+          if (err?.code !== "EEXIST")
+            throw err;
+          if (n > 100) {
+            throw new Error(`sidecar name collision exceeded 100 attempts for ${base}.md (clock stuck or runaway writer)`);
+          }
+          name = `${base}-${n}.md`;
+        }
+      }
+      record.recordFile = `records/${name}`;
+    }
+    const indexPath = join7(projectDir, "index.jsonl");
+    appendFileSync(indexPath, `${JSON.stringify(record)}
+`, "utf-8");
+    return indexPath;
+  } catch (error) {
+    console.error(`[plannotator] warning: could not archive submitted feedback (${error instanceof Error ? error.message : String(error)}); keeping the annotation draft as the recovery copy`);
+    return null;
+  }
+}
+function countChangedFiles(patch) {
+  if (!patch)
+    return 0;
+  const files = new Set;
+  const re = /^diff --git a\/(.+?) b\/(.+)$/gm;
+  let match;
+  while ((match = re.exec(patch)) !== null)
+    files.add(match[2]);
+  return files.size;
+}
+var FEEDBACK_RECORD_VERSION = 1, FEEDBACK_RECORD_CLIENT = "plannotator", SURFACE_TITLES;
+var init_feedback_archive = __esm(() => {
+  init_data_dir();
+  init_project();
+  SURFACE_TITLES = {
+    plan: "Plan review feedback",
+    review: "Code review feedback",
+    annotate: "Annotate feedback",
+    "annotate-url": "Annotate feedback (URL)",
+    "annotate-app": "Annotate feedback (live app)",
+    "annotate-last": "Annotate feedback (agent message)",
+    "annotate-folder": "Annotate feedback (folder)"
+  };
+});
+
+// ../../packages/shared/improvement-hooks.ts
+import { join as join8 } from "path";
 import { readFileSync as readFileSync4, statSync as statSync4 } from "fs";
 function getImprovementHookExpectedPath(hookName) {
   const entry = KNOWN_HOOKS[hookName];
   if (!entry)
     return null;
-  return join7(HOOKS_BASE_DIR, entry.path);
+  return join8(HOOKS_BASE_DIR, entry.path);
 }
 function fileExists2(path) {
   try {
@@ -2079,18 +2282,18 @@ function readImprovementHook(hookName) {
   const entry = KNOWN_HOOKS[hookName];
   if (!entry)
     return null;
-  const newPath = join7(HOOKS_BASE_DIR, entry.path);
+  const newPath = join8(HOOKS_BASE_DIR, entry.path);
   if (fileExists2(newPath)) {
     return tryReadHookFile(newPath, hookName);
   }
-  const legacyFilePath = join7(LEGACY_BASE_DIR, entry.legacyPath);
+  const legacyFilePath = join8(LEGACY_BASE_DIR, entry.legacyPath);
   return tryReadHookFile(legacyFilePath, hookName);
 }
 var DATA_DIR2, HOOKS_BASE_DIR, LEGACY_BASE_DIR, MAX_FILE_SIZE, KNOWN_HOOKS;
 var init_improvement_hooks = __esm(() => {
   init_data_dir();
   DATA_DIR2 = getPlannotatorDataDir();
-  HOOKS_BASE_DIR = join7(DATA_DIR2, "hooks");
+  HOOKS_BASE_DIR = join8(DATA_DIR2, "hooks");
   LEGACY_BASE_DIR = DATA_DIR2;
   MAX_FILE_SIZE = 50 * 1024;
   KNOWN_HOOKS = {
@@ -2975,7 +3178,7 @@ var init_qr = __esm(() => {
 });
 
 // ../../packages/server/image.ts
-import { resolve as resolve4, join as join8 } from "path";
+import { resolve as resolve4, join as join9 } from "path";
 import { tmpdir } from "os";
 function getExtension(filePath) {
   const lastDot = filePath.lastIndexOf(".");
@@ -3023,26 +3226,26 @@ var init_image = __esm(() => {
     "tif",
     "avif"
   ]);
-  UPLOAD_DIR = join8(tmpdir(), "plannotator");
+  UPLOAD_DIR = join9(tmpdir(), "plannotator");
 });
 
 // ../../packages/shared/draft.ts
-import { join as join9 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
 import { createHash } from "crypto";
 function getDraftDir() {
-  const dir = join9(getPlannotatorDataDir(), "drafts");
-  mkdirSync4(dir, { recursive: true });
+  const dir = join10(getPlannotatorDataDir(), "drafts");
+  mkdirSync5(dir, { recursive: true });
   return dir;
 }
 function contentHash(content) {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 function draftPath(key) {
-  return join9(getDraftDir(), `${key}.json`);
+  return join10(getDraftDir(), `${key}.json`);
 }
 function tombstonePath(key) {
-  return join9(getDraftDir(), `${key}.deleted.json`);
+  return join10(getDraftDir(), `${key}.deleted.json`);
 }
 function readGeneration(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
@@ -3078,7 +3281,7 @@ function getDraftGeneration(key) {
 }
 function writeTombstoneGeneration(key, draftGeneration) {
   const filePath = tombstonePath(key);
-  writeFileSync3(filePath, JSON.stringify({ draftGeneration }), "utf-8");
+  writeFileSync4(filePath, JSON.stringify({ draftGeneration }), "utf-8");
 }
 function clearTombstone(key) {
   const filePath = tombstonePath(key);
@@ -3099,7 +3302,7 @@ function saveDraft(key, data) {
   }
   const finalPath = draftPath(key);
   const tmpPath = `${finalPath}.tmp`;
-  writeFileSync3(tmpPath, JSON.stringify(data), "utf-8");
+  writeFileSync4(tmpPath, JSON.stringify(data), "utf-8");
   renameSync2(tmpPath, finalPath);
   if (draftGeneration === null) {
     clearTombstone(key);
@@ -3196,27 +3399,27 @@ import {
   closeSync as closeSync2,
   existsSync as existsSync8,
   fstatSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync as openSync2,
   readdirSync as readdirSync3,
   readFileSync as readFileSync6,
   readSync,
   realpathSync as realpathSync2,
   statSync as statSync5,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function resolveGlobalSkillRoots() {
   const home = process.env.HOME?.trim() || homedir3();
-  const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join10(home, ".claude");
-  const codexHome = process.env.CODEX_HOME?.trim() || join10(home, ".codex");
-  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join10(home, ".config");
+  const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join11(home, ".claude");
+  const codexHome = process.env.CODEX_HOME?.trim() || join11(home, ".codex");
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join11(home, ".config");
   const candidates = [
-    { dir: join10(claudeHome, "skills"), root: "claude" },
-    { dir: join10(codexHome, "skills"), root: "codex" },
-    { dir: join10(home, ".agents", "skills"), root: "universal" },
-    { dir: join10(configHome, "agents", "skills"), root: "universal" }
+    { dir: join11(claudeHome, "skills"), root: "claude" },
+    { dir: join11(codexHome, "skills"), root: "codex" },
+    { dir: join11(home, ".agents", "skills"), root: "universal" },
+    { dir: join11(configHome, "agents", "skills"), root: "universal" }
   ];
   const seen = new Set;
   const roots = [];
@@ -3236,7 +3439,7 @@ function resolveGlobalSkillRoots() {
 }
 function hasSkillMd(dir) {
   try {
-    return statSync5(join10(dir, "SKILL.md")).isFile();
+    return statSync5(join11(dir, "SKILL.md")).isFile();
   } catch {
     return false;
   }
@@ -3256,7 +3459,7 @@ function listSubdirs(dir) {
       return true;
     if (e.isSymbolicLink()) {
       try {
-        return statSync5(join10(dir, e.name)).isDirectory();
+        return statSync5(join11(dir, e.name)).isDirectory();
       } catch {
         return false;
       }
@@ -3273,7 +3476,7 @@ function discoverSkills() {
     byName.set(name, {
       name,
       sourcePath: dir,
-      skillMdPath: join10(dir, "SKILL.md"),
+      skillMdPath: join11(dir, "SKILL.md"),
       root
     });
   };
@@ -3281,13 +3484,13 @@ function discoverSkills() {
     if (!existsSync8(rootDir))
       continue;
     for (const childName of listSubdirs(rootDir)) {
-      const childDir = join10(rootDir, childName);
+      const childDir = join11(rootDir, childName);
       if (hasSkillMd(childDir)) {
         add(childDir, root);
         continue;
       }
       for (const grandName of listSubdirs(childDir)) {
-        const grandDir = join10(childDir, grandName);
+        const grandDir = join11(childDir, grandName);
         if (hasSkillMd(grandDir))
           add(grandDir, root);
       }
@@ -3438,7 +3641,7 @@ function readReferenceSkillContent(name) {
   };
 }
 function readCuratedSkillNames() {
-  const path2 = join10(getPlannotatorDataDir(), "review-skills.json");
+  const path2 = join11(getPlannotatorDataDir(), "review-skills.json");
   if (!existsSync8(path2))
     return null;
   let parsed;
@@ -3481,8 +3684,8 @@ function enableReviewSkill(name) {
   current.add(name);
   const enabled = [...current];
   const dir = getPlannotatorDataDir();
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync4(join10(dir, "review-skills.json"), JSON.stringify({ version: 1, enabled }, null, 2) + `
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync5(join11(dir, "review-skills.json"), JSON.stringify({ version: 1, enabled }, null, 2) + `
 `);
   return { enabled };
 }
@@ -3554,7 +3757,7 @@ var init_review_skill_loader = __esm(() => {
 });
 
 // ../../packages/server/shared-handlers.ts
-import { appendFileSync, mkdirSync as mkdirSync6 } from "fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "fs";
 import { dirname } from "path";
 function normalizeDraftGeneration(value) {
   if (typeof value !== "number")
@@ -3617,7 +3820,7 @@ async function handleUpload(req) {
     if (!extResult.valid) {
       return Response.json({ error: extResult.error }, { status: 400 });
     }
-    mkdirSync6(UPLOAD_DIR, { recursive: true });
+    mkdirSync7(UPLOAD_DIR, { recursive: true });
     const tempPath = `${UPLOAD_DIR}/${crypto.randomUUID()}.${extResult.ext}`;
     await Bun.write(tempPath, file);
     return Response.json({ path: tempPath, originalName: file.name });
@@ -3696,8 +3899,8 @@ function handleFavicon() {
   });
 }
 function writeServerReadyMetadata(readyFile, metadata) {
-  mkdirSync6(dirname(readyFile), { recursive: true });
-  appendFileSync(readyFile, `${JSON.stringify(metadata)}
+  mkdirSync7(dirname(readyFile), { recursive: true });
+  appendFileSync2(readyFile, `${JSON.stringify(metadata)}
 `, "utf8");
 }
 function isCodexDesktopHost(env = process.env) {
@@ -20458,14 +20661,14 @@ function process2(parentNode) {
     } else if (node.nodeType === 1) {
       replacement = replacementForNode.call(self2, node);
     }
-    return join11(output, replacement);
+    return join12(output, replacement);
   }, "");
 }
 function postProcess(output) {
   var self2 = this;
   this.rules.forEach(function(rule) {
     if (typeof rule.append === "function") {
-      output = join11(output, rule.append(self2.options));
+      output = join12(output, rule.append(self2.options));
     }
   });
   return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -20478,7 +20681,7 @@ function replacementForNode(node) {
     content = content.trim();
   return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
 }
-function join11(output, replacement) {
+function join12(output, replacement) {
   var s1 = trimTrailingNewlines(output);
   var s2 = trimLeadingNewlines(replacement);
   var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -21291,9 +21494,9 @@ import {
   renameSync as renameSync3,
   statSync as statSync7,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { basename, dirname as dirname2, join as join12 } from "path";
+import { basename, dirname as dirname2, join as join13 } from "path";
 function hashSourceBytes(bytes) {
   return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
 }
@@ -21379,7 +21582,7 @@ function resolveFolderSourceFileForSave(filePath, folderPath) {
     const realParent = realpathSync4(dirname2(candidate));
     if (!isWithinProjectRoot(realParent, root2))
       return null;
-    const resolvedMissingLeaf = join12(realParent, basename(candidate));
+    const resolvedMissingLeaf = join13(realParent, basename(candidate));
     if (!isWithinProjectRoot(resolvedMissingLeaf, root2))
       return null;
     return resolvedMissingLeaf;
@@ -21441,7 +21644,7 @@ function createSourceSaveCapabilityFromText(scope, filePath, text, folderPath) {
       return enabledSourceSave(scope, real, sourceFileSnapshotFromText(text));
     }
     const realParent = realpathSync4(dirname2(resolved));
-    return enabledSourceSave(scope, join12(realParent, basename(resolved)), sourceFileSnapshotFromText(text));
+    return enabledSourceSave(scope, join13(realParent, basename(resolved)), sourceFileSnapshotFromText(text));
   } catch {
     return disabledSourceSave("missing-file");
   }
@@ -21534,7 +21737,7 @@ function saveSourceFileAtomic(filePath, text, baseHash, options = {}) {
     }
     try {
       const realParent = realpathSync4(dirname2(filePath));
-      filePath = join12(realParent, basename(filePath));
+      filePath = join13(realParent, basename(filePath));
       if (allowedRoot && !isWithinProjectRoot(filePath, allowedRoot)) {
         return {
           ok: false,
@@ -21573,9 +21776,9 @@ function saveSourceFileAtomic(filePath, text, baseHash, options = {}) {
   }
   const output = applySourceEolPolicy(text, outputEol);
   const dir = dirname2(filePath);
-  const tmp = join12(dir, `.plannotator-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);
+  const tmp = join13(dir, `.plannotator-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);
   try {
-    writeFileSync5(tmp, output, { encoding: "utf8", mode });
+    writeFileSync6(tmp, output, { encoding: "utf8", mode });
     if (mode !== undefined)
       chmodSync(tmp, mode);
     if (recreateMissingBase) {
@@ -42529,7 +42732,7 @@ var init_ssr = __esm(() => {
 // ../../packages/server/reference-handlers.ts
 import { existsSync as existsSync10, statSync as statSync8 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import { join as join13, relative as relative2, resolve as resolve6 } from "path";
+import { join as join14, relative as relative2, resolve as resolve6 } from "path";
 function getAllowedRootPaths(options) {
   const rawRoots = options?.rootPaths?.length ? options.rootPaths : [options?.rootPath ?? process.cwd()];
   const roots = [];
@@ -42945,7 +43148,7 @@ async function walkFileBrowserFiles(dir, root3, state) {
   for (const entry of entries) {
     if (state.truncated)
       return;
-    const fullPath = join13(dir, entry.name);
+    const fullPath = join14(dir, entry.name);
     const relativePath = relative2(root3, fullPath).replace(/\\/g, "/");
     if (entry.isDirectory()) {
       if (isFileBrowserExcludedPath(relativePath))
@@ -76866,7 +77069,8 @@ class OpenCodeProvider {
   server = null;
   client = null;
   startPromise = null;
-  lastAttachError = null;
+  exitHandler = null;
+  startEpoch = 0;
   constructor(config) {
     this.config = config;
   }
@@ -76880,50 +77084,40 @@ class OpenCodeProvider {
     return this.startPromise;
   }
   async doStart() {
-    this.lastAttachError = null;
+    const epoch = this.startEpoch;
     const { createOpencodeServer: createOpencodeServer2, createOpencodeClient: createOpencodeClient2 } = await getSDK();
-    const attachedClient = await this.tryAttachExistingServer(createOpencodeClient2);
-    if (attachedClient) {
-      this.client = attachedClient;
-      return;
+    const server2 = await createOpencodeServer2({
+      hostname: this.config.hostname ?? "127.0.0.1",
+      port: this.config.port ?? 0,
+      timeout: 15000
+    });
+    const exitHandler = () => {
+      try {
+        server2.close();
+      } catch {}
+    };
+    process.once("exit", exitHandler);
+    const reap = () => {
+      process.removeListener("exit", exitHandler);
+      try {
+        server2.close();
+      } catch {}
+    };
+    if (epoch !== this.startEpoch) {
+      reap();
+      throw new Error("OpenCode provider was disposed during startup.");
     }
     try {
-      this.server = await createOpencodeServer2({
-        hostname: this.config.hostname ?? "127.0.0.1",
-        ...this.config.port != null && { port: this.config.port },
-        timeout: 15000
+      this.client = createOpencodeClient2({
+        baseUrl: server2.url,
+        directory: this.config.cwd ?? process.cwd()
       });
     } catch (err) {
-      const spawnMessage = err instanceof Error ? err.message : String(err);
-      if (this.lastAttachError) {
-        throw new Error(`${this.lastAttachError}
-Fallback startup also failed: ${spawnMessage}`);
-      }
+      reap();
       throw err;
     }
-    this.client = createOpencodeClient2({
-      baseUrl: this.server.url,
-      directory: this.config.cwd ?? process.cwd()
-    });
-  }
-  async tryAttachExistingServer(createOpencodeClient2) {
-    const cwd = this.config.cwd ?? process.cwd();
-    const baseUrl = `http://${this.config.hostname ?? "127.0.0.1"}:${this.config.port ?? 4096}`;
-    const client3 = createOpencodeClient2({
-      baseUrl,
-      directory: cwd
-    });
-    try {
-      await client3.config.get({
-        throwOnError: true,
-        signal: AbortSignal.timeout(1000)
-      });
-      return client3;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.lastAttachError = `Failed to attach to existing OpenCode server at ${baseUrl}: ${message}`;
-      return null;
-    }
+    this.server = server2;
+    this.exitHandler = exitHandler;
   }
   getClient() {
     if (!this.client) {
@@ -76985,6 +77179,11 @@ Fallback startup also failed: ${spawnMessage}`);
     });
   }
   dispose() {
+    this.startEpoch++;
+    if (this.exitHandler) {
+      process.removeListener("exit", this.exitHandler);
+      this.exitHandler = null;
+    }
     if (this.server) {
       this.server.close();
       this.server = null;
@@ -77292,17 +77491,17 @@ async function createAIRuntime(options = {}) {
     }
   } catch {}
   try {
-    const { OpenCodeProvider: OpenCodeProvider2 } = await Promise.resolve().then(() => (init_opencode_sdk(), exports_opencode_sdk));
+    await Promise.resolve().then(() => (init_opencode_sdk(), exports_opencode_sdk));
     const opencodePath = Bun.which("opencode");
     if (opencodePath) {
       const provider = await createProvider({
         type: "opencode-sdk",
         cwd
       });
-      if (provider instanceof OpenCodeProvider2) {
-        modelDiscovery.push(provider.fetchModels().catch(() => {}));
+      const providerId = registry2.register(provider);
+      if ("fetchModels" in provider) {
+        providerInitializers.set(providerId, createBestEffortOnce(() => provider.fetchModels()));
       }
-      registry2.register(provider);
     }
   } catch {}
   const endpoints = createAIEndpoints({
@@ -77427,6 +77626,26 @@ async function startPlannotatorServer(options) {
   } else {
     decisionPromise = new Promise(() => {});
   }
+  const archivePlanDecision = (decision, feedback) => {
+    if (mode === "archive")
+      return;
+    if (!resolveFeedbackHistory(loadConfig()))
+      return;
+    appendFeedbackRecord({
+      project: project2,
+      origin,
+      surface: "plan",
+      decision,
+      target: {
+        slug,
+        ...versionInfo.version > 0 ? {
+          planVersion: versionInfo.version,
+          planVersionFile: getPlanVersionPath(project2, slug, versionInfo.version) ?? undefined
+        } : {}
+      },
+      feedback
+    });
+  };
   const server2 = await startBunServerOnAvailablePort((port2) => Bun.serve({
     hostname: getServerHostname(),
     port: port2,
@@ -77691,6 +77910,7 @@ async function startPlannotatorServer(options) {
           }
           savedPath = saveFinalSnapshot(slug, "approved", plan, annotations, planSaveCustomPath);
         }
+        archivePlanDecision(typeof feedback === "string" && feedback.trim() ? "approved-with-notes" : "approved", feedback);
         deleteDraft(draftKey, draftGeneration);
         const effectivePermissionMode = requestedPermissionMode || permissionMode;
         resolveDecision({ approved: true, feedback, savedPath, agentSwitch, permissionMode: effectivePermissionMode });
@@ -77715,6 +77935,7 @@ async function startPlannotatorServer(options) {
           saveAnnotations(slug, feedback, planSaveCustomPath);
           savedPath = saveFinalSnapshot(slug, "denied", plan, feedback, planSaveCustomPath);
         }
+        archivePlanDecision("denied", feedback);
         deleteDraft(draftKey, draftGeneration);
         resolveDecision({ approved: false, feedback, savedPath });
         return Response.json({ ok: true, savedPath });
@@ -77772,6 +77993,7 @@ var init_server2 = __esm(() => {
   init_repo();
   init_project2();
   init_config2();
+  init_feedback_archive();
   init_favicon2();
   init_improvement_hooks();
   init_shared_handlers();
@@ -80231,7 +80453,7 @@ var init_gitbutler_core = __esm(() => {
 // ../../packages/shared/vcs-core.ts
 import { mkdtemp } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { isAbsolute as isAbsolute6, join as join16, relative as relative6, resolve as resolve11 } from "path";
+import { isAbsolute as isAbsolute6, join as join17, relative as relative6, resolve as resolve11 } from "path";
 import { rmSync as rmSync2 } from "fs";
 function selectNearestProvider(candidates, cwd) {
   if (candidates.length === 0)
@@ -80612,8 +80834,8 @@ function removeDirectoryBestEffort(path2) {
   } catch {}
 }
 async function createSyntheticSnapshot(runtime, sourceCwd, baseCommit, patches) {
-  const tempRoot = await mkdtemp(join16(tmpdir2(), "plannotator-review-snapshot-"));
-  const snapshotCwd = join16(tempRoot, "repo");
+  const tempRoot = await mkdtemp(join17(tmpdir2(), "plannotator-review-snapshot-"));
+  const snapshotCwd = join17(tempRoot, "repo");
   const cleanup = () => removeDirectoryBestEffort(tempRoot);
   try {
     await git(runtime, sourceCwd, ["clone", "--shared", "--no-checkout", "--quiet", "--", sourceCwd, snapshotCwd]);
@@ -80718,8 +80940,8 @@ async function materializeJjSnapshot(jjRuntime, gitRuntime, options) {
   const fromRevision = await resolveJjSnapshotEndpoint(jjRuntime, endpoints.from, options.cwd);
   const toRevision = await resolveJjSnapshotEndpoint(jjRuntime, endpoints.to, options.cwd);
   const filesets = options.includedExtensions.map((extension) => `root-glob-i:"**/*${extension}"`);
-  const tempRoot = await mkdtemp(join16(tmpdir2(), "plannotator-review-jj-snapshot-"));
-  const snapshotCwd = join16(tempRoot, "repo");
+  const tempRoot = await mkdtemp(join17(tmpdir2(), "plannotator-review-jj-snapshot-"));
+  const snapshotCwd = join17(tempRoot, "repo");
   const cleanup = () => removeDirectoryBestEffort(tempRoot);
   try {
     await git(gitRuntime, tempRoot, ["init", "--quiet", "--", snapshotCwd]);
@@ -81438,9 +81660,9 @@ var init_worktree_pool = () => {};
 // ../../packages/shared/semantic-diff.ts
 import { spawn as spawn4 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { delimiter, join as join17 } from "path";
+import { delimiter, join as join18 } from "path";
 function defaultRunCommand(command, args, options = {}) {
   return new Promise((resolveResult) => {
     let settled = false;
@@ -81531,17 +81753,17 @@ function semBinaryName(platform) {
   return platform === "win32" ? "sem.exe" : "sem";
 }
 function getManagedSemBinaryPath(dataDir = getPlannotatorDataDir(), platform = process.platform) {
-  return join17(dataDir, "vendor", "sem", PLANNOTATOR_SEM_VERSION, semBinaryName(platform));
+  return join18(dataDir, "vendor", "sem", PLANNOTATOR_SEM_VERSION, semBinaryName(platform));
 }
 function getSemanticDiffScratchCwd(dataDir = getPlannotatorDataDir()) {
-  const primary = join17(dataDir, "semantic-diff", "patch-only");
+  const primary = join18(dataDir, "semantic-diff", "patch-only");
   try {
-    mkdirSync8(primary, { recursive: true });
+    mkdirSync9(primary, { recursive: true });
     return primary;
   } catch {
-    const fallback = join17(tmpdir3(), "plannotator-semantic-diff");
+    const fallback = join18(tmpdir3(), "plannotator-semantic-diff");
     try {
-      mkdirSync8(fallback, { recursive: true });
+      mkdirSync9(fallback, { recursive: true });
       return fallback;
     } catch {
       return tmpdir3();
@@ -81556,7 +81778,7 @@ function pathCandidates(runtime4) {
     const pathext = (runtime4.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").map((ext) => ext.trim()).filter(Boolean);
     for (const dir of (runtime4.env.PATH || "").split(runtime4.pathDelimiter)) {
       for (const ext of pathext) {
-        const candidate = join17(dir, `sem${ext.toLowerCase()}`);
+        const candidate = join18(dir, `sem${ext.toLowerCase()}`);
         if (runtime4.fileExists(candidate)) {
           return [{ command: candidate, source: "path", explicit: false }];
         }
@@ -83610,14 +83832,14 @@ var init_call_flow_pack_locks = __esm(() => {
 import { randomUUID } from "crypto";
 import {
   closeSync as closeSync4,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   openSync as openSync4,
   readFileSync as readFileSync10,
   rmSync as rmSync3,
   statSync as statSync12,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { dirname as dirname6, join as join18 } from "path";
+import { dirname as dirname6, join as join19 } from "path";
 function hasErrorCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
@@ -83628,7 +83850,7 @@ function removeOwnedLock(lockPath, token2) {
   } catch {}
 }
 async function withCallFlowInstallLock(work, options = {}) {
-  const lockPath = options.lockPath ?? join18(getPlannotatorDataDir(), "vendor", "call-flow", ".install.lock");
+  const lockPath = options.lockPath ?? join19(getPlannotatorDataDir(), "vendor", "call-flow", ".install.lock");
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
   const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -83636,12 +83858,12 @@ async function withCallFlowInstallLock(work, options = {}) {
   const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve12) => setTimeout(resolve12, milliseconds)));
   const token2 = `${process.pid}:${randomUUID()}`;
   const deadline = now() + waitTimeoutMs;
-  mkdirSync9(dirname6(lockPath), { recursive: true });
+  mkdirSync10(dirname6(lockPath), { recursive: true });
   while (true) {
     try {
       const descriptor = openSync4(lockPath, "wx", 384);
       try {
-        writeFileSync6(descriptor, token2, "utf8");
+        writeFileSync7(descriptor, token2, "utf8");
       } finally {
         closeSync4(descriptor);
       }
@@ -83961,24 +84183,24 @@ var init_call_flow_types = __esm(() => {
 
 // ../../packages/shared/call-flow.ts
 import { createHash as createHash4 } from "crypto";
-import { chmodSync as chmodSync2, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync13, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync2, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync11, readdirSync as readdirSync5, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync13, writeFileSync as writeFileSync8 } from "fs";
 import { mkdtemp as mkdtemp2 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename7, dirname as dirname7, isAbsolute as isAbsolute7, join as join19 } from "path";
+import { basename as basename7, dirname as dirname7, isAbsolute as isAbsolute7, join as join20 } from "path";
 import { spawn as spawn5, spawnSync as spawnSync5 } from "child_process";
 function getCallFlowManagedRuntimeDir(dataDir = getPlannotatorDataDir()) {
-  return join19(dataDir, "vendor", "call-flow", `calldiff-${CALLDIFF_VERSION}`);
+  return join20(dataDir, "vendor", "call-flow", `calldiff-${CALLDIFF_VERSION}`);
 }
 function getCallFlowGrammarCacheDir(runtimeDir) {
-  return join19(runtimeDir, "grammar-cache");
+  return join20(runtimeDir, "grammar-cache");
 }
 function getLanguagePackageRoot(runtimeDir, language) {
   if (language.kind === "core")
-    return join19(runtimeDir, "node_modules", "tree-sitter-typescript");
-  return join19(getCallFlowGrammarCacheDir(runtimeDir), "node_modules", ...(language.packageName ?? "").split("/"));
+    return join20(runtimeDir, "node_modules", "tree-sitter-typescript");
+  return join20(getCallFlowGrammarCacheDir(runtimeDir), "node_modules", ...(language.packageName ?? "").split("/"));
 }
 function getLanguageLockMarker(runtimeDir, id) {
-  return join19(getCallFlowGrammarCacheDir(runtimeDir), ".plannotator-locks", `${id}.json`);
+  return join20(getCallFlowGrammarCacheDir(runtimeDir), ".plannotator-locks", `${id}.json`);
 }
 function packHasCommittedLock(runtimeDir, id) {
   try {
@@ -83990,7 +84212,7 @@ function packHasCommittedLock(runtimeDir, id) {
 }
 function installDirHasCommittedPackLock(installDir, id) {
   try {
-    const installed = JSON.parse(readFileSync11(join19(installDir, "package-lock.json"), "utf8"));
+    const installed = JSON.parse(readFileSync11(join20(installDir, "package-lock.json"), "utf8"));
     return JSON.stringify(installed) === JSON.stringify(CALL_FLOW_PACK_LOCKS[id]);
   } catch {
     return false;
@@ -83999,21 +84221,21 @@ function installDirHasCommittedPackLock(installDir, id) {
 function isLanguageInstalled(runtimeDir, language, managed) {
   if (language.kind === "core")
     return true;
-  const packageRoot = managed ? getLanguagePackageRoot(runtimeDir, language) : join19(runtimeDir, "node_modules", ...(language.packageName ?? "").split("/"));
+  const packageRoot = managed ? getLanguagePackageRoot(runtimeDir, language) : join20(runtimeDir, "node_modules", ...(language.packageName ?? "").split("/"));
   if (readPackageVersion(packageRoot) !== language.packageVersion)
     return false;
   return !managed || packHasCommittedLock(runtimeDir, language.id);
 }
 function readPackageVersion(packageRoot) {
   try {
-    const parsed = JSON.parse(readFileSync11(join19(packageRoot, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync11(join20(packageRoot, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
     return null;
   }
 }
 function resolvePackageEntry(packageRoot) {
-  const entry = join19(packageRoot, "dist", "run.js");
+  const entry = join20(packageRoot, "dist", "run.js");
   return existsSync15(entry) ? entry : null;
 }
 function runtimeJson(value) {
@@ -84022,7 +84244,7 @@ function runtimeJson(value) {
 }
 function hasCommittedRuntimeLock(runtimeDir) {
   try {
-    const lock = JSON.parse(readFileSync11(join19(runtimeDir, "package-lock.json"), "utf8"));
+    const lock = JSON.parse(readFileSync11(join20(runtimeDir, "package-lock.json"), "utf8"));
     return JSON.stringify(lock) === JSON.stringify(package_lock_default);
   } catch {
     return false;
@@ -84046,7 +84268,7 @@ function findExecutable(name) {
     if (!directory)
       continue;
     for (const extension of extensions) {
-      const candidate = join19(directory, `${name}${extension}`);
+      const candidate = join20(directory, `${name}${extension}`);
       if (existsSync15(candidate))
         return candidate;
     }
@@ -84079,7 +84301,7 @@ async function resolveCallFlowRuntime() {
   }
   const runtimeDir = override ?? getCallFlowManagedRuntimeDir();
   const managed = !override;
-  const packageRoot = override ? runtimeDir : join19(runtimeDir, "node_modules", "calldiff");
+  const packageRoot = override ? runtimeDir : join20(runtimeDir, "node_modules", "calldiff");
   const version = readPackageVersion(packageRoot);
   const packageEntry = resolvePackageEntry(packageRoot);
   if (!version || !packageEntry) {
@@ -84093,7 +84315,7 @@ async function resolveCallFlowRuntime() {
     return { ok: false, reason: "version-mismatch", message: `CallDiff ${version} is installed; Plannotator requires ${CALLDIFF_VERSION}.` };
   }
   if (!override) {
-    const revisionPath = join19(runtimeDir, ".calldiff-revision");
+    const revisionPath = join20(runtimeDir, ".calldiff-revision");
     const installedRevision = existsSync15(revisionPath) ? readFileSync11(revisionPath, "utf8").trim() : "";
     if (installedRevision !== CALLDIFF_COMMIT) {
       return { ok: false, reason: "revision-mismatch", message: "The managed Call flow core is stale and needs reinstalling." };
@@ -84102,7 +84324,7 @@ async function resolveCallFlowRuntime() {
       return { ok: false, reason: "runtime-lock-mismatch", message: "The managed Call flow core dependency lock is stale and needs reinstalling." };
     }
   }
-  const invalidCore = CORE_RUNTIME_DEPENDENCIES.filter(({ packageName, version: expected }) => readPackageVersion(join19(runtimeDir, "node_modules", packageName)) !== expected);
+  const invalidCore = CORE_RUNTIME_DEPENDENCIES.filter(({ packageName, version: expected }) => readPackageVersion(join20(runtimeDir, "node_modules", packageName)) !== expected);
   if (invalidCore.length > 0) {
     return {
       ok: false,
@@ -84125,8 +84347,8 @@ async function resolveCallFlowRuntime() {
   };
 }
 function writeRuntimeManifest(runtimeDir) {
-  writeFileSync7(join19(runtimeDir, "package.json"), runtimeJson(package_default), "utf8");
-  writeFileSync7(join19(runtimeDir, "package-lock.json"), runtimeJson(package_lock_default), "utf8");
+  writeFileSync8(join20(runtimeDir, "package.json"), runtimeJson(package_default), "utf8");
+  writeFileSync8(join20(runtimeDir, "package-lock.json"), runtimeJson(package_lock_default), "utf8");
 }
 function removeDirectoryBestEffort2(path2) {
   try {
@@ -84164,7 +84386,7 @@ async function downloadVerifiedCallDiffArchive(destination, onStage) {
   if (integrity !== CALLDIFF_SOURCE_INTEGRITY) {
     throw new Error("CallDiff source archive failed its repository-pinned SHA-512 check.");
   }
-  writeFileSync7(destination, Buffer.concat(chunks, totalBytes));
+  writeFileSync8(destination, Buffer.concat(chunks, totalBytes));
 }
 async function downloadVerifiedLockArtifacts(lock, destination, onStage) {
   const packages = lock.packages;
@@ -84208,21 +84430,21 @@ async function downloadVerifiedLockArtifacts(lock, destination, onStage) {
     downloaded.push({ ...spec, bytes: Buffer.concat(chunks, artifactBytes) });
   }
   onStage("verifying");
-  mkdirSync10(destination, { recursive: true });
+  mkdirSync11(destination, { recursive: true });
   const verifiedPaths = [];
   for (const [index, artifact] of downloaded.entries()) {
     const integrity = `sha512-${createHash4("sha512").update(artifact.bytes).digest("base64")}`;
     if (integrity !== artifact.integrity) {
       throw new Error(`Pinned grammar package failed its repository-owned SHA-512 check: ${artifact.url}`);
     }
-    const path2 = join19(destination, `artifact-${index}.tgz`);
-    writeFileSync7(path2, artifact.bytes);
+    const path2 = join20(destination, `artifact-${index}.tgz`);
+    writeFileSync8(path2, artifact.bytes);
     verifiedPaths.push(path2);
   }
   return verifiedPaths;
 }
 async function seedVerifiedNpmCache(npmPath, installDir, artifacts) {
-  const cacheDir = join19(installDir, ".verified-npm-cache");
+  const cacheDir = join20(installDir, ".verified-npm-cache");
   for (const artifact of artifacts) {
     const cached2 = await runCommand(npmPath, [
       "cache",
@@ -84257,26 +84479,26 @@ function assertPathRemoved(path2, description) {
     throw new Error(`Call-flow pruning did not remove ${description}.`);
 }
 function prunePrebuilds(packageRoot) {
-  const prebuilds = join19(packageRoot, "prebuilds");
+  const prebuilds = join20(packageRoot, "prebuilds");
   if (!existsSync15(prebuilds))
     return;
   const currentPlatform = `${process.platform}-${process.arch}`;
   for (const entry of readdirSync5(prebuilds)) {
     if (entry !== currentPlatform)
-      removeDirectoryStrict(join19(prebuilds, entry));
+      removeDirectoryStrict(join20(prebuilds, entry));
   }
 }
 function assertNativePackagePruned(packageRoot) {
   for (const directory of PRUNED_PACKAGE_DIRECTORIES) {
     if (directory !== "build") {
-      assertPathRemoved(join19(packageRoot, directory), `${basename7(packageRoot)}/${directory}`);
+      assertPathRemoved(join20(packageRoot, directory), `${basename7(packageRoot)}/${directory}`);
     }
   }
-  assertPathRemoved(join19(packageRoot, "node_modules"), `${basename7(packageRoot)}/node_modules`);
+  assertPathRemoved(join20(packageRoot, "node_modules"), `${basename7(packageRoot)}/node_modules`);
   for (const file of ["binding.gyp", "grammar.js", "tree-sitter.json"]) {
-    assertPathRemoved(join19(packageRoot, file), `${basename7(packageRoot)}/${file}`);
+    assertPathRemoved(join20(packageRoot, file), `${basename7(packageRoot)}/${file}`);
   }
-  const prebuilds = join19(packageRoot, "prebuilds");
+  const prebuilds = join20(packageRoot, "prebuilds");
   if (existsSync15(prebuilds)) {
     const currentPlatform = `${process.platform}-${process.arch}`;
     const foreign = readdirSync5(prebuilds).filter((entry) => entry !== currentPlatform);
@@ -84288,7 +84510,7 @@ function assertNativePackagePruned(packageRoot) {
     if (!existsSync15(directory))
       return;
     for (const entry of readdirSync5(directory, { withFileTypes: true })) {
-      const path2 = join19(directory, entry.name);
+      const path2 = join20(directory, entry.name);
       if (entry.isDirectory())
         assertOnlyNativeAddons(path2);
       else if (!entry.isFile() || !entry.name.endsWith(".node")) {
@@ -84296,8 +84518,8 @@ function assertNativePackagePruned(packageRoot) {
       }
     }
   };
-  assertOnlyNativeAddons(join19(packageRoot, "build"));
-  const bindings = join19(packageRoot, "bindings", "node");
+  assertOnlyNativeAddons(join20(packageRoot, "build"));
+  const bindings = join20(packageRoot, "bindings", "node");
   if (existsSync15(bindings)) {
     const retainedSource = readdirSync5(bindings).find((file) => file === "binding.cc" || file.endsWith("_test.js"));
     if (retainedSource)
@@ -84315,7 +84537,7 @@ function pruneCallFlowNativePackage(packageRoot) {
     if (!existsSync15(directory))
       return;
     for (const entry of readdirSync5(directory, { withFileTypes: true })) {
-      const path2 = join19(directory, entry.name);
+      const path2 = join20(directory, entry.name);
       if (entry.isDirectory())
         collectBuiltAddons(path2);
       else if (entry.isFile() && entry.name.endsWith(".node")) {
@@ -84323,56 +84545,56 @@ function pruneCallFlowNativePackage(packageRoot) {
       }
     }
   };
-  collectBuiltAddons(join19(packageRoot, "build"));
+  collectBuiltAddons(join20(packageRoot, "build"));
   prunePrebuilds(packageRoot);
   for (const directory of PRUNED_PACKAGE_DIRECTORIES) {
-    removeDirectoryStrict(join19(packageRoot, directory));
+    removeDirectoryStrict(join20(packageRoot, directory));
   }
-  removeDirectoryStrict(join19(packageRoot, "node_modules"));
-  const bindings = join19(packageRoot, "bindings", "node");
+  removeDirectoryStrict(join20(packageRoot, "node_modules"));
+  const bindings = join20(packageRoot, "bindings", "node");
   if (existsSync15(bindings)) {
     for (const file of readdirSync5(bindings)) {
       if (file === "binding.cc" || file.endsWith("_test.js"))
-        rmSync4(join19(bindings, file), { force: true });
+        rmSync4(join20(bindings, file), { force: true });
     }
   }
   for (const file of ["binding.gyp", "grammar.js", "tree-sitter.json"]) {
-    rmSync4(join19(packageRoot, file), { force: true });
+    rmSync4(join20(packageRoot, file), { force: true });
   }
   if (builtAddons.length > 0) {
-    const releaseDir = join19(packageRoot, "build", "Release");
-    mkdirSync10(releaseDir, { recursive: true });
+    const releaseDir = join20(packageRoot, "build", "Release");
+    mkdirSync11(releaseDir, { recursive: true });
     for (const addon of builtAddons)
-      writeFileSync7(join19(releaseDir, addon.name), addon.bytes);
+      writeFileSync8(join20(releaseDir, addon.name), addon.bytes);
   }
   if (existsSync15(packageRoot)) {
     for (const file of readdirSync5(packageRoot)) {
       if (file.endsWith(".wasm"))
-        rmSync4(join19(packageRoot, file), { force: true });
+        rmSync4(join20(packageRoot, file), { force: true });
     }
   }
   assertNativePackagePruned(packageRoot);
 }
 function pruneCoreRuntime(runtimeDir) {
   for (const packageName of ["tree-sitter", ...CORE_GRAMMAR_PACKAGES]) {
-    pruneCallFlowNativePackage(join19(runtimeDir, "node_modules", packageName));
+    pruneCallFlowNativePackage(join20(runtimeDir, "node_modules", packageName));
   }
-  const packageRoot = join19(runtimeDir, "node_modules", "calldiff");
-  removeDirectoryStrict(join19(packageRoot, "src"));
-  for (const file of readdirSync5(join19(packageRoot, "dist"))) {
+  const packageRoot = join20(runtimeDir, "node_modules", "calldiff");
+  removeDirectoryStrict(join20(packageRoot, "src"));
+  for (const file of readdirSync5(join20(packageRoot, "dist"))) {
     if (file.startsWith("cli.") || file === "index.js" || file === "index.d.ts") {
-      rmSync4(join19(packageRoot, "dist", file), { force: true });
+      rmSync4(join20(packageRoot, "dist", file), { force: true });
     }
   }
   for (const packagePath of CORE_PRUNED_PACKAGES) {
-    removeDirectoryStrict(join19(runtimeDir, "node_modules", ...packagePath.split("/")));
+    removeDirectoryStrict(join20(runtimeDir, "node_modules", ...packagePath.split("/")));
   }
-  removeDirectoryStrict(join19(runtimeDir, "node_modules", ".bin"));
-  assertPathRemoved(join19(packageRoot, "src"), "calldiff/src");
+  removeDirectoryStrict(join20(runtimeDir, "node_modules", ".bin"));
+  assertPathRemoved(join20(packageRoot, "src"), "calldiff/src");
   for (const packagePath of CORE_PRUNED_PACKAGES) {
-    assertPathRemoved(join19(runtimeDir, "node_modules", ...packagePath.split("/")), `node_modules/${packagePath}`);
+    assertPathRemoved(join20(runtimeDir, "node_modules", ...packagePath.split("/")), `node_modules/${packagePath}`);
   }
-  assertPathRemoved(join19(runtimeDir, "node_modules", ".bin"), "node_modules/.bin");
+  assertPathRemoved(join20(runtimeDir, "node_modules", ".bin"), "node_modules/.bin");
 }
 function validationFilesForLanguage(id) {
   if (id === CALL_FLOW_CORE_LANGUAGE_ID) {
@@ -84382,7 +84604,7 @@ function validationFilesForLanguage(id) {
   return [`validation${extension}`];
 }
 async function validatePrunedLanguage(nodePath, runtimeDir, grammarCacheDir, ids) {
-  const extractEntry = join19(runtimeDir, "node_modules", "calldiff", "dist", "extract.js");
+  const extractEntry = join20(runtimeDir, "node_modules", "calldiff", "dist", "extract.js");
   const script = String.raw`
 import { pathToFileURL } from "node:url";
 const request = JSON.parse(process.argv[1]);
@@ -84416,8 +84638,8 @@ for (const file of request.files) mod.extractFunctions(file, "");
   }
 }
 function ensureGrammarCacheManifest(cacheDir) {
-  mkdirSync10(cacheDir, { recursive: true });
-  writeFileSync7(join19(cacheDir, "package.json"), runtimeJson({
+  mkdirSync11(cacheDir, { recursive: true });
+  writeFileSync8(join20(cacheDir, "package.json"), runtimeJson({
     name: "plannotator-calldiff-grammar-cache",
     private: true
   }), "utf8");
@@ -84431,13 +84653,13 @@ async function preserveValidatedLanguagePacks(nodePath, currentRuntimeDir, candi
     const packId = language.id;
     const currentRoot = getLanguagePackageRoot(currentRuntimeDir, language);
     const candidateRoot = getLanguagePackageRoot(candidateRuntimeDir, language);
-    mkdirSync10(dirname7(candidateRoot), { recursive: true });
+    mkdirSync11(dirname7(candidateRoot), { recursive: true });
     cpSync(currentRoot, candidateRoot, { recursive: true, force: true });
     try {
       await validatePrunedLanguage(nodePath, candidateRuntimeDir, candidateCache, [language.id]);
       const marker = getLanguageLockMarker(candidateRuntimeDir, language.id);
-      mkdirSync10(dirname7(marker), { recursive: true });
-      writeFileSync7(marker, runtimeJson(CALL_FLOW_PACK_LOCKS[packId]), "utf8");
+      mkdirSync11(dirname7(marker), { recursive: true });
+      writeFileSync8(marker, runtimeJson(CALL_FLOW_PACK_LOCKS[packId]), "utf8");
     } catch {
       removeDirectoryStrict(candidateRoot);
     }
@@ -84449,7 +84671,7 @@ function measureCallFlowDirectoryBytes(path2) {
   const stat5 = statSync13(path2);
   if (!stat5.isDirectory())
     return stat5.size;
-  return readdirSync5(path2).reduce((total, entry) => total + measureCallFlowDirectoryBytes(join19(path2, entry)), 0);
+  return readdirSync5(path2).reduce((total, entry) => total + measureCallFlowDirectoryBytes(join20(path2, entry)), 0);
 }
 async function installCallFlowRuntime(onStage = () => {}) {
   return await withCallFlowInstallLock(() => installCallFlowRuntimeUnlocked(onStage));
@@ -84469,12 +84691,12 @@ async function installCallFlowRuntimeUnlocked(onStage) {
     return { ok: true, status: "already-installed", runtimeDir, languageId: CALL_FLOW_CORE_LANGUAGE_ID, message: `Call-flow core already installed at ${runtimeDir}.` };
   }
   const runtimeParent = dirname7(runtimeDir);
-  mkdirSync10(runtimeParent, { recursive: true });
-  const installDir = await mkdtemp2(join19(runtimeParent, ".calldiff-install-"));
+  mkdirSync11(runtimeParent, { recursive: true });
+  const installDir = await mkdtemp2(join20(runtimeParent, ".calldiff-install-"));
   const backupDir = `${runtimeDir}.previous-${process.pid}-${Date.now()}`;
   try {
     writeRuntimeManifest(installDir);
-    await downloadVerifiedCallDiffArchive(join19(installDir, CALLDIFF_ARCHIVE_FILE), onStage);
+    await downloadVerifiedCallDiffArchive(join20(installDir, CALLDIFF_ARCHIVE_FILE), onStage);
     onStage("installing-deps");
     const install = await runCommand(npmPath, [
       "ci",
@@ -84508,8 +84730,8 @@ async function installCallFlowRuntimeUnlocked(onStage) {
       throw new Error(rebuild.stderr.trim() || rebuild.stdout.trim() || "grammar rebuild failed");
     }
     onStage("building");
-    const packageRoot = join19(installDir, "node_modules", "calldiff");
-    const tscPath = process.platform === "win32" ? join19(installDir, "node_modules", ".bin", "tsc.cmd") : join19(installDir, "node_modules", ".bin", "tsc");
+    const packageRoot = join20(installDir, "node_modules", "calldiff");
+    const tscPath = process.platform === "win32" ? join20(installDir, "node_modules", ".bin", "tsc.cmd") : join20(installDir, "node_modules", ".bin", "tsc");
     const build = await runCommand(tscPath, ["-p", "tsconfig.json"], {
       cwd: packageRoot,
       timeoutMs: 120000,
@@ -84518,8 +84740,8 @@ async function installCallFlowRuntimeUnlocked(onStage) {
     if (build.exitCode !== 0) {
       throw new Error(build.stderr.trim() || build.stdout.trim() || "CallDiff TypeScript build failed");
     }
-    rmSync4(join19(installDir, CALLDIFF_ARCHIVE_FILE), { force: true });
-    writeFileSync7(join19(installDir, ".calldiff-revision"), `${CALLDIFF_COMMIT}
+    rmSync4(join20(installDir, CALLDIFF_ARCHIVE_FILE), { force: true });
+    writeFileSync8(join20(installDir, ".calldiff-revision"), `${CALLDIFF_COMMIT}
 `, "utf8");
     if (readPackageVersion(packageRoot) !== CALLDIFF_VERSION || !resolvePackageEntry(packageRoot)) {
       throw new Error("The verified CallDiff package did not produce the expected runtime entry.");
@@ -84588,16 +84810,16 @@ async function installCallFlowLanguagePackUnlocked(id, onStage) {
     return { ok: true, status: "already-installed", runtimeDir, languageId: id, message: `${language.label} support is already installed.` };
   }
   const runtimeParent = dirname7(runtimeDir);
-  const installDir = await mkdtemp2(join19(runtimeParent, `.calldiff-${id}-install-`));
-  const stagingCache = await mkdtemp2(join19(runtimeDir, `.grammar-cache-${id}-`));
-  const packageRoot = join19(installDir, "node_modules", ...(language.packageName ?? "").split("/"));
-  const stagedPackageRoot = join19(stagingCache, "node_modules", ...(language.packageName ?? "").split("/"));
+  const installDir = await mkdtemp2(join20(runtimeParent, `.calldiff-${id}-install-`));
+  const stagingCache = await mkdtemp2(join20(runtimeDir, `.grammar-cache-${id}-`));
+  const packageRoot = join20(installDir, "node_modules", ...(language.packageName ?? "").split("/"));
+  const stagedPackageRoot = join20(stagingCache, "node_modules", ...(language.packageName ?? "").split("/"));
   const finalPackageRoot = getLanguagePackageRoot(runtimeDir, language);
   const backupPackageRoot = `${finalPackageRoot}.previous-${process.pid}-${Date.now()}`;
   try {
-    writeFileSync7(join19(installDir, "package.json"), runtimeJson(packManifest(id)), "utf8");
-    writeFileSync7(join19(installDir, "package-lock.json"), runtimeJson(CALL_FLOW_PACK_LOCKS[id]), "utf8");
-    const verifiedArtifacts = await downloadVerifiedLockArtifacts(CALL_FLOW_PACK_LOCKS[id], join19(installDir, ".verified-artifacts"), onStage);
+    writeFileSync8(join20(installDir, "package.json"), runtimeJson(packManifest(id)), "utf8");
+    writeFileSync8(join20(installDir, "package-lock.json"), runtimeJson(CALL_FLOW_PACK_LOCKS[id]), "utf8");
+    const verifiedArtifacts = await downloadVerifiedLockArtifacts(CALL_FLOW_PACK_LOCKS[id], join20(installDir, ".verified-artifacts"), onStage);
     const npmCacheDir = await seedVerifiedNpmCache(npmPath, installDir, verifiedArtifacts);
     onStage("installing-deps");
     const install = await runCommand(npmPath, [
@@ -84648,18 +84870,18 @@ async function installCallFlowLanguagePackUnlocked(id, onStage) {
     const sizeBeforePruneBytes = measureCallFlowDirectoryBytes(packageRoot);
     pruneCallFlowNativePackage(packageRoot);
     const sizeAfterPruneBytes = measureCallFlowDirectoryBytes(packageRoot);
-    mkdirSync10(dirname7(stagedPackageRoot), { recursive: true });
+    mkdirSync11(dirname7(stagedPackageRoot), { recursive: true });
     cpSync(packageRoot, stagedPackageRoot, { recursive: true });
     ensureGrammarCacheManifest(stagingCache);
     await validatePrunedLanguage(nodePath, runtimeDir, stagingCache, [id]);
     ensureGrammarCacheManifest(getCallFlowGrammarCacheDir(runtimeDir));
-    mkdirSync10(dirname7(finalPackageRoot), { recursive: true });
+    mkdirSync11(dirname7(finalPackageRoot), { recursive: true });
     if (existsSync15(finalPackageRoot))
       renameSync5(finalPackageRoot, backupPackageRoot);
     try {
       renameSync5(stagedPackageRoot, finalPackageRoot);
-      mkdirSync10(dirname7(getLanguageLockMarker(runtimeDir, id)), { recursive: true });
-      writeFileSync7(getLanguageLockMarker(runtimeDir, id), runtimeJson(CALL_FLOW_PACK_LOCKS[id]), "utf8");
+      mkdirSync11(dirname7(getLanguageLockMarker(runtimeDir, id)), { recursive: true });
+      writeFileSync8(getLanguageLockMarker(runtimeDir, id), runtimeJson(CALL_FLOW_PACK_LOCKS[id]), "utf8");
     } catch (error) {
       removeDirectoryBestEffort2(finalPackageRoot);
       if (existsSync15(backupPackageRoot))
@@ -84772,15 +84994,15 @@ async function runCommand(executable, args, options = {}) {
 }
 function grammarChecksForLanguages(runtime4, ids) {
   const checks2 = new Map;
-  const callDiffRoot = runtime4.managed ? join19(runtime4.runtimeDir, "node_modules", "calldiff") : runtime4.runtimeDir;
+  const callDiffRoot = runtime4.managed ? join20(runtime4.runtimeDir, "node_modules", "calldiff") : runtime4.runtimeDir;
   checks2.set("calldiff", {
-    packageJson: join19(callDiffRoot, "package.json"),
+    packageJson: join20(callDiffRoot, "package.json"),
     version: CALLDIFF_VERSION,
     message: `CallDiff ${CALLDIFF_VERSION} is not installed.`
   });
   for (const dependency of CORE_RUNTIME_DEPENDENCIES) {
     checks2.set(dependency.packageName, {
-      packageJson: join19(runtime4.runtimeDir, "node_modules", dependency.packageName, "package.json"),
+      packageJson: join20(runtime4.runtimeDir, "node_modules", dependency.packageName, "package.json"),
       version: dependency.version,
       message: `${dependency.label} support is not installed at the required version.`
     });
@@ -84789,9 +85011,9 @@ function grammarChecksForLanguages(runtime4, ids) {
     const language = getCallFlowLanguage(id);
     if (language.kind !== "pack" || !language.packageName || !language.packageVersion)
       continue;
-    const packageRoot = runtime4.managed ? getLanguagePackageRoot(runtime4.runtimeDir, language) : join19(runtime4.runtimeDir, "node_modules", ...language.packageName.split("/"));
+    const packageRoot = runtime4.managed ? getLanguagePackageRoot(runtime4.runtimeDir, language) : join20(runtime4.runtimeDir, "node_modules", ...language.packageName.split("/"));
     checks2.set(language.packageName, {
-      packageJson: join19(packageRoot, "package.json"),
+      packageJson: join20(packageRoot, "package.json"),
       version: language.packageVersion,
       message: `${language.label} support is not installed.`
     });
@@ -84799,15 +85021,15 @@ function grammarChecksForLanguages(runtime4, ids) {
   return [...checks2.values()];
 }
 async function createNpmBlocker() {
-  const root3 = await mkdtemp2(join19(tmpdir4(), "plannotator-call-flow-path-"));
+  const root3 = await mkdtemp2(join20(tmpdir4(), "plannotator-call-flow-path-"));
   if (process.platform === "win32") {
-    writeFileSync7(join19(root3, "npm.cmd"), `@echo CallDiff package installation is disabled during analysis. 1>&2\r
+    writeFileSync8(join20(root3, "npm.cmd"), `@echo CallDiff package installation is disabled during analysis. 1>&2\r
 @exit /b 91\r
 `, "utf8");
-    writeFileSync7(join19(root3, "npm.exe"), "", "utf8");
+    writeFileSync8(join20(root3, "npm.exe"), "", "utf8");
   } else {
-    const blocker = join19(root3, "npm");
-    writeFileSync7(blocker, `#!/bin/sh
+    const blocker = join20(root3, "npm");
+    writeFileSync8(blocker, `#!/bin/sh
 echo 'CallDiff package installation is disabled during analysis.' >&2
 exit 91
 `, "utf8");
@@ -86892,10 +87114,10 @@ var init_guide2 = __esm(() => {
 });
 
 // ../../packages/shared/guide-instructions-store.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname8, join as join20 } from "path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname8, join as join21 } from "path";
 function instructionsPath() {
-  return join20(getPlannotatorDataDir(), "guide-instructions.md");
+  return join21(getPlannotatorDataDir(), "guide-instructions.md");
 }
 function bound(value) {
   const trimmed = value.trim();
@@ -86917,8 +87139,8 @@ function writeGuideInstructions(value) {
     } catch {}
     return "";
   }
-  mkdirSync11(dirname8(path2), { recursive: true });
-  writeFileSync8(path2, bounded + `
+  mkdirSync12(dirname8(path2), { recursive: true });
+  writeFileSync9(path2, bounded + `
 `, "utf8");
   return bounded;
 }
@@ -87469,7 +87691,7 @@ var init_agent_jobs2 = __esm(() => {
 });
 
 // ../../packages/server/codex-review.ts
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 import { appendFile, mkdir, unlink, writeFile, readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
@@ -87525,7 +87747,7 @@ async function buildCodexCommand(options) {
   return command;
 }
 function generateOutputPath() {
-  return join21(tmpdir5(), `plannotator-codex-${crypto.randomUUID()}.json`);
+  return join22(tmpdir5(), `plannotator-codex-${crypto.randomUUID()}.json`);
 }
 async function parseCodexOutput(outputPath) {
   await debugLog("PARSE_OUTPUT_START", { outputPath });
@@ -87659,7 +87881,7 @@ var init_codex_review = __esm(() => {
   init_external_annotation2();
   DATA_DIR3 = getPlannotatorDataDir();
   DEBUG_ENABLED = !!process.env.PLANNOTATOR_DEBUG;
-  DEBUG_LOG_PATH = join21(DATA_DIR3, "codex-review-debug.log");
+  DEBUG_LOG_PATH = join22(DATA_DIR3, "codex-review-debug.log");
   CODEX_REVIEW_SCHEMA = JSON.stringify({
     type: "object",
     properties: {
@@ -87702,7 +87924,7 @@ var init_codex_review = __esm(() => {
     additionalProperties: false
   });
   SCHEMA_DIR = DATA_DIR3;
-  SCHEMA_FILE = join21(SCHEMA_DIR, "codex-review-schema.json");
+  SCHEMA_FILE = join22(SCHEMA_DIR, "codex-review-schema.json");
 });
 
 // ../../packages/server/agent-review-message.ts
@@ -87903,7 +88125,7 @@ var init_agent_review_message = __esm(() => {
 });
 
 // ../../packages/server/tour/tour-review.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { tmpdir as tmpdir6 } from "os";
 import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3, unlink as unlink2 } from "fs/promises";
 function buildTourUserMessage(patch, diffType, options, prMetadata) {
@@ -88055,7 +88277,7 @@ async function ensureTourSchemaFile() {
   return TOUR_SCHEMA_FILE;
 }
 function generateTourOutputPath() {
-  return join22(tmpdir6(), `plannotator-tour-${crypto.randomUUID()}.json`);
+  return join23(tmpdir6(), `plannotator-tour-${crypto.randomUUID()}.json`);
 }
 async function buildTourCodexCommand(options) {
   const { cwd, outputPath, prompt, model, reasoningEffort, fastMode } = options;
@@ -88458,11 +88680,11 @@ var init_tour_review = __esm(() => {
     additionalProperties: false
   });
   TOUR_SCHEMA_DIR = getPlannotatorDataDir();
-  TOUR_SCHEMA_FILE = join22(TOUR_SCHEMA_DIR, "tour-schema.json");
+  TOUR_SCHEMA_FILE = join23(TOUR_SCHEMA_DIR, "tour-schema.json");
 });
 
 // ../../packages/server/guide/guide-review.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { tmpdir as tmpdir7 } from "os";
 import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4, unlink as unlink3 } from "fs/promises";
 function composeGuideMethodology(extraInstructions) {
@@ -88656,7 +88878,7 @@ async function ensureGuideSchemaFile() {
   return GUIDE_SCHEMA_FILE;
 }
 function generateGuideOutputPath() {
-  return join23(tmpdir7(), `plannotator-guide-${crypto.randomUUID()}.json`);
+  return join24(tmpdir7(), `plannotator-guide-${crypto.randomUUID()}.json`);
 }
 async function buildGuideCodexCommand(options) {
   const { cwd, outputPath, prompt, model, reasoningEffort, fastMode } = options;
@@ -89480,7 +89702,7 @@ var init_guide_review = __esm(() => {
     additionalProperties: false
   });
   GUIDE_SCHEMA_DIR = getPlannotatorDataDir();
-  GUIDE_SCHEMA_FILE = join23(GUIDE_SCHEMA_DIR, "guide-schema.json");
+  GUIDE_SCHEMA_FILE = join24(GUIDE_SCHEMA_DIR, "guide-schema.json");
 });
 
 // ../../packages/core/compress.ts
@@ -90111,8 +90333,8 @@ function parsePRUrl(url) {
 }
 
 // ../../packages/shared/guide-store.ts
-import { join as join24, resolve as resolve12, basename as basename8 } from "path";
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync9, readFileSync as readFileSync13, readdirSync as readdirSync6, renameSync as renameSync6, unlinkSync as unlinkSync6, existsSync as existsSync17 } from "fs";
+import { join as join25, resolve as resolve12, basename as basename8 } from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync10, readFileSync as readFileSync13, readdirSync as readdirSync6, renameSync as renameSync6, unlinkSync as unlinkSync6, existsSync as existsSync17 } from "fs";
 import { createHash as createHash5 } from "crypto";
 function sanitizeKeySegment(segment) {
   const cleaned = segment.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "");
@@ -90151,13 +90373,13 @@ function makeGuideId(title, now = Date.now()) {
   return `${now}-${slug || "guide"}`;
 }
 function guidesDir(repoKey) {
-  return join24(getPlannotatorDataDir(), "guides", repoKey);
+  return join25(getPlannotatorDataDir(), "guides", repoKey);
 }
 function guidePath(repoKey, id) {
-  return join24(guidesDir(repoKey), `${id}.json`);
+  return join25(guidesDir(repoKey), `${id}.json`);
 }
 function guidePatchPath(repoKey, id) {
-  return join24(guidesDir(repoKey), `${id}.patch`);
+  return join25(guidesDir(repoKey), `${id}.patch`);
 }
 function coerceReviewed(value, sectionCount) {
   const out = new Array(sectionCount).fill(false);
@@ -90255,10 +90477,10 @@ function saveGuide(repoKey, id, envelope) {
   if (!isValidGuideId(id))
     return false;
   try {
-    mkdirSync12(guidesDir(repoKey), { recursive: true });
+    mkdirSync13(guidesDir(repoKey), { recursive: true });
     const finalPath = guidePath(repoKey, id);
     const tmpPath = `${finalPath}.tmp`;
-    writeFileSync9(tmpPath, JSON.stringify(envelope, null, 2), "utf-8");
+    writeFileSync10(tmpPath, JSON.stringify(envelope, null, 2), "utf-8");
     renameSync6(tmpPath, finalPath);
     return true;
   } catch (e10) {
@@ -90270,10 +90492,10 @@ function saveGuidePatch(repoKey, id, rawPatch) {
   if (!isValidGuideId(id))
     return false;
   try {
-    mkdirSync12(guidesDir(repoKey), { recursive: true });
+    mkdirSync13(guidesDir(repoKey), { recursive: true });
     const finalPath = guidePatchPath(repoKey, id);
     const tmpPath = `${finalPath}.tmp`;
-    writeFileSync9(tmpPath, rawPatch, "utf-8");
+    writeFileSync10(tmpPath, rawPatch, "utf-8");
     renameSync6(tmpPath, finalPath);
     return true;
   } catch (e10) {
@@ -90285,7 +90507,7 @@ function loadGuidePatch(repoKey, envelope) {
   if (!envelope.review)
     return null;
   try {
-    const filePath = join24(guidesDir(repoKey), envelope.review.patchFile);
+    const filePath = join25(guidesDir(repoKey), envelope.review.patchFile);
     if (!existsSync17(filePath))
       return null;
     return readFileSync13(filePath, "utf-8");
@@ -91310,8 +91532,8 @@ var init_pr_github = __esm(() => {
 });
 
 // ../../packages/shared/pr-gitlab.ts
-import { join as join25 } from "path";
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync10 } from "fs";
+import { join as join26 } from "path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync11 } from "fs";
 function encodeProject(projectPath) {
   return encodeURIComponent(projectPath);
 }
@@ -91786,11 +92008,11 @@ async function submitGlMRReview(runtime4, ref, headSha, action, body3, fileComme
       const failed = failedFileComments.map((failure) => failure.comment);
       let savedTo = null;
       try {
-        const dir = join25(getPlannotatorDataDir(), "failed-comments");
-        mkdirSync13(dir, { recursive: true });
+        const dir = join26(getPlannotatorDataDir(), "failed-comments");
+        mkdirSync14(dir, { recursive: true });
         const slug = `${ref.host}-${ref.projectPath.replace(/\//g, "_")}-mr${ref.iid}-${Date.now()}`;
-        savedTo = join25(dir, `${slug}.json`);
-        writeFileSync10(savedTo, JSON.stringify({ ref, headSha, baseSha, startSha, errors, failedComments: failed }, null, 2));
+        savedTo = join26(dir, `${slug}.json`);
+        writeFileSync11(savedTo, JSON.stringify({ ref, headSha, baseSha, startSha, errors, failedComments: failed }, null, 2));
       } catch (writeErr) {
         console.error(`[plannotator] Failed to persist unposted comments: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}`);
       }
@@ -101625,6 +101847,49 @@ async function startReviewServer(options) {
   };
   let currentContextRevision = getGitButlerContextRevision(clientGitContext) ?? "";
   const currentSnapshotId = () => `${draftKey}:${currentDiffType}${isPRMode ? `:${currentPRDiffScope}` : ""}${currentContextRevision ? `:${currentContextRevision}` : ""}`;
+  const feedbackProject = () => options.project?.trim() ? options.project : deriveFeedbackProject(gitContext?.cwd ?? options.agentCwd ?? process.cwd());
+  const feedbackReviewTarget = () => {
+    const target = {
+      diffType: String(currentDiffType),
+      base: currentBase,
+      gitRef: currentGitRef,
+      snapshotId: currentSnapshotId(),
+      changedFiles: countChangedFiles(currentPatch),
+      patchBytes: currentPatch.length
+    };
+    if (sessionVcsType)
+      target.vcsType = sessionVcsType;
+    else if (workspace)
+      target.vcsType = "workspace";
+    const cwd = gitContext?.cwd ?? options.agentCwd;
+    if (cwd)
+      target.cwd = cwd;
+    if (prMetadata) {
+      target.pr = {
+        provider: prMetadata.platform,
+        repo: prMetadata.platform === "github" ? `${prMetadata.owner}/${prMetadata.repo}` : prMetadata.projectPath,
+        number: prMetadata.platform === "github" ? prMetadata.number : prMetadata.iid
+      };
+    }
+    return target;
+  };
+  const archiveReviewSubmission = (feedback, annotations, decision) => {
+    if (!resolveFeedbackHistory(loadConfig()))
+      return true;
+    const feedbackText = typeof feedback === "string" ? feedback : "";
+    const annotationList = Array.isArray(annotations) ? annotations : [];
+    const hasContent = feedbackText.trim().length > 0 || annotationList.length > 0;
+    const written = appendFeedbackRecord({
+      project: feedbackProject(),
+      origin,
+      surface: "review",
+      decision,
+      target: { review: feedbackReviewTarget() },
+      feedback: feedbackText,
+      annotations: annotationList
+    });
+    return written !== null || !hasContent;
+  };
   const buildCurrentAiReviewContext = (patch = currentPatch, base = currentBase, diffType = currentDiffType) => {
     if (!aiEnabled)
       return;
@@ -103285,6 +103550,7 @@ async function startReviewServer(options) {
       if (agentResponse)
         return agentResponse;
       if (url.pathname === "/api/exit" && req.method === "POST") {
+        archiveReviewSubmission("", [], "dismissed");
         deleteDraft(draftKey, readDraftGenerationFromUrl(req));
         resolveDecision({ approved: false, feedback: "", annotations: [], exit: true });
         return Response.json({ ok: true });
@@ -103292,11 +103558,17 @@ async function startReviewServer(options) {
       if (url.pathname === "/api/feedback" && req.method === "POST") {
         try {
           const body3 = await req.json();
-          deleteDraft(draftKey, readDraftGenerationFromBody(body3));
+          const approved = body3.approved ?? false;
+          const feedbackValue = body3.feedback || "";
+          const annotationsValue = body3.annotations || [];
+          const hasContent = typeof feedbackValue === "string" && feedbackValue.trim().length > 0 || Array.isArray(annotationsValue) && annotationsValue.length > 0;
+          const durable = archiveReviewSubmission(feedbackValue, annotationsValue, approved ? hasContent ? "approved-with-notes" : "lgtm" : "feedback");
+          if (durable)
+            deleteDraft(draftKey, readDraftGenerationFromBody(body3));
           resolveDecision({
-            approved: body3.approved ?? false,
-            feedback: body3.feedback || "",
-            annotations: body3.annotations || [],
+            approved,
+            feedback: feedbackValue,
+            annotations: annotationsValue,
             agentSwitch: body3.agentSwitch
           });
           return Response.json({ ok: true });
@@ -103463,6 +103735,7 @@ var init_review = __esm(() => {
   init_guide_viewer_manifest2();
   init_marker_review();
   init_config2();
+  init_feedback_archive();
   init_favicon2();
   init_pr();
   init_pr_artifact_document();
@@ -104280,11 +104553,11 @@ function shutdown() {
 var init_agent_terminal_node_sidecar = () => {};
 
 // ../../packages/server/agent-terminal-runtime.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync15, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
+import { join as join27 } from "path";
 import { fileURLToPath } from "url";
 function getAgentTerminalManagedRuntimeDir(dataDir = getPlannotatorDataDir()) {
-  return join26(dataDir, "vendor", "agent-terminal", `webtui-${AGENT_TERMINAL_WEBTUI_VERSION}`);
+  return join27(dataDir, "vendor", "agent-terminal", `webtui-${AGENT_TERMINAL_WEBTUI_VERSION}`);
 }
 function isAgentTerminalRemoteEnabled(env = process.env) {
   return isTruthy(env.PLANNOTATOR_AGENT_TERMINAL_REMOTE);
@@ -104364,9 +104637,9 @@ async function resolveManagedAgentTerminalRuntime(nodePath) {
   };
 }
 function materializeAgentTerminalSidecar(runtimeDir) {
-  mkdirSync14(runtimeDir, { recursive: true });
-  const sidecarPath = join26(runtimeDir, "agent-terminal-node-sidecar.mjs");
-  writeFileSync11(sidecarPath, agent_terminal_node_sidecar_default, "utf8");
+  mkdirSync15(runtimeDir, { recursive: true });
+  const sidecarPath = join27(runtimeDir, "agent-terminal-node-sidecar.mjs");
+  writeFileSync12(sidecarPath, agent_terminal_node_sidecar_default, "utf8");
   return sidecarPath;
 }
 function tryMaterializeAgentTerminalSidecar(runtimeDir) {
@@ -104381,7 +104654,7 @@ function tryMaterializeAgentTerminalSidecar(runtimeDir) {
   }
 }
 function readInstalledWebTuiVersion(runtimeDir) {
-  const packageJsonPath = join26(runtimeDir, "node_modules", "@plannotator", "webtui", "package.json");
+  const packageJsonPath = join27(runtimeDir, "node_modules", "@plannotator", "webtui", "package.json");
   if (!existsSync20(packageJsonPath))
     return null;
   try {
@@ -106088,23 +106361,40 @@ async function startAnnotateServer(options) {
   }
   const draftSource = mode === "annotate-app" && liveApp ? `annotate-app\x00${liveAppDraftIdentity(liveApp.targetUrl)}` : mode === "annotate-folder" && folderPath ? `folder:${resolvePath4(folderPath)}` : renderHtml && rawHtml ? rawHtml : markdown;
   const draftKey = contentHash(draftSource);
-  const persistSubmittedDecision = (feedback, annotations, approved) => {
-    const feedbackText = typeof feedback === "string" ? feedback : "";
-    const annotationList = Array.isArray(annotations) ? annotations : [];
-    if (!feedbackText.trim() && annotationList.length === 0)
+  const annotateFeedbackSurface = mode === "annotate-app" ? "annotate-app" : mode === "annotate-last" ? "annotate-last" : mode === "annotate-folder" ? "annotate-folder" : singleFileLocalAnnotate ? "annotate" : "annotate-url";
+  const archiveAnnotateDecision = (feedbackText, annotationList, decision2) => {
+    if (!resolveFeedbackHistory(loadConfig()))
       return true;
     if (!annotateHistoryEnabled)
       return true;
-    if (!singleFileLocalAnnotate)
-      return true;
-    return persistAnnotateSubmission({
+    const isUrlTarget = /^https?:\/\//i.test(filePath);
+    return appendFeedbackRecord({
       project: annotateProjectName,
-      sessionPath: resolvePath4(filePath),
+      origin,
+      surface: annotateFeedbackSurface,
+      decision: decision2,
+      target: mode === "annotate-app" && liveApp ? { url: liveApp.targetUrl } : isUrlTarget ? { url: filePath } : mode === "annotate-last" ? { filePath } : { filePath: resolvePath4(filePath) },
       feedback: feedbackText,
-      annotations: annotationList,
-      approved
+      annotations: annotationList
     }) !== null;
   };
+  const persistSubmittedDecision = (feedback, annotations, approved) => {
+    const feedbackText = typeof feedback === "string" ? feedback : "";
+    const annotationList = Array.isArray(annotations) ? annotations : [];
+    const hasContent = feedbackText.trim().length > 0 || annotationList.length > 0;
+    const archived = archiveAnnotateDecision(feedbackText, annotationList, approved ? hasContent ? "approved-with-notes" : "approved" : "feedback");
+    let legacyDurable = true;
+    if (hasContent && annotateHistoryEnabled && singleFileLocalAnnotate) {
+      legacyDurable = persistAnnotateSubmission({
+        project: annotateProjectName,
+        sessionPath: resolvePath4(filePath),
+        feedback: feedbackText,
+        annotations: annotationList,
+        approved
+      }) !== null;
+    }
+    return legacyDurable && (archived || !hasContent);
+  };
   const externalAnnotations = createExternalAnnotationHandler("plan");
   const aiRuntime = resolveAIEnabled() ? await createAIRuntime() : null;
   const htmlAssets = createHtmlAssetRegistry();
@@ -106587,6 +106877,7 @@ async function startAnnotateServer(options) {
         if (!decision.settle({ feedback: "", annotations: [], exit: true })) {
           return alreadyDecided();
         }
+        archiveAnnotateDecision("", [], "dismissed");
         deleteDraft(draftKey, readDraftGenerationFromUrl(req));
         clientLease.cancel();
         return Response.json({ ok: true });
@@ -106726,6 +107017,7 @@ var init_annotate = __esm(() => {
   init_source_save_node();
   init_external_annotations();
   init_config2();
+  init_feedback_archive();
   init_favicon2();
   init_html_assets_node();
   init_browser();
@@ -107911,6 +108203,7 @@ async function handleReviewCommand(event, deps) {
     gitRef,
     error: diffError,
     origin: "opencode",
+    project: await detectProjectName() ?? undefined,
     diffType: isPRMode ? undefined : userDiffType,
     gitContext,
     initialFingerprint,