@macintacos/caret 1.0.2 → 1.1.0

package/dist/cli.js

@@ -419,6 +419,7 @@ var init_claude = __esm(() => {
   claudeAdapter = {
     id: "claude",
     approveVariants: APPROVE_VARIANTS,
+    restartHint: "Then run /reload-plugins or restart Claude Code.",
     parseHookInput(stdin) {
       const hook = parseHookStdin(stdin);
       return {
@@ -2983,212 +2984,6 @@ function isNewer(latest, current) {
   return a2 > b2;
 }
 
-// src/adapters/opencode/upgrade.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, rmSync } from "fs";
-import { join as join6 } from "path";
-function upgradeVerdict(input) {
-  const { entry, cached, published } = input;
-  if (published === null) {
-    return { kind: "unknown", reason: "could not reach npm for the published caret version" };
-  }
-  if (parseVersionTriple(published) === null) {
-    return { kind: "unknown", reason: `npm reported an unreadable version (${published})` };
-  }
-  if (entry === null)
-    return { kind: "fresh" };
-  const pinned = splitPluginSpecifier(entry).version;
-  if (pinned !== null && parseVersionTriple(pinned) !== null) {
-    return isNewer(published, pinned) ? { kind: "stale-pin", entry, pinned, published } : { kind: "current", version: pinned };
-  }
-  if (cached === null)
-    return { kind: "fresh" };
-  if (parseVersionTriple(cached) === null) {
-    return { kind: "unknown", reason: `OpenCode cached an unreadable version (${cached})` };
-  }
-  return isNewer(published, cached) ? { kind: "stale-cache", cached, published } : { kind: "current", version: cached };
-}
-function readCachedCaretVersion(dirs = existingOpencodeCachePackageDirs()) {
-  for (const d of dirs) {
-    try {
-      const deps = JSON.parse(readFileSync3(join6(d, "package.json"), "utf-8")).dependencies;
-      const v = deps?.[CARET_PACKAGE];
-      if (typeof v === "string" && v.length > 0)
-        return v;
-    } catch {}
-  }
-  return null;
-}
-function clearCachedCaret(dirs = existingOpencodeCachePackageDirs()) {
-  const cleared = [];
-  for (const d of dirs) {
-    if (!existsSync2(d))
-      continue;
-    rmSync(d, { recursive: true, force: true });
-    cleared.push(d);
-  }
-  return cleared;
-}
-var init_upgrade = __esm(() => {
-  init_config_plugin();
-  init_paths2();
-});
-
-// src/adapters/opencode/install.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join7 } from "path";
-function readOpencodeInstallState() {
-  const dir = opencodeConfigDir();
-  if (!existsSync3(dir)) {
-    return { pluginVersion: "unknown", pluginEnabled: "unknown", hookInUserSettings: "unknown" };
-  }
-  const version = readCachedCaretVersion(existingOpencodeCachePackageDirs()) ?? "unknown";
-  return {
-    pluginVersion: version,
-    pluginEnabled: version !== "unknown",
-    hookInUserSettings: readCaretInPluginArray(dir)
-  };
-}
-function readCaretInPluginArray(dir) {
-  let sawConfig = false;
-  for (const name of CONFIG_FILENAMES) {
-    const path = join7(dir, name);
-    if (!existsSync3(path))
-      continue;
-    let cfg;
-    try {
-      cfg = parse3(readFileSync4(path, "utf-8"));
-    } catch {
-      continue;
-    }
-    if (cfg === undefined || cfg === null)
-      continue;
-    sawConfig = true;
-    const arr = cfg.plugin;
-    if (Array.isArray(arr) && arr.some((e) => typeof e === "string" && e.includes("caret"))) {
-      return true;
-    }
-  }
-  return sawConfig ? false : "unknown";
-}
-var init_install3 = __esm(() => {
-  init_main();
-  init_paths2();
-  init_upgrade();
-});
-
-// src/adapters/opencode/skills.ts
-import { readdir as readdir2 } from "fs/promises";
-import { sep as sep2 } from "path";
-async function commandNamesUnder(dir) {
-  let entries;
-  try {
-    entries = await readdir2(dir, { recursive: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((rel) => rel.endsWith(".md")).map((rel) => rel.slice(0, -".md".length).split(sep2).join("/"));
-}
-async function readOpencodeCommands() {
-  const perDir = await Promise.all(commandDirs(opencodeConfigDir()).map(commandNamesUnder));
-  const names = new Set(perDir.flat());
-  return [...names].sort().map((name) => ({ name, origin: "command" }));
-}
-async function readOpencodeCommandDescription(name) {
-  const relative = `${name}.md`;
-  for (const dir of commandDirs(opencodeConfigDir())) {
-    const abs = await containedFile(dir, relative);
-    if (abs !== null)
-      return descriptionOf(abs);
-  }
-  return null;
-}
-var init_skills2 = __esm(() => {
-  init_paths2();
-  init_skill_doc();
-});
-
-// src/adapters/opencode/index.ts
-var opencodeAdapter;
-var init_opencode = __esm(() => {
-  init_approve3();
-  init_feedback3();
-  init_install3();
-  init_skills2();
-  opencodeAdapter = {
-    id: "opencode",
-    approveVariants: APPROVE_VARIANTS3,
-    parseHookInput(stdin) {
-      const hook = parseHookStdin(stdin);
-      return {
-        sessionId: hook.session_id,
-        cwd: hook.cwd,
-        plan: hook.tool_input?.plan,
-        planFilePath: hook.tool_input?.planFilePath
-      };
-    },
-    emitDecision(decision) {
-      return JSON.stringify(toWireDecision(decision));
-    },
-    fatalDenyLine,
-    readInstallState() {
-      return readOpencodeInstallState();
-    },
-    listSkills() {
-      return readOpencodeCommands();
-    },
-    readSkillDescription(_cwd, skill) {
-      return readOpencodeCommandDescription(skill.name);
-    }
-  };
-});
-
-// src/adapters/index.ts
-function agentIds() {
-  return Object.keys(REGISTRY);
-}
-function selectAdapter(id) {
-  const raw = (id ?? process.env.CARET_AGENT ?? "").trim();
-  const key = raw === "" ? DEFAULT_AGENT : raw;
-  const adapter = REGISTRY[key];
-  if (!adapter) {
-    throw new Error(`unknown agent adapter: "${key}" (known: ${agentIds().join(", ")})`);
-  }
-  return adapter;
-}
-function fatalDeny(reason) {
-  let adapter;
-  try {
-    adapter = selectAdapter();
-  } catch {}
-  if (adapter) {
-    try {
-      return adapter.emitDecision({ behavior: "deny", feedback: reason, decidedAt: Date.now() });
-    } catch {}
-    try {
-      return adapter.fatalDenyLine(reason);
-    } catch {}
-  }
-  return permissionRequestDenyLine(reason);
-}
-var DEFAULT_AGENT = "claude", CLAUDE_MCP_AGENT = "claude-mcp", REGISTRY;
-var init_adapters = __esm(() => {
-  init_claude();
-  init_codex();
-  init_opencode();
-  REGISTRY = {
-    claude: claudeAdapter,
-    codex: codexAdapter,
-    opencode: opencodeAdapter,
-    [CLAUDE_MCP_AGENT]: {
-      ...claudeAdapter,
-      id: CLAUDE_MCP_AGENT,
-      parseHookInput: opencodeAdapter.parseHookInput,
-      emitDecision: opencodeAdapter.emitDecision,
-      fatalDenyLine: opencodeAdapter.fatalDenyLine
-    }
-  };
-});
-
 // node_modules/.bun/zod@4.5.4/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -4105,7 +3900,7 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version) => {
 }, email, _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
-}, integer, number, boolean, _null, lowercase, uppercase;
+}, bigint, integer, number, boolean, _null, lowercase, uppercase;
 var init_regexes = __esm(() => {
   cuid = /^[cC][0-9a-z]{6,}$/;
   cuid2 = /^[0-9a-z]+$/;
@@ -4125,6 +3920,7 @@ var init_regexes = __esm(() => {
   httpProtocol = /^https?$/;
   e164 = /^\+[1-9]\d{6,14}$/;
   date = /* @__PURE__ */ anchor(dateSource);
+  bigint = /^-?\d+n?$/;
   integer = /^-?\d+$/;
   number = /^-?\d+(?:\.\d+)?$/;
   boolean = /^(?:true|false)$/i;
@@ -4955,7 +4751,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-var $ZodType, toStandardResult = (r) => r.success ? { value: r.data } : { issues: r.error?.issues }, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, URL_BAD_FORMAT = 1, URL_UNPARSEABLE = 2, asciiTabOrNewline, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, ipv6Alphabet, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodNull, $ZodUnknown, $ZodNever, $ZodArray, NO_SYMBOL_KEYS, propShapes, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodPreprocess, $ZodReadonly, $ZodCustom;
+var $ZodType, toStandardResult = (r) => r.success ? { value: r.data } : { issues: r.error?.issues }, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, URL_BAD_FORMAT = 1, URL_UNPARSEABLE = 2, asciiTabOrNewline, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, ipv6Alphabet, $ZodIPv6, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodNull, $ZodUnknown, $ZodNever, $ZodDate, $ZodArray, NO_SYMBOL_KEYS, propShapes, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodDiscriminatedUnion, $ZodIntersection, $ZodRecord, $ZodEnum, $ZodLiteral, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodCatch, $ZodPipe, $ZodPreprocess, $ZodReadonly, $ZodCustom;
 var init_schemas = __esm(() => {
   init_checks();
   init_core();
@@ -5376,6 +5172,25 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = bigint;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = BigInt(payload.value);
+        } catch (_) {}
+      if (typeof payload.value === "bigint")
+        return payload;
+      payload.issues.push({
+        expected: "bigint",
+        code: "invalid_type",
+        input: payload.value,
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.pattern = _null;
@@ -5409,6 +5224,29 @@ var init_schemas = __esm(() => {
       return payload;
     };
   });
+  $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce) {
+        try {
+          payload.value = new Date(payload.value);
+        } catch (_err) {}
+      }
+      const input = payload.value;
+      const isDate = input instanceof Date;
+      const isValidDate = isDate && !Number.isNaN(input.getTime());
+      if (isValidDate)
+        return payload;
+      payload.issues.push({
+        expected: "date",
+        code: "invalid_type",
+        input,
+        ...isDate ? { received: "Invalid Date" } : {},
+        inst
+      });
+      return payload;
+    };
+  });
   $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     $ZodType.init(inst, def);
     const memo = globalConfig.memoizer;
@@ -6620,6 +6458,13 @@ function _string(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedString(Class, params) {
+  return new Class({
+    type: "string",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _email(Class, params) {
   return new Class({
     type: "string",
@@ -6864,6 +6709,14 @@ function _number(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedNumber(Class, params) {
+  return new Class({
+    type: "number",
+    coerce: true,
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
 function _int(Class, params) {
   return new Class({
     type: "number",
@@ -6879,6 +6732,20 @@ function _boolean(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedBoolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
+function _coercedBigint(Class, params) {
+  return new Class({
+    type: "bigint",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _null2(Class, params) {
   return new Class({
     type: "null",
@@ -6896,6 +6763,13 @@ function _never(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedDate(Class, params) {
+  return new Class({
+    type: "date",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _lt(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
@@ -8517,7 +8391,7 @@ function preprocess(fn, schema) {
     out: schema
   });
 }
-var ZodType, _ZodString, ZodString, ZodStringFormat, ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodNull, ZodUnknown, ZodNever, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodPreprocess, ZodReadonly, ZodCustom;
+var ZodType, _ZodString, ZodString, ZodStringFormat, ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration, ZodEmail, ZodGUID, ZodUUID, ZodURL, ZodEmoji, ZodNanoID, ZodCUID, ZodCUID2, ZodULID, ZodXID, ZodKSUID, ZodIPv4, ZodIPv6, ZodCIDRv4, ZodCIDRv6, ZodBase64, ZodBase64URL, ZodE164, ZodJWT, ZodNumber, ZodNumberFormat, ZodBoolean, ZodBigInt, ZodNull, ZodUnknown, ZodNever, ZodDate, ZodArray, ZodObject, ZodUnion, ZodDiscriminatedUnion, ZodIntersection, ZodRecord, ZodEnum, ZodLiteral, ZodTransform, ZodOptional, ZodExactOptional, ZodNullable, ZodDefault, ZodPrefault, ZodNonOptional, ZodCatch, ZodPipe, ZodPreprocess, ZodReadonly, ZodCustom;
 var init_schemas2 = __esm(() => {
   init_core2();
   init_core2();
@@ -8991,6 +8865,49 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
   });
+  ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
+    $ZodBigInt.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => bigintProcessor(inst, ctx, json, params);
+    const bag = inst._zod.bag;
+    inst.minValue = bag.minimum ?? null;
+    inst.maxValue = bag.maximum ?? null;
+    inst.format = bag.format ?? null;
+  }, {
+    gte(value, params) {
+      return this.check(_gte(value, params));
+    },
+    min(value, params) {
+      return this.check(_gte(value, params));
+    },
+    gt(value, params) {
+      return this.check(_gt(value, params));
+    },
+    lt(value, params) {
+      return this.check(_lt(value, params));
+    },
+    lte(value, params) {
+      return this.check(_lte(value, params));
+    },
+    max(value, params) {
+      return this.check(_lte(value, params));
+    },
+    positive(params) {
+      return this.check(_gt(BigInt(0), params));
+    },
+    negative(params) {
+      return this.check(_lt(BigInt(0), params));
+    },
+    nonpositive(params) {
+      return this.check(_lte(BigInt(0), params));
+    },
+    nonnegative(params) {
+      return this.check(_gte(BigInt(0), params));
+    },
+    multipleOf(value, params) {
+      return this.check(_multipleOf(value, params));
+    }
+  });
   ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
     $ZodNull.init(inst, def);
     ZodType.init(inst, def);
@@ -9006,6 +8923,16 @@ var init_schemas2 = __esm(() => {
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
   });
+  ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+    $ZodDate.init(inst, def);
+    ZodType.init(inst, def);
+    inst._zod.processJSONSchema = (ctx, json, params) => dateProcessor(inst, ctx, json, params);
+    inst.min = (value, params) => inst.check(_gte(value, params));
+    inst.max = (value, params) => inst.check(_lte(value, params));
+    const c = inst._zod.bag;
+    inst.minDate = c.minimum ? new Date(c.minimum) : null;
+    inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+  });
   ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
     _ensureDefaultMemoizer();
     $ZodArray.init(inst, def);
@@ -9272,7 +9199,33 @@ var init_iso = __esm(() => {
 });
 
 // node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/coerce.js
-var init_coerce = () => {};
+var exports_coerce = {};
+__export(exports_coerce, {
+  bigint: () => bigint2,
+  boolean: () => boolean3,
+  date: () => date2,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint2(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date2(params) {
+  return _coercedDate(ZodDate, params);
+}
+var init_coerce = __esm(() => {
+  init_core2();
+  init_schemas2();
+});
 
 // node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/external.js
 var init_external = __esm(() => {
@@ -9293,6 +9246,429 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "@macintacos/caret",
+    version: "1.1.0",
+    license: "MIT",
+    type: "module",
+    description: "A Claude Code plugin that replaces the terminal plan-approval prompt with a local web UI for inline review, annotation, and approval.",
+    main: "./opencode/index.ts",
+    exports: {
+      ".": "./opencode/index.ts"
+    },
+    bin: {
+      caret: "./bin/caret"
+    },
+    homepage: "https://github.com/macintacos/caret",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/macintacos/caret.git"
+    },
+    publishConfig: {
+      access: "public"
+    },
+    files: [
+      "dist/",
+      "ui/dist/",
+      "bin/caret",
+      "bin/caret-launcher",
+      "hooks/",
+      "commands/",
+      "opencode/",
+      "templates/",
+      ".claude-plugin/plugin.json"
+    ],
+    scripts: {
+      test: "bun test --conditions browser --parallel --timeout 35000",
+      lint: "mise run lint",
+      format: "mise run format",
+      build: "mise run build"
+    },
+    devDependencies: {
+      "@clack/prompts": "^1.7.0",
+      "@codemirror/autocomplete": "^6.20.3",
+      "@codemirror/commands": "^6.10.3",
+      "@codemirror/lang-markdown": "^6.5.0",
+      "@codemirror/language": "^6.12.3",
+      "@codemirror/language-data": "^6.5.2",
+      "@codemirror/state": "^6.6.0",
+      "@codemirror/view": "^6.43.0",
+      "@commander-js/extra-typings": "^15.0.0",
+      "@happy-dom/global-registrator": "^20.11.2",
+      "@internationalized/date": "^3.12.2",
+      "@laststance/tailwind-suggest-canonical-classes": "^0.1.1",
+      "@lezer/highlight": "^1.2.3",
+      "@modelcontextprotocol/sdk": "^1.30.0",
+      "@pierre/diffs": "1.3.6",
+      "@pierre/trees": "1.0.0-beta.6",
+      "@playwright/test": "^1.62.1",
+      "@sveltejs/vite-plugin-svelte": "^7.3.0",
+      "@tailwindcss/vite": "^4.3.3",
+      "@types/bun": "^1.4.0",
+      "@types/semver": "^7.7.1",
+      "@typescript/native": "npm:typescript@^7.0.2",
+      "bits-ui": "^2.18.1",
+      clsx: "^2.1.1",
+      commander: "^15.0.0",
+      cuelume: "^0.2.2",
+      "happy-dom": "^20.11.2",
+      "jsonc-parser": "^3.3.1",
+      listr2: "^11.0.0",
+      marked: "^18.0.4",
+      pino: "^10.3.1",
+      "pino-pretty": "^13.1.3",
+      semver: "^7.8.1",
+      shiki: "^4.4.3",
+      "smol-toml": "^1.8.0",
+      svelte: "^5.56.9",
+      "svelte-check": "^4.7.5",
+      "tailwind-merge": "^3.6.0",
+      "tailwind-variants": "^3.2.2",
+      tailwindcss: "^4.3.3",
+      "tw-animate-css": "^1.4.0",
+      typescript: "^6.0.3",
+      vite: "^8.2.1",
+      xss: "^1.0.15",
+      zod: "^4.4.3"
+    },
+    dependencies: {
+      "@opencode-ai/plugin": "^1.18.17"
+    },
+    pinned: {
+      "//": "bun.lock is committed, so it is what pins every dependency exactly; a range above is the upgrade policy, not the resolved version. A bare version therefore means `bun update` must never move this one on its own, and these entries are the whole set. Everything else takes a range deliberately \u2014 zod and the TOML parser reading the config.toml trust boundary included: the lockfile already holds them, so a range costs no reproducibility and keeps them visible to an upgrade sweep. test/structure/exact-pin.test.ts fails on an exact pin with no reason, and on a reason that outlived its pin.",
+      "@pierre/diffs": "Version-coupled to shiki through the resolve.alias block in ui/vite.config.ts, where an alias that stops matching grows the bundle by ~600 KB. That growth is no longer silent \u2014 the caret-bundle-budget plugin fails `vite build` against the recorded budget in ui/bundle-budget.ts \u2014 but the gate reports the size, not the cause, so the pair still moves as one reviewed bump, never on a sweep.",
+      "@pierre/trees": "No stable release exists \u2014 the `latest` and `beta` dist-tags both point at the same prerelease. Exact rather than caret because a prerelease under a caret range is still a caret range: `^1.0.0-beta.6` expands to `>=1.0.0-beta.6 <2.0.0-0`, so a sweep would take a stable 1.0.0 the day it lands, and beta-to-stable is the jump that wants a human."
+    },
+    held: {
+      "//": "A dependency whose range deliberately stops below the current major, with the evidence for that and the condition that lifts it. Distinct from `pinned` above, which is about exact versions: an entry here names a range that is doing its job by excluding something. Unlike a pin, a held range is self-describing to `bun outdated` \u2014 it shows up as a major behind \u2014 so this block answers the question it raises rather than surfacing a decision nothing else would show.",
+      typescript: "NOT a hold on adoption \u2014 TypeScript 7 IS what type-checks this tree (EXC-1089). It arrives as the `@typescript/native` alias above; hk.pkl runs the backend program through node_modules/@typescript/native/bin/tsc and the UI program through `svelte-check --tsgo`, and both were proved live against injected type errors rather than trusted because they exited 0. This range stops at ^6 because svelte-check requires BOTH majors installed: 4.7.6 hard-throws from bin/ts-version-check.js once `typescript` is major >= 7, and the recipe it throws is the arrangement used here verbatim \u2014 `typescript@~6 @typescript/native@npm:typescript@7`, plus --tsgo. Its README repeats it and dist/src/index.js resolves `@typescript/native` before `@typescript/native-preview`, so this is upstream's supported setup rather than a workaround. A second reason keeps 6.x honest even so: the test/structure/ suites that import `typescript` use its compiler API as a PARSING LIBRARY, and 7.x exports lib/version.cjs as `.` with the API behind ./unstable/* subpaths that offer no standalone parse (unstable/ast's createSourceFile is a factory over Statement[]; the only SourceFile producer is Program.getSourceFile). With 6.x installed those suites need no port, and `tsc` 7 type-checks them clean \u2014 the 50 errors EXC-1083 measured were never caret's code, only two files typed against a package whose `.` export had moved. What lifts this: a svelte-check release whose peerDependencies.typescript admits ^7 \u2014 but that clears only the first reason. Collapsing to a single `typescript@7` means dropping the alias, moving this range to ^7, AND porting those suites off the compiler API in the same pass, or they break on `ts.ScriptTarget` being undefined. test/structure/typescript-arrangement.test.ts reds on exactly that widening, and also pins the tsc path, the --tsgo flag, and this entry's own existence, because losing any of them silently reverts the adoption. Full evidence: EXC-1089, and the trial in EXC-1083."
+    }
+  };
+});
+
+// src/lib/upstream.ts
+async function readJson(url, fetchImpl, headers) {
+  try {
+    const res = await fetchImpl(url, {
+      signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
+      ...headers ? { headers } : {}
+    });
+    return res.ok ? await res.json() : null;
+  } catch {
+    return null;
+  }
+}
+async function publishedCaretVersion(fetchImpl = fetch) {
+  const body = await readJson(NPM_LATEST_URL, fetchImpl);
+  const v = body?.version;
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+async function latestReleaseTag(fetchImpl = fetch) {
+  const body = await readJson(LATEST_RELEASE_URL, fetchImpl, GITHUB_HEADERS);
+  const tag = body?.tag_name;
+  if (typeof tag !== "string" || tag.length === 0)
+    return null;
+  const stripped = tag.replace(/^v/, "");
+  return stripped.length > 0 ? stripped : null;
+}
+async function commitsAheadOfTrunk(commit, fetchImpl = fetch) {
+  const url = `${COMPARE_URL}/${encodeURIComponent(commit)}...trunk`;
+  const body = await readJson(url, fetchImpl, GITHUB_HEADERS);
+  const ahead = body?.ahead_by;
+  return typeof ahead === "number" && Number.isFinite(ahead) ? ahead : null;
+}
+async function readParsed(url, schema, fetchImpl) {
+  const parsed = schema.safeParse(await readJson(url, fetchImpl, GITHUB_HEADERS));
+  return parsed.success ? parsed.data : null;
+}
+function listReleases(fetchImpl = fetch) {
+  return readParsed(RELEASES_URL, array(ReleaseSchema), fetchImpl);
+}
+function compareToTrunk(commit, fetchImpl = fetch) {
+  return readParsed(`${COMPARE_URL}/${encodeURIComponent(commit)}...trunk`, CompareSchema, fetchImpl);
+}
+var NPM_LATEST_URL, LATEST_RELEASE_URL = "https://api.github.com/repos/macintacos/caret/releases/latest", COMPARE_URL = "https://api.github.com/repos/macintacos/caret/compare", RELEASES_URL = "https://api.github.com/repos/macintacos/caret/releases?per_page=100", UPSTREAM_TIMEOUT_MS = 3000, GITHUB_HEADERS, ReleaseSchema, CommitSchema, CompareSchema;
+var init_upstream = __esm(() => {
+  init_zod();
+  init_package();
+  NPM_LATEST_URL = `https://registry.npmjs.org/${package_default.name}/latest`;
+  GITHUB_HEADERS = { "user-agent": "caret" };
+  ReleaseSchema = object({
+    tag_name: string2(),
+    body: string2().nullable(),
+    draft: boolean2(),
+    prerelease: boolean2()
+  });
+  CommitSchema = object({
+    sha: string2(),
+    commit: object({ message: string2() })
+  });
+  CompareSchema = object({
+    total_commits: number2(),
+    commits: array(CommitSchema)
+  });
+});
+
+// src/adapters/opencode/upgrade.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, rmSync } from "fs";
+import { join as join6 } from "path";
+function upgradeVerdict(input) {
+  const { entry, cached, published } = input;
+  if (published === null) {
+    return { kind: "unknown", reason: "could not reach npm for the published caret version" };
+  }
+  if (parseVersionTriple(published) === null) {
+    return { kind: "unknown", reason: `npm reported an unreadable version (${published})` };
+  }
+  if (entry === null)
+    return { kind: "fresh" };
+  const pinned = splitPluginSpecifier(entry).version;
+  if (pinned !== null && parseVersionTriple(pinned) !== null) {
+    return isNewer(published, pinned) ? { kind: "stale-pin", entry, pinned, published } : { kind: "current", version: pinned };
+  }
+  if (cached === null)
+    return { kind: "fresh" };
+  if (parseVersionTriple(cached) === null) {
+    return { kind: "unknown", reason: `OpenCode cached an unreadable version (${cached})` };
+  }
+  return isNewer(published, cached) ? { kind: "stale-cache", cached, published } : { kind: "current", version: cached };
+}
+function upgradeVerdictLine(verdict) {
+  switch (verdict.kind) {
+    case "fresh":
+      return "OpenCode will resolve caret on its next start";
+    case "current":
+      return `OpenCode's caret is ${verdict.version} \u2014 already current`;
+    case "stale-cache":
+      return `OpenCode's cached caret is ${verdict.cached}; ${verdict.published} is published`;
+    case "stale-pin":
+      return `Your config pins ${verdict.entry}; ${verdict.published} is published`;
+    case "unknown":
+      return "Could not check which caret OpenCode would load";
+  }
+}
+function upgradeCheck(verdict) {
+  const base = {
+    id: "opencode-caret-version",
+    title: "OpenCode's caret",
+    detail: upgradeVerdictLine(verdict)
+  };
+  switch (verdict.kind) {
+    case "unknown":
+      return { ...base, status: "unknown", reason: verdict.reason };
+    case "stale-cache":
+      return {
+        ...base,
+        status: "fail",
+        remedy: "run `caret install --refresh` to clear the cached copy"
+      };
+    case "stale-pin":
+      return { ...base, status: "fail", remedy: "run `caret install --refresh` to bump the pin" };
+    case "fresh":
+    case "current":
+      return { ...base, status: "pass" };
+  }
+}
+async function readUpgradeVerdict(deps) {
+  return upgradeVerdict({
+    entry: findPluginEntry(readConfigText(deps.configFile), CARET_PACKAGE),
+    cached: readCachedCaretVersion((deps.cacheDirs ?? existingOpencodeCachePackageDirs)()),
+    published: await (deps.published ?? publishedCaretVersion)()
+  });
+}
+function hasCaretPluginEntry(configFile) {
+  return findPluginEntry(readConfigText(configFile), CARET_PACKAGE) !== null;
+}
+function readConfigText(path) {
+  return existsSync2(path) ? readFileSync3(path, "utf-8") : null;
+}
+function readCachedCaretVersion(dirs = existingOpencodeCachePackageDirs()) {
+  for (const d of dirs) {
+    try {
+      const deps = JSON.parse(readFileSync3(join6(d, "package.json"), "utf-8")).dependencies;
+      const v = deps?.[CARET_PACKAGE];
+      if (typeof v === "string" && v.length > 0)
+        return v;
+    } catch {}
+  }
+  return null;
+}
+function clearCachedCaret(dirs = existingOpencodeCachePackageDirs()) {
+  const cleared = [];
+  for (const d of dirs) {
+    if (!existsSync2(d))
+      continue;
+    rmSync(d, { recursive: true, force: true });
+    cleared.push(d);
+  }
+  return cleared;
+}
+var init_upgrade = __esm(() => {
+  init_config_plugin();
+  init_paths2();
+  init_upstream();
+});
+
+// src/adapters/opencode/install.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join7 } from "path";
+function readOpencodeInstallState() {
+  const dir = opencodeConfigDir();
+  if (!existsSync3(dir)) {
+    return { pluginVersion: "unknown", pluginEnabled: "unknown", hookInUserSettings: "unknown" };
+  }
+  const version = readCachedCaretVersion(existingOpencodeCachePackageDirs()) ?? "unknown";
+  return {
+    pluginVersion: version,
+    pluginEnabled: version !== "unknown",
+    hookInUserSettings: readCaretInPluginArray(dir)
+  };
+}
+function readCaretInPluginArray(dir) {
+  let sawConfig = false;
+  for (const name of CONFIG_FILENAMES) {
+    const path = join7(dir, name);
+    if (!existsSync3(path))
+      continue;
+    let cfg;
+    try {
+      cfg = parse3(readFileSync4(path, "utf-8"));
+    } catch {
+      continue;
+    }
+    if (cfg === undefined || cfg === null)
+      continue;
+    sawConfig = true;
+    const arr = cfg.plugin;
+    if (Array.isArray(arr) && arr.some((e) => typeof e === "string" && e.includes("caret"))) {
+      return true;
+    }
+  }
+  return sawConfig ? false : "unknown";
+}
+var init_install3 = __esm(() => {
+  init_main();
+  init_paths2();
+  init_upgrade();
+});
+
+// src/adapters/opencode/skills.ts
+import { readdir as readdir2 } from "fs/promises";
+import { sep as sep2 } from "path";
+async function commandNamesUnder(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { recursive: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((rel) => rel.endsWith(".md")).map((rel) => rel.slice(0, -".md".length).split(sep2).join("/"));
+}
+async function readOpencodeCommands() {
+  const perDir = await Promise.all(commandDirs(opencodeConfigDir()).map(commandNamesUnder));
+  const names = new Set(perDir.flat());
+  return [...names].sort().map((name) => ({ name, origin: "command" }));
+}
+async function readOpencodeCommandDescription(name) {
+  const relative = `${name}.md`;
+  for (const dir of commandDirs(opencodeConfigDir())) {
+    const abs = await containedFile(dir, relative);
+    if (abs !== null)
+      return descriptionOf(abs);
+  }
+  return null;
+}
+var init_skills2 = __esm(() => {
+  init_paths2();
+  init_skill_doc();
+});
+
+// src/adapters/opencode/index.ts
+var opencodeAdapter;
+var init_opencode = __esm(() => {
+  init_approve3();
+  init_feedback3();
+  init_install3();
+  init_skills2();
+  opencodeAdapter = {
+    id: "opencode",
+    approveVariants: APPROVE_VARIANTS3,
+    restartHint: "Then restart OpenCode.",
+    parseHookInput(stdin) {
+      const hook = parseHookStdin(stdin);
+      return {
+        sessionId: hook.session_id,
+        cwd: hook.cwd,
+        plan: hook.tool_input?.plan,
+        planFilePath: hook.tool_input?.planFilePath
+      };
+    },
+    emitDecision(decision) {
+      return JSON.stringify(toWireDecision(decision));
+    },
+    fatalDenyLine,
+    readInstallState() {
+      return readOpencodeInstallState();
+    },
+    listSkills() {
+      return readOpencodeCommands();
+    },
+    readSkillDescription(_cwd, skill) {
+      return readOpencodeCommandDescription(skill.name);
+    }
+  };
+});
+
+// src/adapters/index.ts
+function agentIds() {
+  return Object.keys(REGISTRY);
+}
+function selectAdapter(id) {
+  const raw = (id ?? process.env.CARET_AGENT ?? "").trim();
+  const key = raw === "" ? DEFAULT_AGENT : raw;
+  const adapter = REGISTRY[key];
+  if (!adapter) {
+    throw new Error(`unknown agent adapter: "${key}" (known: ${agentIds().join(", ")})`);
+  }
+  return adapter;
+}
+function fatalDeny(reason) {
+  let adapter;
+  try {
+    adapter = selectAdapter();
+  } catch {}
+  if (adapter) {
+    try {
+      return adapter.emitDecision({ behavior: "deny", feedback: reason, decidedAt: Date.now() });
+    } catch {}
+    try {
+      return adapter.fatalDenyLine(reason);
+    } catch {}
+  }
+  return permissionRequestDenyLine(reason);
+}
+var DEFAULT_AGENT = "claude", CLAUDE_MCP_AGENT = "claude-mcp", REGISTRY;
+var init_adapters = __esm(() => {
+  init_claude();
+  init_codex();
+  init_opencode();
+  REGISTRY = {
+    claude: claudeAdapter,
+    codex: codexAdapter,
+    opencode: opencodeAdapter,
+    [CLAUDE_MCP_AGENT]: {
+      ...claudeAdapter,
+      id: CLAUDE_MCP_AGENT,
+      parseHookInput: opencodeAdapter.parseHookInput,
+      emitDecision: opencodeAdapter.emitDecision,
+      fatalDenyLine: opencodeAdapter.fatalDenyLine
+    }
+  };
+});
+
 // src/config/constants.ts
 function hasKnownFileExtension(path) {
   const base = path.split("/").pop() ?? "";
@@ -9353,6 +9729,7 @@ var init_constants = __esm(() => {
     "php",
     "swift",
     "dart",
+    "lua",
     "txt",
     "lock",
     "cfg",
@@ -9428,6 +9805,9 @@ function daemonStderrLogFile() {
 function daemonLock() {
   return `${stateDir()}/daemon.lock`;
 }
+function daemonBootMarker() {
+  return `${stateDir()}/daemon.boot`;
+}
 function ensureStateDir(target = stateDir()) {
   mkdirSync(target, { recursive: true, mode: 448 });
   chmodSync(target, 448);
@@ -9513,109 +9893,6 @@ async function loadUiAssets() {
 }
 var init_assets = () => {};
 
-// package.json
-var package_default;
-var init_package = __esm(() => {
-  package_default = {
-    name: "@macintacos/caret",
-    version: "1.0.2",
-    license: "MIT",
-    type: "module",
-    description: "A Claude Code plugin that replaces the terminal plan-approval prompt with a local web UI for inline review, annotation, and approval.",
-    main: "./opencode/index.ts",
-    exports: {
-      ".": "./opencode/index.ts"
-    },
-    bin: {
-      caret: "./bin/caret"
-    },
-    homepage: "https://github.com/macintacos/caret",
-    repository: {
-      type: "git",
-      url: "git+https://github.com/macintacos/caret.git"
-    },
-    publishConfig: {
-      access: "public"
-    },
-    files: [
-      "dist/",
-      "ui/dist/",
-      "bin/caret",
-      "bin/caret-launcher",
-      "hooks/",
-      "commands/",
-      "opencode/",
-      "templates/",
-      ".claude-plugin/plugin.json"
-    ],
-    scripts: {
-      test: "bun test --conditions browser --parallel --timeout 35000",
-      lint: "mise run lint",
-      format: "mise run format",
-      build: "mise run build"
-    },
-    devDependencies: {
-      "@clack/prompts": "^1.7.0",
-      "@codemirror/autocomplete": "^6.20.3",
-      "@codemirror/commands": "^6.10.3",
-      "@codemirror/lang-markdown": "^6.5.0",
-      "@codemirror/language": "^6.12.3",
-      "@codemirror/language-data": "^6.5.2",
-      "@codemirror/state": "^6.6.0",
-      "@codemirror/view": "^6.43.0",
-      "@commander-js/extra-typings": "^15.0.0",
-      "@happy-dom/global-registrator": "^20.11.2",
-      "@internationalized/date": "^3.12.2",
-      "@laststance/tailwind-suggest-canonical-classes": "^0.1.1",
-      "@lezer/highlight": "^1.2.3",
-      "@modelcontextprotocol/sdk": "^1.30.0",
-      "@pierre/diffs": "1.3.6",
-      "@pierre/trees": "1.0.0-beta.6",
-      "@playwright/test": "^1.62.1",
-      "@sveltejs/vite-plugin-svelte": "^7.3.0",
-      "@tailwindcss/vite": "^4.3.3",
-      "@types/bun": "^1.4.0",
-      "@types/semver": "^7.7.1",
-      "@typescript/native": "npm:typescript@^7.0.2",
-      "bits-ui": "^2.18.1",
-      clsx: "^2.1.1",
-      commander: "^15.0.0",
-      cuelume: "^0.2.2",
-      "happy-dom": "^20.11.2",
-      "jsonc-parser": "^3.3.1",
-      listr2: "^11.0.0",
-      marked: "^18.0.4",
-      pino: "^10.3.1",
-      "pino-pretty": "^13.1.3",
-      semver: "^7.8.1",
-      shiki: "^4.4.3",
-      "smol-toml": "^1.8.0",
-      svelte: "^5.56.9",
-      "svelte-check": "^4.7.5",
-      "tailwind-merge": "^3.6.0",
-      "tailwind-variants": "^3.2.2",
-      tailwindcss: "^4.3.3",
-      "tw-animate-css": "^1.4.0",
-      typescript: "^6.0.3",
-      vite: "^8.2.1",
-      xss: "^1.0.15",
-      zod: "^4.4.3"
-    },
-    dependencies: {
-      "@opencode-ai/plugin": "^1.18.17"
-    },
-    pinned: {
-      "//": "bun.lock is committed, so it is what pins every dependency exactly; a range above is the upgrade policy, not the resolved version. A bare version therefore means `bun update` must never move this one on its own, and these entries are the whole set. Everything else takes a range deliberately \u2014 zod and the TOML parser reading the config.toml trust boundary included: the lockfile already holds them, so a range costs no reproducibility and keeps them visible to an upgrade sweep. test/structure/exact-pin.test.ts fails on an exact pin with no reason, and on a reason that outlived its pin.",
-      "@pierre/diffs": "Version-coupled to shiki through the resolve.alias block in ui/vite.config.ts, where an alias that stops matching grows the bundle by ~600 KB. That growth is no longer silent \u2014 the caret-bundle-budget plugin fails `vite build` against the recorded budget in ui/bundle-budget.ts \u2014 but the gate reports the size, not the cause, so the pair still moves as one reviewed bump, never on a sweep.",
-      "@pierre/trees": "No stable release exists \u2014 the `latest` and `beta` dist-tags both point at the same prerelease. Exact rather than caret because a prerelease under a caret range is still a caret range: `^1.0.0-beta.6` expands to `>=1.0.0-beta.6 <2.0.0-0`, so a sweep would take a stable 1.0.0 the day it lands, and beta-to-stable is the jump that wants a human."
-    },
-    held: {
-      "//": "A dependency whose range deliberately stops below the current major, with the evidence for that and the condition that lifts it. Distinct from `pinned` above, which is about exact versions: an entry here names a range that is doing its job by excluding something. Unlike a pin, a held range is self-describing to `bun outdated` \u2014 it shows up as a major behind \u2014 so this block answers the question it raises rather than surfacing a decision nothing else would show.",
-      typescript: "NOT a hold on adoption \u2014 TypeScript 7 IS what type-checks this tree (EXC-1089). It arrives as the `@typescript/native` alias above; hk.pkl runs the backend program through node_modules/@typescript/native/bin/tsc and the UI program through `svelte-check --tsgo`, and both were proved live against injected type errors rather than trusted because they exited 0. This range stops at ^6 because svelte-check requires BOTH majors installed: 4.7.6 hard-throws from bin/ts-version-check.js once `typescript` is major >= 7, and the recipe it throws is the arrangement used here verbatim \u2014 `typescript@~6 @typescript/native@npm:typescript@7`, plus --tsgo. Its README repeats it and dist/src/index.js resolves `@typescript/native` before `@typescript/native-preview`, so this is upstream's supported setup rather than a workaround. A second reason keeps 6.x honest even so: the test/structure/ suites that import `typescript` use its compiler API as a PARSING LIBRARY, and 7.x exports lib/version.cjs as `.` with the API behind ./unstable/* subpaths that offer no standalone parse (unstable/ast's createSourceFile is a factory over Statement[]; the only SourceFile producer is Program.getSourceFile). With 6.x installed those suites need no port, and `tsc` 7 type-checks them clean \u2014 the 50 errors EXC-1083 measured were never caret's code, only two files typed against a package whose `.` export had moved. What lifts this: a svelte-check release whose peerDependencies.typescript admits ^7 \u2014 but that clears only the first reason. Collapsing to a single `typescript@7` means dropping the alias, moving this range to ^7, AND porting those suites off the compiler API in the same pass, or they break on `ts.ScriptTarget` being undefined. test/structure/typescript-arrangement.test.ts reds on exactly that widening, and also pins the tsc path, the --tsgo flag, and this entry's own existence, because losing any of them silently reverts the adoption. Full evidence: EXC-1089, and the trial in EXC-1083."
-    }
-  };
-});
-
 // src/lib/build-id.ts
 import { createHash } from "crypto";
 function buildKind(argv1 = process.argv[1]) {
@@ -11641,7 +11918,7 @@ var require_indexes = __commonJS(function(exports, module) {
 
 // node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream/index.js
 var require_thread_stream = __commonJS(function(exports, module) {
-  var __dirname = "/Users/juliantorres/GitLocal/Play/caret/trunk/node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream";
+  var __dirname = "/Users/juliantorres/GitLocal/Play/caret/node_modules/.bun/thread-stream@4.2.0/node_modules/thread-stream";
   var { version } = require_package();
   var { EventEmitter } = __require("events");
   var { Worker } = __require("worker_threads");
@@ -12157,7 +12434,7 @@ var require_thread_stream = __commonJS(function(exports, module) {
 
 // node_modules/.bun/pino@10.3.1/node_modules/pino/lib/transport.js
 var require_transport = __commonJS(function(exports, module) {
-  var __dirname = "/Users/juliantorres/GitLocal/Play/caret/trunk/node_modules/.bun/pino@10.3.1/node_modules/pino/lib";
+  var __dirname = "/Users/juliantorres/GitLocal/Play/caret/node_modules/.bun/pino@10.3.1/node_modules/pino/lib";
   var { createRequire } = __require("module");
   var { existsSync } = __require("fs");
   var getCallers = require_caller();
@@ -14294,9 +14571,10 @@ var init_node = __esm(() => {
 });
 
 // src/lib/log.ts
-function wrap(logger, liveLevel, liveRedact, source, rotate) {
+function wrap(logger, opts) {
+  const { liveLevel, liveRedact, source, rotate, bound } = opts;
   function fields(extra, step, redact) {
-    const out = scrubValue({ ...extra }, redact);
+    const out = scrubValue(Object.assign({}, ...bound, extra), redact);
     out.step = step;
     if (out.source == null) {
       out.source = source;
@@ -14322,17 +14600,19 @@ function wrap(logger, liveLevel, liveRedact, source, rotate) {
     debug: (step, msg, extra) => emit("debug", step, msg, extra),
     info: (step, msg, extra) => emit("info", step, msg, extra),
     warn: (step, msg, extra) => emit("warn", step, msg, extra),
-    error(step, err, extra) {
+    error(step, code, err, extra) {
       try {
         rotate?.();
         const r = liveRedact();
-        const f = fields(extra, step, r);
+        const record = fields(extra, step, r);
+        record.code = code;
         if (err instanceof Error)
-          f.err = scrubValue(import_pino.default.stdSerializers.errWithCause(err), r);
+          record.err = scrubValue(import_pino.default.stdSerializers.errWithCause(err), r);
         const msg = errorMessage(err);
-        logger.error(f, r ? scrubString(msg) : msg);
+        logger.error(record, r ? scrubString(msg) : msg);
       } catch {}
-    }
+    },
+    child: (ctx) => wrap(logger, { ...opts, bound: [...bound, ctx] })
   };
 }
 function createHookLogger(level, redact, limits) {
@@ -14341,7 +14621,14 @@ function createHookLogger(level, redact, limits) {
     ensureLogsDir();
     const dest = import_pino.default.destination({ dest: path, sync: true, mode: 384 });
     const rotate = () => rotateIfOversized(path, limits.maxSize(), limits.keep());
-    return { log: wrap(import_pino.default(pinoOpts, dest), level, redact, "hook", rotate), dest, path };
+    const log = wrap(import_pino.default(pinoOpts, dest), {
+      liveLevel: level,
+      liveRedact: redact,
+      source: "hook",
+      rotate,
+      bound: []
+    });
+    return { log, dest, path };
   } catch {
     return { log: noopLogger, dest: null, path };
   }
@@ -14349,14 +14636,14 @@ function createHookLogger(level, redact, limits) {
 function hook() {
   const path = logFile();
   if (hookState.instance && hookState.instance.path === path) {
-    return hookState.instance.log;
+    return hookState.instance.log.child(hookState.context);
   }
   try {
     hookState.instance?.dest?.destroy();
   } catch {}
   const next = createHookLogger(() => hookState.level, () => hookState.redact, { maxSize: () => hookState.maxSize, keep: () => hookState.keep });
   hookState.instance = next.dest ? next : null;
-  return next.log;
+  return next.log.child(hookState.context);
 }
 function setLogLevel(level) {
   hookState.level = level;
@@ -14368,6 +14655,9 @@ function setLogRotation(maxSize, keep) {
   hookState.maxSize = maxSize;
   hookState.keep = keep;
 }
+function setLogContext(ctx) {
+  hookState.context = { ...ctx };
+}
 function logDebug(step, msg, extra) {
   hook().debug(step, msg, extra);
 }
@@ -14377,8 +14667,8 @@ function logInfo(step, msg, extra) {
 function logWarn(step, msg, extra) {
   hook().warn(step, msg, extra);
 }
-function logError(step, err, ctx) {
-  hook().error(step, err, ctx);
+function logError(step, code, err, extra) {
+  hook().error(step, code, err, extra);
 }
 function createDaemonLogger(level, dest = daemonLogFile(), redact = () => false, limits) {
   try {
@@ -14390,7 +14680,13 @@ function createDaemonLogger(level, dest = daemonLogFile(), redact = () => false,
     });
     const logger = import_pino.default({ ...pinoOpts, base: { pid: process.pid } }, target);
     const rotate = limits && typeof dest === "string" ? () => rotateIfOversized(dest, limits.maxSize(), limits.keep()) : undefined;
-    return wrap(logger, level, redact, "daemon", rotate);
+    return wrap(logger, {
+      liveLevel: level,
+      liveRedact: redact,
+      source: "daemon",
+      rotate,
+      bound: []
+    });
   } catch {
     return noopLogger;
   }
@@ -14413,13 +14709,15 @@ var init_log = __esm(() => {
     debug: () => {},
     info: () => {},
     warn: () => {},
-    error: () => {}
+    error: () => {},
+    child: () => noopLogger
   };
   hookState = {
     level: "info",
     redact: false,
     maxSize: DEFAULT_LOG_MAX_SIZE,
     keep: DEFAULT_LOG_KEEP,
+    context: {},
     instance: null
   };
 });
@@ -14438,7 +14736,7 @@ function freeze(s) {
 }
 function logValidationFailure(err) {
   const safe = err.issues.map((i) => `${i.path.length ? i.path.join(".") : "(root)"}: ${i.code}`).join("; ");
-  logError("settings", new Error(`config.toml ignored \u2014 invalid: ${safe}`));
+  logError("settings", "config-invalid", new Error(`config.toml ignored \u2014 invalid: ${safe}`));
 }
 function parseAndValidate(text, isCompiled) {
   let raw;
@@ -14675,18 +14973,24 @@ async function postReview(baseUrl, input) {
     throw new Error(`POST /api/reviews failed: ${res.status}`);
   return await res.json();
 }
-async function expireReview(baseUrl, id) {
-  const res = await fetch(`${baseUrl}/api/reviews/${id}/expire`, {
+function versionSearch(version) {
+  return version === undefined ? "" : `?version=${version}`;
+}
+async function expireReview(baseUrl, id, version) {
+  const res = await fetch(`${baseUrl}/api/reviews/${id}/expire${versionSearch(version)}`, {
     method: "POST",
     signal: AbortSignal.timeout(1000)
   });
-  if (!res.ok && res.status !== 404)
+  if (!res.ok && res.status !== 404 && res.status !== 409) {
     throw new Error(`POST /expire failed: ${res.status}`);
+  }
 }
-async function longPoll(baseUrl, id) {
-  const res = await fetch(`${baseUrl}/api/reviews/${id}/decision`);
+async function longPoll(baseUrl, id, version) {
+  const res = await fetch(`${baseUrl}/api/reviews/${id}/decision${versionSearch(version)}`);
   if (res.status === 204)
     return null;
+  if (res.status === 409)
+    return "superseded";
   if (!res.ok)
     throw new Error(`decision long-poll failed: ${res.status}`);
   return await res.json();
@@ -14714,9 +15018,12 @@ import {
   chmodSync as chmodSync2,
   constants,
   existsSync as existsSync6,
+  linkSync,
   openSync as openSync2,
   readFileSync as readFileSync8,
-  unlinkSync as unlinkSync2
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
 import { join as join9, normalize } from "path";
 function isAddrInUse(e) {
@@ -14738,7 +15045,9 @@ async function ensureDaemon(deps, mode = "takeover") {
   let windowSpent = mode === "successor" ? await awaitDrained(deps, windowEnd) : false;
   let supervised;
   let spawnedPid;
+  let waitingOn;
   for (let attempt = 0;attempt < timing.maxAttempts && timing.now() < deadline; attempt++) {
+    waitingOn = undefined;
     windowSpent ||= timing.now() >= windowEnd;
     const h = await deps.health(deps.baseUrl);
     if (h && h.service === "caret") {
@@ -14783,17 +15092,27 @@ async function ensureDaemon(deps, mode = "takeover") {
       deps.removeLock();
       logDebug("spawn", "orphan daemon lock removed");
     }
-    if (spawnedPid === undefined || !deps.isAlive(spawnedPid)) {
+    const claim = claimBoot(deps);
+    if (claim.claimed && spawnedPid !== undefined && deps.isAlive(spawnedPid)) {
+      deps.bootMarker.clear();
+    } else if (claim.claimed) {
       try {
         spawnedPid = deps.spawn();
+        deps.bootMarker.assign(spawnedPid);
         logDebug("spawn", "daemon spawned", { pid: spawnedPid });
       } catch (e) {
+        deps.bootMarker.clear();
         if (!isAddrInUse(e))
           throw e;
       }
+    } else if (claim.bootPid !== spawnedPid) {
+      waitingOn = claim.bootPid;
     }
     await timing.backoff(attempt);
   }
+  if (waitingOn !== undefined) {
+    logDebug("spawn", "gave up waiting on a booting daemon", { bootPid: waitingOn });
+  }
   const final = await deps.health(deps.baseUrl);
   if (final && final.service === "caret") {
     if (isForeignWorld(final, deps.currentStateDir))
@@ -14802,6 +15121,22 @@ async function ensureDaemon(deps, mode = "takeover") {
   }
   throw new Error("caret daemon did not become healthy in time");
 }
+function claimBoot(deps) {
+  const { bootMarker, timing } = deps;
+  if (bootMarker.claim({ pid: process.pid, claimedAt: timing.wallNow() })) {
+    return { claimed: true };
+  }
+  const held = bootMarker.read();
+  if (!held)
+    return { claimed: false };
+  const age = timing.wallNow() - held.claimedAt;
+  if (deps.isAlive(held.pid) && age >= 0 && age < BOOT_MARKER_TTL_MS) {
+    return { claimed: false, bootPid: held.pid };
+  }
+  bootMarker.clear();
+  logDebug("spawn", "stale boot marker removed", { bootPid: held.pid });
+  return { claimed: false };
+}
 async function awaitDrained(deps, until) {
   const h = await deps.health(deps.baseUrl);
   if (h?.service !== "caret")
@@ -14868,6 +15203,51 @@ function readDaemonLock() {
     return lock;
   return null;
 }
+function readBootMarker() {
+  const m = readJsonFileSync(daemonBootMarker());
+  if (m && typeof m.pid === "number" && typeof m.claimedAt === "number")
+    return m;
+  return null;
+}
+function fileBootMarker() {
+  const write = (marker, place) => {
+    const path = daemonBootMarker();
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync3(tmp, JSON.stringify(marker), { mode: 384 });
+    try {
+      place(tmp, path);
+    } finally {
+      rmQuiet(tmp);
+    }
+  };
+  return {
+    claim: (marker) => {
+      try {
+        ensureStateDir();
+        write(marker, linkSync);
+        return true;
+      } catch (e) {
+        return e.code !== "EEXIST";
+      }
+    },
+    assign: (pid) => {
+      try {
+        write({ pid, claimedAt: readBootMarker()?.claimedAt ?? 0 }, renameSync2);
+      } catch {}
+    },
+    read: readBootMarker,
+    clear: () => rmQuiet(daemonBootMarker())
+  };
+}
+function removeOwnBootMarker() {
+  if (readBootMarker()?.pid === process.pid)
+    rmQuiet(daemonBootMarker());
+}
+function rmQuiet(path) {
+  try {
+    unlinkSync2(path);
+  } catch {}
+}
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -14877,9 +15257,7 @@ function isPidAlive(pid) {
   }
 }
 function removeDaemonLock() {
-  try {
-    unlinkSync2(daemonLock());
-  } catch {}
+  rmQuiet(daemonLock());
 }
 function removeOwnDaemonLock() {
   if (readDaemonLock()?.pid === process.pid)
@@ -14972,16 +15350,18 @@ async function prodEnsureDeps(s, service, reserveMs) {
     retire: (baseUrl, lock) => retireDaemon(baseUrl, lock, world),
     removeLock: removeDaemonLock,
     spawn: () => spawnDaemon(s),
+    bootMarker: fileBootMarker(),
     timing: {
       backoff,
       maxAttempts: PROD_MAX_ATTEMPTS,
       now: () => performance.now(),
+      wallNow: Date.now,
       windowMs: SUPERVISOR_WINDOW_MS,
       reserveMs
     }
   };
 }
-var FOREIGN_WORLD_ERROR = "port serves a different caret world (state dir mismatch) \u2014 set CARET_PORT to a free port", DAEMON_CWD = "/", PROD_MAX_ATTEMPTS = 12, SUPERVISOR_WINDOW_MS;
+var BOOT_MARKER_TTL_MS = 30000, FOREIGN_WORLD_ERROR = "port serves a different caret world (state dir mismatch) \u2014 set CARET_PORT to a free port", DAEMON_CWD = "/", PROD_MAX_ATTEMPTS = 12, SUPERVISOR_WINDOW_MS;
 var init_lifecycle = __esm(() => {
   init_paths3();
   init_settings();
@@ -16342,7 +16722,7 @@ __export(exports_dist, {
   box: () => box,
   cancel: () => cancel,
   confirm: () => confirm,
-  date: () => date2,
+  date: () => date3,
   formatInstructionFooter: () => formatInstructionFooter,
   group: () => group,
   groupMultiselect: () => groupMultiselect,
@@ -16375,8 +16755,8 @@ __export(exports_dist, {
 });
 import { styleText as styleText2, stripVTControlCharacters } from "util";
 import process$1 from "process";
-import { existsSync as existsSync13, lstatSync, readdirSync as readdirSync6 } from "fs";
-import { dirname as dirname9, join as join18 } from "path";
+import { existsSync as existsSync10, lstatSync, readdirSync as readdirSync4 } from "fs";
+import { dirname as dirname8, join as join15 } from "path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -16725,7 +17105,7 @@ ${g}
       }
     }
   }).prompt();
-}, date2 = (e) => {
+}, date3 = (e) => {
   const r = e.validate;
   return new U2({
     ...e,
@@ -17087,10 +17467,10 @@ ${n}
         return [];
       try {
         let i;
-        existsSync13(t) ? lstatSync(t).isDirectory() && (!e.directory || t.endsWith("/")) ? i = t : i = dirname9(t) : i = dirname9(t);
+        existsSync10(t) ? lstatSync(t).isDirectory() && (!e.directory || t.endsWith("/")) ? i = t : i = dirname8(t) : i = dirname8(t);
         const c = t.length > 1 && t.endsWith("/") ? t.slice(0, -1) : t;
-        return readdirSync6(i).map((r) => {
-          const n = join18(i, r), m = lstatSync(n);
+        return readdirSync4(i).map((r) => {
+          const n = join15(i, r), m = lstatSync(n);
           return {
             name: r,
             path: n,
@@ -18675,7 +19055,7 @@ var handleResult = (ctx, result) => {
       }
     };
   }
-}, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`, dateRegex, ZodString2, ZodNumber2, ZodBigInt, ZodBoolean2, ZodDate, ZodSymbol, ZodUndefined, ZodNull2, ZodAny, ZodUnknown2, ZodNever2, ZodVoid, ZodArray2, ZodObject2, ZodUnion2, getDiscriminator = (type) => {
+}, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`, dateRegex, ZodString2, ZodNumber2, ZodBigInt2, ZodBoolean2, ZodDate2, ZodSymbol, ZodUndefined, ZodNull2, ZodAny, ZodUnknown2, ZodNever2, ZodVoid, ZodArray2, ZodObject2, ZodUnion2, getDiscriminator = (type) => {
   if (type instanceof ZodLazy) {
     return getDiscriminator(type.schema);
   } else if (type instanceof ZodEffects) {
@@ -19502,7 +19882,7 @@ var init_types = __esm(() => {
       ...processCreateParams(params)
     });
   };
-  ZodBigInt = class ZodBigInt extends ZodType2 {
+  ZodBigInt2 = class ZodBigInt2 extends ZodType2 {
     constructor() {
       super(...arguments);
       this.min = this.gte;
@@ -19587,7 +19967,7 @@ var init_types = __esm(() => {
       return this.setLimit("max", value, false, errorUtil.toString(message));
     }
     setLimit(kind, value, inclusive, message) {
-      return new ZodBigInt({
+      return new ZodBigInt2({
         ...this._def,
         checks: [
           ...this._def.checks,
@@ -19601,7 +19981,7 @@ var init_types = __esm(() => {
       });
     }
     _addCheck(check) {
-      return new ZodBigInt({
+      return new ZodBigInt2({
         ...this._def,
         checks: [...this._def.checks, check]
       });
@@ -19666,8 +20046,8 @@ var init_types = __esm(() => {
       return max;
     }
   };
-  ZodBigInt.create = (params) => {
-    return new ZodBigInt({
+  ZodBigInt2.create = (params) => {
+    return new ZodBigInt2({
       checks: [],
       typeName: ZodFirstPartyTypeKind2.ZodBigInt,
       coerce: params?.coerce ?? false,
@@ -19699,7 +20079,7 @@ var init_types = __esm(() => {
       ...processCreateParams(params)
     });
   };
-  ZodDate = class ZodDate extends ZodType2 {
+  ZodDate2 = class ZodDate2 extends ZodType2 {
     _parse(input) {
       if (this._def.coerce) {
         input.data = new Date(input.data);
@@ -19760,7 +20140,7 @@ var init_types = __esm(() => {
       };
     }
     _addCheck(check) {
-      return new ZodDate({
+      return new ZodDate2({
         ...this._def,
         checks: [...this._def.checks, check]
       });
@@ -19800,8 +20180,8 @@ var init_types = __esm(() => {
       return max != null ? new Date(max) : null;
     }
   };
-  ZodDate.create = (params) => {
-    return new ZodDate({
+  ZodDate2.create = (params) => {
+    return new ZodDate2({
       checks: [],
       coerce: params?.coerce || false,
       typeName: ZodFirstPartyTypeKind2.ZodDate,
@@ -21467,9 +21847,9 @@ var init_types = __esm(() => {
   stringType = ZodString2.create;
   numberType = ZodNumber2.create;
   nanType = ZodNaN.create;
-  bigIntType = ZodBigInt.create;
+  bigIntType = ZodBigInt2.create;
   booleanType = ZodBoolean2.create;
-  dateType = ZodDate.create;
+  dateType = ZodDate2.create;
   symbolType = ZodSymbol.create;
   undefinedType = ZodUndefined.create;
   nullType = ZodNull2.create;
@@ -33494,6 +33874,89 @@ function optedOut(text) {
 // src/commands/daemon.ts
 init_settings();
 
+// src/daemon/update-changes.ts
+var COMMIT_CAP = 50;
+var RELEASE_TAG = /^v?\d+\.\d+\.\d+$/;
+var FULL_SHA = /^[0-9a-f]{40}$/;
+var COMPARABLE_COMMIT = /^[0-9a-f]{7,40}$/;
+function selectReleases(releases, running, target) {
+  return releases.filter((r) => !r.draft && !r.prerelease && RELEASE_TAG.test(r.tag_name)).map((r) => ({ version: r.tag_name.replace(/^v/, ""), body: r.body ?? "" })).filter((r) => isNewer(r.version, running) && !isNewer(r.version, target)).sort((a, b) => isNewer(a.version, b.version) ? -1 : isNewer(b.version, a.version) ? 1 : 0);
+}
+function selectCommits(newestFirst, total, cap) {
+  const commits = newestFirst.filter((c) => FULL_SHA.test(c.sha)).slice(0, cap).map((c) => {
+    const subject = c.commit.message.split(`
+`, 1)[0] ?? "";
+    return { sha: c.sha, subject, pr: prNumber(subject) };
+  });
+  return { kind: "commits", commits, more: Math.max(0, total - commits.length) };
+}
+function prNumber(subject) {
+  const match = /\(#(\d+)\)$/.exec(subject);
+  return match ? Number(match[1]) : null;
+}
+function createUpdateChanges(deps) {
+  let slot = null;
+  return () => {
+    const status = deps.status();
+    if (slot?.status === status)
+      return slot.promise;
+    const promise = changesFor(deps, status).catch(() => failed(deps.log)).then((changes) => {
+      if (changes === null && slot?.promise === promise)
+        slot = null;
+      return changes;
+    });
+    slot = { status, promise };
+    return promise;
+  };
+}
+async function changesFor(deps, status) {
+  if (deps.install === "bundle" && status.kind === "behind-release") {
+    const releases = await deps.releases();
+    if (!releases)
+      return failed(deps.log);
+    return { kind: "releases", releases: selectReleases(releases, deps.version, status.available) };
+  }
+  const behind = status.kind === "behind-release" || status.kind === "behind-commit";
+  if (deps.install !== "binary" || !behind || !COMPARABLE_COMMIT.test(deps.commit))
+    return null;
+  const comparison = await deps.compare(deps.commit);
+  if (!comparison)
+    return failed(deps.log);
+  return selectCommits([...comparison.commits].reverse(), comparison.total_commits, COMMIT_CAP);
+}
+function failed(log) {
+  log.warn("update", "update changes read failed");
+  return null;
+}
+
+// src/daemon/dev-update.ts
+var RELEASES_BACK = 3;
+var COMMITS_BACK = 60;
+function devUpdateIdentity(raw, built, git) {
+  if (built.install !== "dev")
+    return null;
+  if (raw === "release") {
+    const tags = git(["tag", "--list", "v*", "--sort=-v:refname"])?.split(`
+`) ?? [];
+    const tag = tags.filter((t) => RELEASE_TAG.test(t))[RELEASES_BACK];
+    return tag ? { install: "bundle", version: tag.replace(/^v/, ""), commit: built.commit } : null;
+  }
+  if (raw === "commit") {
+    const commit = git(["rev-parse", "--verify", "--quiet", `origin/trunk~${COMMITS_BACK}`]);
+    return commit ? { install: "binary", version: built.version, commit } : null;
+  }
+  return null;
+}
+function sourceGit(args) {
+  try {
+    const r = Bun.spawnSync(["git", "-C", import.meta.dir, ...args]);
+    const out = r.exitCode === 0 ? r.stdout.toString().trim() : "";
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
 // src/daemon/diagnostics.ts
 init_settings();
 init_core3();
@@ -33533,7 +33996,7 @@ function buildDiagnostics(deps) {
 init_lifecycle();
 
 // src/daemon/server.ts
-import { renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
+import { renameSync as renameSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname6 } from "path";
 init_constants();
 init_paths3();
@@ -33686,8 +34149,10 @@ var BehaviorSchema = _enum(["allow", "deny"]);
 var ResolveBodySchema = object({
   behavior: BehaviorSchema.catch("allow"),
   feedback: string2().optional(),
-  acceptMode: string2().optional().catch(undefined)
+  acceptMode: string2().optional().catch(undefined),
+  version: number2().int().positive().optional().catch(undefined)
 }).catch({ behavior: "allow" });
+var VersionQuerySchema = exports_coerce.number().int().positive().optional().catch(undefined);
 var ConfigPatchSchema = object({ updates: object({ check: boolean2() }).strict().optional() }).strict();
 var LineAnnotationSchema = object({
   id: string2(),
@@ -33835,7 +34300,8 @@ var EXT_LANGUAGE = {
   ".gql": "graphql",
   ".php": "php",
   ".swift": "swift",
-  ".dart": "dart"
+  ".dart": "dart",
+  ".lua": "lua"
 };
 function languageForPath(path) {
   return EXT_LANGUAGE[extname(path).toLowerCase()] ?? "text";
@@ -35529,23 +35995,37 @@ var un = x.lex;
 init_log();
 
 // src/plan/canonical-file.ts
-import { appendFileSync, existsSync as existsSync7, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
+function isPlanFile(path) {
+  return path.endsWith(".md") && existsSync7(path) && statSync3(path).isFile();
+}
+function readPlanFile(path) {
+  try {
+    return isPlanFile(path) ? readFileSync10(path, "utf8") : undefined;
+  } catch {
+    return;
+  }
+}
 function guardedPlanFileWrite(planFilePath, log, failMsg, write) {
   try {
-    if (!planFilePath.endsWith(".md"))
-      return;
-    if (!existsSync7(planFilePath) || !statSync3(planFilePath).isFile())
+    if (!isPlanFile(planFilePath))
       return;
-    write(planFilePath);
+    return write(planFilePath);
   } catch (err) {
     const code = err?.code;
-    log.warn("review", failMsg, code ? { code } : {});
+    log.warn("review", failMsg, code ? { fsCode: code } : {});
+    return;
   }
 }
-function writeCanonicalPlanFile(planFilePath, canonical, log) {
-  if (!planFilePath)
-    return;
-  guardedPlanFileWrite(planFilePath, log, "plan file canonicalize failed", (p) => writeFileSync3(p, canonical));
+function writeCanonicalPlanFile(input, canonical, log) {
+  return guardedPlanFileWrite(input.planFilePath, log, "plan file canonicalize failed", (p) => {
+    if (readFileSync10(p, "utf8") !== (input.plan ?? "")) {
+      log.info("review", "plan file changed; rewrite skipped");
+      return "changed";
+    }
+    writeFileSync4(p, canonical);
+    return "written";
+  }) ?? "skipped";
 }
 function appendReviewerNotesToPlanFile(planFilePath, notes, log) {
   const section = reviewerNotesSection(notes);
@@ -35560,7 +36040,7 @@ init_log();
 // src/plan/rumdl.ts
 init_paths3();
 import { createHash as createHash2 } from "crypto";
-import { chmodSync as chmodSync3, existsSync as existsSync8, mkdirSync as mkdirSync2, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync8, mkdirSync as mkdirSync2, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
 import { mkdtemp, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname as dirname5, join as join13 } from "path";
@@ -35620,7 +36100,7 @@ async function downloadRumdl(binPath, asset, fetchImpl = fetch) {
     const tmp = `${binPath}.${process.pid}.tmp`;
     await Bun.write(tmp, Bun.file(extracted));
     chmodSync3(tmp, 493);
-    renameSync2(tmp, binPath);
+    renameSync3(tmp, binPath);
     return binPath;
   } finally {
     await rm3(work, { recursive: true, force: true });
@@ -35645,7 +36125,7 @@ var acquisition = { cooldownUntil: 0 };
 async function ensureRumdl(install = installPinnedRumdl, now = Date.now, state = acquisition) {
   ensureStateDir(rumdlDir());
   const config = rumdlConfig();
-  writeFileSync4(config, RUMDL_CONFIG);
+  writeFileSync5(config, RUMDL_CONFIG);
   const override = process.env.CARET_RUMDL_BIN?.trim();
   if (override && await installedVersion(override) === RUMDL_VERSION) {
     return { bin: override, config, installed: false };
@@ -35727,21 +36207,25 @@ function deriveTitle(plan) {
 }
 async function routeIncomingPlan(input, store, log = noopLogger) {
   const sessionId = input.sessionId ?? `anon-${Date.now()}`;
-  const plan = await formatPlanMarkdown(input.plan ?? "", log);
-  writeCanonicalPlanFile(input.planFilePath, plan, log);
+  const sessionLog = log.child({ sessionId });
+  const plan = await formatPlanMarkdown(input.plan ?? "", sessionLog);
+  const { planFilePath } = input;
+  const planFile = planFilePath ? {
+    planFileCurrent: writeCanonicalPlanFile({ ...input, planFilePath }, plan, sessionLog) !== "changed"
+  } : {};
   const now = Date.now();
+  const [latest, ...older] = store.bySession(sessionId);
   const expired = [];
-  for (const stale of store.bySession(sessionId).filter((r) => r.status === "pending")) {
-    await store.expire(stale.id);
-    expired.push(stale.id);
-    log.info("review", `review superseded: ${shortId(stale.id)}`, {
-      reviewId: stale.id,
+  for (const orphan of older.filter((r) => r.status === "pending")) {
+    await store.expire(orphan.id);
+    expired.push(orphan.id);
+    log.info("review", `review superseded: ${shortId(orphan.id)}`, {
+      reviewId: orphan.id,
       sessionId,
       action: "supersede"
     });
   }
-  const latest = store.bySession(sessionId)[0];
-  if (latest && latest.status === "rejected") {
+  if (latest && (latest.status === "rejected" || latest.status === "pending")) {
     const version = latest.versions.length + 1;
     await store.update(latest.id, (r) => {
       r.versions.push({ version, plan, annotations: [], createdAt: now });
@@ -35760,7 +36244,8 @@ async function routeIncomingPlan(input, store, log = noopLogger) {
       id: latest.id,
       action: "append",
       version,
-      expired
+      expired,
+      ...planFile
     };
   }
   const id = newReviewId();
@@ -35782,7 +36267,7 @@ async function routeIncomingPlan(input, store, log = noopLogger) {
     action: "new",
     version: 1
   });
-  return { id, action: "new", version: 1, expired };
+  return { id, action: "new", version: 1, expired, ...planFile };
 }
 
 // src/service/manager.ts
@@ -35824,7 +36309,16 @@ var MAX_BODY_BYTES = 64 * 1024;
 var MAX_EVENTS = 100;
 var MAX_MSG_LEN = 256;
 var STEP_RE = /^[a-z][a-z0-9-]{0,31}$/;
-var RESERVED_KEYS = new Set(["level", "time", "msg", "step", "pid", "err", "caller"]);
+var RESERVED_KEYS = new Set([
+  "level",
+  "time",
+  "msg",
+  "step",
+  "pid",
+  "err",
+  "caller",
+  "code"
+]);
 var CONTROL_RE = /[\u0000-\u0008\u000A-\u001F\u007F-\u009F]/g;
 function sanitizeString(s) {
   return s.replace(CONTROL_RE, "");
@@ -35898,6 +36392,8 @@ function resolveOptions(opts) {
     readSkillDescription: opts.readSkillDescription,
     diagnostics: opts.diagnostics,
     updateReport: opts.updateReport,
+    updateChanges: opts.updateChanges,
+    restartHint: opts.restartHint,
     onUpdatesEnabled: opts.onUpdatesEnabled,
     onDecisionAwaited: opts.onDecisionAwaited,
     markPaneRead: opts.markPaneRead ?? ((pane) => markPaneRead(pane, { log: opts.log })),
@@ -35916,6 +36412,19 @@ function ifNoneMatchHit(header, etag) {
     return false;
   return header.split(",").some((t) => t.trim().replace(/^W\//, "") === etag);
 }
+function isStaleVersion(review, version) {
+  return review !== undefined && version !== undefined && currentVersion(review).version !== version;
+}
+function expiredDeny() {
+  return {
+    behavior: "deny",
+    feedback: "caret: this review expired before a decision; denying so no unreviewed plan ships.",
+    decidedAt: Date.now()
+  };
+}
+function versionQuery(req) {
+  return VersionQuerySchema.parse(new URL(req.url).searchParams.get("version") ?? undefined);
+}
 function createServer(opts) {
   const cfg = resolveOptions(opts);
   const { store, idle, heartbeat, resident, assets, onShutdown, routePlan, configPath, log } = cfg;
@@ -35955,6 +36464,9 @@ function createServer(opts) {
   function notFound() {
     return new Response("not found", { status: 404 });
   }
+  function versionConflict() {
+    return new Response("superseded by a newer version", { status: 409 });
+  }
   function tooLarge() {
     return new Response("too large", { status: 413 });
   }
@@ -35970,7 +36482,8 @@ function createServer(opts) {
       supervised: isSupervised(),
       ...process.env.CARET_FRESH === "1" ? { fresh: true } : {},
       ...approveVariants ? { approveVariants: [...approveVariants] } : {},
-      ...source ? { source } : {}
+      ...source ? { source } : {},
+      ...cfg.restartHint ? { restartHint: cfg.restartHint } : {}
     };
     return Response.json(body);
   }
@@ -35984,6 +36497,12 @@ function createServer(opts) {
       return notFound();
     return Response.json(await cfg.updateReport());
   }
+  async function handleUpdateChanges() {
+    if (!cfg.updateChanges)
+      return notFound();
+    const changes = await cfg.updateChanges();
+    return changes ? Response.json(changes) : new Response("upstream unavailable", { status: 502 });
+  }
   function handleRetire() {
     log.info("retire", "retire requested");
     liveness.drain();
@@ -36023,19 +36542,21 @@ function createServer(opts) {
     const cacheControl = path.startsWith("/assets/") ? ASSET_CACHE_CONTROL : INDEX_CACHE_CONTROL;
     return assetResponse(req, file, cacheControl);
   }
-  async function handleCreateReview(req) {
+  async function handleCreateReview(req, routed) {
     if (liveness.isDraining()) {
       log.warn("drain", "review refused: draining");
       return new Response("draining", { status: 503 });
     }
     const body = await parseBody(req, PlanInputSchema);
-    const routed = await routePlan(body, store, log);
-    for (const staleId of routed.expired)
+    if (body.sessionId)
+      routed.log = log.child({ sessionId: body.sessionId });
+    const routing = await routePlan(body, store, routed.log);
+    for (const staleId of routing.expired)
       clearDecision(staleId);
-    if (routed.action === "append")
-      clearDecision(routed.id);
+    if (routing.action === "append")
+      clearDecision(routing.id);
     const hasLiveClient = isClientLive(lastReviewsPollAt, Date.now(), LIVE_CLIENT_WINDOW_MS);
-    return Response.json({ ...routed, hasLiveClient });
+    return Response.json({ ...routing, hasLiveClient });
   }
   async function handleLogs(req) {
     const reject = (status) => {
@@ -36057,8 +36578,12 @@ function createServer(opts) {
     const result = parseUiLogBatch(parsed);
     if ("status" in result)
       return reject(result.status);
-    for (const ev of result.events)
-      log[ev.level](ev.step, ev.msg, ev.extra);
+    for (const ev of result.events) {
+      if (ev.level === "error")
+        log.error(ev.step, "ui-error", ev.msg, ev.extra);
+      else
+        log[ev.level](ev.step, ev.msg, ev.extra);
+    }
     return new Response(null, { status: 204 });
   }
   function handleListReviews() {
@@ -36095,11 +36620,12 @@ function createServer(opts) {
       cfg.onUpdatesEnabled?.();
     return Response.json({ ok: true });
   }
-  function handleGetReview(id) {
+  function handleGetReview({ id }) {
     const r = store.get(id);
     return r ? Response.json(toClientReview(r)) : notFound();
   }
-  async function handleFileRefs(req, id) {
+  async function handleFileRefs(req, route) {
+    const { id } = route;
     const r = store.get(id);
     if (!r)
       return notFound();
@@ -36121,14 +36647,13 @@ function createServer(opts) {
       })));
     }
     const resolved = Object.fromEntries(entries.filter((e) => e !== null));
-    log.debug("request", `file-refs resolved: ${Object.keys(resolved).length}/${unique.length}`, {
-      reviewId: id,
+    route.log.debug("request", `file-refs resolved: ${Object.keys(resolved).length}/${unique.length}`, {
       requested: paths.length,
       directories: Object.values(resolved).filter((k) => k === "directory").length
     });
     return Response.json({ resolved });
   }
-  async function handleFileExcerpt(req, id) {
+  async function handleFileExcerpt(req, { id }) {
     const r = store.get(id);
     if (!r)
       return notFound();
@@ -36147,7 +36672,8 @@ function createServer(opts) {
       return Response.json(excerpt);
     return await isFileTooLargeToPreview(r.cwd, path) ? tooLarge() : notFound();
   }
-  async function handleDirListing(req, id) {
+  async function handleDirListing(req, route) {
+    const { id } = route;
     const r = store.get(id);
     if (!r)
       return notFound();
@@ -36155,24 +36681,25 @@ function createServer(opts) {
     const listing = await listDirectory(r.cwd, params.get("root") ?? "", params.get("path") ?? "");
     if (listing === null)
       return notFound();
-    log.debug("request", "dir listed", {
-      reviewId: id,
+    route.log.debug("request", "dir listed", {
       total: listing.total,
       returned: listing.entries.length
     });
     return Response.json(listing);
   }
-  async function handleSkills(id) {
+  async function handleSkills(route) {
+    const { id } = route;
     if (!cfg.listSkills)
       return notFound();
     const r = store.get(id);
     if (!r)
       return notFound();
     const skills = await cfg.listSkills(r.cwd);
-    log.debug("request", "skills listed", { reviewId: id, count: skills.length });
+    route.log.debug("request", "skills listed", { count: skills.length });
     return Response.json(skills);
   }
-  async function handleSkillDescription(req, id) {
+  async function handleSkillDescription(req, route) {
+    const { id } = route;
     if (!cfg.readSkillDescription)
       return notFound();
     const r = store.get(id);
@@ -36183,10 +36710,11 @@ function createServer(opts) {
       name: params.get("name") ?? "",
       origin: params.get("origin") ?? ""
     });
-    log.debug("request", "skill description read", { reviewId: id, found: description !== null });
+    route.log.debug("request", "skill description read", { found: description !== null });
     return Response.json({ description });
   }
-  async function handleFileSearch(req, id) {
+  async function handleFileSearch(req, route) {
+    const { id } = route;
     const r = store.get(id);
     if (!r)
       return notFound();
@@ -36194,26 +36722,30 @@ function createServer(opts) {
     const result = await searchFiles(r.cwd, query);
     if (result === null)
       return notFound();
-    log.debug("request", "file search answered", {
-      reviewId: id,
+    route.log.debug("request", "file search answered", {
       returned: result.paths.length,
       stoppedAt: result.stoppedAt
     });
     return Response.json(result);
   }
-  async function handleDecision(id) {
+  async function handleDecision(req, route) {
+    const { id } = route;
     const inMem = store.get(id);
+    const disk = inMem ? undefined : await store.persisted(id);
+    if (isStaleVersion(inMem ?? disk, versionQuery(req)))
+      return versionConflict();
     if (inMem?.decision) {
       clearDecision(id);
       return Response.json(inMem.decision);
     }
-    if (!inMem) {
-      const disk = await store.persisted(id);
-      if (disk?.decision) {
-        log.debug("decision", `decision served from disk: ${shortId(id)}`, { reviewId: id });
-        clearDecision(id);
-        return Response.json(disk.decision);
-      }
+    if (disk?.decision) {
+      route.log.debug("decision", `decision served from disk: ${shortId(id)}`);
+      clearDecision(id);
+      return Response.json(disk.decision);
+    }
+    if (disk?.status === "expired") {
+      route.log.debug("decision", `expired review denied: ${shortId(id)}`);
+      return Response.json(expiredDeny());
     }
     const decision = await raceDecision(id, heartbeat);
     if (!decision)
@@ -36221,31 +36753,38 @@ function createServer(opts) {
     clearDecision(id);
     return Response.json(decision);
   }
-  async function handleDraft(req, id) {
+  async function handleDraft(req, route) {
+    const { id } = route;
     const raw = await req.json().catch(() => ({}));
     const invalid = malformedLineAnchor(raw);
     if (invalid)
       return Response.json({ error: invalid }, { status: 400 });
     const body = DraftBodySchema.parse(raw);
     const updated = await store.update(id, (r) => {
-      if (body.annotations != null) {
-        currentVersion(r).annotations = body.annotations;
+      const cur = currentVersion(r);
+      const isStale = body.version != null && body.version !== cur.version;
+      if (body.annotations != null && !isStale) {
+        cur.annotations = body.annotations;
       }
       if (body.generalCommentDraft != null) {
         r.generalCommentDraft = body.generalCommentDraft;
       }
-      const cur = currentVersion(r);
-      if (body.composerScratches != null && (body.version == null || body.version === cur.version)) {
+      if (body.composerScratches != null && !isStale) {
         cur.composerScratches = body.composerScratches;
       }
     });
     if (updated)
-      log.debug("draft", `draft saved: ${shortId(id)}`, { reviewId: id });
+      route.log.debug("draft", `draft saved: ${shortId(id)}`);
     return updated ? Response.json({ ok: true }) : notFound();
   }
-  async function handleResolve(req, id) {
+  async function handleResolve(req, route) {
+    const { id } = route;
     const body = await parseBody(req, ResolveBodySchema);
     const existing = store.get(id);
+    if (isStaleVersion(existing, body.version)) {
+      route.log.info("resolve", "resolve refused: stale version", { version: body.version });
+      return versionConflict();
+    }
     if (existing?.status !== "pending")
       return notFound();
     const decision = {
@@ -36270,26 +36809,28 @@ function createServer(opts) {
     if (existing.cmux)
       cfg.markPaneRead(existing.cmux);
     setTimeout(() => resolveDecision(id, decision), 0);
-    log.info("resolve", `review ${shortId(id)} resolved: ${decision.behavior}`, {
-      reviewId: id,
+    route.log.info("resolve", `review ${shortId(id)} resolved: ${decision.behavior}`, {
       sessionId: existing.sessionId,
       acceptMode: decision.acceptMode
     });
     return Response.json({ ok: true });
   }
-  async function handleExpire(id) {
-    clearDecision(id);
+  async function handleExpire(req, route) {
+    const { id } = route;
     const existing = store.get(id);
+    if (isStaleVersion(existing ?? await store.persisted(id), versionQuery(req))) {
+      return versionConflict();
+    }
+    clearDecision(id);
     if (existing?.status !== "pending")
       return notFound();
     await store.expire(id);
-    log.info("review", `review expired: ${shortId(id)}`, {
-      reviewId: id,
+    route.log.info("review", `review expired: ${shortId(id)}`, {
       sessionId: existing.sessionId
     });
     return Response.json({ ok: true });
   }
-  function handleSeen(id) {
+  function handleSeen({ id }) {
     const existing = store.get(id);
     if (!existing)
       return notFound();
@@ -36297,7 +36838,8 @@ function createServer(opts) {
       cfg.markPaneRead(existing.cmux);
     return new Response(null, { status: 204 });
   }
-  async function dispatch(req, method, path) {
+  async function dispatch(req, routed) {
+    const { method, path, route } = routed;
     const readsUi = method === "GET" || method === "HEAD";
     if (method === "GET" && path === "/api/health")
       return handleHealth();
@@ -36305,12 +36847,14 @@ function createServer(opts) {
       return handleDiagnostics();
     if (method === "GET" && path === "/api/update")
       return handleUpdate();
+    if (method === "GET" && path === "/api/update/changes")
+      return handleUpdateChanges();
     if (method === "POST" && path === "/api/retire")
       return handleRetire();
     if (readsUi && (path === "/" || path === INDEX_PATH))
       return handleIndex(req);
     if (method === "POST" && path === "/api/reviews")
-      return handleCreateReview(req);
+      return handleCreateReview(req, routed);
     if (method === "POST" && path === "/api/logs")
       return handleLogs(req);
     if (method === "POST" && path === "/api/ui/gone")
@@ -36319,34 +36863,33 @@ function createServer(opts) {
       return handleListReviews();
     if (method === "POST" && path === "/api/config")
       return handleSetConfig(req);
-    const route = matchIdRoute(path);
     if (route) {
-      const { id, sub } = route;
+      const { sub } = route;
       if (method === "GET" && !sub)
-        return handleGetReview(id);
+        return handleGetReview(route);
       if (method === "GET" && sub === "/file")
-        return handleFileExcerpt(req, id);
+        return handleFileExcerpt(req, route);
       if (method === "GET" && sub === "/dir")
-        return handleDirListing(req, id);
+        return handleDirListing(req, route);
       if (method === "GET" && sub === "/skills")
-        return handleSkills(id);
+        return handleSkills(route);
       if (method === "GET" && sub === "/skill-description") {
-        return handleSkillDescription(req, id);
+        return handleSkillDescription(req, route);
       }
       if (method === "POST" && sub === "/file-refs")
-        return handleFileRefs(req, id);
+        return handleFileRefs(req, route);
       if (method === "POST" && sub === "/file-search")
-        return handleFileSearch(req, id);
+        return handleFileSearch(req, route);
       if (method === "GET" && sub === "/decision")
-        return handleDecision(id);
+        return handleDecision(req, route);
       if (method === "PUT" && sub === "/draft")
-        return handleDraft(req, id);
+        return handleDraft(req, route);
       if (method === "POST" && sub === "/resolve")
-        return handleResolve(req, id);
+        return handleResolve(req, route);
       if (method === "POST" && sub === "/expire")
-        return handleExpire(id);
+        return handleExpire(req, route);
       if (method === "POST" && sub === "/seen")
-        return handleSeen(id);
+        return handleSeen(route);
     }
     if (readsUi) {
       const asset = handleAsset(req, path);
@@ -36357,6 +36900,7 @@ function createServer(opts) {
   }
   async function handle(req, self) {
     const end = liveness.begin(req.method);
+    let routed;
     try {
       const port = self.port ?? -1;
       if (isForeignHost(req, port)) {
@@ -36368,10 +36912,13 @@ function createServer(opts) {
       if (!isSafeMethod(method) && isCrossOrigin(req, port)) {
         return new Response("cross-origin request blocked", { status: 403 });
       }
-      return await dispatch(req, method, path);
+      const idRoute = matchIdRoute(path);
+      const route = idRoute && { ...idRoute, log: log.child({ reviewId: idRoute.id }) };
+      routed = { method, path, route, log: route?.log ?? log };
+      return await dispatch(req, routed);
     } catch (err) {
       try {
-        log.error("request", err);
+        (routed?.log ?? log).error("request", "request-failed", err);
       } catch {}
       return new Response("internal error", { status: 500 });
     } finally {
@@ -36405,8 +36952,8 @@ function createServer(opts) {
         instanceId
       };
       const tmp = `${lockPath}.tmp.${process.pid}`;
-      writeFileSync5(tmp, JSON.stringify(lock));
-      renameSync3(tmp, lockPath);
+      writeFileSync6(tmp, JSON.stringify(lock));
+      renameSync4(tmp, lockPath);
     } catch {}
   }
   function removeLock() {
@@ -36432,7 +36979,7 @@ function createServer(opts) {
 // src/daemon/update-check.ts
 init_paths3();
 init_json_file();
-import { writeFileSync as writeFileSync6 } from "fs";
+import { writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname7 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 var REFRESH_COMMAND = "bunx --no-cache @macintacos/caret@latest install --refresh";
@@ -36502,7 +37049,7 @@ function fileUpdateCache(path) {
     write: (entry) => {
       try {
         ensureStateDir(dirname7(path));
-        writeFileSync6(path, JSON.stringify(entry, null, 2), { mode: 384 });
+        writeFileSync7(path, JSON.stringify(entry, null, 2), { mode: 384 });
       } catch {}
     }
   };
@@ -36564,44 +37111,7 @@ function startUpkeep({ tasks, log, everyMs, schedule }) {
 // src/commands/daemon.ts
 init_build_id();
 init_log();
-
-// src/lib/upstream.ts
-init_package();
-var NPM_LATEST_URL = `https://registry.npmjs.org/${package_default.name}/latest`;
-var LATEST_RELEASE_URL = "https://api.github.com/repos/macintacos/caret/releases/latest";
-var COMPARE_URL = "https://api.github.com/repos/macintacos/caret/compare";
-var UPSTREAM_TIMEOUT_MS = 3000;
-var GITHUB_HEADERS = { "user-agent": "caret" };
-async function readJson(url, fetchImpl, headers) {
-  try {
-    const res = await fetchImpl(url, {
-      signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
-      ...headers ? { headers } : {}
-    });
-    return res.ok ? await res.json() : null;
-  } catch {
-    return null;
-  }
-}
-async function publishedCaretVersion(fetchImpl = fetch) {
-  const body = await readJson(NPM_LATEST_URL, fetchImpl);
-  const v = body?.version;
-  return typeof v === "string" && v.length > 0 ? v : null;
-}
-async function latestReleaseTag(fetchImpl = fetch) {
-  const body = await readJson(LATEST_RELEASE_URL, fetchImpl, GITHUB_HEADERS);
-  const tag = body?.tag_name;
-  if (typeof tag !== "string" || tag.length === 0)
-    return null;
-  const stripped = tag.replace(/^v/, "");
-  return stripped.length > 0 ? stripped : null;
-}
-async function commitsAheadOfTrunk(commit, fetchImpl = fetch) {
-  const url = `${COMPARE_URL}/${encodeURIComponent(commit)}...trunk`;
-  const body = await readJson(url, fetchImpl, GITHUB_HEADERS);
-  const ahead = body?.ahead_by;
-  return typeof ahead === "number" && Number.isFinite(ahead) ? ahead : null;
-}
+init_upstream();
 
 // src/review/store.ts
 init_paths3();
@@ -36733,11 +37243,16 @@ async function runDaemon(opts) {
   });
   warnInvalidEnvVars((msg) => log.warn("env", msg));
   const adapter = selectAdapter();
-  const install = buildKind();
-  const version = VERSION;
-  const commit = currentCommit();
+  const built = { install: buildKind(), version: VERSION, commit: currentCommit() };
+  const devPose = process.env.CARET_DEV_UPDATE;
+  const posed = devUpdateIdentity(devPose, built, sourceGit);
+  if (devPose && built.install === "dev") {
+    log.info("update", posed ? `CARET_DEV_UPDATE=${devPose}: posing as ${posed.install} ${posed.version} at ${posed.commit.slice(0, 7)}` : `CARET_DEV_UPDATE=${devPose}: no older build to pose as`);
+  }
+  const { install, version, commit } = posed ?? built;
   const updateCache = fileUpdateCache(updateCheckFile());
   let updateStatus = readCachedStatus(updateCache, version, commit);
+  const servedReport = () => updateReportFor({ install, version, commit }, updateStatus, svc.current().updates.check);
   function refreshUpdate() {
     runUpdateCheck({
       kind: install,
@@ -36753,7 +37268,7 @@ async function runDaemon(opts) {
     }).then((status) => {
       if (status)
         updateStatus = status;
-    }, (err) => log.error("update", err));
+    }, (err) => log.error("update", "update-check-failed", err));
   }
   const store = createStore(reviewsDir(), log);
   await store.rehydrate();
@@ -36778,10 +37293,14 @@ async function runDaemon(opts) {
     shutdown(0);
   });
   process.once("exit", removeOwnDaemonLock);
-  function exitTerminal(reason, err) {
+  process.once("exit", removeOwnBootMarker);
+  function exitTerminal(reason, code, err) {
     process.stderr.write(`caret: ${reason}; exiting.
 `);
-    log.error("fatal", err, { reason, exitStatus: SERVICE_TERMINAL_EXIT_STATUS });
+    log.error("fatal", code, err, {
+      reason,
+      exitStatus: SERVICE_TERMINAL_EXIT_STATUS
+    });
     process.exit(SERVICE_TERMINAL_EXIT_STATUS);
   }
   const buildId = await currentBuildId();
@@ -36798,7 +37317,7 @@ async function runDaemon(opts) {
       lockPath: daemonLock(),
       buildId,
       assetDigest,
-      commit,
+      commit: built.commit,
       stateDir: stateDir(),
       instanceId: randomUUID().slice(0, 8),
       approveVariants: adapter.approveVariants,
@@ -36812,8 +37331,18 @@ async function runDaemon(opts) {
         settings: () => settings().current(),
         configPath: cfg
       })),
-      updateReport: () => updateReportFor({ install, version, commit }, updateStatus, svc.current().updates.check),
+      updateReport: servedReport,
       onUpdatesEnabled: refreshUpdate,
+      updateChanges: createUpdateChanges({
+        install,
+        version,
+        commit,
+        status: () => servedReport().status,
+        releases: listReleases,
+        compare: compareToTrunk,
+        log
+      }),
+      restartHint: resident ? undefined : adapter.restartHint,
       log
     });
   } catch (e) {
@@ -36822,10 +37351,11 @@ async function runDaemon(opts) {
 `);
       process.exit(0);
     }
-    exitTerminal("cannot bind the daemon port", e);
+    exitTerminal("cannot bind the daemon port", "daemon-bind-failed", e);
   }
+  removeOwnBootMarker();
   const onFatal = (label) => (err) => {
-    log.error(label, err);
+    log.error(label, "daemon-crashed", err);
     shutdown(1);
   };
   process.once("uncaughtException", onFatal("uncaughtException"));
@@ -36844,21 +37374,141 @@ async function runDaemon(opts) {
   return server.port;
 }
 
-// src/commands/discovery.ts
+// src/commands/doctor.ts
 init_adapters();
+init_paths2();
+init_upgrade();
+import { existsSync as existsSync11 } from "fs";
+import { release } from "os";
+
+// src/commands/install/ui.ts
+function isTerminal() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+var silentUI = {
+  intro: () => {},
+  step: async (_label, work) => work(() => {}),
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  note: () => {},
+  cancel: () => {},
+  outro: () => {}
+};
+function plainUI(write) {
+  const line = (s) => write(`caret: ${s}
+`);
+  return {
+    intro: (action) => line(action),
+    async step(label, work, done) {
+      try {
+        const value = await work(() => {});
+        line(done ? done(value) : label);
+        return value;
+      } catch (e) {
+        line(`${label} \u2014 failed`);
+        throw e;
+      }
+    },
+    info: line,
+    warn: line,
+    error: line,
+    note: (body, title) => line(`${title}
+${body.split(`
+`).map((l) => `  ${l}`).join(`
+`)}`),
+    cancel: line,
+    outro: line
+  };
+}
+async function createInstallUI(opts = {}) {
+  const write = opts.write ?? ((s) => void process.stdout.write(s));
+  const interactive = opts.interactive ?? (process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.CI !== "true");
+  if (!interactive)
+    return plainUI(write);
+  const clack = await Promise.resolve().then(() => (init_dist5(), {}));
+  return {
+    intro: (action) => intro(`caret \xB7 ${action}`),
+    async step(label, work, done) {
+      const spin = spinner();
+      spin.start(label);
+      try {
+        const value = await work((m) => spin.message(m));
+        spin.stop(done ? done(value) : label);
+        return value;
+      } catch (e) {
+        spin.error(label);
+        throw e;
+      }
+    },
+    info: (m) => log.info(m),
+    warn: (m) => log.warn(m),
+    error: (m) => log.error(m),
+    note: (body, title) => note(body, title),
+    cancel: (m) => cancel(m),
+    outro: (m) => outro(m)
+  };
+}
+
+// src/commands/doctor.ts
 init_paths3();
 init_settings();
 init_lifecycle();
-import { existsSync as existsSync10 } from "fs";
-import { release } from "os";
 
-// src/discovery.ts
+// src/doctor/bundle.ts
+import { readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
+import { basename as basename3, join as join16 } from "path";
+function stamp2(now) {
+  return now.toISOString().replace(/[-:.]/g, "");
+}
+function bundlePath(stateDir, now) {
+  return join16(stateDir, `doctor-${stamp2(now)}.zip`);
+}
+function member(path, name) {
+  try {
+    return { name, data: readFileSync11(path) };
+  } catch {
+    return null;
+  }
+}
+var MAX_REVIEW_MEMBERS = 5000;
+function entriesFor(deps) {
+  const logs = deps.logPaths.map((p) => member(p, `logs/${basename3(p)}`));
+  let reviews;
+  try {
+    reviews = readdirSync5(deps.reviewsDir).filter((f) => f.endsWith(".json"));
+  } catch {
+    reviews = [];
+  }
+  const records = reviews.slice(0, MAX_REVIEW_MEMBERS).map((f) => member(join16(deps.reviewsDir, f), `reviews/${f}`));
+  return [...logs, ...records].filter((e) => e !== null);
+}
+async function runBundle(opts, deps) {
+  if (!opts.yes) {
+    if (!deps.isInteractive()) {
+      return {
+        kind: "refused",
+        message: "a diagnostics bundle holds unredacted logs and full plan bodies, so it is never written unasked \u2014 re-run with --yes to confirm"
+      };
+    }
+    if (await deps.confirm() !== true)
+      return { kind: "declined" };
+  }
+  const now = deps.now();
+  const path = bundlePath(deps.stateDir, now);
+  deps.write(path, entriesFor(deps), now);
+  return { kind: "written", path };
+}
+
+// src/doctor/report.ts
 init_paths3();
 init_json_file();
 init_log();
-import { readdirSync as readdirSync4, statSync as statSync4 } from "fs";
-import { basename as basename3, join as join15 } from "path";
+init_node();
+import { readdirSync as readdirSync6, statSync as statSync4 } from "fs";
+import { basename as basename4, join as join17 } from "path";
 var CARET_BIN = "caret-native";
+var ERROR_RECORD_FIELDS = ["time", "source", "step", "code", "reviewId", "sessionId"];
 async function safe(build) {
   try {
     return await build();
@@ -36874,19 +37524,31 @@ async function collectReport(deps) {
   } catch (e) {
     healthError = { error: errorMessage(e) };
   }
-  const [system, install, settings, daemon, lockAndPort, processes, reviews, installState, logs] = await Promise.all([
+  const [
+    system,
+    install,
+    settings,
+    daemon,
+    lockAndPort,
+    processes,
+    reviews,
+    installState,
+    logs,
+    failures
+  ] = await Promise.all([
     safe(() => deps.system()),
     safe(() => deps.install()),
     safe(() => buildSettings(deps)),
-    healthError ?? safe(() => buildDaemon(health)),
+    healthError ?? safe(() => buildDaemon(deps, health)),
     healthError ?? safe(() => buildLockAndPort(deps, health)),
     safe(() => buildProcesses(deps)),
     safe(() => tallyReviews(deps.listReviewFiles())),
     safe(() => deps.readAgentInstallState()),
-    safe(() => buildLogs(deps))
+    safe(() => buildLogs(deps)),
+    safe(() => buildFailures(deps))
   ]);
   return {
-    schema: "caret-discovery/1",
+    schema: "caret-doctor/1",
     version: deps.version,
     generatedAt: deps.now().toISOString(),
     system,
@@ -36897,7 +37559,8 @@ async function collectReport(deps) {
     processes,
     reviews,
     installState,
-    logs
+    logs,
+    failures
   };
 }
 function buildSettings(deps) {
@@ -36918,11 +37581,13 @@ function buildSettings(deps) {
     effectiveHeartbeatMs: e.heartbeatMs
   };
 }
-function buildDaemon(health) {
+function buildDaemon(deps, health) {
+  const serviceInstalled = deps.serviceInstalled();
   if (!health)
-    return { reachable: false };
+    return { reachable: false, serviceInstalled };
   return {
     reachable: true,
+    serviceInstalled,
     service: health.service,
     daemonVersion: health.version,
     build: health.build,
@@ -36931,11 +37596,17 @@ function buildDaemon(health) {
 }
 function buildLockAndPort(deps, health) {
   const portServesCaret = health?.service === "caret";
+  const marker = deps.readBootMarker();
+  const bootFields = marker && {
+    bootMarkerPid: marker.pid,
+    bootMarkerAgeMs: deps.now().getTime() - marker.claimedAt
+  };
   const lock = deps.readLock();
   if (!lock)
-    return { lockExists: false, portServesCaret };
+    return { lockExists: false, portServesCaret, ...bootFields };
   return {
     lockExists: true,
+    lockPath: daemonLock(),
     lockPid: lock.pid,
     lockPort: lock.port,
     lockBuild: lock.build,
@@ -36943,7 +37614,8 @@ function buildLockAndPort(deps, health) {
     lockStartedAt: lock.startedAt,
     pidAlive: deps.isPidAlive(lock.pid),
     portServesCaret,
-    portMismatch: lock.port !== deps.effective().port
+    portMismatch: lock.port !== deps.effective().port,
+    ...bootFields
   };
 }
 function buildProcesses(deps) {
@@ -36962,6 +37634,21 @@ async function buildLogs(deps) {
   ]);
   return { caret, daemon, daemonStderr };
 }
+async function buildFailures(deps) {
+  const [caret, daemon] = await Promise.all([
+    deps.logErrorRecords(deps.logPaths.caret),
+    deps.logErrorRecords(deps.logPaths.daemon)
+  ]);
+  return groupFailures([...caret, ...daemon], deps.now().getTime());
+}
+var ERROR_WINDOW_HOURS = 24;
+var ERROR_WINDOW_MS = ERROR_WINDOW_HOURS * 60 * 60 * 1000;
+function inErrorWindow(time, generatedAt) {
+  if (time === undefined)
+    return true;
+  const age = generatedAt - Date.parse(time);
+  return Number.isNaN(age) || age < ERROR_WINDOW_MS;
+}
 function tallyReviews(records) {
   const counts = { pending: 0, approved: 0, rejected: 0, expired: 0, other: 0 };
   const pendingIds = [];
@@ -36987,11 +37674,47 @@ function tallyReviews(records) {
   }
   return { ...counts, total: records.length, pendingIds };
 }
-var HEADER_KEYS = new Set(["schema", "version", "generatedAt"]);
-function renderReport(report) {
+var FAILURES_CAP = 50;
+function groupFailures(records, generatedAt) {
+  const recent = records.filter((r) => inErrorWindow(r.time, generatedAt)).sort((a, b) => compareTimes(a.time ?? "", b.time ?? ""));
+  const newest = recent.slice(-FAILURES_CAP);
+  const groups = new Map;
+  const ungrouped = [];
+  for (const { reviewId, sessionId, ...record } of newest) {
+    const groupId = reviewId !== undefined ? { reviewId } : sessionId !== undefined ? { sessionId } : null;
+    if (groupId === null) {
+      ungrouped.push(record);
+      continue;
+    }
+    const key = JSON.stringify(groupId);
+    const group = groups.get(key) ?? { ...groupId, records: [] };
+    group.records.push(record);
+    groups.set(key, group);
+  }
+  return {
+    windowHours: ERROR_WINDOW_HOURS,
+    total: recent.length,
+    omitted: recent.length - newest.length,
+    groups: [...groups.values()],
+    ungrouped
+  };
+}
+function compareTimes(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var HEADER_KEYS = new Set(["schema", "version", "generatedAt", "checks"]);
+var STATUS_GLYPH = { pass: "\u2713", fail: "\u2717", unknown: "?" };
+var STATUS_COLOR = { pass: "\x1B[32m", fail: "\x1B[31m", unknown: "\x1B[33m" };
+var COLOR_RESET = "\x1B[0m";
+function renderStdout(doc, format, color = false) {
+  const redacted = scrubValue(doc, true);
+  return format === "json" ? JSON.stringify(redacted, null, 2) : renderDocument(redacted, color);
+}
+function renderDocument(doc, color = false) {
   const lines = [];
-  lines.push(`caret discovery (${report.schema}) version ${report.version} at ${report.generatedAt}`);
-  const sections = Object.entries(report).filter(([key]) => !HEADER_KEYS.has(key));
+  lines.push(`caret doctor (${doc.schema}) version ${doc.version} at ${doc.generatedAt}`);
+  lines.push("", "checks:", ...renderChecks(doc.checks, color));
+  const sections = Object.entries(doc).filter(([key]) => !HEADER_KEYS.has(key));
   for (const [title, value] of sections) {
     lines.push("");
     lines.push(`${title}:`);
@@ -37000,6 +37723,19 @@ function renderReport(report) {
   return lines.join(`
 `);
 }
+function renderChecks(checks, color) {
+  const out = [];
+  for (const c of checks) {
+    const glyph = STATUS_GLYPH[c.status];
+    const marker = color ? `${STATUS_COLOR[c.status]}${glyph}${COLOR_RESET}` : glyph;
+    out.push(`  ${marker} ${c.id}${c.detail ? ` \u2014 ${c.detail}` : ""}`);
+    if (c.status === "fail")
+      out.push(`    remedy: ${c.remedy}`);
+    if (c.status === "unknown")
+      out.push(`    reason: ${c.reason}`);
+  }
+  return out;
+}
 function isSectionError(v) {
   return typeof v === "object" && v !== null && "error" in v && typeof v.error === "string";
 }
@@ -37038,7 +37774,7 @@ function parsePsLines(text) {
     const [, pidStr, comm] = m ?? [];
     if (pidStr === undefined || comm === undefined)
       continue;
-    const name = basename3(comm.trim());
+    const name = basename4(comm.trim());
     if (name === CARET_BIN)
       out.push({ pid: Number(pidStr), name });
   }
@@ -37058,7 +37794,7 @@ function listReviewFiles() {
   const dir = reviewsDir();
   let files;
   try {
-    files = readdirSync4(dir);
+    files = readdirSync6(dir);
   } catch {
     return [];
   }
@@ -37068,7 +37804,7 @@ function listReviewFiles() {
       continue;
     if (out.length >= 5000)
       break;
-    const raw = readJsonFileSync(join15(dir, file));
+    const raw = readJsonFileSync(join17(dir, file));
     if (raw && typeof raw.id === "string" && typeof raw.status === "string") {
       out.push({ id: raw.id, status: raw.status });
     }
@@ -37084,44 +37820,321 @@ async function logStats(path) {
     return { path, exists: false, size: 0, errors: 0, warns: 0 };
   }
   try {
-    const start = Math.max(0, size - TAIL_BYTES);
-    const text = await Bun.file(path).slice(start).text();
-    const { errors, warns } = countLogLevels(text, start > 0);
-    return { path, exists: true, size, errors, warns };
+    const { text, partial } = await readTail(path, size);
+    const { errors, warns, lastErrorAt } = countLogLevels(text, partial);
+    return { path, exists: true, size, errors, warns, lastErrorAt };
   } catch {
     return { path, exists: true, size, errors: 0, warns: 0 };
   }
 }
-function countLogLevels(tailText, dropFirstLine) {
-  let errors = 0;
-  let warns = 0;
-  const lines = tailText.split(`
-`);
-  for (const [i, line] of lines.entries()) {
+async function readTail(path, size) {
+  const start = Math.max(0, size - TAIL_BYTES);
+  return { text: await Bun.file(path).slice(start).text(), partial: start > 0 };
+}
+async function logErrorRecords(path) {
+  let size;
+  try {
+    size = statSync4(path).size;
+  } catch {
+    return [];
+  }
+  const { text, partial } = await readTail(path, size);
+  return parseErrorRecords(text, partial);
+}
+function parseErrorRecords(tailText, dropFirstLine) {
+  const out = [];
+  for (const record of tailRecords(tailText, dropFirstLine)) {
+    if (typeof record.level !== "number" || record.level < 50)
+      continue;
+    const triageFields = {};
+    for (const field of ERROR_RECORD_FIELDS) {
+      const value = record[field];
+      if (typeof value === "string")
+        triageFields[field] = value;
+    }
+    out.push(triageFields);
+  }
+  return out;
+}
+function* tailRecords(tailText, dropFirstLine) {
+  for (const [i, line] of tailText.split(`
+`).entries()) {
     if (i === 0 && dropFirstLine)
       continue;
     if (!line.startsWith("{"))
       continue;
-    let level;
+    let record;
     try {
-      level = JSON.parse(line).level;
+      record = JSON.parse(line);
     } catch {
       continue;
     }
-    if (typeof level !== "number")
+    if (typeof record === "object" && record !== null)
+      yield record;
+  }
+}
+function countLogLevels(tailText, dropFirstLine) {
+  let errors = 0;
+  let warns = 0;
+  let lastErrorAt;
+  for (const record of tailRecords(tailText, dropFirstLine)) {
+    if (typeof record.level !== "number")
       continue;
-    if (level >= 50)
+    if (record.level >= 50) {
       errors++;
-    else if (level === 40)
+      lastErrorAt = typeof record.time === "string" ? record.time : undefined;
+    } else if (record.level === 40)
       warns++;
   }
-  return { errors, warns };
+  return { errors, warns, lastErrorAt };
+}
+
+// src/doctor/checks.ts
+function present(value) {
+  return isSectionError(value) ? undefined : value;
+}
+function undecided(id, title, section) {
+  return {
+    id,
+    title,
+    status: "unknown",
+    detail: "",
+    reason: `the ${section} section could not be collected`
+  };
+}
+function daemonReachable(report) {
+  const daemon = present(report.daemon);
+  if (daemon === undefined)
+    return undecided("daemon-reachable", "Daemon", "daemon");
+  if (daemon.serviceInstalled && !daemon.reachable) {
+    return {
+      id: "daemon-reachable",
+      title: "Daemon",
+      status: "fail",
+      detail: "a caret service is recorded for this install, but /api/health did not answer",
+      remedy: "run `caret install --refresh` \u2014 or check the service is not disabled \u2014 then read logs/daemon-stderr.log"
+    };
+  }
+  if (daemon.reachable && daemon.service !== "caret") {
+    return {
+      id: "daemon-reachable",
+      title: "Daemon",
+      status: "fail",
+      detail: `the effective port is answering as ${daemon.service ?? "an unnamed service"}, not caret`,
+      remedy: "stop whatever is bound to caret's effective port, or set `[daemon] port` to a free one"
+    };
+  }
+  return {
+    id: "daemon-reachable",
+    title: "Daemon",
+    status: "pass",
+    detail: daemon.reachable ? "answering on the effective port" : "not running"
+  };
+}
+function daemonLock2(report) {
+  const lock = present(report.lockAndPort);
+  if (lock === undefined)
+    return undecided("daemon-lock", "Daemon lock", "lockAndPort");
+  const faults = [];
+  const remedies = [];
+  if (lock.pidAlive === false) {
+    faults.push(`its pid ${lock.lockPid} is not alive`);
+    remedies.push(`delete the stale lock at ${lock.lockPath}`);
+  }
+  if (lock.portMismatch === true) {
+    faults.push(`its port ${lock.lockPort} is not the effective one`);
+    remedies.push("restart caret so it binds the configured port");
+  }
+  if (faults.length === 0) {
+    return {
+      id: "daemon-lock",
+      title: "Daemon lock",
+      status: "pass",
+      detail: lock.lockExists ? "live, on the effective port" : "no lock file"
+    };
+  }
+  return {
+    id: "daemon-lock",
+    title: "Daemon lock",
+    status: "fail",
+    detail: faults.join("; "),
+    remedy: remedies.join("; ")
+  };
+}
+function agentInstall(report) {
+  const probe = present(report.installState);
+  if (probe === undefined)
+    return undecided("agent-install", "Agent install", "installState");
+  if (probe.pluginEnabled === false) {
+    return {
+      id: "agent-install",
+      title: "Agent install",
+      status: "fail",
+      detail: `${probe.agent} does not have caret enabled`,
+      remedy: "run `caret install`"
+    };
+  }
+  return {
+    id: "agent-install",
+    title: "Agent install",
+    status: "pass",
+    detail: probe.pluginEnabled === true ? `caret ${probe.pluginVersion} is enabled for ${probe.agent}` : `${probe.agent}'s install state could not be read`
+  };
+}
+function describeErrors(log) {
+  const when = log.lastErrorAt ? `, last at ${log.lastErrorAt}` : "";
+  return `${log.errors} error record(s) in ${log.path}${when}`;
+}
+function logErrors(report) {
+  const logs = present(report.logs);
+  if (logs === undefined)
+    return undecided("log-errors", "Logs", "logs");
+  const noisy = Object.values(logs).filter((l) => l.errors > 0);
+  if (noisy.length === 0) {
+    return {
+      id: "log-errors",
+      title: "Logs",
+      status: "pass",
+      detail: "no NDJSON error records"
+    };
+  }
+  const generatedAt = Date.parse(report.generatedAt);
+  const erring = noisy.filter((l) => inErrorWindow(l.lastErrorAt, generatedAt));
+  if (erring.length === 0) {
+    return {
+      id: "log-errors",
+      title: "Logs",
+      status: "pass",
+      detail: `none in the last ${ERROR_WINDOW_HOURS}h; ${noisy.map(describeErrors).join("; ")}`
+    };
+  }
+  return {
+    id: "log-errors",
+    title: "Logs",
+    status: "fail",
+    detail: erring.map(describeErrors).join("; "),
+    remedy: `read ${erring.map((l) => l.path).join(" and ")}, then /systematic-debugging`
+  };
+}
+function runChecks(report, adapterChecks = []) {
+  return [
+    daemonReachable(report),
+    daemonLock2(report),
+    agentInstall(report),
+    logErrors(report),
+    ...adapterChecks
+  ];
+}
+
+// src/doctor/zip.ts
+import { closeSync as closeSync2, openSync as openSync3, rmSync as rmSync2, writeSync } from "fs";
+import { crc32 } from "zlib";
+var LOCAL_SIG = 67324752;
+var CENTRAL_SIG = 33639248;
+var EOCD_SIG = 101010256;
+var ZIP_VERSION = 20;
+var DEFLATE = 8;
+var UNIX_HOST = 3;
+var ENTRY_MODE = 384;
+function dosStamp(now) {
+  return {
+    time: now.getUTCHours() << 11 | now.getUTCMinutes() << 5 | now.getUTCSeconds() >> 1,
+    date: now.getUTCFullYear() - 1980 << 9 | now.getUTCMonth() + 1 << 5 | now.getUTCDate()
+  };
+}
+function localHeader(r, stamp) {
+  const head = new DataView(new ArrayBuffer(30));
+  head.setUint32(0, LOCAL_SIG, true);
+  head.setUint16(4, ZIP_VERSION, true);
+  head.setUint16(6, 0, true);
+  head.setUint16(8, DEFLATE, true);
+  head.setUint16(10, stamp.time, true);
+  head.setUint16(12, stamp.date, true);
+  head.setUint32(14, r.crc, true);
+  head.setUint32(18, r.compressedSize, true);
+  head.setUint32(22, r.size, true);
+  head.setUint16(26, r.name.length, true);
+  head.setUint16(28, 0, true);
+  return new Uint8Array(head.buffer);
+}
+function centralHeader(r, stamp) {
+  const head = new DataView(new ArrayBuffer(46));
+  head.setUint32(0, CENTRAL_SIG, true);
+  head.setUint16(4, UNIX_HOST << 8 | ZIP_VERSION, true);
+  head.setUint16(6, ZIP_VERSION, true);
+  head.setUint16(8, 0, true);
+  head.setUint16(10, DEFLATE, true);
+  head.setUint16(12, stamp.time, true);
+  head.setUint16(14, stamp.date, true);
+  head.setUint32(16, r.crc, true);
+  head.setUint32(20, r.compressedSize, true);
+  head.setUint32(24, r.size, true);
+  head.setUint16(28, r.name.length, true);
+  head.setUint16(30, 0, true);
+  head.setUint16(32, 0, true);
+  head.setUint16(34, 0, true);
+  head.setUint16(36, 0, true);
+  head.setUint32(38, ENTRY_MODE << 16, true);
+  head.setUint32(42, r.offset, true);
+  return new Uint8Array(head.buffer);
+}
+function eocd(count, size, offset) {
+  const head = new DataView(new ArrayBuffer(22));
+  head.setUint32(0, EOCD_SIG, true);
+  head.setUint16(4, 0, true);
+  head.setUint16(6, 0, true);
+  head.setUint16(8, count, true);
+  head.setUint16(10, count, true);
+  head.setUint32(12, size, true);
+  head.setUint32(16, offset, true);
+  head.setUint16(20, 0, true);
+  return new Uint8Array(head.buffer);
+}
+function writeZip(path, entries, now) {
+  const stamp = dosStamp(now);
+  const encoder = new TextEncoder;
+  const fd = openSync3(path, "wx", 384);
+  try {
+    const records = [];
+    let offset = 0;
+    const put = (bytes) => {
+      const written = writeSync(fd, bytes);
+      if (written !== bytes.length) {
+        throw new Error(`zip write truncated: ${written} of ${bytes.length} bytes`);
+      }
+      offset += bytes.length;
+    };
+    for (const entry of entries) {
+      const body = Bun.deflateSync(entry.data, { windowBits: -15 });
+      const record = {
+        name: encoder.encode(entry.name),
+        compressedSize: body.length,
+        crc: crc32(entry.data),
+        size: entry.data.length,
+        offset
+      };
+      records.push(record);
+      put(localHeader(record, stamp));
+      put(record.name);
+      put(body);
+    }
+    const directoryStart = offset;
+    for (const record of records) {
+      put(centralHeader(record, stamp));
+      put(record.name);
+    }
+    put(eocd(records.length, offset - directoryStart, directoryStart));
+  } catch (e) {
+    rmSync2(path, { force: true });
+    throw e;
+  } finally {
+    closeSync2(fd);
+  }
 }
 
-// src/commands/discovery.ts
+// src/commands/doctor.ts
 init_build_id();
-init_node();
-function prodDiscoveryDeps(s) {
+function prodDoctorDeps(s) {
   return {
     now: () => new Date,
     version: VERSION,
@@ -37133,7 +38146,7 @@ function prodDiscoveryDeps(s) {
     }),
     settings: () => s,
     configPath: configFile(),
-    configExists: () => existsSync10(configFile()),
+    configExists: () => existsSync11(configFile()),
     effective: () => ({
       port: getPort(s),
       idleMs: idleMs(s),
@@ -37142,12 +38155,18 @@ function prodDiscoveryDeps(s) {
     }),
     baseUrl: `http://localhost:${getPort(s)}`,
     health: httpHealth,
+    serviceInstalled: () => existsSync11(launcherServiceFile()),
     readLock: readDaemonLock,
+    readBootMarker,
     isPidAlive,
     listProcesses,
     listReviewFiles,
-    readAgentInstallState: () => selectAdapter().readInstallState(),
+    readAgentInstallState: () => {
+      const adapter = selectAdapter();
+      return { agent: adapter.id, ...adapter.readInstallState() };
+    },
     logStats,
+    logErrorRecords,
     logPaths: {
       caret: logFile(),
       daemon: daemonLogFile(),
@@ -37155,19 +38174,66 @@ function prodDiscoveryDeps(s) {
     }
   };
 }
-async function runDiscoverySubcommand(opts) {
+async function readAdapterChecks() {
   try {
+    const config = resolveConfigFile(opencodeConfigDir());
+    if (!hasCaretPluginEntry(config))
+      return [];
+    return [upgradeCheck(await readUpgradeVerdict({ configFile: config }))];
+  } catch (e) {
+    return [upgradeCheck({ kind: "unknown", reason: errorMessage(e) })];
+  }
+}
+function prodBundleDeps() {
+  return {
+    stateDir: stateDir(),
+    logPaths: [logFile(), daemonLogFile(), daemonStderrLogFile()],
+    reviewsDir: reviewsDir(),
+    now: () => new Date,
+    isInteractive: isTerminal,
+    confirm: confirmBundle,
+    write: (path, entries, now) => {
+      ensureStateDir();
+      writeZip(path, entries, now);
+    }
+  };
+}
+async function confirmBundle() {
+  await Promise.resolve().then(() => init_dist5());
+  const answer = await confirm({
+    message: "The bundle holds your logs and plan bodies, unredacted. Write it?"
+  });
+  return isCancel(answer) ? null : answer === true;
+}
+async function runDoctorSubcommand(opts) {
+  try {
+    const bundled = opts.bundle ? await runBundle({ yes: opts.yes }, prodBundleDeps()) : undefined;
+    if (bundled?.kind === "refused") {
+      process.stderr.write(`caret doctor: ${bundled.message}
+`);
+      process.exit(2);
+    }
+    if (bundled?.kind === "written") {
+      const note = opts.json ? process.stderr : process.stdout;
+      note.write(`caret doctor: wrote ${bundled.path}
+`);
+      note.write(`caret doctor: it is unredacted \u2014 move it over a channel you trust
+`);
+    }
     const s = loadSettings();
-    const report = await collectReport(prodDiscoveryDeps(s));
-    const redacted = scrubValue(report, true);
-    const out = opts.json ? JSON.stringify(redacted, null, 2) : renderReport(redacted);
-    process.stdout.write(`${out}
+    const [report, adapterChecks] = await Promise.all([
+      collectReport(prodDoctorDeps(s)),
+      readAdapterChecks()
+    ]);
+    const doc = { ...report, checks: runChecks(report, adapterChecks) };
+    const color = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.CI !== "true";
+    process.stdout.write(`${renderStdout(doc, opts.json ? "json" : "text", color)}
 `);
-    process.exit(0);
+    process.exit(doc.checks.some((c) => c.status === "fail") ? 1 : 0);
   } catch (e) {
-    process.stderr.write(`caret discovery: ${e}
+    process.stderr.write(`caret doctor: ${errorMessage(e)}
 `);
-    process.exit(1);
+    process.exit(2);
   }
 }
 
@@ -37175,38 +38241,38 @@ async function runDiscoverySubcommand(opts) {
 import {
   accessSync as accessSync2,
   constants as constants2,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync3,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   statSync as statSync5,
   symlinkSync,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join as join17, resolve as resolve2 } from "path";
+import { join as join19, resolve as resolve2 } from "path";
 
 // src/adapters/opencode/packaging.ts
-import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname8, join as join16 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname9, join as join18 } from "path";
 function resolveCaretRoot() {
   const candidates = [];
   const script = process.argv[1];
   if (script)
-    candidates.push(join16(dirname8(script), ".."));
-  candidates.push(join16(dirname8(process.execPath), ".."));
+    candidates.push(join18(dirname9(script), ".."));
+  candidates.push(join18(dirname9(process.execPath), ".."));
   for (const root of candidates) {
-    if (existsSync11(join16(root, "opencode", "caret.plugin.ts")))
+    if (existsSync12(join18(root, "opencode", "caret.plugin.ts")))
       return root;
   }
   throw new Error(`caret OpenCode packaging not found (no opencode/caret.plugin.ts under: ${candidates.join(", ") || "(none)"}). The OpenCode plugin source must ship with caret.`);
 }
 var DEMO_TEMPLATE = "templates/demo.md";
 function loadOpencodePackaging(root = resolveCaretRoot()) {
-  const binPath = join16(root, "bin", "caret");
-  const demoTemplate = readFileSync10(join16(root, DEMO_TEMPLATE), "utf-8");
-  const commandsDir = join16(root, "opencode", "commands");
+  const binPath = join18(root, "bin", "caret");
+  const demoTemplate = readFileSync12(join18(root, DEMO_TEMPLATE), "utf-8");
+  const commandsDir = join18(root, "opencode", "commands");
   let commands = [];
   try {
-    commands = readdirSync5(commandsDir).filter((f) => f.endsWith(".md")).sort().map((f) => ({ name: f, contents: readFileSync10(join16(commandsDir, f), "utf-8") }));
+    commands = readdirSync7(commandsDir).filter((f) => f.endsWith(".md")).sort().map((f) => ({ name: f, contents: readFileSync12(join18(commandsDir, f), "utf-8") }));
   } catch {
     commands = [];
   }
@@ -37216,17 +38282,17 @@ function loadOpencodePackaging(root = resolveCaretRoot()) {
 // src/commands/install/local.ts
 init_paths3();
 function devMarketplaceDir() {
-  return join17(stateDir(), "dev-marketplace");
+  return join19(stateDir(), "dev-marketplace");
 }
 function resolveLocalCheckout(opts = {}, deps = {}) {
   const repoDir = resolve2(caretRoot(deps));
-  if (!existsSync12(join17(repoDir, ".claude-plugin", "marketplace.json"))) {
+  if (!existsSync13(join19(repoDir, ".claude-plugin", "marketplace.json"))) {
     throw new Error(`--from-local must run from a caret checkout (no .claude-plugin/marketplace.json at ${repoDir}). A published caret installs with a plain \`caret install\`.`);
   }
   if (opts.requireArtifacts !== false) {
     const missing = [
-      isExecutable(join17(repoDir, "bin", "caret-native")) ? null : "bin/caret-native",
-      isDirectory(join17(repoDir, "bin", "ui")) ? null : "bin/ui"
+      isExecutable(join19(repoDir, "bin", "caret-native")) ? null : "bin/caret-native",
+      isDirectory(join19(repoDir, "bin", "ui")) ? null : "bin/ui"
     ].filter((m) => m !== null);
     if (missing.length > 0) {
       throw new Error(`--from-local reuses the build artifacts bin/caret-native + bin/ui, and ${repoDir} is missing ${missing.join(" + ")} \u2014 run \`mise run build\` first.`);
@@ -37244,10 +38310,10 @@ function caretRoot(deps) {
   }
 }
 function writeDevMarketplace(repoDir, outDir) {
-  rmSync2(outDir, { recursive: true, force: true });
-  mkdirSync3(join17(outDir, ".claude-plugin"), { recursive: true });
-  symlinkSync(resolve2(repoDir), join17(outDir, "caret"));
-  writeFileSync7(join17(outDir, ".claude-plugin", "marketplace.json"), `${JSON.stringify({
+  rmSync3(outDir, { recursive: true, force: true });
+  mkdirSync3(join19(outDir, ".claude-plugin"), { recursive: true });
+  symlinkSync(resolve2(repoDir), join19(outDir, "caret"));
+  writeFileSync8(join19(outDir, ".claude-plugin", "marketplace.json"), `${JSON.stringify({
     name: "caret",
     description: "Local caret dev build (generated by caret install --from-local).",
     owner: { name: "macintacos" },
@@ -37258,7 +38324,7 @@ function writeDevMarketplace(repoDir, outDir) {
 async function prewarmLocalBuild(repoDir, deps = {}) {
   const spawn = deps.spawn ?? runCaptured;
   try {
-    await spawn([join17(repoDir, "bin", "caret-native"), "prewarm"]);
+    await spawn([join19(repoDir, "bin", "caret-native"), "prewarm"]);
   } catch {}
 }
 function isExecutable(path) {
@@ -37294,75 +38360,6 @@ async function runCaptured(cmd) {
   return await proc.exited;
 }
 
-// src/commands/install/ui.ts
-function isTerminal() {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-var silentUI = {
-  intro: () => {},
-  step: async (_label, work) => work(() => {}),
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  note: () => {},
-  cancel: () => {},
-  outro: () => {}
-};
-function plainUI(write) {
-  const line = (s) => write(`caret: ${s}
-`);
-  return {
-    intro: (action) => line(action),
-    async step(label, work, done) {
-      try {
-        const value = await work(() => {});
-        line(done ? done(value) : label);
-        return value;
-      } catch (e) {
-        line(`${label} \u2014 failed`);
-        throw e;
-      }
-    },
-    info: line,
-    warn: line,
-    error: line,
-    note: (body, title) => line(`${title}
-${body.split(`
-`).map((l) => `  ${l}`).join(`
-`)}`),
-    cancel: line,
-    outro: line
-  };
-}
-async function createInstallUI(opts = {}) {
-  const write = opts.write ?? ((s) => void process.stdout.write(s));
-  const interactive = opts.interactive ?? (process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.CI !== "true");
-  if (!interactive)
-    return plainUI(write);
-  const clack = await Promise.resolve().then(() => (init_dist5(), {}));
-  return {
-    intro: (action) => intro(`caret \xB7 ${action}`),
-    async step(label, work, done) {
-      const spin = spinner();
-      spin.start(label);
-      try {
-        const value = await work((m) => spin.message(m));
-        spin.stop(done ? done(value) : label);
-        return value;
-      } catch (e) {
-        spin.error(label);
-        throw e;
-      }
-    },
-    info: (m) => log.info(m),
-    warn: (m) => log.warn(m),
-    error: (m) => log.error(m),
-    note: (body, title) => note(body, title),
-    cancel: (m) => cancel(m),
-    outro: (m) => outro(m)
-  };
-}
-
 // src/commands/install/claude.ts
 var MARKETPLACE_SOURCE = "macintacos/caret";
 var MARKETPLACE_NAME = "caret";
@@ -37537,11 +38534,11 @@ async function runInstallClaudeTarget(opts, deps = {}) {
 
 // src/commands/install/opencode.ts
 init_config_plugin();
-import { existsSync as existsSync16, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename4, join as join19 } from "path";
+import { existsSync as existsSync16, writeFileSync as writeFileSync10 } from "fs";
+import { basename as basename5, join as join20 } from "path";
 
 // src/adapters/opencode/deploy.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname10 } from "path";
 function renderPlugin(source, opts) {
   return source.replaceAll("__CARET_VERSION__", () => opts.version).replaceAll("__CARET_BIN__", () => opts.binPath).replaceAll("__CARET_DEMO_TEMPLATE__", () => opts.demoTemplate);
@@ -37551,7 +38548,7 @@ function deployFiles(files, opts) {
   for (const f of files) {
     if (!opts.dryRun) {
       mkdirSync4(dirname10(f.path), { recursive: true });
-      writeFileSync8(f.path, f.contents);
+      writeFileSync9(f.path, f.contents);
     }
     paths.push(f.path);
   }
@@ -37563,7 +38560,7 @@ function removeFiles(targets, opts) {
     if (!existsSync14(p))
       continue;
     if (!opts.dryRun)
-      rmSync3(p, { force: true });
+      rmSync4(p, { force: true });
     paths.push(p);
   }
   return { paths, dryRun: opts.dryRun };
@@ -37573,6 +38570,9 @@ function removeFiles(targets, opts) {
 init_paths2();
 init_upgrade();
 
+// src/commands/install/prompt.ts
+init_upgrade();
+
 // src/commands/install/targets.ts
 init_paths2();
 import { existsSync as existsSync15 } from "fs";
@@ -37631,20 +38631,6 @@ async function promptForServiceChoice() {
   });
   return isCancel(choice) ? null : choice;
 }
-function upgradeVerdictLine(verdict) {
-  switch (verdict.kind) {
-    case "fresh":
-      return "OpenCode will resolve caret on its next start";
-    case "current":
-      return `OpenCode's caret is ${verdict.version} \u2014 already current`;
-    case "stale-cache":
-      return `OpenCode's cached caret is ${verdict.cached}; ${verdict.published} is published`;
-    case "stale-pin":
-      return `Your config pins ${verdict.entry}; ${verdict.published} is published`;
-    case "unknown":
-      return "Could not check which caret OpenCode would load";
-  }
-}
 function upgradePromptMessage(verdict) {
   const remedy = verdict.kind === "stale-pin" ? "Bump the pin?" : "Clear the cached copy so OpenCode re-resolves?";
   return `${upgradeVerdictLine(verdict)}. ${remedy}`;
@@ -37658,7 +38644,7 @@ async function promptUpgrade(verdict, clack) {
 // src/commands/install/opencode.ts
 init_build_id();
 function isCaretCheckout(dir) {
-  return existsSync16(join19(dir, "opencode", "caret.plugin.ts"));
+  return existsSync16(join20(dir, "opencode", "caret.plugin.ts"));
 }
 function caretEntries(text, isCheckout) {
   return pluginEntries(text).filter((entry) => {
@@ -37684,12 +38670,12 @@ async function runInstallOpencodeTarget(opts, deps = {}) {
   const ui = deps.ui ?? silentUI;
   const isCheckout = deps.isCheckout ?? isCaretCheckout;
   const configFile = resolveConfigFile(dir);
-  const commandPaths = pkg.commands.map((c) => join19(commandDir(dir), namespacedCommandFilename(c.name)));
+  const commandPaths = pkg.commands.map((c) => join20(commandDir(dir), namespacedCommandFilename(c.name)));
   const legacy = existingLegacyInstallFiles(dir);
   const specifier = opts.local ? localPluginSpecifier(opts.local.repoDir) : CARET_PACKAGE;
   if (opts.dryRun) {
     const verb = opts.uninstall ? "remove" : "write";
-    const found = checks3(opts) ? ["", previewLine(await check(configFile, deps))] : [];
+    const found = checks3(opts) ? ["", previewLine(await readVerdict(configFile, deps))] : [];
     const entry = opts.uninstall ? [] : ["", `plugin entry: ${specifier}`];
     const sweep = legacy.length === 0 ? [] : ["", "pre-array-install files to remove:", ...legacy];
     ui.note([configFile, ...commandPaths, ...entry, ...sweep, ...found].join(`
@@ -37697,17 +38683,17 @@ async function runInstallOpencodeTarget(opts, deps = {}) {
     return;
   }
   if (opts.uninstall) {
-    await ui.step("Removing caret from OpenCode's plugin array", async () => editConfig(configFile, (text) => text === null ? null : caretEntries(text, isCheckout).reduce((acc, entry) => removePluginFromConfigText(acc, entry), text)), (changed) => changed.length > 0 ? `Removed caret from ${basename4(configFile)}` : `caret was not in ${basename4(configFile)}`);
+    await ui.step("Removing caret from OpenCode's plugin array", async () => editConfig(configFile, (text) => text === null ? null : caretEntries(text, isCheckout).reduce((acc, entry) => removePluginFromConfigText(acc, entry), text)), (changed) => changed.length > 0 ? `Removed caret from ${basename5(configFile)}` : `caret was not in ${basename5(configFile)}`);
     await ui.step("Removing the /caret:* command files", async () => removeFiles(commandPaths, { dryRun: false }), (removed) => `Removed ${removed.paths.length} command file(s) from ${dir}`);
     await sweepLegacy(legacy, dir, ui);
     return;
   }
-  await ui.step(`Adding ${specifier} to OpenCode's plugin array`, async () => editConfig(configFile, (text) => setCaretPluginEntry(text, specifier, isCheckout)), (changed) => changed.length > 0 ? `Added ${specifier} to ${basename4(configFile)}` : `${specifier} was already in ${basename4(configFile)}`);
+  await ui.step(`Adding ${specifier} to OpenCode's plugin array`, async () => editConfig(configFile, (text) => setCaretPluginEntry(text, specifier, isCheckout)), (changed) => changed.length > 0 ? `Added ${specifier} to ${basename5(configFile)}` : `${specifier} was already in ${basename5(configFile)}`);
   if (checks3(opts))
     await upgradeStep(configFile, opts, deps, ui);
   await sweepLegacy(legacy, dir, ui);
   const files = pkg.commands.map((c) => ({
-    path: join19(commandDir(dir), namespacedCommandFilename(c.name)),
+    path: join20(commandDir(dir), namespacedCommandFilename(c.name)),
     contents: renderPlugin(c.contents, {
       version: VERSION,
       binPath: pkg.binPath,
@@ -37728,15 +38714,11 @@ function previewLine(verdict) {
   const line = upgradeVerdictLine(verdict);
   return verdict.kind === "unknown" ? `${line} (${verdict.reason})` : line;
 }
-async function check(configFile, deps) {
-  return upgradeVerdict({
-    entry: findPluginEntry(readConfigText(configFile), CARET_PACKAGE),
-    cached: readCachedCaretVersion((deps.cacheDirs ?? existingOpencodeCachePackageDirs)()),
-    published: await (deps.published ?? publishedCaretVersion)()
-  });
+async function readVerdict(configFile, deps) {
+  return readUpgradeVerdict({ configFile, cacheDirs: deps.cacheDirs, published: deps.published });
 }
 async function upgradeStep(configFile, opts, deps, ui) {
-  const verdict = await ui.step("Checking OpenCode's caret version", () => check(configFile, deps), upgradeVerdictLine);
+  const verdict = await ui.step("Checking OpenCode's caret version", () => readVerdict(configFile, deps), upgradeVerdictLine);
   if (verdict.kind === "unknown") {
     ui.warn(`Could not check OpenCode's caret version (${verdict.reason}) \u2014 nothing changed.`);
     return;
@@ -37757,36 +38739,33 @@ async function upgradeStep(configFile, opts, deps, ui) {
     await ui.step("Clearing OpenCode's cached caret", async () => (deps.clearCache ?? clearCachedCaret)(dirs), (cleared) => `Cleared ${cleared.length} cached ${cleared.length === 1 ? "copy" : "copies"} \u2014 OpenCode re-resolves on next start`);
     return;
   }
-  await ui.step(`Bumping ${CARET_PACKAGE} to ${verdict.published}`, async () => editConfig(configFile, (text) => text === null ? null : setPluginVersionInConfigText(text, CARET_PACKAGE, verdict.published)), (changed) => changed.length > 0 ? `Bumped the pin to ${CARET_PACKAGE}@${verdict.published}` : `Left ${basename4(configFile)} unchanged`);
-}
-function readConfigText(path) {
-  return existsSync16(path) ? readFileSync11(path, "utf-8") : null;
+  await ui.step(`Bumping ${CARET_PACKAGE} to ${verdict.published}`, async () => editConfig(configFile, (text) => text === null ? null : setPluginVersionInConfigText(text, CARET_PACKAGE, verdict.published)), (changed) => changed.length > 0 ? `Bumped the pin to ${CARET_PACKAGE}@${verdict.published}` : `Left ${basename5(configFile)} unchanged`);
 }
 function editConfig(path, transform) {
   const existing = readConfigText(path);
   const next = transform(existing);
   if (next === null || next === existing)
     return [];
-  writeFileSync9(path, next);
+  writeFileSync10(path, next);
   return [path];
 }
 
 // src/commands/install/launcher.ts
-import { chmodSync as chmodSync4, copyFileSync, existsSync as existsSync17, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname11, join as join20 } from "path";
+import { chmodSync as chmodSync4, copyFileSync, existsSync as existsSync17, renameSync as renameSync5, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname11, join as join21 } from "path";
 init_paths3();
 init_build_id();
 function installLauncher(deps = {}) {
-  const source = (deps.source ?? (() => join20(resolveCaretRoot(), "bin", "caret-launcher")))();
+  const source = (deps.source ?? (() => join21(resolveCaretRoot(), "bin", "caret-launcher")))();
   ensureStateDir(dirname11(launcherPath()));
   const tmp = `${launcherPath()}.${process.pid}.tmp`;
   copyFileSync(source, tmp);
   chmodSync4(tmp, 493);
-  renameSync4(tmp, launcherPath());
+  renameSync5(tmp, launcherPath());
   const bunPath = deps.bunPath ?? (buildKind() === "binary" ? undefined : process.execPath);
   const unpinned = deps.pinnedRoot === undefined && existsSync17(launcherPinnedRootFile());
   if (unpinned)
-    rmSync4(launcherPinnedRootFile(), { force: true });
+    rmSync5(launcherPinnedRootFile(), { force: true });
   if (bunPath === undefined && deps.serviceLabel === undefined && deps.pinnedRoot === undefined) {
     return { unpinned };
   }
@@ -37800,12 +38779,12 @@ function installLauncher(deps = {}) {
   return { unpinned };
 }
 function writeRecord(path, value) {
-  writeFileSync10(path, `${value}
+  writeFileSync11(path, `${value}
 `, { mode: 384 });
 }
 function uninstallLauncher() {
-  rmSync4(dirname11(launcherPath()), { recursive: true, force: true });
-  rmSync4(launcherRecordDir(), { recursive: true, force: true });
+  rmSync5(dirname11(launcherPath()), { recursive: true, force: true });
+  rmSync5(launcherRecordDir(), { recursive: true, force: true });
 }
 
 // src/commands/install/service.ts
@@ -38051,9 +39030,9 @@ function servicePlatform(platform = process.platform) {
 
 // src/service/launchd-manager.ts
 init_log();
-import { mkdirSync as mkdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync5, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // src/service/launchd.ts
 var EXIT_TIMEOUT_SEC = 20;
@@ -38114,10 +39093,10 @@ function commandError(tool, verb, result) {
 }
 
 // src/service/unit-file.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 function unitUnchanged(path, text) {
   try {
-    return readFileSync12(path, "utf-8") === text;
+    return readFileSync13(path, "utf-8") === text;
   } catch {
     return false;
   }
@@ -38129,14 +39108,14 @@ var RUNNING = [/^\s*state\s*=\s*running\b/m, /^\s*pid\s*=\s*\d+/m];
 var DISABLED2 = new RegExp(`"${LAUNCHD_LABEL.replace(/\./g, "\\.")}"\\s*=>\\s*(?:true|disabled)\\b`);
 var launchctlError = (action, result) => commandError("launchctl", action, result);
 function createLaunchdManager(deps = {}) {
-  const launchAgentsDir = deps.launchAgentsDir ?? join21(homedir6(), "Library", "LaunchAgents");
+  const launchAgentsDir = deps.launchAgentsDir ?? join22(homedir6(), "Library", "LaunchAgents");
   const launchctl = deps.launchctl ?? spawnLaunchctl;
   const uid = deps.uid ?? process.getuid?.();
   if (uid === undefined)
     throw new Error("caret service: launchd needs a POSIX uid");
   const domain = `gui/${uid}`;
   const target = `${domain}/${LAUNCHD_LABEL}`;
-  const plistPath = join21(launchAgentsDir, `${LAUNCHD_LABEL}.plist`);
+  const plistPath = join22(launchAgentsDir, `${LAUNCHD_LABEL}.plist`);
   async function readStatus() {
     const [printed, printDisabled] = await Promise.all([
       launchctl(["print", target]),
@@ -38165,7 +39144,7 @@ function createLaunchdManager(deps = {}) {
         }
       }
       mkdirSync5(launchAgentsDir, { recursive: true });
-      writeFileSync11(plistPath, text);
+      writeFileSync12(plistPath, text);
       await launchctl(["bootout", target]);
       const bootstrapped = await launchctl(["bootstrap", domain, plistPath]);
       if (bootstrapped.code !== 0)
@@ -38173,7 +39152,7 @@ function createLaunchdManager(deps = {}) {
     },
     async uninstall() {
       await launchctl(["bootout", target]);
-      rmSync5(plistPath, { force: true });
+      rmSync6(plistPath, { force: true });
     },
     status: readStatus,
     async restart() {
@@ -38186,9 +39165,9 @@ function createLaunchdManager(deps = {}) {
 
 // src/service/systemd-manager.ts
 init_log();
-import { mkdirSync as mkdirSync6, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "fs";
+import { mkdirSync as mkdirSync6, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // src/service/systemd.ts
 var START_LIMIT_INTERVAL_SEC = 60;
@@ -38230,10 +39209,10 @@ WantedBy=default.target
 
 // src/service/systemd-manager.ts
 function createSystemdManager(deps = {}) {
-  const configHome = process.env.XDG_CONFIG_HOME || join22(homedir7(), ".config");
-  const unitDir = deps.unitDir ?? join22(configHome, "systemd", "user");
+  const configHome = process.env.XDG_CONFIG_HOME || join23(homedir7(), ".config");
+  const unitDir = deps.unitDir ?? join23(configHome, "systemd", "user");
   const run = deps.run ?? runCommand;
-  const unitPath = join22(unitDir, SYSTEMD_UNIT);
+  const unitPath = join23(unitDir, SYSTEMD_UNIT);
   const systemctl = (...args) => run(["systemctl", "--user", ...args]);
   async function probeSystemd() {
     const shown = await systemctl("show-environment");
@@ -38292,7 +39271,7 @@ function createSystemdManager(deps = {}) {
       }
       mkdirSync6(unitDir, { recursive: true });
       try {
-        writeFileSync12(unitPath, text);
+        writeFileSync13(unitPath, text);
         const reloaded = await systemctl("daemon-reload");
         if (reloaded.code !== 0)
           throw commandError("systemctl", "daemon-reload", reloaded);
@@ -38304,14 +39283,14 @@ function createSystemdManager(deps = {}) {
         if (restarted.code !== 0)
           throw commandError("systemctl", "restart", restarted);
       } catch (err) {
-        rmSync6(unitPath, { force: true });
+        rmSync7(unitPath, { force: true });
         throw err;
       }
       await enableLinger();
     },
     async uninstall() {
       await systemctl("disable", "--now", SYSTEMD_UNIT);
-      rmSync6(unitPath, { force: true });
+      rmSync7(unitPath, { force: true });
       await systemctl("daemon-reload");
     },
     status: readStatus,
@@ -38369,79 +39348,6 @@ init_boot();
 init_settings();
 init_log();
 
-// src/review/reconcile.ts
-init_log();
-async function runReconcile(stdin, deps) {
-  const ctx = {};
-  try {
-    const input = deps.parseHookInput(stdin);
-    ctx.sessionId = input.sessionId;
-    if (!input.sessionId)
-      return;
-    const match = (await deps.listReviews()).find((r) => r.sessionId === input.sessionId);
-    if (!match) {
-      logDebug("reconcile", "no pending review for session; nothing to reconcile", { ...ctx });
-      return;
-    }
-    ctx.reviewId = match.id;
-    await deps.resolveReview(match.id);
-    logInfo("reconcile", "terminal approval reconciled", { ...ctx });
-  } catch (err) {
-    logDebug("reconcile", "reconcile skipped", { ...ctx, err: String(err) });
-  }
-}
-
-// src/commands/reconcile.ts
-function prodReconcileDeps(baseUrl, adapter) {
-  return {
-    parseHookInput: (stdin) => adapter.parseHookInput(stdin),
-    listReviews: () => listReviews(baseUrl),
-    resolveReview: (id) => resolveReview(baseUrl, id, { behavior: "allow" })
-  };
-}
-async function runReconcileSubcommand() {
-  try {
-    const loaded = loadSettings();
-    bootHookLogging(loaded);
-    const adapter = selectAdapter();
-    const baseUrl = `http://localhost:${getPort(loaded)}`;
-    const stdin = await Bun.stdin.text();
-    await runReconcile(stdin, prodReconcileDeps(baseUrl, adapter));
-  } catch (err) {
-    logDebug("reconcile", "reconcile subcommand skipped", { err: String(err) });
-  }
-  process.exit(0);
-}
-
-// src/commands/redact.ts
-init_node();
-function runRedactSubcommand() {
-  try {
-    const written = redactLogFiles();
-    if (written.length === 0) {
-      process.stdout.write(`caret redact: no logs found to redact.
-`);
-    } else {
-      for (const path of written)
-        process.stdout.write(`${path}
-`);
-    }
-    process.exit(0);
-  } catch (e) {
-    process.stderr.write(`caret redact: ${e}
-`);
-    process.exit(1);
-  }
-}
-
-// src/commands/review.ts
-init_adapters();
-init_boot();
-init_paths3();
-init_settings();
-init_lifecycle();
-init_log();
-
 // src/review/orchestrate.ts
 init_constants();
 init_paths3();
@@ -38466,9 +39372,27 @@ function hasUntaggedCodeBlock(plan) {
 function denyDecision(reason) {
   return { behavior: "deny", feedback: reason, decidedAt: Date.now() };
 }
+function parseHook(parse, stdin) {
+  try {
+    return { input: parse(stdin) };
+  } catch (error) {
+    return { error };
+  }
+}
 
 class TimeoutError extends Error {
 }
+var REVIEW_FAILURE_CODES = {
+  parse: "hook-input-invalid",
+  validatePlan: "unexpected",
+  ensureDaemon: "daemon-unreachable",
+  postReview: "review-create-failed",
+  reconnect: "daemon-unreachable",
+  longPoll: "unexpected"
+};
+function reviewFailureCode(step, err) {
+  return err instanceof TimeoutError ? "review-timeout" : REVIEW_FAILURE_CODES[step];
+}
 function withTimeout(p, ms, message) {
   return new Promise((resolve, reject) => {
     const t = setTimeout(() => reject(new TimeoutError(message)), ms);
@@ -38485,25 +39409,29 @@ async function expireAbandoned(expire, handle) {
   if (!handle)
     return;
   try {
-    await expire(handle.baseUrl, handle.id);
+    await expire(handle.baseUrl, handle.id, handle.version);
   } catch {}
 }
-async function runReview(stdin, deps) {
+async function runReview(parsed, deps) {
   let step = "parse";
-  const ctx = {};
+  setLogContext({});
   let baseUrl;
+  let version;
+  let reviewId;
   try {
-    const input = deps.parseHookInput(stdin);
-    ctx.sessionId = input.sessionId;
-    ctx.cwd = input.cwd;
-    logInfo("review", "review requested", { ...ctx });
+    if ("error" in parsed)
+      throw parsed.error;
+    const input = parsed.input;
+    const ids = { sessionId: input.sessionId, cwd: input.cwd };
+    setLogContext(ids);
+    logInfo("review", "review requested");
     step = "validatePlan";
     if (!input.plan?.trim()) {
-      logInfo(step, "plan rejected: plan is empty", ctx);
+      logInfo(step, "plan rejected: plan is empty");
       return denyDecision(PLAN_EMPTY_DENY_MESSAGE);
     }
     if (hasUntaggedCodeBlock(input.plan)) {
-      logInfo(step, "plan rejected: code block missing language marker", ctx);
+      logInfo(step, "plan rejected: code block missing language marker");
       return denyDecision(PLAN_FORMAT_DENY_MESSAGE);
     }
     step = "ensureDaemon";
@@ -38512,7 +39440,7 @@ async function runReview(stdin, deps) {
     const payload = { ...input, cmux: deps.readPane?.() };
     let created = await deps.postReview(baseUrl, payload);
     if (!created) {
-      logInfo("review", "review refused: daemon draining", { ...ctx });
+      logInfo("review", "review refused: daemon draining");
       step = "reconnect";
       baseUrl = await deps.ensureDaemon("successor");
       step = "postReview";
@@ -38520,10 +39448,12 @@ async function runReview(stdin, deps) {
       if (!created)
         throw new Error("daemon draining; review not created");
     }
-    const { id, hasLiveClient } = created;
-    ctx.reviewId = id;
-    deps.onPosted?.(baseUrl, id);
-    logDebug("review", `review created: ${shortId(id)}`, { ...ctx });
+    const { id, hasLiveClient, planFileCurrent } = created;
+    version = created.version;
+    reviewId = id;
+    setLogContext({ ...ids, reviewId });
+    deps.onPosted?.({ baseUrl, id, version, planFileCurrent });
+    logDebug("review", `review created: ${shortId(id)}`);
     const open = new URL(baseUrl);
     open.hostname = VANITY_HOST;
     const url = `${open.origin}/?review=${id}`;
@@ -38538,7 +39468,12 @@ async function runReview(stdin, deps) {
       if (remaining <= 0)
         throw new TimeoutError("review timed out");
       try {
-        decision = await withTimeout(deps.longPoll(baseUrl, id), remaining, "review timed out") ?? undefined;
+        const polled = await withTimeout(deps.longPoll(baseUrl, id, version), remaining, "review timed out");
+        if (polled === "superseded") {
+          logInfo("review", `review yielded to newer version: ${shortId(id)}`, { version });
+          return denyDecision("caret: superseded by a newer revision of this plan.");
+        }
+        decision = polled ?? undefined;
       } catch (err) {
         if (err instanceof TimeoutError)
           throw err;
@@ -38548,19 +39483,19 @@ async function runReview(stdin, deps) {
       }
     }
     if (decision.behavior === "deny") {
-      logInfo("decision", "plan rejected", { ...ctx, feedbackChars: decision.feedback?.length });
+      logInfo("decision", "plan rejected", { feedbackChars: decision.feedback?.length });
     } else {
-      logInfo("decision", "plan approved", { ...ctx, acceptMode: decision.acceptMode });
+      logInfo("decision", "plan approved", { acceptMode: decision.acceptMode });
     }
     return decision;
   } catch (err) {
-    logError(step, err, ctx);
-    if (ctx.reviewId && baseUrl) {
+    logError(step, reviewFailureCode(step, err), err);
+    if (reviewId && baseUrl) {
       try {
-        await deps.expire(baseUrl, ctx.reviewId);
-        logDebug("review", `review expire requested: ${shortId(ctx.reviewId)}`, { ...ctx });
+        await deps.expire(baseUrl, reviewId, version);
+        logDebug("review", `review expire requested: ${shortId(reviewId)}`);
       } catch {
-        logDebug("review", "review expire failed; resubmit supersedes", { ...ctx });
+        logDebug("review", "review expire failed; next plan reclaims it");
       }
     }
     const msg = errorMessage(err);
@@ -38568,7 +39503,79 @@ async function runReview(stdin, deps) {
   }
 }
 
+// src/review/reconcile.ts
+init_log();
+async function runReconcile(parsed, deps) {
+  const ctx = {};
+  try {
+    if ("error" in parsed)
+      throw parsed.error;
+    const input = parsed.input;
+    ctx.sessionId = input.sessionId;
+    if (!input.sessionId)
+      return;
+    const match = (await deps.listReviews()).find((r) => r.sessionId === input.sessionId);
+    if (!match) {
+      logDebug("reconcile", "no pending review for session; nothing to reconcile", { ...ctx });
+      return;
+    }
+    ctx.reviewId = match.id;
+    await deps.resolveReview(match.id);
+    logInfo("reconcile", "terminal approval reconciled", { ...ctx });
+  } catch (err) {
+    logDebug("reconcile", "reconcile skipped", { ...ctx, err: String(err) });
+  }
+}
+
+// src/commands/reconcile.ts
+function prodReconcileDeps(baseUrl) {
+  return {
+    listReviews: () => listReviews(baseUrl),
+    resolveReview: (id) => resolveReview(baseUrl, id, { behavior: "allow" })
+  };
+}
+async function runReconcileSubcommand() {
+  try {
+    const loaded = loadSettings();
+    bootHookLogging(loaded);
+    const adapter = selectAdapter();
+    const baseUrl = `http://localhost:${getPort(loaded)}`;
+    const stdin = await Bun.stdin.text();
+    await runReconcile(parseHook(adapter.parseHookInput, stdin), prodReconcileDeps(baseUrl));
+  } catch (err) {
+    logDebug("reconcile", "reconcile subcommand skipped", { err: String(err) });
+  }
+  process.exit(0);
+}
+
+// src/commands/redact.ts
+init_node();
+function runRedactSubcommand() {
+  try {
+    const written = redactLogFiles();
+    if (written.length === 0) {
+      process.stdout.write(`caret redact: no logs found to redact.
+`);
+    } else {
+      for (const path of written)
+        process.stdout.write(`${path}
+`);
+    }
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`caret redact: ${e}
+`);
+    process.exit(1);
+  }
+}
+
 // src/commands/review.ts
+init_adapters();
+init_boot();
+init_paths3();
+init_settings();
+init_lifecycle();
+init_log();
 function browserOpenCmd(platform, url) {
   return platform === "darwin" ? ["open", url] : platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
 }
@@ -38576,6 +39583,13 @@ function reviewUrlLine(url) {
   return `caret: review this plan at ${url}
 `;
 }
+function notesAppendTarget(decision, planFilePath, posted) {
+  if (decision.behavior !== "allow" || !decision.feedback || !planFilePath)
+    return;
+  if (posted?.planFileCurrent === false)
+    return "skip-moved-on";
+  return { path: planFilePath, notes: decision.feedback };
+}
 function openBrowser(url) {
   try {
     Bun.spawn(browserOpenCmd(process.platform, url), {
@@ -38584,10 +39598,9 @@ function openBrowser(url) {
   } catch {}
 }
 var REVIEW_RESERVE_MS = SUPERVISOR_WINDOW_MS;
-function prodReviewDeps(s, adapter) {
+function prodReviewDeps(settings) {
   return {
-    parseHookInput: (stdin) => adapter.parseHookInput(stdin),
-    ensureDaemon: async (mode) => ensureDaemon(await prodEnsureDeps(s, () => prodService().manager, REVIEW_RESERVE_MS), mode),
+    ensureDaemon: async (mode) => ensureDaemon(await prodEnsureDeps(settings, () => prodService().manager, REVIEW_RESERVE_MS), mode),
     postReview,
     longPoll,
     openBrowser,
@@ -38595,10 +39608,18 @@ function prodReviewDeps(s, adapter) {
       process.stderr.write(reviewUrlLine(url));
     },
     readPane: readCmuxPane,
-    timeoutMs: reviewTimeoutMs(s),
+    timeoutMs: reviewTimeoutMs(settings),
     expire: expireReview
   };
 }
+async function reviewHookInput(parsed, deps, readPlan) {
+  if ("error" in parsed)
+    return { decision: await runReview(parsed, deps) };
+  const payload = parsed.input;
+  const fromFile = payload.planFilePath ? readPlan(payload.planFilePath) : undefined;
+  const input = fromFile?.trim() ? { ...payload, plan: fromFile } : payload;
+  return { decision: await runReview({ input }, deps), input };
+}
 async function runReviewSubcommand() {
   const loaded = loadSettings();
   bootHookLogging(loaded);
@@ -38615,7 +39636,7 @@ async function runReviewSubcommand() {
   };
   const denyAndExit = async (reason) => {
     if (!responded)
-      logError("signal", new Error(reason));
+      logError("signal", "hook-interrupted", new Error(reason));
     respond({ behavior: "deny", feedback: `${reason} See ${logFile()}.`, decidedAt: Date.now() });
     await expireAbandoned(expireReview, posted);
     process.exit(0);
@@ -38623,18 +39644,17 @@ async function runReviewSubcommand() {
   process.once("SIGINT", () => void denyAndExit("caret: interrupted (SIGINT) \u2014 denying to fail safe."));
   process.once("SIGTERM", () => void denyAndExit("caret: terminated (SIGTERM) \u2014 denying to fail safe."));
   const stdin = await Bun.stdin.text();
-  try {
-    hookInput = adapter.parseHookInput(stdin);
-  } catch {
-    hookInput = undefined;
-  }
-  const deps = prodReviewDeps(loaded, adapter);
-  deps.onPosted = (baseUrl, id) => {
-    posted = { baseUrl, id };
-  };
-  const out = await runReview(stdin, deps);
-  if (out.behavior === "allow" && out.feedback && hookInput?.planFilePath) {
-    appendReviewerNotesToPlanFile(hookInput.planFilePath, out.feedback, { warn: logWarn });
+  const deps = prodReviewDeps(loaded);
+  deps.onPosted = (handle) => {
+    posted = handle;
+  };
+  const { decision: out, input } = await reviewHookInput(parseHook(adapter.parseHookInput, stdin), deps, readPlanFile);
+  hookInput = input;
+  const target = notesAppendTarget(out, hookInput?.planFilePath, posted);
+  if (target === "skip-moved-on") {
+    logInfo("review", "plan file changed; notes append skipped");
+  } else if (target) {
+    appendReviewerNotesToPlanFile(target.path, target.notes, { warn: logWarn });
   }
   respond(out);
   process.exit(0);
@@ -40763,7 +41783,11 @@ function buildProgram() {
   program.command("reconcile").description("reconcile a terminal plan approval into the daemon (ExitPlanMode PostToolUse hook)").action(() => runReconcileSubcommand());
   program.command("steer").description("steer the model to title its plan (EnterPlanMode PostToolUse / UserPromptSubmit hook)").action(() => runSteerSubcommand());
   program.command("redact").description("write redacted copies of the logs").action(() => runRedactSubcommand());
-  program.command("discovery").description("print a diagnostics report").option("--json", "emit the machine-readable JSON document").action((opts) => runDiscoverySubcommand({ json: opts.json ?? false }));
+  program.command("doctor").description("diagnose this caret install").option("--json", "emit the machine-readable JSON document").option("--bundle", "also write a zip of the raw logs and review records, to share").option("--yes", "write the bundle without asking \u2014 it holds unredacted content").action((opts) => runDoctorSubcommand({
+    json: opts.json ?? false,
+    bundle: opts.bundle ?? false,
+    yes: opts.yes ?? false
+  }));
   program.command("install").description("install caret into a coding agent, plus the rumdl plan formatter, and choose whether the review UI runs as a service").option("--uninstall", "remove caret from every agent on this machine, and its service, instead of installing").option("--dry-run", "print what would change without writing").option("--refresh", "take the published caret in every target without asking \u2014 clears OpenCode's cached copy, or bumps a pinned entry (Claude Code always takes an update) \u2014 and cycles caret's service onto it").option("--from-local", "dev loop: install the built caret checkout this binary runs from, then hand it the daemon").action(async (opts) => {
     const outcome = await runInstallSubcommand({
       uninstall: opts.uninstall ?? false,
@@ -40777,7 +41801,7 @@ function buildProgram() {
 }
 if (import.meta.main) {
   runProgram(buildProgram(), (err) => {
-    logError("fatal", err);
+    logError("fatal", "unexpected", err);
     const reason = `caret: fatal ${err} \u2014 denying to fail safe. See ${logFile()}.`;
     process.stdout.write(`${fatalDeny(reason)}
 `);