@macintacos/caret 0.13.0 → 0.14.0

package/dist/cli.js

@@ -5804,7 +5804,7 @@ __export(exports_dist, {
 import { styleText as styleText2, stripVTControlCharacters } from "util";
 import process$1 from "process";
 import { existsSync as existsSync11, lstatSync, readdirSync as readdirSync6 } from "fs";
-import { dirname as dirname8, join as join17 } from "path";
+import { dirname as dirname9, join as join17 } from "path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
     return process$1.env.TERM !== "linux";
@@ -6515,7 +6515,7 @@ ${n3}
         return [];
       try {
         let i;
-        existsSync11(t2) ? lstatSync(t2).isDirectory() && (!e.directory || t2.endsWith("/")) ? i = t2 : i = dirname8(t2) : i = dirname8(t2);
+        existsSync11(t2) ? lstatSync(t2).isDirectory() && (!e.directory || t2.endsWith("/")) ? i = t2 : i = dirname9(t2) : i = dirname9(t2);
         const c2 = t2.length > 1 && t2.endsWith("/") ? t2.slice(0, -1) : t2;
         return readdirSync6(i).map((r2) => {
           const n3 = join17(i, r2), m3 = lstatSync(n3);
@@ -9841,9 +9841,7 @@ function removePluginFromConfigText(existing, pkg) {
   return applyEdits(existing, edits);
 }
 
-// src/adapters/opencode/upgrade.ts
-var NPM_LATEST_URL = `https://registry.npmjs.org/${CARET_PACKAGE}/latest`;
-var NPM_TIMEOUT_MS = 3000;
+// src/lib/semver.ts
 function parseVersionTriple(v) {
   const m = v.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
   return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
@@ -9861,6 +9859,8 @@ function isNewer(latest, current) {
     return a1 > b1;
   return a2 > b2;
 }
+
+// src/adapters/opencode/upgrade.ts
 function upgradeVerdict(input) {
   const { entry, cached, published } = input;
   if (published === null) {
@@ -9903,18 +9903,6 @@ function clearCachedCaret(dirs = existingOpencodeCachePackageDirs()) {
   }
   return cleared;
 }
-async function publishedCaretVersion(fetchImpl = fetch) {
-  try {
-    const res = await fetchImpl(NPM_LATEST_URL, { signal: AbortSignal.timeout(NPM_TIMEOUT_MS) });
-    if (!res.ok)
-      return null;
-    const body = await res.json();
-    const v = body?.version;
-    return typeof v === "string" && v.length > 0 ? v : null;
-  } catch {
-    return null;
-  }
-}
 
 // src/adapters/opencode/install.ts
 function readOpencodeInstallState() {
@@ -10051,7 +10039,7 @@ function fatalDeny(reason) {
 
 // src/commands/daemon.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync7, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // src/config/settings.ts
 import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
@@ -24435,6 +24423,9 @@ function configFile() {
 function prefsFile() {
   return `${stateDir()}/prefs.json`;
 }
+function updateCheckFile() {
+  return `${stateDir()}/update-check.json`;
+}
 function logsDir() {
   return `${stateDir()}/logs`;
 }
@@ -24535,7 +24526,7 @@ async function loadUiAssets() {
 // package.json
 var package_default = {
   name: "@macintacos/caret",
-  version: "0.13.0",
+  version: "0.14.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.",
@@ -25241,6 +25232,53 @@ function warnInvalidEnvVars(warn) {
     warn(`${name} invalid; using config/default`);
 }
 
+// src/config/prefs.ts
+import { readFile as readFile3, writeFile } from "fs/promises";
+import { dirname as dirname4 } from "path";
+var DEFAULT_SET = { valid: ["default"], fallback: "default" };
+async function readApproveMode(file2 = prefsFile(), log = noopLogger, set2 = DEFAULT_SET) {
+  try {
+    const parsed = JSON.parse(await readFile3(file2, "utf-8"));
+    if (typeof parsed.approveMode === "string" && set2.valid.includes(parsed.approveMode)) {
+      return parsed.approveMode;
+    }
+    log.debug("prefs", "unrecognized approve mode; using default");
+    return set2.fallback;
+  } catch (err) {
+    const absent = err?.code === "ENOENT";
+    log.debug("prefs", absent ? "no prefs file; using default approve mode" : "prefs unreadable; using default approve mode");
+    return set2.fallback;
+  }
+}
+async function readUpdatesCheck(file2 = prefsFile()) {
+  const parsed = await readJsonFile(file2);
+  return parsed?.updates?.check !== false;
+}
+function createPrefsWriter(file2 = prefsFile()) {
+  let tail = Promise.resolve();
+  return {
+    merge(patch) {
+      const next = tail.then(async () => {
+        ensureStateDir(dirname4(file2));
+        const existing = await readJsonFile(file2) ?? {};
+        await writeFile(file2, JSON.stringify({ ...existing, ...patch }, null, 2), {
+          mode: 384
+        });
+      });
+      tail = next.catch(() => {});
+      return next;
+    }
+  };
+}
+async function writeApproveMode(mode, writer, log = noopLogger, set2 = DEFAULT_SET) {
+  if (!set2.valid.includes(mode)) {
+    log.warn("prefs", "ignoring invalid approve mode");
+    return;
+  }
+  await writer.merge({ approveMode: mode });
+  log.debug("prefs", `approve mode saved: ${mode}`);
+}
+
 // src/daemon/diagnostics.ts
 function buildDiagnostics(deps) {
   return {
@@ -25393,6 +25431,10 @@ function removeDaemonLock() {
     unlinkSync2(daemonLock());
   } catch {}
 }
+function removeOwnDaemonLock() {
+  if (readDaemonLock()?.pid === process.pid)
+    removeDaemonLock();
+}
 async function retireDaemon(baseUrl, lock, currentStateDir, kill = (pid, sig) => process.kill(pid, sig)) {
   try {
     const res = await fetch(`${baseUrl}/api/retire`, {
@@ -25465,34 +25507,6 @@ async function prodEnsureDeps(s) {
 import { renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname6 } from "path";
 
-// src/config/prefs.ts
-import { readFile as readFile3, writeFile } from "fs/promises";
-import { dirname as dirname4 } from "path";
-var DEFAULT_SET = { valid: ["default"], fallback: "default" };
-async function readApproveMode(file2 = prefsFile(), log = noopLogger, set2 = DEFAULT_SET) {
-  try {
-    const parsed = JSON.parse(await readFile3(file2, "utf-8"));
-    if (typeof parsed.approveMode === "string" && set2.valid.includes(parsed.approveMode)) {
-      return parsed.approveMode;
-    }
-    log.debug("prefs", "unrecognized approve mode; using default");
-    return set2.fallback;
-  } catch (err) {
-    const absent = err?.code === "ENOENT";
-    log.debug("prefs", absent ? "no prefs file; using default approve mode" : "prefs unreadable; using default approve mode");
-    return set2.fallback;
-  }
-}
-async function writeApproveMode(mode, file2 = prefsFile(), log = noopLogger, set2 = DEFAULT_SET) {
-  if (!set2.valid.includes(mode)) {
-    log.warn("prefs", "ignoring invalid approve mode");
-    return;
-  }
-  ensureStateDir(dirname4(file2));
-  await writeFile(file2, JSON.stringify({ approveMode: mode }, null, 2), { mode: 384 });
-  log.debug("prefs", `approve mode saved: ${mode}`);
-}
-
 // src/daemon/guards.ts
 var LIVE_CLIENT_WINDOW_MS = 120000;
 function isClientLive(lastPollAt, now, windowMs) {
@@ -25501,17 +25515,33 @@ function isClientLive(lastPollAt, now, windowMs) {
 function isSafeMethod(method) {
   return method === "GET" || method === "HEAD";
 }
-function isCrossOrigin(req) {
-  const origin = req.headers.get("origin");
-  if (origin) {
-    try {
-      const host = new URL(origin).hostname;
-      if (host !== "127.0.0.1" && host !== "localhost" && host !== VANITY_HOST)
-        return true;
-    } catch {
-      return true;
-    }
+var OWN_HOSTNAMES = new Set(["127.0.0.1", "localhost", VANITY_HOST]);
+function isOwnAuthority(authority, port) {
+  try {
+    const u = new URL(`http://${authority}`);
+    if (u.href !== `http://${u.host}/`)
+      return false;
+    return OWN_HOSTNAMES.has(u.hostname) && (u.port || "80") === String(port);
+  } catch {
+    return false;
   }
+}
+function isForeignHost(req, port) {
+  const host = req.headers.get("host");
+  return host === null || !isOwnAuthority(host, port);
+}
+function isOwnOrigin(origin, port) {
+  try {
+    const u = new URL(origin);
+    return u.protocol === "http:" && isOwnAuthority(u.host, port);
+  } catch {
+    return false;
+  }
+}
+function isCrossOrigin(req, port) {
+  const origin = req.headers.get("origin");
+  if (origin && !isOwnOrigin(origin, port))
+    return true;
   const site = req.headers.get("sec-fetch-site");
   if (site && site !== "same-origin" && site !== "none")
     return true;
@@ -25536,6 +25566,7 @@ var ResolveBodySchema = exports_external.object({
   feedback: exports_external.string().optional(),
   acceptMode: exports_external.string().optional().catch(undefined)
 }).catch({ behavior: "allow" });
+var PrefsPatchSchema = exports_external.object({ updates: exports_external.object({ check: exports_external.boolean() }).strict().optional() }).strict();
 var LineAnnotationSchema = exports_external.object({
   id: exports_external.string(),
   startLine: exports_external.number().int().min(1),
@@ -26293,6 +26324,7 @@ var PLACEHOLDER_HTML = `<!doctype html><html lang="en"><head><meta charset="utf-
 var INDEX_CACHE_CONTROL = "no-cache";
 var ASSET_CACHE_CONTROL = "public, max-age=31536000, immutable";
 var INDEX_PATH = "/index.html";
+var FILE_REF_BATCH = 64;
 function resolveOptions(opts) {
   return {
     store: opts.store,
@@ -26312,6 +26344,8 @@ function resolveOptions(opts) {
     listSkills: opts.listSkills,
     readSkillDescription: opts.readSkillDescription,
     diagnostics: opts.diagnostics,
+    updateReport: opts.updateReport,
+    onUpdatesEnabled: opts.onUpdatesEnabled,
     markPaneRead: opts.markPaneRead ?? ((pane) => markPaneRead(pane, { log: opts.log })),
     log: opts.log ?? noopLogger
   };
@@ -26329,6 +26363,7 @@ function createServer(opts) {
   const { buildId, commit, stateDir: stateDir2, instanceId, approveVariants, source, lockPath } = cfg;
   const { awaitDecision, resolveDecision, clearDecision, openDecisionCount } = createDecisions(log);
   const approveModeSet = approveVariants && approveVariants.length > 0 ? { valid: approveVariants.map((v) => v.id), fallback: approveVariants[0]?.id ?? "default" } : { valid: ["default"], fallback: "default" };
+  const prefsWriter = createPrefsWriter(prefsPath);
   function raceDecision(id, ms) {
     return new Promise((resolve2) => {
       const t = setTimeout(() => resolve2(null), ms);
@@ -26397,6 +26432,11 @@ function createServer(opts) {
       return notFound();
     return Response.json(cfg.diagnostics());
   }
+  async function handleUpdate() {
+    if (!cfg.updateReport)
+      return notFound();
+    return Response.json(await cfg.updateReport());
+  }
   function handleRetire() {
     log.info("retire", "retire requested");
     setTimeout(() => {
@@ -26470,7 +26510,23 @@ function createServer(opts) {
     return new Response(null, { status: 204 });
   }
   async function handlePrefs() {
-    return Response.json({ approveMode: await readApproveMode(prefsPath, log, approveModeSet) });
+    const body = {
+      approveMode: await readApproveMode(prefsPath, log, approveModeSet)
+    };
+    return Response.json(body);
+  }
+  async function handleSetPrefs(req) {
+    const parsed = PrefsPatchSchema.safeParse(await req.json().catch(() => null));
+    if (!parsed.success) {
+      const error51 = parsed.error.issues[0]?.message ?? "invalid prefs patch";
+      log.warn("prefs", "prefs patch rejected", { reason: error51 });
+      return Response.json({ error: error51 }, { status: 400 });
+    }
+    await prefsWriter.merge(parsed.data);
+    log.debug("prefs", "prefs saved");
+    if (parsed.data.updates?.check === true)
+      cfg.onUpdatesEnabled?.();
+    return Response.json({ ok: true });
   }
   function handleGetReview(id) {
     const r = store.get(id);
@@ -26490,10 +26546,13 @@ function createServer(opts) {
       if (unique.push(p) === MAX_FILE_REFS)
         break;
     }
-    const entries = await Promise.all(unique.map(async (p) => {
-      const hit = await resolveInCwd(r.cwd, p);
-      return hit === null ? null : [p, hit.kind];
-    }));
+    const entries = [];
+    for (let i = 0;i < unique.length; i += FILE_REF_BATCH) {
+      entries.push(...await Promise.all(unique.slice(i, i + FILE_REF_BATCH).map(async (p) => {
+        const hit = await resolveInCwd(r.cwd, p);
+        return hit === null ? null : [p, hit.kind];
+      })));
+    }
     const resolved = Object.fromEntries(entries.filter((e) => e !== null));
     log.debug("request", `file-refs resolved: ${Object.keys(resolved).length}/${unique.length}`, {
       reviewId: id,
@@ -26642,7 +26701,7 @@ function createServer(opts) {
       store.bumpEpoch(existing.sessionId);
       await store.remove(id);
       if (decision.acceptMode !== undefined && approveModeSet.valid.includes(decision.acceptMode)) {
-        writeApproveMode(decision.acceptMode, prefsPath, log, approveModeSet).catch(() => {
+        writeApproveMode(decision.acceptMode, prefsWriter, log, approveModeSet).catch(() => {
           log.warn("prefs", "approve mode write failed");
         });
       }
@@ -26682,6 +26741,8 @@ function createServer(opts) {
       return handleHealth();
     if (method === "GET" && path === "/api/diagnostics")
       return handleDiagnostics();
+    if (method === "GET" && path === "/api/update")
+      return handleUpdate();
     if (method === "POST" && path === "/api/retire")
       return handleRetire();
     if (method === "GET" && (path === "/" || path === INDEX_PATH))
@@ -26696,6 +26757,8 @@ function createServer(opts) {
       return handleListReviews();
     if (method === "GET" && path === "/api/prefs")
       return handlePrefs();
+    if (method === "POST" && path === "/api/prefs")
+      return handleSetPrefs(req);
     const route = matchIdRoute(path);
     if (route) {
       const { id, sub } = route;
@@ -26732,14 +26795,18 @@ function createServer(opts) {
     }
     return notFound();
   }
-  async function handle(req) {
+  async function handle(req, self) {
     inFlight++;
     cancelIdle();
     try {
+      const port = self.port ?? -1;
+      if (isForeignHost(req, port)) {
+        return new Response("host not recognized", { status: 403 });
+      }
       const url2 = new URL(req.url);
       const path = url2.pathname;
       const method = req.method;
-      if (!isSafeMethod(method) && isCrossOrigin(req)) {
+      if (!isSafeMethod(method) && isCrossOrigin(req, port)) {
         return new Response("cross-origin request blocked", { status: 403 });
       }
       return await dispatch(req, method, path);
@@ -26804,6 +26871,150 @@ function createServer(opts) {
   return { port: server.port ?? 0, stop };
 }
 
+// src/daemon/update-check.ts
+import { writeFileSync as writeFileSync6 } 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";
+var REBUILD_COMMAND = "mise run build --install";
+var NEEDS_COMPARE = "could not compare this build against trunk";
+var NEVER_CHECKED = {
+  kind: "unknown",
+  reason: "no update check has run for this build yet"
+};
+var DISABLED = { kind: "unavailable", reason: "disabled" };
+function updateStatusFor(facts) {
+  if (facts.kind === "dev")
+    return { kind: "unavailable", reason: "dev" };
+  if (facts.kind === "bundle") {
+    if (facts.npmLatest === null)
+      return unknown2("could not reach npm for the published version");
+    return isNewer(facts.npmLatest, facts.version) ? { kind: "behind-release", available: facts.npmLatest, command: REFRESH_COMMAND } : { kind: "current" };
+  }
+  if (facts.release === null)
+    return unknown2("could not reach GitHub for the newest release");
+  if (isNewer(facts.release, facts.version)) {
+    return { kind: "behind-release", available: facts.release, command: REFRESH_COMMAND };
+  }
+  if (facts.commit === "unknown")
+    return { kind: "current" };
+  if (facts.aheadBy === null)
+    return unknown2(NEEDS_COMPARE);
+  return facts.aheadBy > 0 ? { kind: "behind-commit", aheadBy: facts.aheadBy, command: REBUILD_COMMAND } : { kind: "current" };
+}
+function updateReportFor(identity, status, checkEnabled) {
+  const devBuild = status.kind === "unavailable" && status.reason === "dev";
+  return { ...identity, checkEnabled, status: checkEnabled || devBuild ? status : DISABLED };
+}
+function readCachedStatus(cache, version2, commit) {
+  const rec = cache.read();
+  if (!rec || rec.version !== version2 || rec.commit !== commit)
+    return NEVER_CHECKED;
+  return rec.status;
+}
+async function runUpdateCheck(deps) {
+  if (deps.kind === "dev")
+    return { kind: "unavailable", reason: "dev" };
+  try {
+    if (!await deps.enabled())
+      return null;
+    const now = deps.now();
+    const prev = deps.cache.read();
+    const sameBuild = prev?.version === deps.version && prev?.commit === deps.commit;
+    if (prev && sameBuild && Math.abs(now - prev.checkedAt) < CHECK_INTERVAL_MS)
+      return null;
+    const record2 = (status2) => {
+      deps.cache.write({ checkedAt: now, version: deps.version, commit: deps.commit, status: status2 });
+    };
+    record2(prev && sameBuild ? prev.status : NEVER_CHECKED);
+    const status = await gather(deps);
+    record2(status);
+    deps.log.info("update", `update check: ${status.kind}`, status.kind === "unknown" ? { detail: status.reason } : undefined);
+    return status;
+  } catch (err) {
+    deps.log.warn("update", "update check failed", { detail: errorMessage(err) });
+    return unknown2("the update check failed");
+  }
+}
+function fileUpdateCache(path) {
+  return {
+    read: () => asRecord(readJsonFileSync(path)),
+    write: (entry) => {
+      try {
+        ensureStateDir(dirname7(path));
+        writeFileSync6(path, JSON.stringify(entry, null, 2), { mode: 384 });
+      } catch {}
+    }
+  };
+}
+async function gather(deps) {
+  const base = { kind: deps.kind, version: deps.version, commit: deps.commit };
+  if (deps.kind === "bundle") {
+    return updateStatusFor({
+      ...base,
+      npmLatest: await deps.npmLatest(),
+      release: null,
+      aheadBy: null
+    });
+  }
+  const release = await deps.release();
+  const first = updateStatusFor({ ...base, npmLatest: null, release, aheadBy: null });
+  if (first.kind !== "unknown" || first.reason !== NEEDS_COMPARE)
+    return first;
+  const aheadBy = await deps.aheadBy(deps.commit);
+  return updateStatusFor({ ...base, npmLatest: null, release, aheadBy });
+}
+function asRecord(value) {
+  const r = value;
+  if (typeof r?.checkedAt !== "number")
+    return null;
+  if (typeof r.version !== "string" || typeof r.commit !== "string")
+    return null;
+  if (typeof r.status?.kind !== "string")
+    return null;
+  return r;
+}
+function unknown2(reason) {
+  return { kind: "unknown", reason };
+}
+
+// src/lib/upstream.ts
+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(url2, fetchImpl, headers) {
+  try {
+    const res = await fetchImpl(url2, {
+      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 url2 = `${COMPARE_URL}/${encodeURIComponent(commit)}...trunk`;
+  const body = await readJson(url2, fetchImpl, GITHUB_HEADERS);
+  const ahead = body?.ahead_by;
+  return typeof ahead === "number" && Number.isFinite(ahead) ? ahead : null;
+}
+
 // src/review/store.ts
 import { readdir as readdir6, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
 import { join as join13 } from "path";
@@ -26917,6 +27128,28 @@ async function runDaemon(opts) {
   log.info("settings", existsSync7(cfg) ? `settings: reading ${cfg}` : `settings: no config at ${cfg}; using defaults`, { settings: boot });
   warnInvalidEnvVars((msg) => log.warn("env", msg));
   const adapter = selectAdapter();
+  const install = buildKind();
+  const version2 = VERSION;
+  const commit = currentCommit();
+  const updateCache = fileUpdateCache(updateCheckFile());
+  let updateStatus = readCachedStatus(updateCache, version2, commit);
+  function refreshUpdate() {
+    runUpdateCheck({
+      kind: install,
+      version: version2,
+      commit,
+      enabled: () => readUpdatesCheck(),
+      now: Date.now,
+      cache: updateCache,
+      npmLatest: publishedCaretVersion,
+      release: latestReleaseTag,
+      aheadBy: commitsAheadOfTrunk,
+      log
+    }).then((status) => {
+      if (status)
+        updateStatus = status;
+    }, (err) => log.error("update", err));
+  }
   const store = createStore(reviewsDir(), log);
   await store.rehydrate();
   const assets = await loadUiAssets();
@@ -26924,6 +27157,19 @@ async function runDaemon(opts) {
     log.info("ui", "no embedded ui; serving placeholder");
   const ephemeral = opts.ephemeral;
   let server;
+  const shutdown = (code) => {
+    server?.stop();
+    process.exit(code);
+  };
+  process.once("SIGTERM", () => {
+    log.info("signal", "sigterm: shutting down");
+    shutdown(0);
+  });
+  process.once("SIGINT", () => {
+    log.info("signal", "sigint: shutting down");
+    shutdown(0);
+  });
+  process.once("exit", removeOwnDaemonLock);
   try {
     server = createServer({
       store,
@@ -26933,7 +27179,7 @@ async function runDaemon(opts) {
       assets,
       lockPath: daemonLock(),
       buildId: await currentBuildId(),
-      commit: currentCommit(),
+      commit,
       stateDir: stateDir(),
       instanceId: randomUUID().slice(0, 8),
       approveVariants: adapter.approveVariants,
@@ -26953,6 +27199,8 @@ async function runDaemon(opts) {
         configExists: () => existsSync7(cfg),
         envOverrides
       }),
+      updateReport: async () => updateReportFor({ install, version: version2, commit }, updateStatus, await readUpdatesCheck()),
+      onUpdatesEnabled: refreshUpdate,
       log
     });
   } catch (e) {
@@ -26963,29 +27211,13 @@ async function runDaemon(opts) {
     }
     throw e;
   }
-  const shutdown = (code) => {
-    server.stop();
-    process.exit(code);
-  };
-  process.once("SIGTERM", () => {
-    log.info("signal", "sigterm: shutting down");
-    shutdown(0);
-  });
-  process.once("SIGINT", () => {
-    log.info("signal", "sigint: shutting down");
-    shutdown(0);
-  });
   const onFatal = (label) => (err) => {
     log.error(label, err);
     shutdown(1);
   };
   process.once("uncaughtException", onFatal("uncaughtException"));
   process.once("unhandledRejection", onFatal("unhandledRejection"));
-  process.once("exit", () => {
-    try {
-      unlinkSync4(daemonLock());
-    } catch {}
-  });
+  refreshUpdate();
 }
 
 // src/commands/discovery.ts
@@ -27315,19 +27547,19 @@ import {
   rmSync as rmSync2,
   statSync as statSync5,
   symlinkSync,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { join as join16, resolve as resolve2 } from "path";
 
 // src/adapters/opencode/packaging.ts
 import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname7, join as join15 } from "path";
+import { dirname as dirname8, join as join15 } from "path";
 function resolveCaretRoot() {
   const candidates = [];
   const script = process.argv[1];
   if (script)
-    candidates.push(join15(dirname7(script), ".."));
-  candidates.push(join15(dirname7(process.execPath), ".."));
+    candidates.push(join15(dirname8(script), ".."));
+  candidates.push(join15(dirname8(process.execPath), ".."));
   for (const root of candidates) {
     if (existsSync9(join15(root, "opencode", "caret.plugin.ts")))
       return root;
@@ -27379,7 +27611,7 @@ function writeDevMarketplace(repoDir, outDir) {
   rmSync2(outDir, { recursive: true, force: true });
   mkdirSync3(join16(outDir, ".claude-plugin"), { recursive: true });
   symlinkSync(resolve2(repoDir), join16(outDir, "caret"));
-  writeFileSync6(join16(outDir, ".claude-plugin", "marketplace.json"), `${JSON.stringify({
+  writeFileSync7(join16(outDir, ".claude-plugin", "marketplace.json"), `${JSON.stringify({
     name: "caret",
     description: "Local caret dev build (generated by caret install --from-local).",
     owner: { name: "macintacos" },
@@ -27664,12 +27896,12 @@ async function runInstallClaudeTarget(opts, deps = {}) {
 }
 
 // src/commands/install/opencode.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
 import { basename as basename4, join as join18 } from "path";
 
 // src/adapters/opencode/deploy.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname9 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10 } from "path";
 function renderPlugin(source, opts) {
   return source.replaceAll("__CARET_VERSION__", () => opts.version).replaceAll("__CARET_BIN__", () => opts.binPath);
 }
@@ -27677,8 +27909,8 @@ function deployFiles(files, opts) {
   const paths = [];
   for (const f2 of files) {
     if (!opts.dryRun) {
-      mkdirSync4(dirname9(f2.path), { recursive: true });
-      writeFileSync7(f2.path, f2.contents);
+      mkdirSync4(dirname10(f2.path), { recursive: true });
+      writeFileSync8(f2.path, f2.contents);
     }
     paths.push(f2.path);
   }
@@ -27873,7 +28105,7 @@ function editConfig(path2, transform2) {
   const next = transform2(existing);
   if (next === null || next === existing)
     return [];
-  writeFileSync8(path2, next);
+  writeFileSync9(path2, next);
   return [path2];
 }
 
@@ -27885,10 +28117,10 @@ function parseTargets(raw) {
       error: `--target names no agent (it takes a comma-separated list of: ${INSTALL_TARGET_IDS.join(", ")}) \u2014 omit it entirely to choose interactively.`
     };
   }
-  const unknown2 = parts.filter((p3) => !INSTALL_TARGET_IDS.includes(p3));
-  if (unknown2.length > 0) {
+  const unknown3 = parts.filter((p3) => !INSTALL_TARGET_IDS.includes(p3));
+  if (unknown3.length > 0) {
     return {
-      error: `unknown --target value(s): ${unknown2.join(", ")}. Valid: ${INSTALL_TARGET_IDS.join(", ")}.`
+      error: `unknown --target value(s): ${unknown3.join(", ")}. Valid: ${INSTALL_TARGET_IDS.join(", ")}.`
     };
   }
   const targets = [];
@@ -30942,7 +31174,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     });
     this.runningCommand = proc;
   }
-  _dispatchSubcommand(commandName, operands, unknown2) {
+  _dispatchSubcommand(commandName, operands, unknown3) {
     const subCommand = this._findCommand(commandName);
     if (!subCommand)
       this.help({ error: true });
@@ -30951,9 +31183,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
     promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
     promiseChain = this._chainOrCall(promiseChain, () => {
       if (subCommand._executableHandler) {
-        this._executeSubCommand(subCommand, operands.concat(unknown2));
+        this._executeSubCommand(subCommand, operands.concat(unknown3));
       } else {
-        return subCommand._parseCommand(operands, unknown2);
+        return subCommand._parseCommand(operands, unknown3);
       }
     });
     return promiseChain;
@@ -31050,22 +31282,22 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     return result;
   }
-  _parseCommand(operands, unknown2) {
-    const parsed = this.parseOptions(unknown2);
+  _parseCommand(operands, unknown3) {
+    const parsed = this.parseOptions(unknown3);
     this._parseOptionsEnv();
     this._parseOptionsImplied();
     operands = operands.concat(parsed.operands);
-    unknown2 = parsed.unknown;
-    this.args = operands.concat(unknown2);
+    unknown3 = parsed.unknown;
+    this.args = operands.concat(unknown3);
     if (operands && this._findCommand(operands[0])) {
-      return this._dispatchSubcommand(operands[0], operands.slice(1), unknown2);
+      return this._dispatchSubcommand(operands[0], operands.slice(1), unknown3);
     }
     if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
       return this._dispatchHelpCommand(operands[1]);
     }
     if (this._defaultCommandName) {
-      this._outputHelpIfRequested(unknown2);
-      return this._dispatchSubcommand(this._defaultCommandName, operands, unknown2);
+      this._outputHelpIfRequested(unknown3);
+      return this._dispatchSubcommand(this._defaultCommandName, operands, unknown3);
     }
     if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
       this.help({ error: true });
@@ -31087,7 +31319,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
       if (this.parent) {
         promiseChain = this._chainOrCall(promiseChain, () => {
-          this.parent.emit(commandEvent, operands, unknown2);
+          this.parent.emit(commandEvent, operands, unknown3);
         });
       }
       promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
@@ -31096,13 +31328,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (this.parent?.listenerCount(commandEvent)) {
       checkForUnknownOptions();
       this._processArguments();
-      this.parent.emit(commandEvent, operands, unknown2);
+      this.parent.emit(commandEvent, operands, unknown3);
     } else if (operands.length) {
       if (this._findCommand("*")) {
-        return this._dispatchSubcommand("*", operands, unknown2);
+        return this._dispatchSubcommand("*", operands, unknown3);
       }
       if (this.listenerCount("command:*")) {
-        this.emit("command:*", operands, unknown2);
+        this.emit("command:*", operands, unknown3);
       } else if (this.commands.length) {
         this.unknownCommand();
       } else {
@@ -31157,7 +31389,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
   parseOptions(args) {
     const operands = [];
-    const unknown2 = [];
+    const unknown3 = [];
     let dest = operands;
     function maybeOption(arg) {
       return arg.length > 1 && arg[0] === "-";
@@ -31174,7 +31406,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const arg = activeGroup ?? args[i2++];
       activeGroup = null;
       if (arg === "--") {
-        if (dest === unknown2)
+        if (dest === unknown3)
           dest.push(arg);
         dest.push(...args.slice(i2));
         break;
@@ -31226,18 +31458,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
       }
       if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
-        dest = unknown2;
+        dest = unknown3;
       }
-      if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown2.length === 0) {
+      if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown3.length === 0) {
         if (this._findCommand(arg)) {
           operands.push(arg);
-          unknown2.push(...args.slice(i2));
+          unknown3.push(...args.slice(i2));
           break;
         } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
           operands.push(arg, ...args.slice(i2));
           break;
         } else if (this._defaultCommandName) {
-          unknown2.push(arg, ...args.slice(i2));
+          unknown3.push(arg, ...args.slice(i2));
           break;
         }
       }
@@ -31247,7 +31479,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       dest.push(arg);
     }
-    return { operands, unknown: unknown2 };
+    return { operands, unknown: unknown3 };
   }
   opts() {
     if (this._storeOptionsAsProperties) {