@staff0rd/assist 0.411.0 → 0.412.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.411.0",
+  version: "0.412.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -143,10 +143,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path70) {
-  if (!existsSync(path70)) return {};
+function loadRawYaml(path71) {
+  if (!existsSync(path71)) return {};
   try {
-    const content = readFileSync(path70, "utf8");
+    const content = readFileSync(path71, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -1442,8 +1442,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path70 = line.split("	")[1];
-    if (path70) found.add(path70.trim());
+    const path71 = line.split("	")[1];
+    if (path71) found.add(path71.trim());
   }
   return [...found];
 }
@@ -1542,8 +1542,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path70 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path70}/${ref}`;
+  const path71 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path71}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3410,9 +3410,9 @@ import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path70) {
+function resolveStringsAtPath(data, path71) {
   let current = data;
-  for (const segment of path70.split(".")) {
+  for (const segment of path71.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3425,10 +3425,10 @@ function resolveStringsAtPath(data, path70) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path70 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path70)) {
+  for (const path71 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path71)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path70, value });
+        violations.push({ file: rule.file, path: path71, value });
     }
   }
   return violations;
@@ -3467,8 +3467,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path70, value } of violations) {
-    console.log(`  ${file} ${path70}: ${value}`);
+  for (const { file, path: path71, value } of violations) {
+    console.log(`  ${file} ${path71}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -3760,15 +3760,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path70) => MIGRATION_FILE3.test(basename(path70)));
-  for (const path70 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path71) => MIGRATION_FILE3.test(basename(path71)));
+  for (const path71 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path70}"`, {
+      const content = execSync12(`git show "${ref}:${path71}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path70), content);
+      baseline.set(basename(path71), content);
     } catch {
     }
   }
@@ -5106,8 +5106,16 @@ var daemonPaths = {
 };
 
 // src/commands/sessions/daemon/ensureHooksSettings.ts
-var RUNNING = "assist sessions set-status running";
-var WAITING = "assist sessions set-status waiting";
+var SET_STATUS = "assist sessions set-status";
+function running(source) {
+  return `${SET_STATUS} running --source ${source}`;
+}
+function waiting(source) {
+  return `${SET_STATUS} waiting --source ${source}`;
+}
+function ackWaiting(source) {
+  return `${SET_STATUS} waiting --source ${source} --ack`;
+}
 function on(command, matcher) {
   const hooks = [{ type: "command", command }];
   return [matcher == null ? { hooks } : { matcher, hooks }];
@@ -5116,27 +5124,22 @@ var ASK_USER_QUESTION = "AskUserQuestion";
 var NOT_ASK_USER_QUESTION = `^(?!${ASK_USER_QUESTION}$).*`;
 var hooksSettings = {
   hooks: {
-    UserPromptSubmit: on(RUNNING),
+    UserPromptSubmit: on(running("prompt")),
     PreToolUse: [
-      ...on(WAITING, ASK_USER_QUESTION),
-      ...on(RUNNING, NOT_ASK_USER_QUESTION)
+      ...on(waiting("pretool"), ASK_USER_QUESTION),
+      ...on(running("pretool"), NOT_ASK_USER_QUESTION)
     ],
-    // tool finished, agent resumes; restores running
-    PostToolUse: on(RUNNING),
-    Stop: on(WAITING),
-    Notification: on(WAITING),
-    /* why: a tool/plan approval prompt appears mid-turn, after PreToolUse has
-     * already set running; PermissionRequest fires when the agent blocks on
-     * that decision, so the card shows waiting rather than staying running while
-     * it is genuinely awaiting the user (#449). */
-    PermissionRequest: on(WAITING)
+    PostToolUse: on(running("posttool")),
+    Stop: on(ackWaiting("stop")),
+    Notification: on(ackWaiting("notification")),
+    PermissionRequest: on(ackWaiting("permission"))
   }
 };
 function ensureHooksSettings() {
-  const path70 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path70), { recursive: true });
-  writeFileSync15(path70, JSON.stringify(hooksSettings, null, 2));
-  return path70;
+  const path71 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path71), { recursive: true });
+  writeFileSync15(path71, JSON.stringify(hooksSettings, null, 2));
+  return path71;
 }
 
 // src/shared/spawnInherit.ts
@@ -5401,9 +5404,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path70 = join15(dir, ".assist", name);
-    if (existsSync18(path70)) {
-      renameSync(path70, `${path70}.bak`);
+    const path71 = join15(dir, ".assist", name);
+    if (existsSync18(path71)) {
+      renameSync(path71, `${path71}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -5875,8 +5878,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path70) {
-  const content = readFileSync14(path70, "utf8").trim();
+function parseBacklogJsonl(path71) {
+  const content = readFileSync14(path71, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -5958,8 +5961,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path70) {
-  return path70.replace(/^\/+/, "");
+function stripLeadingSlashes(path71) {
+  return path71.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -6307,20 +6310,87 @@ function sendToDaemon(message) {
   });
 }
 
+// src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
+var ACK_TIMEOUT_MS = 1e3;
+function sendToDaemonAwaitAck(message) {
+  return new Promise((resolve19, reject) => {
+    connectToDaemon().then((socket) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        socket.destroy();
+        if (error) reject(error);
+        else resolve19();
+      };
+      const timer = setTimeout(
+        () => finish(new Error("timed out awaiting daemon ack")),
+        ACK_TIMEOUT_MS
+      );
+      let buffer = "";
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        let newline = buffer.indexOf("\n");
+        while (newline !== -1) {
+          const line = buffer.slice(0, newline);
+          buffer = buffer.slice(newline + 1);
+          if (isAck(line)) return finish();
+          newline = buffer.indexOf("\n");
+        }
+      });
+      socket.on("error", (error) => finish(error));
+      socket.on(
+        "close",
+        () => finish(new Error("daemon closed before acknowledging"))
+      );
+      socket.write(`${JSON.stringify(message)}
+`);
+    }, reject);
+  });
+}
+function isAck(line) {
+  try {
+    return JSON.parse(line).type === "ack";
+  } catch {
+    return false;
+  }
+}
+
 // src/commands/sessions/setSessionStatus.ts
 var DELIVERY_ATTEMPTS = 3;
 var RETRY_DELAY_MS = 100;
-async function setSessionStatus(status3) {
+async function setSessionStatus(status3, opts = {}) {
   const sessionId = process.env.ASSIST_SESSION_ID;
-  logHookFired(status3, sessionId);
+  logHookFired(status3, sessionId, opts.source);
   if (!sessionId) return;
-  await deliverStatus(sessionId, status3);
+  const payload = buildPayload(sessionId, status3, opts);
+  if (opts.ack) await deliverReliably(sessionId, status3, payload);
+  else await deliverBestEffort(sessionId, status3, payload);
 }
-async function deliverStatus(sessionId, status3) {
-  const payload = { type: "set-status", sessionId, status: status3 };
+function buildPayload(sessionId, status3, opts) {
+  const payload = {
+    type: "set-status",
+    sessionId,
+    status: status3
+  };
+  if (opts.source) payload.source = opts.source;
+  if (opts.ack) payload.ack = true;
+  return payload;
+}
+async function deliverBestEffort(sessionId, status3, payload) {
+  try {
+    await sendToDaemon(payload);
+  } catch (error) {
+    appendDaemonLog(
+      `set-status best-effort send failed: id=${sessionId} status=${status3}: ${describeError(error)}`
+    );
+  }
+}
+async function deliverReliably(sessionId, status3, payload) {
   for (let attempt = 1; attempt <= DELIVERY_ATTEMPTS; attempt++) {
     try {
-      await sendToDaemon(payload);
+      await sendToDaemonAwaitAck(payload);
       return;
     } catch (error) {
       if (attempt < DELIVERY_ATTEMPTS) {
@@ -6328,7 +6398,7 @@ async function deliverStatus(sessionId, status3) {
         continue;
       }
       appendDaemonLog(
-        `set-status delivery failed after ${DELIVERY_ATTEMPTS} attempts: id=${sessionId} status=${status3}: ${describeError(error)}`
+        `set-status ack'd delivery failed after ${DELIVERY_ATTEMPTS} attempts: id=${sessionId} status=${status3}: ${describeError(error)}`
       );
     }
   }
@@ -6339,9 +6409,9 @@ function sleep(ms) {
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function logHookFired(status3, sessionId) {
+function logHookFired(status3, sessionId, source) {
   appendDaemonLog(
-    `set-status hook fired: id=${sessionId ?? "none"} status=${status3}`
+    `set-status hook fired: id=${sessionId ?? "none"} status=${status3}${source ? ` source=${source}` : ""}`
   );
 }
 
@@ -6499,24 +6569,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path70 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path70), { recursive: true });
-  writeFileSync17(path70, JSON.stringify({ sessionId }));
+  const path71 = getOwnerPath(itemId2);
+  mkdirSync7(dirname14(path71), { recursive: true });
+  writeFileSync17(path71, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path70 = getOwnerPath(itemId2);
-  if (!existsSync21(path70)) return void 0;
+  const path71 = getOwnerPath(itemId2);
+  if (!existsSync21(path71)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path70, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path71, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path70 = getOwnerPath(itemId2);
+  const path71 = getOwnerPath(itemId2);
   try {
-    rmSync(path70);
+    rmSync(path71);
   } catch {
   }
 }
@@ -6553,19 +6623,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path70 = getSignalPath(target);
-  if (!path70) return;
+  const path71 = getSignalPath(target);
+  if (!path71) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path70), { recursive: true });
-  writeFileSync18(path70, JSON.stringify(signal));
+  mkdirSync8(dirname15(path71), { recursive: true });
+  writeFileSync18(path71, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path70 = getSignalPath();
-  if (!path70 || !existsSync22(path70)) return void 0;
+  const path71 = getSignalPath();
+  if (!path71 || !existsSync22(path71)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path70, "utf8"));
+    return JSON.parse(readFileSync16(path71, "utf8"));
   } catch {
     return void 0;
   }
@@ -6698,13 +6768,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path70 = activityPath(sessionId);
-  mkdirSync9(dirname16(path70), { recursive: true });
-  writeFileSync19(path70, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path71 = activityPath(sessionId);
+  mkdirSync9(dirname16(path71), { recursive: true });
+  writeFileSync19(path71, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path70) {
+function readActivity(path71) {
   try {
-    return JSON.parse(readFileSync17(path70, "utf8"));
+    return JSON.parse(readFileSync17(path71, "utf8"));
   } catch {
     return void 0;
   }
@@ -6714,9 +6784,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path70 = activityPath(sessionId);
-  mkdirSync9(dirname16(path70), { recursive: true });
-  writeFileSync19(path70, JSON.stringify(activity2));
+  const path71 = activityPath(sessionId);
+  mkdirSync9(dirname16(path71), { recursive: true });
+  writeFileSync19(path71, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -7969,8 +8039,8 @@ async function loadItemSummaries(orm, origin) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path70 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path70.split("/").filter(Boolean);
+    const path71 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path71.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -8406,7 +8476,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname20(branchKeyPath);
   const branchPrefix = basename5(branchKeyPath);
   if (!existsSync26(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join24(parent, name, "synthesis.md")).filter((path70) => existsSync26(path70)).map((path70) => ({ path: path70, mtime: statSync2(path70).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join24(parent, name, "synthesis.md")).filter((path71) => existsSync26(path71)).map((path71) => ({ path: path71, mtime: statSync2(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -8460,12 +8530,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path70 = await resolveSynthesisPath(cwd);
-    if (!path70) {
+    const path71 = await resolveSynthesisPath(cwd);
+    if (!path71) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync19(path70, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync19(path71, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -8612,10 +8682,10 @@ function getStorePath(filename) {
   return join27(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path70 = getStorePath(filename);
-  if (existsSync27(path70)) {
+  const path71 = getStorePath(filename);
+  if (existsSync27(path71)) {
     try {
-      return JSON.parse(readFileSync20(path70, "utf8"));
+      return JSON.parse(readFileSync20(path71, "utf8"));
     } catch {
       return {};
     }
@@ -9725,9 +9795,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path70 = origin.slice(firstSlash + 1);
-  if (!path70) return null;
-  return `git@${host}:${path70}.git`;
+  const path71 = origin.slice(firstSlash + 1);
+  if (!path71) return null;
+  return `git@${host}:${path71}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -12036,9 +12106,9 @@ var __dirname4 = dirname21(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path70) {
-  if (!existsSync29(path70)) return [];
-  return readFileSync23(path70, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path71) {
+  if (!existsSync29(path71)) return [];
+  return readFileSync23(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -12530,14 +12600,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path70, description, depth, p) {
-  showProgress(p, path70.join(" "));
-  const subHelp = await runHelp([cli, ...path70]);
+async function resolveCommand(cli, path71, description, depth, p) {
+  showProgress(p, path71.join(" "));
+  const subHelp = await runHelp([cli, ...path71]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path70, description }];
+    return [{ path: path71, description }];
   }
-  const children = await discoverAt(cli, path70, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path70, description }];
+  const children = await discoverAt(cli, path71, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path71, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -12685,9 +12755,9 @@ function logPath(cli) {
   return join31(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path70 = logPath(cli);
-  if (!existsSync31(path70)) return void 0;
-  return readFileSync25(path70, "utf8");
+  const path71 = logPath(cli);
+  if (!existsSync31(path71)) return void 0;
+  return readFileSync25(path71, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join31(homedir16(), ".assist");
@@ -12859,9 +12929,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path70 = join33(dir, entry);
+    const path71 = join33(dir, entry);
     try {
-      if (statSync3(path70).mtimeMs < cutoff) unlinkSync7(path70);
+      if (statSync3(path71).mtimeMs < cutoff) unlinkSync7(path71);
     } catch {
       continue;
     }
@@ -12871,10 +12941,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync32, readFileSync as readFileSync26 } from "fs";
 function readPinState(pin) {
-  const path70 = getPinStatePath(pin);
-  if (!existsSync32(path70)) return void 0;
+  const path71 = getPinStatePath(pin);
+  if (!existsSync32(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path70, "utf8"));
+    const state = JSON.parse(readFileSync26(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -13770,8 +13840,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path70, value) {
-  const keys = path70.split(".");
+function setNestedValue(obj, path71, value) {
+  const keys = path71.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -13851,9 +13921,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path70) {
+function getNestedValue(obj, path71) {
   let current = obj;
-  for (const key of path70.split(".")) current = stepInto(current, key);
+  for (const key of path71.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -13969,10 +14039,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
 function readMigrationPinState(pin) {
-  const path70 = getMigrationPinPath(pin);
-  if (!existsSync34(path70)) return void 0;
+  const path71 = getMigrationPinPath(pin);
+  if (!existsSync34(path71)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path70, "utf8"));
+    const state = JSON.parse(readFileSync28(path71, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -15411,10 +15481,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync41, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path70 = getMigrationApprovalPath(migrationId);
-  if (!existsSync41(path70)) return false;
+  const path71 = getMigrationApprovalPath(migrationId);
+  if (!existsSync41(path71)) return false;
   try {
-    unlinkSync11(path70);
+    unlinkSync11(path71);
     return true;
   } catch {
     return false;
@@ -16588,9 +16658,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path70] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path71] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path70) {
+    for (const key of path71) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -17274,15 +17344,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path70, line, body, startLine) {
+function comment2(path71, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path70, line, startLine });
+    postComment({ prId, body, path: path71, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path70}:${range}`);
+    console.log(`Added review comment on ${path71}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -18161,8 +18231,8 @@ function registerPrs(program2) {
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path70, line, body) => {
-    comment2(path70, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path71, line, body) => {
+    comment2(path71, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -18415,10 +18485,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path70) {
+async function ravenFetch(connection, path71) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path70}`;
+  const url = `${connection.url}${path71}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -18522,16 +18592,16 @@ import chalk170 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path70;
+  let path71;
   if (opts.collection) {
-    path70 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path71 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path70 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path71 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path70 += `&query=${encodeURIComponent(opts.query)}`;
+    path71 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path70;
+  return path71;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -18540,7 +18610,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path70 = buildQueryPath({
+    const path71 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -18548,7 +18618,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path70);
+    const data = await ravenFetch(connection, path71);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -20968,8 +21038,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync45, mkdirSync as mkdirSync18, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path70 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync45(path70)) unlinkSync16(path70);
+  for (const path71 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync45(path71)) unlinkSync16(path71);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -22117,8 +22187,8 @@ import chalk191 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk188 from "chalk";
-async function fetchSeq(conn, path70, params) {
-  const url = `${conn.url}${path70}?${params}`;
+async function fetchSeq(conn, path71, params) {
+  const url = `${conn.url}${path71}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -23605,9 +23675,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path70 = join62(roamDir, name);
+    const path71 = join62(roamDir, name);
     try {
-      return { path: path70, mtimeMs: statSync8(path70).mtimeMs };
+      return { path: path71, mtimeMs: statSync8(path71).mtimeMs };
     } catch {
       return void 0;
     }
@@ -24026,11 +24096,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path70 = process.argv[idx + 1];
+  const path71 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path70, prefix: prefix2 };
+  return { path: path71, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -24911,6 +24981,7 @@ function dismissSession(sessions, id) {
   if (!s) return false;
   if (s.status !== "done") s.pty?.kill();
   s.activityWatcher?.close();
+  s.transcriptWatcher?.close();
   removeActivity(s.id);
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
   sessions.delete(id);
@@ -25017,113 +25088,18 @@ function logSpawnedSession(session) {
   );
 }
 
-// src/commands/sessions/daemon/setStatus.ts
-function setStatus2(session, newStatus) {
-  const now = Date.now();
-  if (session.status === "running" && session.runningSince != null) {
-    session.runningMs += now - session.runningSince;
-  }
-  session.runningSince = newStatus === "running" ? now : null;
-  session.status = newStatus;
-}
-
-// src/commands/sessions/daemon/shouldAutoDismiss.ts
-function shouldAutoDismiss(session, exitCode) {
-  if (session.status !== "done" || exitCode !== 0) {
-    return false;
-  }
-  if (session.reviewStarted) {
-    return session.autoAdvance === true;
-  }
-  const args = session.assistArgs;
-  if (args === void 0) return false;
-  if (args[0] === "update") return true;
-  return args.includes("--once") && args[0] !== "next";
-}
-
-// src/commands/sessions/daemon/shouldAutoRun.ts
-function shouldAutoRun(session) {
-  if (!session.autoRun) return { run: false, reason: null };
-  if (session.status !== "done")
-    return {
-      run: false,
-      reason: `session status is "${session.status}", not "done"`
-    };
-  if (session.commandType !== "assist")
-    return {
-      run: false,
-      reason: `command type is "${session.commandType}", not "assist"`
-    };
-  const cmd = session.assistArgs?.[0];
-  if (cmd !== "draft" && cmd !== "bug" && cmd !== "refine")
-    return {
-      run: false,
-      reason: `command "${cmd ?? "(none)"}" is not draft/bug/refine`
-    };
-  const itemId2 = session.activity?.itemId;
-  if (itemId2 == null)
-    return {
-      run: false,
-      reason: "no itemId in activity (draft did not create an item)"
-    };
-  return { run: true, itemId: itemId2 };
-}
-
-// src/commands/sessions/daemon/watchEscInterrupt.ts
-var ESC3 = "\x1B";
-var SETTLE_MS = 1e3;
-function isInterruptKey(data) {
-  return data === ESC3;
-}
-function scheduleSettle(session, onStatusChange) {
-  if (session.escInterruptTimer) clearTimeout(session.escInterruptTimer);
-  session.escInterruptTimer = setTimeout(() => {
-    session.escInterruptTimer = void 0;
-    if (session.status !== "running") return;
-    daemonLog(`session ${session.id} esc-interrupt settled -> waiting`);
-    onStatusChange(session, "waiting");
-  }, SETTLE_MS);
-}
-function watchEscInterrupt(session, data, onStatusChange) {
-  if (session.status !== "running") return;
-  if (!isInterruptKey(data)) return;
-  scheduleSettle(session, onStatusChange);
-}
-function noteOutputForEscInterrupt(session, onStatusChange) {
-  if (!session.escInterruptTimer) return;
-  scheduleSettle(session, onStatusChange);
-}
-function disarmEscInterrupt(session) {
-  if (!session.escInterruptTimer) return;
-  clearTimeout(session.escInterruptTimer);
-  session.escInterruptTimer = void 0;
-}
-
-// src/commands/sessions/daemon/applyStatusChange.ts
-function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseForRun) {
-  disarmEscInterrupt(session);
-  if (session.status === status3) return;
-  daemonLog(`session ${session.id} status: ${session.status} -> ${status3}`);
-  void flushPhaseActiveMs(session);
-  setStatus2(session, status3);
-  const autoRun = shouldAutoRun(session);
-  if (autoRun.run) {
-    reuseForRun(session, autoRun.itemId);
-    notify2();
-    return;
-  }
-  if (status3 === "done" && autoRun.reason != null) {
+// src/commands/sessions/daemon/applySetStatus.ts
+function applySetStatus(sessions, id, status3, source, onStatusChange) {
+  const session = sessions.get(id);
+  if (!session) {
     daemonLog(
-      `session ${session.id} auto-run enabled but skipped (exit ${exitCode ?? "none"}): ${autoRun.reason}`
+      `set-status for unknown session id=${id} status=${status3} (no live session; ignoring)`
     );
+    return;
   }
-  if (shouldAutoDismiss(session, exitCode)) dismiss(session.id);
-  else notify2();
-}
-
-// src/commands/sessions/daemon/makeStatusChangeHandler.ts
-function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
-  return (s, status3, exitCode) => applyStatusChange(s, status3, exitCode, dismiss, notify2, reuseForRun);
+  if (source === "permission") session.permissionActive = true;
+  if (status3 === "running") session.permissionActive = false;
+  onStatusChange(session, status3);
 }
 
 // src/shared/db/recordPhaseCycleContext.ts
@@ -25282,12 +25258,102 @@ function recordSessionUsage(sessions, claudeSessionId, transcriptPath, usedPct,
   return false;
 }
 
+// src/commands/sessions/daemon/applyUsageRecord.ts
+function applyUsageRecord(sessions, windows, notify2, claudeSessionId, transcriptPath, usedPct) {
+  if (recordSessionUsage(
+    sessions,
+    claudeSessionId,
+    transcriptPath,
+    usedPct,
+    windows
+  ))
+    notify2();
+}
+
+// src/commands/sessions/daemon/setStatus.ts
+function setStatus2(session, newStatus) {
+  const now = Date.now();
+  if (session.status === "running" && session.runningSince != null) {
+    session.runningMs += now - session.runningSince;
+  }
+  session.runningSince = newStatus === "running" ? now : null;
+  session.status = newStatus;
+}
+
+// src/commands/sessions/daemon/shouldAutoDismiss.ts
+function shouldAutoDismiss(session, exitCode) {
+  if (session.status !== "done" || exitCode !== 0) {
+    return false;
+  }
+  if (session.reviewStarted) {
+    return session.autoAdvance === true;
+  }
+  const args = session.assistArgs;
+  if (args === void 0) return false;
+  if (args[0] === "update") return true;
+  return args.includes("--once") && args[0] !== "next";
+}
+
+// src/commands/sessions/daemon/shouldAutoRun.ts
+function shouldAutoRun(session) {
+  if (!session.autoRun) return { run: false, reason: null };
+  if (session.status !== "done")
+    return {
+      run: false,
+      reason: `session status is "${session.status}", not "done"`
+    };
+  if (session.commandType !== "assist")
+    return {
+      run: false,
+      reason: `command type is "${session.commandType}", not "assist"`
+    };
+  const cmd = session.assistArgs?.[0];
+  if (cmd !== "draft" && cmd !== "bug" && cmd !== "refine")
+    return {
+      run: false,
+      reason: `command "${cmd ?? "(none)"}" is not draft/bug/refine`
+    };
+  const itemId2 = session.activity?.itemId;
+  if (itemId2 == null)
+    return {
+      run: false,
+      reason: "no itemId in activity (draft did not create an item)"
+    };
+  return { run: true, itemId: itemId2 };
+}
+
+// src/commands/sessions/daemon/applyStatusChange.ts
+function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseForRun) {
+  if (session.status === status3) return;
+  daemonLog(`session ${session.id} status: ${session.status} -> ${status3}`);
+  void flushPhaseActiveMs(session);
+  setStatus2(session, status3);
+  const autoRun = shouldAutoRun(session);
+  if (autoRun.run) {
+    reuseForRun(session, autoRun.itemId);
+    notify2();
+    return;
+  }
+  if (status3 === "done" && autoRun.reason != null) {
+    daemonLog(
+      `session ${session.id} auto-run enabled but skipped (exit ${exitCode ?? "none"}): ${autoRun.reason}`
+    );
+  }
+  if (shouldAutoDismiss(session, exitCode)) dismiss(session.id);
+  else notify2();
+}
+
+// src/commands/sessions/daemon/makeStatusChangeHandler.ts
+function makeStatusChangeHandler(dismiss, notify2, reuseForRun) {
+  return (s, status3, exitCode) => applyStatusChange(s, status3, exitCode, dismiss, notify2, reuseForRun);
+}
+
 // src/commands/sessions/daemon/errorTail.ts
-var ESC4 = String.fromCharCode(27);
+var ESC3 = String.fromCharCode(27);
 var CSI = String.fromCharCode(155);
 var BEL = String.fromCharCode(7);
 var ANSI = new RegExp(
-  String.raw`[${ESC4}${CSI}][[\]()#;?]*(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?${BEL}|(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~])`,
+  String.raw`[${ESC3}${CSI}][[\]()#;?]*(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?${BEL}|(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~])`,
   "g"
 );
 var MAX_TAIL_LINES = 40;
@@ -25355,10 +25421,10 @@ async function seedRunningMsFromUsage(session, notify2) {
 
 // src/commands/sessions/daemon/watchActivity.ts
 var DEBOUNCE_MS = 50;
-function watchActivity(session, notify2) {
+function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path70 = activityPath(session.id);
-  const dir = dirname29(path70);
+  const path71 = activityPath(session.id);
+  const dir = dirname29(path71);
   try {
     mkdirSync25(dir, { recursive: true });
   } catch {
@@ -25368,21 +25434,23 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path70);
+    const activity2 = readActivity(path71);
     if (!activity2) return;
     session.activity = activity2;
-    if (activity2.claudeSessionId)
+    if (activity2.claudeSessionId) {
       session.claudeSessionId = activity2.claudeSessionId;
+      onClaudeSessionId?.(session);
+    }
     applyReviewPause(session, activity2);
     void seedRunningMsFromUsage(session, notify2);
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path70.endsWith(filename)) return;
+    if (filename && !path71.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync58(path70)) read();
+  if (existsSync58(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -25445,7 +25513,6 @@ function wirePtyEvents(session, clients, onStatusChange) {
   if (!session.pty) return;
   session.pty.onData((data) => {
     appendScrollback(session, data);
-    noteOutputForEscInterrupt(session, onStatusChange);
     broadcast(clients, { type: "output", sessionId: session.id, data });
   });
   session.pty.onExit(
@@ -25613,6 +25680,222 @@ function errorSession(id, persisted, error) {
   };
 }
 
+// src/commands/sessions/shared/normalizeUser.ts
+var INTERRUPT_PREFIX = "[Request interrupted";
+function normalizeUser(entry) {
+  const content = asRecord(entry.message)?.content;
+  if (typeof content === "string")
+    return isInterruptText(content) ? { kind: "interrupt" } : { kind: "user" };
+  if (!Array.isArray(content)) return { kind: "user" };
+  const toolResultIds = [];
+  let hasInterrupt = false;
+  let hasNonToolResult = false;
+  for (const block of content) {
+    const b = asRecord(block);
+    if (!b) continue;
+    if (b.type === "tool_result") {
+      if (typeof b.tool_use_id === "string") toolResultIds.push(b.tool_use_id);
+    } else if (b.type === "text" && isInterruptText(b.text)) {
+      hasInterrupt = true;
+    } else {
+      hasNonToolResult = true;
+    }
+  }
+  if (hasInterrupt) return { kind: "interrupt" };
+  if (hasNonToolResult) return { kind: "user" };
+  return { kind: "toolResult", ids: toolResultIds };
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function isInterruptText(value) {
+  return typeof value === "string" && value.startsWith(INTERRUPT_PREFIX);
+}
+
+// src/commands/sessions/shared/normalizeTranscriptEvents.ts
+function normalizeTranscriptEvents(entries) {
+  return entries.map(normalizeEntry).filter((event) => event !== null);
+}
+function normalizeEntry(entry) {
+  if (entry.isSidechain || entry.isMeta) return null;
+  if (entry.type === "assistant") return normalizeAssistant(entry);
+  if (entry.type === "user") return normalizeUser(entry);
+  return null;
+}
+function normalizeAssistant(entry) {
+  const message = asRecord2(entry.message);
+  const stopReason = typeof message?.stop_reason === "string" ? message.stop_reason : null;
+  const content = message?.content;
+  const toolUses = [];
+  if (Array.isArray(content))
+    for (const block of content) {
+      const b = asRecord2(block);
+      if (b?.type === "tool_use")
+        toolUses.push({
+          id: typeof b.id === "string" ? b.id : "",
+          name: typeof b.name === "string" ? b.name : ""
+        });
+    }
+  return { kind: "assistant", stopReason, toolUses };
+}
+function asRecord2(value) {
+  return value && typeof value === "object" ? value : null;
+}
+
+// src/commands/sessions/shared/deriveTranscriptStatus.ts
+var ASK_USER_QUESTION2 = "AskUserQuestion";
+var TURN_END_STOP_REASONS = /* @__PURE__ */ new Set(["end_turn", "stop_sequence"]);
+function deriveTranscriptStatus(entries, opts = {}) {
+  const events = normalizeTranscriptEvents(entries);
+  const lastIdx = lastDecisiveIndex(events);
+  if (lastIdx === -1) return null;
+  const ev = events[lastIdx];
+  if (ev.kind === "interrupt") return "waiting";
+  if (ev.kind === "user") return "running";
+  if (ev.kind === "toolResult") return null;
+  if (ev.stopReason != null && TURN_END_STOP_REASONS.has(ev.stopReason))
+    return "waiting";
+  const resolved = resolvedToolUseIds(events, lastIdx);
+  const pending = ev.toolUses.filter((tool) => !resolved.has(tool.id));
+  if (pending.length === 0) return "running";
+  if (pending.some((tool) => tool.name === ASK_USER_QUESTION2))
+    return "waiting";
+  if (opts.permissionActive) return "waiting";
+  return "running";
+}
+function lastDecisiveIndex(events) {
+  for (let i = events.length - 1; i >= 0; i--)
+    if (events[i].kind !== "toolResult") return i;
+  return -1;
+}
+function resolvedToolUseIds(events, afterIdx) {
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = afterIdx + 1; i < events.length; i++) {
+    const event = events[i];
+    if (event.kind === "toolResult") for (const id of event.ids) ids.add(id);
+  }
+  return ids;
+}
+
+// src/commands/sessions/shared/readTranscriptTail.ts
+import * as fs37 from "fs";
+var DEFAULT_MAX_BYTES = 256 * 1024;
+function parseTailEntries(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object")
+        entries.push(parsed);
+    } catch {
+    }
+  }
+  return entries;
+}
+function dropPartialFirstLine(raw, sliced) {
+  if (!sliced) return raw;
+  const newline = raw.indexOf("\n");
+  return newline === -1 ? "" : raw.slice(newline + 1);
+}
+async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
+  let handle;
+  try {
+    handle = await fs37.promises.open(filePath, "r");
+    const { size } = await handle.stat();
+    const start3 = Math.max(0, size - maxBytes);
+    const length = size - start3;
+    if (length === 0) return [];
+    const buf = Buffer.alloc(length);
+    await handle.read(buf, 0, length, start3);
+    return parseTailEntries(
+      dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
+    );
+  } catch {
+    return [];
+  } finally {
+    await handle?.close();
+  }
+}
+function readTranscriptTailSync(filePath, maxBytes = DEFAULT_MAX_BYTES) {
+  let fd;
+  try {
+    fd = fs37.openSync(filePath, "r");
+    const { size } = fs37.fstatSync(fd);
+    const start3 = Math.max(0, size - maxBytes);
+    const length = size - start3;
+    if (length === 0) return [];
+    const buf = Buffer.alloc(length);
+    fs37.readSync(fd, buf, 0, length, start3);
+    return parseTailEntries(
+      dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
+    );
+  } catch {
+    return [];
+  } finally {
+    if (fd !== void 0) fs37.closeSync(fd);
+  }
+}
+
+// src/commands/sessions/shared/findTranscriptPathSync.ts
+import * as fs38 from "fs";
+import * as os4 from "os";
+import * as path60 from "path";
+function projectDirForCwd(cwd) {
+  return path60.join(
+    os4.homedir(),
+    ".claude",
+    "projects",
+    cwd.replace(/[^a-zA-Z0-9]/g, "-")
+  );
+}
+function transcriptPathFor(cwd, claudeSessionId) {
+  return path60.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+}
+function findTranscriptPathSync(cwd, claudeSessionId) {
+  const direct = transcriptPathFor(cwd, claudeSessionId);
+  if (fs38.existsSync(direct)) return direct;
+  const dir = projectDirForCwd(cwd);
+  let files;
+  try {
+    files = fs38.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) continue;
+    if (headContainsSessionId(path60.join(dir, file), claudeSessionId))
+      return path60.join(dir, file);
+  }
+  return null;
+}
+function headContainsSessionId(filePath, claudeSessionId) {
+  let fd;
+  try {
+    fd = fs38.openSync(filePath, "r");
+    const buf = Buffer.alloc(16384);
+    const bytesRead = fs38.readSync(fd, buf, 0, buf.length, 0);
+    return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) fs38.closeSync(fd);
+  }
+}
+
+// src/commands/sessions/daemon/deriveRestoreStatus.ts
+function deriveRestoreStatus(persisted) {
+  if (!persisted.claudeSessionId) return "waiting";
+  const filePath = findTranscriptPathSync(
+    persisted.cwd,
+    persisted.claudeSessionId
+  );
+  if (!filePath) return "waiting";
+  const entries = readTranscriptTailSync(filePath);
+  return deriveTranscriptStatus(entries) === "running" ? "running" : "waiting";
+}
+
 // src/commands/sessions/daemon/runningSession.ts
 function runningSession(base, persisted, pty2) {
   return restoredSession(base, persisted, pty2, "running");
@@ -25636,17 +25919,16 @@ function restoredSession(base, persisted, pty2, status3) {
 }
 
 // src/commands/sessions/daemon/restoreInteractiveSession.ts
-function restoreInteractiveSession(id, persisted, base) {
+function restoreInteractiveSession(id, persisted, base, idle) {
   if (persisted.commandType !== "run" && persisted.claudeSessionId) {
-    return resumeViaClaude(id, persisted, base);
+    return resumeViaClaude(id, persisted, base, idle);
   }
   if (persisted.commandType === "claude") {
     return unrecoverableClaude(id, persisted);
   }
   return notRestoredStub(base, persisted);
 }
-function resumeViaClaude(id, persisted, base) {
-  const idle = persisted.status !== "running";
+function resumeViaClaude(id, persisted, base, idle) {
   const pty2 = spawnClaude2({
     resumeSessionId: persisted.claudeSessionId,
     prompt: idle ? void 0 : buildResumePrompt(),
@@ -25695,8 +25977,8 @@ function isUpdate(persisted) {
 function restoreSession(id, persisted) {
   const base = restoreBase(id, persisted);
   if (isUpdate(persisted)) return updatedSession(id, persisted);
+  const idle = deriveRestoreStatus(persisted) !== "running";
   if (needsWrapperRelaunch(persisted)) {
-    const idle = persisted.status !== "running";
     const pty2 = spawnPty(
       assistResumeArgs(persisted),
       persisted.cwd,
@@ -25705,7 +25987,7 @@ function restoreSession(id, persisted) {
     );
     return idle ? waitingSession(base, persisted, pty2) : runningSession(base, persisted, pty2);
   }
-  return restoreInteractiveSession(id, persisted, base);
+  return restoreInteractiveSession(id, persisted, base, idle);
 }
 function needsWrapperRelaunch(persisted) {
   return isBacklogRun(persisted) || isOnceLaunch(persisted) && !!persisted.claudeSessionId;
@@ -25846,6 +26128,77 @@ function shutdownSessions(sessions) {
   }
 }
 
+// src/commands/sessions/daemon/watchTranscript.ts
+import { existsSync as existsSync60, watch as watch2 } from "fs";
+
+// src/commands/sessions/daemon/reconcileTranscriptStatus.ts
+async function resolveTranscriptPath(session) {
+  if (session.transcriptPath) return session.transcriptPath;
+  if (!session.claudeSessionId) return null;
+  const direct = session.cwd ? findTranscriptPathSync(session.cwd, session.claudeSessionId) : null;
+  const filePath = direct ?? await findSessionJsonlPath(session.claudeSessionId);
+  if (filePath) session.transcriptPath = filePath;
+  return filePath;
+}
+async function reconcileTranscriptStatus(session, onStatusChange) {
+  if (session.status === "done" || session.status === "error") return;
+  const filePath = await resolveTranscriptPath(session);
+  if (!filePath) return;
+  const entries = await readTranscriptTail(filePath);
+  const derived = deriveTranscriptStatus(entries, {
+    permissionActive: session.permissionActive
+  });
+  if (!derived) return;
+  if (derived === "running") session.permissionActive = false;
+  if (derived === session.status) return;
+  daemonLog(
+    `session ${session.id} transcript reconcile: ${session.status} -> ${derived}`
+  );
+  onStatusChange(session, derived);
+}
+
+// src/commands/sessions/daemon/watchTranscript.ts
+var DEBOUNCE_MS2 = 100;
+function watchTranscript(session, onStatusChange) {
+  if (!session.cwd || !session.claudeSessionId) return;
+  if (session.watchedTranscriptId === session.claudeSessionId) return;
+  const dir = projectDirForCwd(session.cwd);
+  if (!existsSync60(dir)) return;
+  if (session.transcriptWatcher) {
+    session.transcriptWatcher.close();
+    session.transcriptWatcher = void 0;
+  }
+  session.transcriptPath = void 0;
+  const fileName = `${session.claudeSessionId}.jsonl`;
+  let timer = null;
+  const run4 = () => {
+    timer = null;
+    void reconcileTranscriptStatus(session, onStatusChange);
+  };
+  try {
+    session.transcriptWatcher = watch2(dir, (_event, changed) => {
+      if (changed && changed !== fileName) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(run4, DEBOUNCE_MS2);
+    });
+  } catch (error) {
+    daemonLog(
+      `session ${session.id} transcript watch failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  session.watchedTranscriptId = session.claudeSessionId;
+  daemonLog(`session ${session.id} watching transcript ${fileName}`);
+  run4();
+}
+
+// src/commands/sessions/daemon/wireSessionWatchers.ts
+function wireSessionWatchers(session, notify2, onStatusChange) {
+  const wireTranscript = (s) => watchTranscript(s, onStatusChange);
+  watchActivity(session, notify2, wireTranscript);
+  wireTranscript(session);
+}
+
 // src/commands/sessions/daemon/connectToWindowsDaemon.ts
 import * as net2 from "net";
 
@@ -25961,13 +26314,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync59, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync49 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync59(sessionsFile)) return false;
+    if (!existsSync61(sessionsFile)) return false;
     const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -26528,7 +26881,6 @@ function writeToSession(sessions, id, data, onStatusChange) {
   const s = sessions.get(id);
   if (!s || s.status === "done") return;
   s.pty?.write(data);
-  watchEscInterrupt(s, data, onStatusChange);
   watchPromptSubmit(s, data, onStatusChange);
 }
 function resizeSession(sessions, id, cols, rows) {
@@ -26608,7 +26960,7 @@ var SessionManager = class {
   drain = () => drainSessions(this.sessions, this.notify);
   add(session) {
     this.wire(session);
-    watchActivity(session, this.notify);
+    wireSessionWatchers(session, this.notify, this.onStatusChange);
     logSpawnedSession(session);
     return session.id;
   }
@@ -26671,27 +27023,20 @@ var SessionManager = class {
   setStarred(id, starred) {
     if (setStarred2(this.sessions, id, starred)) this.notify();
   }
-  setStatus(id, status3) {
-    const session = this.sessions.get(id);
-    if (!session) {
-      daemonLog(
-        `set-status for unknown session id=${id} status=${status3} (no live session; ignoring)`
-      );
-      return;
-    }
-    this.onStatusChange(session, status3);
+  setStatus(id, status3, source) {
+    applySetStatus(this.sessions, id, status3, source, this.onStatusChange);
   }
   /* why: the status line relays token totals keyed by Claude's session id; join
    * it to the running backlog phase so the spend accumulates against that row. */
   recordUsage(claudeSessionId, transcriptPath, usedPct) {
-    if (recordSessionUsage(
+    applyUsageRecord(
       this.sessions.values(),
+      this.clients.currentWindows(),
+      this.notify,
       claudeSessionId,
       transcriptPath,
-      usedPct,
-      this.clients.currentWindows()
-    ))
-      this.notify();
+      usedPct
+    );
   }
   listSessions = () => {
     const local = [...this.sessions.values()].map(toSessionInfo);
@@ -26712,8 +27057,30 @@ import * as net3 from "net";
 // src/commands/sessions/daemon/handleConnection.ts
 import { createInterface as createInterface9 } from "readline";
 
+// src/commands/sessions/daemon/creator.ts
+function creator(isNew, spawn12) {
+  return (client, m, d) => {
+    if (m.windowsProxy.route(client, d)) return;
+    sendTo(client, { type: "created", sessionId: spawn12(m, d), isNew });
+  };
+}
+
+// src/commands/sessions/daemon/handleSetStatus.ts
+function handleSetStatus(client, m, d) {
+  daemonLog(
+    `set-status received: id=${d.sessionId} status=${d.status}${d.source ? ` source=${d.source}` : ""}`
+  );
+  if (m.windowsProxy.route(client, d)) return;
+  m.setStatus(
+    d.sessionId,
+    d.status,
+    d.source
+  );
+  if (d.ack) sendTo(client, { type: "ack", sessionId: d.sessionId });
+}
+
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs37 from "fs";
+import * as fs39 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -26765,7 +27132,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs37.promises.readFile(filePath, "utf8");
+    const raw = await fs39.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -26829,12 +27196,6 @@ function spawnCreate(m, d) {
 }
 
 // src/commands/sessions/daemon/messageHandlers.ts
-function creator(isNew, spawn12) {
-  return (client, m, d) => {
-    if (m.windowsProxy.route(client, d)) return;
-    sendTo(client, { type: "created", sessionId: spawn12(m, d), isNew });
-  };
-}
 function routed(local) {
   return (client, m, d) => {
     if (!m.windowsProxy.route(client, d)) local(client, m, d);
@@ -26903,11 +27264,7 @@ var messageHandlers = {
     (_client, m, d) => m.setStarred(d.sessionId, d.starred)
   ),
   "set-active": (_client, m, d) => m.active.set(d.cwd, d.sessionId),
-  "set-status": (client, m, d) => {
-    daemonLog(`set-status received: id=${d.sessionId} status=${d.status}`);
-    if (!m.windowsProxy.route(client, d))
-      m.setStatus(d.sessionId, d.status);
-  },
+  "set-status": handleSetStatus,
   "ui-status": (_client, _m, d) => daemonLog(`ui rendered: id=${d.sessionId} status=${d.status}`)
 };
 
@@ -27093,18 +27450,33 @@ function registerDaemon(program2) {
   ).action(drainDaemon);
 }
 
+// src/commands/sessions/registerSetStatusCommand.ts
+function registerSetStatusCommand(cmd) {
+  cmd.command("set-status <status>").description(
+    "Report the current session's status to the sessions daemon (used by Claude Code hooks)"
+  ).option(
+    "--source <source>",
+    "Originating hook (permission, stop, notification, prompt, pretool, posttool)"
+  ).option(
+    "--ack",
+    "Wait for the daemon to acknowledge delivery, retrying on failure"
+  ).action(
+    (status3, options2) => setSessionStatus(status3, { source: options2.source, ack: options2.ack })
+  );
+}
+
 // src/commands/sessions/summarise/index.ts
-import * as fs39 from "fs";
+import * as fs41 from "fs";
 import chalk200 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs38 from "fs";
+import * as fs40 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs38.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs40.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs38.existsSync(summaryPathFor(jsonlPath2));
+  return fs40.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -27191,7 +27563,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs39.statSync(b).mtimeMs - fs39.statSync(a).mtimeMs;
+      return fs41.statSync(b).mtimeMs - fs41.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -27229,9 +27601,7 @@ function registerSessions(program2) {
     (options2, command) => web({ ...options2, open: command.optsWithGlobals().open })
   );
   cmd.command("summarise").description("Generate one-line summaries for Claude sessions").option("-f, --force", "Re-generate all summaries, even existing ones").option("-n, --limit <count>", "Maximum number of sessions to summarise").action(summarise2);
-  cmd.command("set-status <status>").description(
-    "Report the current session's status to the sessions daemon (used by Claude Code hooks)"
-  ).action(setSessionStatus);
+  registerSetStatusCommand(cmd);
   configHelp(cmd, [
     {
       key: "sessions.windowsProjectsRoot",
@@ -27332,9 +27702,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync52, statSync as statSync11 } from "fs";
-import { isAbsolute as isAbsolute2, join as join68, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute2, join as join69, resolve as resolve17 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join68(cwd, ".git");
+  const dotGit = join69(cwd, ".git");
   let stat2;
   try {
     stat2 = statSync11(dotGit);
@@ -27364,7 +27734,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync52(join68(gitDir, "HEAD"), "utf8");
+    head = readFileSync52(join69(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -27432,21 +27802,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs46 from "fs";
-import * as os4 from "os";
-import * as path68 from "path";
+import * as fs48 from "fs";
+import * as os5 from "os";
+import * as path69 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs40 from "fs";
-import * as path60 from "path";
+import * as fs42 from "fs";
+import * as path61 from "path";
 import chalk203 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path60.join(claudeDir, "CLAUDE.md");
-  const target = path60.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs40.readFileSync(source, "utf8");
-  if (fs40.existsSync(target)) {
-    const targetContent = fs40.readFileSync(target, "utf8");
+  const source = path61.join(claudeDir, "CLAUDE.md");
+  const target = path61.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs42.readFileSync(source, "utf8");
+  if (fs42.existsSync(target)) {
+    const targetContent = fs42.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk203.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -27463,38 +27833,38 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs40.copyFileSync(source, target);
+  fs42.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path63 from "path";
+import * as path64 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
-import * as fs41 from "fs";
-import * as path61 from "path";
+import * as fs43 from "fs";
+import * as path62 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path61.join(claudeDir, "commands");
-  const files = fs41.readdirSync(commandsSource);
+  const commandsSource = path62.join(claudeDir, "commands");
+  const files = fs43.readdirSync(commandsSource);
   let synced = 0;
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
-    const content = fs41.readFileSync(path61.join(commandsSource, file), "utf8");
-    const target = path61.join(harness.homeDir, harness.sync.commandDest(name));
-    fs41.mkdirSync(path61.dirname(target), { recursive: true });
-    fs41.writeFileSync(target, transform(name, content));
+    const content = fs43.readFileSync(path62.join(commandsSource, file), "utf8");
+    const target = path62.join(harness.homeDir, harness.sync.commandDest(name));
+    fs43.mkdirSync(path62.dirname(target), { recursive: true });
+    fs43.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path61.join(harness.homeDir, harness.sync.agentsFile);
-  fs41.mkdirSync(path61.dirname(agentsTarget), { recursive: true });
-  fs41.copyFileSync(path61.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path62.join(harness.homeDir, harness.sync.agentsFile);
+  fs43.mkdirSync(path62.dirname(agentsTarget), { recursive: true });
+  fs43.copyFileSync(path62.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced };
 }
 
 // src/commands/sync/syncCodexHooks.ts
-import * as fs42 from "fs";
-import * as path62 from "path";
+import * as fs44 from "fs";
+import * as path63 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -27524,11 +27894,11 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs42.readFileSync(sourcePath, "utf8");
-  const configPath = path62.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs42.existsSync(configPath) ? fs42.readFileSync(configPath, "utf8") : "";
-  fs42.mkdirSync(path62.dirname(configPath), { recursive: true });
-  fs42.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const body = fs44.readFileSync(sourcePath, "utf8");
+  const configPath = path63.join(harnesses.codex.homeDir, "config.toml");
+  const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
+  fs44.mkdirSync(path63.dirname(configPath), { recursive: true });
+  fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
   );
@@ -27559,50 +27929,50 @@ function syncCodex(claudeDir) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path63.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path64.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
 }
 
 // src/commands/sync/syncDesign.ts
-import * as fs43 from "fs";
-import * as path64 from "path";
+import * as fs45 from "fs";
+import * as path65 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path64.join(claudeDir, "system-prompt.md");
-  const systemPromptTarget = path64.join(targetBase, "system-prompt.md");
-  fs43.copyFileSync(systemPromptSource, systemPromptTarget);
+  const systemPromptSource = path65.join(claudeDir, "system-prompt.md");
+  const systemPromptTarget = path65.join(targetBase, "system-prompt.md");
+  fs45.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log("Copied system-prompt.md to ~/.claude/system-prompt.md");
-  const skillsSource = path64.join(claudeDir, "skills");
-  const skillsTarget = path64.join(targetBase, "skills");
-  fs43.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs43.readdirSync(skillsSource);
+  const skillsSource = path65.join(claudeDir, "skills");
+  const skillsTarget = path65.join(targetBase, "skills");
+  fs45.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
-    fs43.copyFileSync(
-      path64.join(skillsSource, file),
-      path64.join(skillsTarget, file)
+    fs45.copyFileSync(
+      path65.join(skillsSource, file),
+      path65.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path66 from "path";
+import * as path67 from "path";
 
 // src/commands/sync/syncPiHooks.ts
-import * as fs44 from "fs";
-import * as path65 from "path";
+import * as fs46 from "fs";
+import * as path66 from "path";
 function piExtensionsDir() {
-  return path65.join(harnesses.pi.homeDir, "extensions");
+  return path66.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
-  fs44.mkdirSync(target, { recursive: true });
-  const files = fs44.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  fs46.mkdirSync(target, { recursive: true });
+  const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    fs44.copyFileSync(
-      path65.join(sourceDir, file),
-      path65.join(target, `assist-${file}`)
+    fs46.copyFileSync(
+      path66.join(sourceDir, file),
+      path66.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -27639,23 +28009,23 @@ function syncPi(claudeDir) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path66.join(claudeDir, "..", "pi"));
+  syncPiHooks(path67.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs45 from "fs";
-import * as path67 from "path";
+import * as fs47 from "fs";
+import * as path68 from "path";
 import chalk204 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path67.join(claudeDir, "settings.json");
-  const target = path67.join(targetBase, "settings.json");
-  const sourceContent = fs45.readFileSync(source, "utf8");
+  const source = path68.join(claudeDir, "settings.json");
+  const target = path68.join(targetBase, "settings.json");
+  const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs45.existsSync(target);
-  const targetContent = targetExists ? fs45.readFileSync(target, "utf8") : "";
+  const targetExists = fs47.existsSync(target);
+  const targetContent = targetExists ? fs47.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -27684,18 +28054,18 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs45.writeFileSync(target, mergedContent);
+  fs47.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path68.dirname(__filename5);
+var __dirname7 = path69.dirname(__filename5);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path68.join(__dirname7, "..", "claude");
-  const targetBase = path68.join(os4.homedir(), ".claude");
+  const claudeDir = path69.join(__dirname7, "..", "claude");
+  const targetBase = path69.join(os5.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -27704,12 +28074,12 @@ async function sync(options2) {
   syncPi(claudeDir);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path68.join(claudeDir, "commands");
-  const targetDir = path68.join(targetBase, "commands");
-  fs46.mkdirSync(targetDir, { recursive: true });
-  const files = fs46.readdirSync(sourceDir);
+  const sourceDir = path69.join(claudeDir, "commands");
+  const targetDir = path69.join(targetBase, "commands");
+  fs48.mkdirSync(targetDir, { recursive: true });
+  const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs46.copyFileSync(path68.join(sourceDir, file), path68.join(targetDir, file));
+    fs48.copyFileSync(path69.join(sourceDir, file), path69.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -27717,7 +28087,7 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync59 } from "child_process";
-import * as path69 from "path";
+import * as path70 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -27736,12 +28106,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path69.resolve(dir);
-    if (resolved.split(path69.sep).includes("node_modules")) {
+    const resolved = path70.resolve(dir);
+    if (resolved.split(path70.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync59("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path69.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path70.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }