@staff0rd/assist 0.448.0 → 0.450.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.448.0",
+  version: "0.450.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1770,6 +1770,8 @@ function collectCommitRefs(message2) {
     const subject = message2.split("\n", 1)[0];
     if (subject) ref.title = subject;
     refs.push(ref);
+    const parent = git("rev-parse HEAD^");
+    if (parent) refs.push({ kind: "commit-parent", ref: parent });
   }
   return refs;
 }
@@ -3715,9 +3717,9 @@ function forbiddenStrings() {
     console.log("No forbidden-strings rules configured.");
     process.exit(0);
   }
-  const cache3 = /* @__PURE__ */ new Map();
+  const cache4 = /* @__PURE__ */ new Map();
   const readJson = (file) => {
-    if (cache3.has(file)) return cache3.get(file);
+    if (cache4.has(file)) return cache4.get(file);
     if (!existsSync12(file)) {
       console.log(`Forbidden-strings file not found: ${file}`);
       process.exit(1);
@@ -3729,7 +3731,7 @@ function forbiddenStrings() {
       console.log(`Could not parse ${file}: ${error.message}`);
       process.exit(1);
     }
-    cache3.set(file, parsed);
+    cache4.set(file, parsed);
     return parsed;
   };
   const violations = findForbiddenStrings(rules, readJson);
@@ -6091,7 +6093,13 @@ var backlogCommentSchema = z3.strictObject({
   timestamp: z3.string(),
   type: backlogCommentTypeSchema
 });
-var gitRefKindSchema = z3.enum(["branch", "commit", "pr", "slack"]);
+var gitRefKindSchema = z3.enum([
+  "branch",
+  "commit",
+  "commit-parent",
+  "pr",
+  "slack"
+]);
 var gitRefSchema = z3.strictObject({
   kind: gitRefKindSchema,
   ref: z3.string(),
@@ -8372,19 +8380,19 @@ import { dirname as dirname19, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
   const file = join23(dirname19(fileURLToPath4(importMetaUrl)), bundlePath);
-  let cache3;
+  let cache4;
   return (req, res) => {
     const mtimeMs = statSync2(file).mtimeMs;
-    if (cache3?.mtimeMs !== mtimeMs) {
+    if (cache4?.mtimeMs !== mtimeMs) {
       const body = readFileSync19(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
-      cache3 = { body, etag, mtimeMs };
+      cache4 = { body, etag, mtimeMs };
     }
     const headers = {
-      ETag: cache3.etag,
+      ETag: cache4.etag,
       "Cache-Control": "no-cache"
     };
-    if (req.headers["if-none-match"] === cache3.etag) {
+    if (req.headers["if-none-match"] === cache4.etag) {
       res.writeHead(304, headers);
       res.end();
       return;
@@ -8393,7 +8401,7 @@ function createBundleHandler(importMetaUrl, bundlePath, contentType = "applicati
       "Content-Type": contentType,
       ...headers
     });
-    res.end(cache3.body);
+    res.end(cache4.body);
   };
 }
 
@@ -8881,6 +8889,73 @@ function getCwdParam(req, res) {
   return cwd;
 }
 
+// src/commands/sessions/web/getSessionParam.ts
+function getSessionParam(req) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  return url.searchParams.get("session") ?? void 0;
+}
+
+// src/shared/db/findCommitAnchor.ts
+import { and as and7, asc as asc6, eq as eq16, inArray as inArray3 } from "drizzle-orm";
+async function findCommitAnchor(db, itemId2) {
+  const rows = await db.select({ kind: itemGitRefs.kind, ref: itemGitRefs.ref }).from(itemGitRefs).where(
+    and7(
+      eq16(itemGitRefs.itemId, itemId2),
+      inArray3(itemGitRefs.kind, ["commit", "commit-parent"])
+    )
+  ).orderBy(asc6(itemGitRefs.createdAt));
+  const anchor = {};
+  for (const row of rows) {
+    if (row.kind === "commit") anchor.commit ??= row.ref;
+    else anchor.parent ??= row.ref;
+  }
+  return anchor;
+}
+
+// src/shared/db/findItemBySessionId.ts
+import { asc as asc7, eq as eq17 } from "drizzle-orm";
+async function findItemBySessionId(db, claudeSessionId) {
+  const rows = await db.select({ itemId: phaseUsage.itemId }).from(phaseUsage).where(eq17(phaseUsage.claudeSessionId, claudeSessionId)).orderBy(asc7(phaseUsage.itemId), asc7(phaseUsage.phaseIdx)).limit(1);
+  return rows[0]?.itemId;
+}
+
+// src/commands/sessions/web/sessionCommitAnchor.ts
+var EMPTY_TTL_MS = 3e4;
+var cache3 = /* @__PURE__ */ new Map();
+var inFlight = /* @__PURE__ */ new Map();
+async function sessionCommitAnchor(sessionId) {
+  const cached = cache3.get(sessionId);
+  if (cached && cached.expiresAt > Date.now()) return cached.anchor;
+  const pending = inFlight.get(sessionId);
+  if (pending) return pending;
+  const lookup = loadAnchor(sessionId).finally(
+    () => inFlight.delete(sessionId)
+  );
+  inFlight.set(sessionId, lookup);
+  return lookup;
+}
+async function loadAnchor(sessionId) {
+  const anchor = await queryAnchor(sessionId);
+  const found = Boolean(anchor.commit || anchor.parent);
+  cache3.set(sessionId, {
+    anchor,
+    expiresAt: found ? Number.POSITIVE_INFINITY : Date.now() + EMPTY_TTL_MS
+  });
+  return anchor;
+}
+async function queryAnchor(sessionId) {
+  try {
+    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
+      return {};
+    const db = await getDb();
+    const itemId2 = await findItemBySessionId(db, sessionId);
+    if (itemId2 === void 0) return {};
+    return await findCommitAnchor(db, itemId2);
+  } catch {
+    return {};
+  }
+}
+
 // src/commands/sessions/web/windowsCwdToWslPath.ts
 function windowsCwdToWslPath(cwd) {
   const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
@@ -8914,7 +8989,13 @@ async function refExists2(cwd, ref) {
     return false;
   }
 }
-async function resolveDiffBase(cwd) {
+async function anchoredBase(cwd, sessionId) {
+  const { commit: commit2, parent } = await sessionCommitAnchor(sessionId);
+  if (parent && await refExists2(cwd, parent)) return parent;
+  if (commit2 && await refExists2(cwd, `${commit2}^`)) return `${commit2}^`;
+  return void 0;
+}
+async function resolveDiffBase(cwd, sessionId) {
   let defaultBranch;
   try {
     const config = loadConfigFrom(toGitCwd(cwd));
@@ -8923,6 +9004,10 @@ async function resolveDiffBase(cwd) {
   } catch {
     return "HEAD";
   }
+  if (sessionId) {
+    const anchored = await anchoredBase(cwd, sessionId);
+    if (anchored) return anchored;
+  }
   for (const candidate of baseCandidates(defaultBranch)) {
     if (!await refExists2(cwd, candidate)) continue;
     try {
@@ -8960,7 +9045,7 @@ async function diff2(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const base = await resolveDiffBase(cwd);
+    const base = await resolveDiffBase(cwd, getSessionParam(req));
     const tracked = await execGit(cwd, ["diff", base], {
       maxBuffer: MAX_DIFF_BYTES
     });
@@ -9280,7 +9365,7 @@ async function gitStatus(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const base = await resolveDiffBase(cwd);
+    const base = await resolveDiffBase(cwd, getSessionParam(req));
     respondJson(
       res,
       200,
@@ -9569,7 +9654,7 @@ async function listNewsItems(_req, res) {
 }
 
 // src/shared/db/listUsagePeaks.ts
-import { and as and7, count, desc as desc2, eq as eq16, getTableColumns, sql as sql16 } from "drizzle-orm";
+import { and as and8, count, desc as desc2, eq as eq18, getTableColumns, sql as sql16 } from "drizzle-orm";
 async function listUsagePeaks(db, paging) {
   const avgContext = db.select({
     window: phaseCycleContext.window,
@@ -9585,9 +9670,9 @@ async function listUsagePeaks(db, paging) {
     phaseCount: avgContext.phaseCount
   }).from(usagePeaks).leftJoin(
     avgContext,
-    and7(
-      eq16(usagePeaks.window, avgContext.window),
-      eq16(usagePeaks.resetsAt, avgContext.resetsAt)
+    and8(
+      eq18(usagePeaks.window, avgContext.window),
+      eq18(usagePeaks.resetsAt, avgContext.resetsAt)
     )
   ).orderBy(
     desc2(usagePeaks.resetsAt),
@@ -9644,11 +9729,11 @@ var execFileAsync4 = promisify5(execFile5);
 var CACHE_TTL_MS2 = 3e4;
 function createCachedGhJson(args, parse3, fallback, options2 = {}) {
   const { cacheFallback = true } = options2;
-  const cache3 = /* @__PURE__ */ new Map();
+  const cache4 = /* @__PURE__ */ new Map();
   return async (cwd, extraArgs = []) => {
     const key = extraArgs.length ? `${cwd}\0${extraArgs.join("\0")}` : cwd;
     const now = Date.now();
-    const cached = cache3.get(key);
+    const cached = cache4.get(key);
     if (cached && cached.expires > now) return cached.value;
     let value = fallback;
     try {
@@ -9661,7 +9746,7 @@ function createCachedGhJson(args, parse3, fallback, options2 = {}) {
       value = fallback;
     }
     if (cacheFallback || value !== fallback)
-      cache3.set(key, { value, expires: now + CACHE_TTL_MS2 });
+      cache4.set(key, { value, expires: now + CACHE_TTL_MS2 });
     return value;
   };
 }
@@ -10172,22 +10257,22 @@ import { readFileSync as readFileSync21 } from "fs";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 function createCssHandler(packageEntry) {
-  let cache3;
+  let cache4;
   return (req, res) => {
-    if (!cache3) {
+    if (!cache4) {
       const resolved = require3.resolve(packageEntry);
       const body = readFileSync21(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
-      cache3 = { body, etag };
+      cache4 = { body, etag };
     }
-    const headers = { ETag: cache3.etag, "Cache-Control": "no-cache" };
-    if (req.headers["if-none-match"] === cache3.etag) {
+    const headers = { ETag: cache4.etag, "Cache-Control": "no-cache" };
+    if (req.headers["if-none-match"] === cache4.etag) {
       res.writeHead(304, headers);
       res.end();
       return;
     }
     res.writeHead(200, { "Content-Type": "text/css", ...headers });
-    res.end(cache3.body);
+    res.end(cache4.body);
   };
 }
 
@@ -10685,11 +10770,11 @@ function registerActivityCommands(cmd) {
 
 // src/commands/backlog/associate-github/index.ts
 import chalk64 from "chalk";
-import { eq as eq18 } from "drizzle-orm";
+import { eq as eq20 } from "drizzle-orm";
 
 // src/commands/backlog/beginAssociation.ts
 import chalk63 from "chalk";
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq19 } from "drizzle-orm";
 async function beginAssociation(id, options2, clearPatch, label2) {
   const found = await findOneItem(id);
   if (!found) {
@@ -10699,7 +10784,7 @@ async function beginAssociation(id, options2, clearPatch, label2) {
   const { orm } = found;
   const itemId2 = found.item.id;
   if (options2.clear) {
-    await orm.update(items).set(clearPatch).where(eq17(items.id, itemId2));
+    await orm.update(items).set(clearPatch).where(eq19(items.id, itemId2));
     console.log(
       chalk63.green(
         `Cleared ${label2} association on item ${formatItemId(itemId2)}.`
@@ -10767,7 +10852,7 @@ async function associateGithub(id, issue, options2) {
     return;
   }
   const title = fetchGithubIssueTitle(normalized);
-  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq18(items.id, itemId2));
+  await orm.update(items).set({ githubIssue: normalized, jiraKey: null }).where(eq20(items.id, itemId2));
   console.log(
     chalk64.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     title ? chalk64.dim(`(${title})`) : ""
@@ -10781,7 +10866,7 @@ function registerAssociateGithubCommand(cmd) {
 
 // src/commands/backlog/associate-jira/index.ts
 import chalk66 from "chalk";
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
 import { execSync as execSync32 } from "child_process";
@@ -10846,7 +10931,7 @@ async function associateJira(id, key, options2) {
   const parsed = fetchIssue(normalized, "summary");
   const fields = parsed?.fields;
   const summary = fields?.summary;
-  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq19(items.id, itemId2));
+  await orm.update(items).set({ jiraKey: normalized, githubIssue: null }).where(eq21(items.id, itemId2));
   console.log(
     chalk66.green(`Associated ${normalized} with item ${formatItemId(itemId2)}.`),
     summary ? chalk66.dim(`(${summary})`) : ""
@@ -11219,15 +11304,15 @@ function registerImportCommand(cmd) {
 import chalk74 from "chalk";
 
 // src/commands/backlog/insertPhaseAt.ts
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq23 } from "drizzle-orm";
 
 // src/commands/backlog/shiftPhasesUp.ts
-import { and as and8, desc as desc3, eq as eq20, gte } from "drizzle-orm";
+import { and as and9, desc as desc3, eq as eq22, gte } from "drizzle-orm";
 async function shiftPhasesUp(db, itemId2, fromIdx) {
-  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and8(eq20(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
+  const toShift = await db.select({ idx: planPhases.idx }).from(planPhases).where(and9(eq22(planPhases.itemId, itemId2), gte(planPhases.idx, fromIdx))).orderBy(desc3(planPhases.idx));
   for (const p of toShift) {
-    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and8(eq20(planTasks.itemId, itemId2), eq20(planTasks.phaseIdx, p.idx)));
-    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and8(eq20(planPhases.itemId, itemId2), eq20(planPhases.idx, p.idx)));
+    await db.update(planTasks).set({ phaseIdx: p.idx + 1 }).where(and9(eq22(planTasks.itemId, itemId2), eq22(planTasks.phaseIdx, p.idx)));
+    await db.update(planPhases).set({ idx: p.idx + 1 }).where(and9(eq22(planPhases.itemId, itemId2), eq22(planPhases.idx, p.idx)));
   }
 }
 
@@ -11240,7 +11325,7 @@ async function insertPhaseAt(orm, itemId2, phaseIdx, name, tasks, manualChecks,
       await tx.insert(planTasks).values(tasks.map((task, i) => ({ itemId: itemId2, phaseIdx, idx: i, task })));
     }
     if (currentPhase !== void 0 && currentPhase - 1 >= phaseIdx) {
-      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq21(items.id, itemId2));
+      await tx.update(items).set({ currentPhase: phaseIdx + 1 }).where(eq23(items.id, itemId2));
     }
   });
 }
@@ -11403,9 +11488,9 @@ import chalk76 from "chalk";
 
 // src/commands/backlog/resolveInsertPosition.ts
 import chalk75 from "chalk";
-import { count as count2, eq as eq22 } from "drizzle-orm";
+import { count as count2, eq as eq24 } from "drizzle-orm";
 async function resolveInsertPosition(orm, itemId2, position) {
-  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq22(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count2() }).from(planPhases).where(eq24(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   if (position === void 0) return phaseCount;
   const pos = Number.parseInt(position, 10);
@@ -11734,9 +11819,9 @@ function hasCycle(adjacency, fromId, toId) {
 }
 
 // src/commands/backlog/loadDependencyGraph.ts
-import { eq as eq23 } from "drizzle-orm";
+import { eq as eq25 } from "drizzle-orm";
 async function loadDependencyGraph(orm) {
-  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq23(links.type, "depends-on"));
+  const rows = await orm.select({ itemId: links.itemId, targetId: links.targetId }).from(links).where(eq25(links.type, "depends-on"));
   const graph = /* @__PURE__ */ new Map();
   for (const { itemId: itemId2, targetId } of rows) {
     const bucket = graph.get(itemId2);
@@ -11803,7 +11888,7 @@ async function link(fromId, toId, opts) {
 
 // src/commands/backlog/unlink.ts
 import chalk82 from "chalk";
-import { and as and9, eq as eq24 } from "drizzle-orm";
+import { and as and10, eq as eq26 } from "drizzle-orm";
 async function unlink(fromId, toId) {
   const fromNum = parseItemId(fromId);
   const toNum = parseItemId(toId);
@@ -11827,7 +11912,7 @@ async function unlink(fromId, toId) {
     );
     return;
   }
-  await orm.delete(links).where(and9(eq24(links.itemId, fromNum), eq24(links.targetId, toNum)));
+  await orm.delete(links).where(and10(eq26(links.itemId, fromNum), eq26(links.targetId, toNum)));
   console.log(
     chalk82.green(
       `Removed link from ${formatItemId(fromNum)} to ${formatItemId(toNum)}.`
@@ -11847,7 +11932,7 @@ function registerLinkCommands(cmd) {
 
 // src/commands/backlog/move-repo/index.ts
 import chalk84 from "chalk";
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 
 // src/commands/backlog/move-repo/confirmMove.ts
 import chalk83 from "chalk";
@@ -11862,9 +11947,9 @@ async function confirmMove(cnt, oldOrigin, newOrigin) {
 }
 
 // src/commands/backlog/move-repo/countByOrigin.ts
-import { count as count3, eq as eq25 } from "drizzle-orm";
+import { count as count3, eq as eq27 } from "drizzle-orm";
 async function countByOrigin(orm, origin) {
-  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq25(items.origin, origin));
+  const [{ cnt }] = await orm.select({ cnt: count3() }).from(items).where(eq27(items.origin, origin));
   return cnt;
 }
 
@@ -11907,7 +11992,7 @@ async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
     console.log(chalk84.yellow("Move cancelled; no changes made."));
     return;
   }
-  await orm.update(items).set({ origin: newOrigin }).where(eq26(items.origin, oldOrigin));
+  await orm.update(items).set({ origin: newOrigin }).where(eq28(items.origin, oldOrigin));
   console.log(
     chalk84.green(
       `Moved ${pluralItems(cnt)} from "${oldOrigin}" to "${newOrigin}".`
@@ -12324,10 +12409,10 @@ async function start(id) {
 
 // src/commands/backlog/stop/index.ts
 import chalk96 from "chalk";
-import { and as and10, eq as eq27 } from "drizzle-orm";
+import { and as and11, eq as eq29 } from "drizzle-orm";
 async function stop() {
   const { orm } = await getReady();
-  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and10(eq27(items.status, "in-progress"), eq27(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
+  const stopped = await orm.update(items).set({ status: "todo", currentPhase: 1 }).where(and11(eq29(items.status, "in-progress"), eq29(items.origin, getOrigin()))).returning({ id: items.id, name: items.name });
   if (stopped.length === 0) {
     console.log(chalk96.yellow("No in-progress items to stop."));
     return;
@@ -12444,13 +12529,13 @@ async function findSubtask(id, index3) {
 }
 
 // src/commands/backlog/updateSubtask.ts
-import { and as and11, eq as eq28 } from "drizzle-orm";
+import { and as and12, eq as eq30 } from "drizzle-orm";
 async function updateSubtask(orm, itemId2, idx, fields) {
   const set = {};
   if (fields.title !== void 0) set.title = fields.title;
   if (fields.description !== void 0) set.description = fields.description;
   if (fields.status !== void 0) set.status = fields.status;
-  const [row] = await orm.update(itemSubtasks).set(set).where(and11(eq28(itemSubtasks.itemId, itemId2), eq28(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.update(itemSubtasks).set(set).where(and12(eq30(itemSubtasks.itemId, itemId2), eq30(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   return row?.title;
 }
 
@@ -12505,16 +12590,16 @@ async function editSubtask(id, index3, options2) {
 import chalk102 from "chalk";
 
 // src/commands/backlog/deleteSubtask.ts
-import { and as and12, asc as asc6, eq as eq29 } from "drizzle-orm";
+import { and as and13, asc as asc8, eq as eq31 } from "drizzle-orm";
 async function deleteSubtask(orm, itemId2, idx) {
-  const [row] = await orm.delete(itemSubtasks).where(and12(eq29(itemSubtasks.itemId, itemId2), eq29(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
+  const [row] = await orm.delete(itemSubtasks).where(and13(eq31(itemSubtasks.itemId, itemId2), eq31(itemSubtasks.idx, idx))).returning({ title: itemSubtasks.title });
   if (!row) return void 0;
-  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq29(itemSubtasks.itemId, itemId2)).orderBy(asc6(itemSubtasks.idx));
+  const remaining = await orm.select({ idx: itemSubtasks.idx }).from(itemSubtasks).where(eq31(itemSubtasks.itemId, itemId2)).orderBy(asc8(itemSubtasks.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
     await orm.update(itemSubtasks).set({ idx: i }).where(
-      and12(eq29(itemSubtasks.itemId, itemId2), eq29(itemSubtasks.idx, oldIdx))
+      and13(eq31(itemSubtasks.itemId, itemId2), eq31(itemSubtasks.idx, oldIdx))
     );
   }
   return row.title;
@@ -12583,20 +12668,20 @@ function registerSubtaskCommands(cmd) {
 
 // src/commands/backlog/movePhase.ts
 import chalk104 from "chalk";
-import { count as count5, eq as eq32 } from "drizzle-orm";
+import { count as count5, eq as eq34 } from "drizzle-orm";
 
 // src/commands/backlog/reorderPhaseRows.ts
-import { and as and14, asc as asc8, eq as eq31 } from "drizzle-orm";
+import { and as and15, asc as asc10, eq as eq33 } from "drizzle-orm";
 
 // src/commands/backlog/reindexPhases.ts
-import { and as and13, asc as asc7, count as count4, eq as eq30 } from "drizzle-orm";
+import { and as and14, asc as asc9, count as count4, eq as eq32 } from "drizzle-orm";
 async function reindexPhases(db, itemId2) {
-  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq30(planPhases.itemId, itemId2)).orderBy(asc7(planPhases.idx));
+  const remaining = await db.select({ idx: planPhases.idx }).from(planPhases).where(eq32(planPhases.itemId, itemId2)).orderBy(asc9(planPhases.idx));
   for (let i = 0; i < remaining.length; i++) {
     const oldIdx = remaining[i].idx;
     if (oldIdx === i) continue;
-    await db.update(planTasks).set({ phaseIdx: i }).where(and13(eq30(planTasks.itemId, itemId2), eq30(planTasks.phaseIdx, oldIdx)));
-    await db.update(planPhases).set({ idx: i }).where(and13(eq30(planPhases.itemId, itemId2), eq30(planPhases.idx, oldIdx)));
+    await db.update(planTasks).set({ phaseIdx: i }).where(and14(eq32(planTasks.itemId, itemId2), eq32(planTasks.phaseIdx, oldIdx)));
+    await db.update(planPhases).set({ idx: i }).where(and14(eq32(planPhases.itemId, itemId2), eq32(planPhases.idx, oldIdx)));
   }
 }
 async function adjustCurrentPhase(db, item, removedIdx) {
@@ -12604,24 +12689,24 @@ async function adjustCurrentPhase(db, item, removedIdx) {
   if (currentPhase === void 0) return;
   const currentIdx = currentPhase - 1;
   if (removedIdx < currentIdx) {
-    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq30(items.id, item.id));
+    await db.update(items).set({ currentPhase: currentPhase - 1 }).where(eq32(items.id, item.id));
     return;
   }
   if (removedIdx !== currentIdx) return;
-  const [row] = await db.select({ cnt: count4() }).from(planPhases).where(eq30(planPhases.itemId, item.id));
+  const [row] = await db.select({ cnt: count4() }).from(planPhases).where(eq32(planPhases.itemId, item.id));
   const cnt = row?.cnt ?? 0;
-  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq30(items.id, item.id));
+  await db.update(items).set({ currentPhase: cnt === 0 ? null : Math.min(currentPhase, cnt) }).where(eq32(items.id, item.id));
 }
 
 // src/commands/backlog/reorderPhaseRows.ts
 async function reorderPhaseRows(orm, itemId2, fromIdx, toIdx) {
   await orm.transaction(async (tx) => {
-    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and14(eq31(planPhases.itemId, itemId2), eq31(planPhases.idx, fromIdx)));
-    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and14(eq31(planTasks.itemId, itemId2), eq31(planTasks.phaseIdx, fromIdx))).orderBy(asc8(planTasks.idx));
+    const [phaseRow] = await tx.select({ name: planPhases.name, manualChecks: planPhases.manualChecks }).from(planPhases).where(and15(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, fromIdx)));
+    const tasks = await tx.select({ idx: planTasks.idx, task: planTasks.task }).from(planTasks).where(and15(eq33(planTasks.itemId, itemId2), eq33(planTasks.phaseIdx, fromIdx))).orderBy(asc10(planTasks.idx));
     await tx.delete(planTasks).where(
-      and14(eq31(planTasks.itemId, itemId2), eq31(planTasks.phaseIdx, fromIdx))
+      and15(eq33(planTasks.itemId, itemId2), eq33(planTasks.phaseIdx, fromIdx))
     );
-    await tx.delete(planPhases).where(and14(eq31(planPhases.itemId, itemId2), eq31(planPhases.idx, fromIdx)));
+    await tx.delete(planPhases).where(and15(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, fromIdx)));
     await reindexPhases(tx, itemId2);
     await shiftPhasesUp(tx, itemId2, toIdx);
     await tx.insert(planPhases).values({
@@ -12662,7 +12747,7 @@ async function movePhase(id, from, to) {
   if (!found) return;
   const { orm, item } = found;
   const itemId2 = item.id;
-  const [row] = await orm.select({ cnt: count5() }).from(planPhases).where(eq32(planPhases.itemId, itemId2));
+  const [row] = await orm.select({ cnt: count5() }).from(planPhases).where(eq34(planPhases.itemId, itemId2));
   const phaseCount = row?.cnt ?? 0;
   const fromIdx = toIndex(from, phaseCount);
   if (fromIdx === void 0) return;
@@ -12678,22 +12763,22 @@ async function movePhase(id, from, to) {
 import chalk106 from "chalk";
 
 // src/commands/backlog/applyPhaseUpdate.ts
-import { and as and15, eq as eq33 } from "drizzle-orm";
+import { and as and16, eq as eq35 } from "drizzle-orm";
 async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
   await orm.transaction(async (tx) => {
     if (fields.name) {
       await tx.update(planPhases).set({ name: fields.name }).where(
-        and15(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, phaseIdx))
+        and16(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, phaseIdx))
       );
     }
     if (fields.manualCheck) {
       await tx.update(planPhases).set({ manualChecks: JSON.stringify(fields.manualCheck) }).where(
-        and15(eq33(planPhases.itemId, itemId2), eq33(planPhases.idx, phaseIdx))
+        and16(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, phaseIdx))
       );
     }
     if (fields.task) {
       await tx.delete(planTasks).where(
-        and15(eq33(planTasks.itemId, itemId2), eq33(planTasks.phaseIdx, phaseIdx))
+        and16(eq35(planTasks.itemId, itemId2), eq35(planTasks.phaseIdx, phaseIdx))
       );
       if (fields.task.length) {
         await tx.insert(planTasks).values(
@@ -12711,14 +12796,14 @@ async function applyPhaseUpdate(orm, itemId2, phaseIdx, fields) {
 
 // src/commands/backlog/findPhase.ts
 import chalk105 from "chalk";
-import { and as and16, count as count6, eq as eq34 } from "drizzle-orm";
+import { and as and17, count as count6, eq as eq36 } from "drizzle-orm";
 async function findPhase(id, phase) {
   const found = await findOneItem(id);
   if (!found) return void 0;
   const { orm, item } = found;
   const itemId2 = item.id;
   const phaseIdx = Number.parseInt(phase, 10) - 1;
-  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(and16(eq34(planPhases.itemId, itemId2), eq34(planPhases.idx, phaseIdx)));
+  const [row] = await orm.select({ cnt: count6() }).from(planPhases).where(and17(eq36(planPhases.itemId, itemId2), eq36(planPhases.idx, phaseIdx)));
   if (!row || row.cnt === 0) {
     console.log(
       chalk105.red(
@@ -12891,16 +12976,16 @@ function registerUpdatePhaseCommand(cmd) {
 
 // src/commands/backlog/removePhase.ts
 import chalk107 from "chalk";
-import { and as and17, eq as eq35 } from "drizzle-orm";
+import { and as and18, eq as eq37 } from "drizzle-orm";
 async function removePhase(id, phase) {
   const found = await findPhase(id, phase);
   if (!found) return;
   const { item, orm, itemId: itemId2, phaseIdx } = found;
   await orm.transaction(async (tx) => {
     await tx.delete(planTasks).where(
-      and17(eq35(planTasks.itemId, itemId2), eq35(planTasks.phaseIdx, phaseIdx))
+      and18(eq37(planTasks.itemId, itemId2), eq37(planTasks.phaseIdx, phaseIdx))
     );
-    await tx.delete(planPhases).where(and17(eq35(planPhases.itemId, itemId2), eq35(planPhases.idx, phaseIdx)));
+    await tx.delete(planPhases).where(and18(eq37(planPhases.itemId, itemId2), eq37(planPhases.idx, phaseIdx)));
     await reindexPhases(tx, itemId2);
     await adjustCurrentPhase(tx, item, phaseIdx);
   });
@@ -12913,7 +12998,7 @@ async function removePhase(id, phase) {
 
 // src/commands/backlog/update/update.ts
 import chalk111 from "chalk";
-import { eq as eq36 } from "drizzle-orm";
+import { eq as eq38 } from "drizzle-orm";
 
 // src/commands/backlog/update/buildUpdateValues.ts
 import chalk108 from "chalk";
@@ -13024,7 +13109,7 @@ async function update(id, options2) {
   if (!built) return;
   const { orm } = found;
   const itemId2 = found.item.id;
-  await orm.update(items).set(built.set).where(eq36(items.id, itemId2));
+  await orm.update(items).set(built.set).where(eq38(items.id, itemId2));
   console.log(
     chalk111.green(`Updated ${built.fields} on item ${formatItemId(itemId2)}.`)
   );
@@ -17107,9 +17192,9 @@ function registerGithub(program2) {
 }
 
 // src/commands/handover/countPendingHandovers.ts
-import { and as and18, eq as eq37, isNull, sql as sql18 } from "drizzle-orm";
+import { and as and19, eq as eq39, isNull, sql as sql18 } from "drizzle-orm";
 async function countPendingHandovers(orm, origin) {
-  const [row] = await orm.select({ count: sql18`count(*)::int` }).from(handovers).where(and18(eq37(handovers.origin, origin), isNull(handovers.recalledAt)));
+  const [row] = await orm.select({ count: sql18`count(*)::int` }).from(handovers).where(and19(eq39(handovers.origin, origin), isNull(handovers.recalledAt)));
   return row?.count ?? 0;
 }
 
@@ -17249,13 +17334,13 @@ async function load2(options2 = {}) {
 }
 
 // src/commands/handover/listPendingHandovers.ts
-import { and as and19, desc as desc4, eq as eq38, isNull as isNull2 } from "drizzle-orm";
+import { and as and20, desc as desc4, eq as eq40, isNull as isNull2 } from "drizzle-orm";
 async function listPendingHandovers(orm, origin) {
   return orm.select({
     id: handovers.id,
     summary: handovers.summary,
     createdAt: handovers.createdAt
-  }).from(handovers).where(and19(eq38(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
+  }).from(handovers).where(and20(eq40(handovers.origin, origin), isNull2(handovers.recalledAt))).orderBy(desc4(handovers.createdAt), desc4(handovers.id));
 }
 
 // src/commands/handover/printPendingHandovers.ts
@@ -17268,17 +17353,17 @@ async function printPendingHandovers() {
 }
 
 // src/commands/handover/recallHandover.ts
-import { and as and20, desc as desc5, eq as eq39, isNull as isNull3 } from "drizzle-orm";
+import { and as and21, desc as desc5, eq as eq41, isNull as isNull3 } from "drizzle-orm";
 async function recallHandover(orm, origin, id) {
   const [row] = await orm.select().from(handovers).where(
-    and20(
-      eq39(handovers.origin, origin),
+    and21(
+      eq41(handovers.origin, origin),
       isNull3(handovers.recalledAt),
-      ...id === void 0 ? [] : [eq39(handovers.id, id)]
+      ...id === void 0 ? [] : [eq41(handovers.id, id)]
     )
   ).orderBy(desc5(handovers.createdAt), desc5(handovers.id)).limit(1);
   if (!row) return void 0;
-  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq39(handovers.id, row.id));
+  await orm.update(handovers).set({ recalledAt: /* @__PURE__ */ new Date() }).where(eq41(handovers.id, row.id));
   return row.content;
 }
 
@@ -19281,20 +19366,20 @@ function resolveThread(threadId) {
   }
 }
 function requireCache(prNumber) {
-  const cache3 = loadCommentsCache(prNumber);
-  if (!cache3) {
+  const cache4 = loadCommentsCache(prNumber);
+  if (!cache4) {
     console.error(
       `Error: No cached comments found for PR #${prNumber}. Run "assist prs list-comments" first.`
     );
     process.exit(1);
   }
-  return cache3;
+  return cache4;
 }
 function findLineComment(comments3, commentId) {
   return comments3.find((c) => c.type === "line" && c.id === commentId);
 }
-function requireLineComment(cache3, commentId) {
-  const comment3 = findLineComment(cache3.comments, commentId);
+function requireLineComment(cache4, commentId) {
+  const comment3 = findLineComment(cache4.comments, commentId);
   if (!comment3 || comment3.type !== "line" || !comment3.threadId) {
     console.error(
       `Error: Comment #${commentId} not found or has no thread ID.`
@@ -19303,8 +19388,8 @@ function requireLineComment(cache3, commentId) {
   }
   return comment3;
 }
-function cleanupCacheIfDone(cache3, prNumber, commentId) {
-  const hasRemaining = cache3.comments.some(
+function cleanupCacheIfDone(cache4, prNumber, commentId) {
+  const hasRemaining = cache4.comments.some(
     (c) => c.type === "line" && c.id !== commentId
   );
   if (!hasRemaining) deleteCommentsCache(prNumber);
@@ -19312,13 +19397,13 @@ function cleanupCacheIfDone(cache3, prNumber, commentId) {
 function resolveCommentWithReply(commentId, message2) {
   const prNumber = getCurrentPrNumber();
   const { org, repo } = getRepoInfo();
-  const cache3 = requireCache(prNumber);
-  const comment3 = requireLineComment(cache3, commentId);
+  const cache4 = requireCache(prNumber);
+  const comment3 = requireLineComment(cache4, commentId);
   replyToComment(org, repo, prNumber, commentId, message2);
   console.log("Reply posted successfully.");
   resolveThread(comment3.threadId);
   console.log("Thread resolved successfully.");
-  cleanupCacheIfDone(cache3, prNumber, commentId);
+  cleanupCacheIfDone(cache4, prNumber, commentId);
 }
 
 // src/commands/prs/fixed.ts
@@ -26478,6 +26563,7 @@ function toSessionInfo({
   serverOrigin,
   assistArgs,
   cwd,
+  claudeSessionId,
   restored,
   error,
   activity: activity2,
@@ -26508,6 +26594,7 @@ function toSessionInfo({
     remoteOrigin: serverOrigin ?? originForCwd(cwd),
     assistArgs,
     cwd,
+    claudeSessionId,
     repoGroup: repoGroupForCwd(cwd),
     restored,
     error,
@@ -27155,13 +27242,6 @@ function greetClient(client, sessions, windowsProxy) {
   void windowsProxy.discover();
 }
 
-// src/commands/sessions/daemon/logSpawnedSession.ts
-function logSpawnedSession(session) {
-  daemonLog(
-    `session ${session.id} spawned: ${session.name} [${session.commandType}] ${session.cwd ?? ""}`
-  );
-}
-
 // src/commands/sessions/daemon/decidePrPreview.ts
 function decidePrPreview(sessions, waiters, notify2, d) {
   const id = d.sessionId;
@@ -27249,361 +27329,93 @@ var PrPreviewCoordinator = class {
   }
 };
 
-// src/commands/sessions/daemon/applySetStatus.ts
-function applySetStatus(sessions, id, status3, source, onStatusChange) {
-  const session = sessions.get(id);
-  if (!session) {
-    daemonLog(
-      `set-status for unknown session id=${id} status=${status3} (no live session; ignoring)`
-    );
-    return;
-  }
-  if (session.status === "stopped") {
-    daemonLog(
-      `set-status for stopped session id=${id} status=${status3} (held pending durable close; ignoring)`
-    );
-    return;
-  }
-  if (source === "permission") session.permissionActive = true;
-  if (status3 === "running") session.permissionActive = false;
-  onStatusChange(session, status3);
-}
-
-// src/shared/db/recordPhaseCycleContext.ts
-import { sql as sql21 } from "drizzle-orm";
-async function recordPhaseCycleContext(db, itemId2, phaseIdx, window, resetsAt, pct) {
-  if (pct <= 0) return;
-  await db.insert(phaseCycleContext).values({ itemId: itemId2, phaseIdx, window, resetsAt, peakContextPct: pct }).onConflictDoUpdate({
-    target: [
-      phaseCycleContext.itemId,
-      phaseCycleContext.phaseIdx,
-      phaseCycleContext.window,
-      phaseCycleContext.resetsAt
-    ],
-    set: {
-      peakContextPct: sql21`GREATEST(${phaseCycleContext.peakContextPct}, ${pct})`
-    }
-  });
+// src/commands/sessions/daemon/logSpawnedSession.ts
+function logSpawnedSession(session) {
+  daemonLog(
+    `session ${session.id} spawned: ${session.name} [${session.commandType}] ${session.cwd ?? ""}`
+  );
 }
 
-// src/shared/db/recordPhasePeakContext.ts
-import { sql as sql22 } from "drizzle-orm";
-async function recordPhasePeakContext(db, itemId2, phaseIdx, pct) {
-  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, peakContextPct: pct }).onConflictDoUpdate({
-    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
-    set: {
-      peakContextPct: sql22`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
-    }
-  });
+// src/commands/sessions/daemon/emitSessionOutput.ts
+var MAX_SCROLLBACK = 256 * 1024;
+function emitSessionOutput(session, clients, data) {
+  session.scrollback += data;
+  if (session.scrollback.length > MAX_SCROLLBACK) {
+    session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
+  }
+  broadcast(clients, { type: "output", sessionId: session.id, data });
 }
 
-// src/shared/db/recordPhaseTranscriptUsage.ts
-import { sql as sql23 } from "drizzle-orm";
-async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const r of responses) byId.set(r.messageId, r);
-  const unique = [...byId.values()];
-  if (unique.length === 0) return { tokensUp: 0, tokensDown: 0 };
-  return db.transaction(async (tx) => {
-    const inserted = await tx.insert(phaseUsageMessages).values(unique.map((r) => ({ itemId: itemId2, phaseIdx, messageId: r.messageId }))).onConflictDoNothing().returning({ messageId: phaseUsageMessages.messageId });
-    let tokensUp = 0;
-    let tokensDown = 0;
-    for (const { messageId } of inserted) {
-      const r = byId.get(messageId);
-      if (!r) continue;
-      tokensUp += r.outputTokens;
-      tokensDown += r.inputTokens;
-    }
-    if (tokensUp <= 0 && tokensDown <= 0) return { tokensUp: 0, tokensDown: 0 };
-    await tx.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, tokensUp, tokensDown }).onConflictDoUpdate({
-      target: [phaseUsage.itemId, phaseUsage.phaseIdx],
-      set: {
-        tokensUp: sql23`${phaseUsage.tokensUp} + ${tokensUp}`,
-        tokensDown: sql23`${phaseUsage.tokensDown} + ${tokensDown}`
-      }
-    });
-    return { tokensUp, tokensDown };
-  });
+// src/commands/sessions/daemon/exitReason.ts
+import { existsSync as existsSync64 } from "fs";
+function exitReason(session, exitCode) {
+  const base = `process exited with code ${exitCode}`;
+  if (session.cwd && !existsSync64(session.cwd))
+    return `${base}: working directory ${session.cwd} no longer exists`;
+  return base;
 }
 
-// src/shared/db/recordWindowTokens.ts
-import { and as and21, eq as eq40, sql as sql24 } from "drizzle-orm";
-async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
-  if (tokensUp <= 0 && tokensDown <= 0) return;
-  await db.update(usagePeaks).set({
-    tokensUp: sql24`${usagePeaks.tokensUp} + ${tokensUp}`,
-    tokensDown: sql24`${usagePeaks.tokensDown} + ${tokensDown}`
-  }).where(
-    and21(
-      eq40(usagePeaks.window, window),
-      eq40(usagePeaks.resetsAt, resetsAt),
-      eq40(usagePeaks.segment, 0)
-    )
+// src/commands/sessions/daemon/handleFailedResume.ts
+function handleFailedResume(session, exitCode, onStatusChange) {
+  const failed2 = session.restored === true && exitCode !== 0 && session.scrollback.length === 0;
+  if (!failed2) return false;
+  session.error = `resume process exited with code ${exitCode} before producing any output`;
+  daemonLog(
+    `could not resume restored session "${session.name}" (id ${session.id}): ${session.error}`
   );
+  onStatusChange(session, "error", exitCode);
+  return true;
 }
 
-// src/commands/sessions/shared/transcriptUsage.ts
-import * as fs36 from "fs";
-function transcriptUsage(lines) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (entry.type !== "assistant") continue;
-    const id = entry.message?.id;
-    const usage = entry.message?.usage;
-    if (!id || !usage) continue;
-    byId.set(id, {
-      messageId: id,
-      inputTokens: usage.input_tokens ?? 0,
-      outputTokens: usage.output_tokens ?? 0
-    });
+// src/commands/sessions/daemon/watchActivity.ts
+import { existsSync as existsSync65, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
+import { dirname as dirname31 } from "path";
+
+// src/commands/sessions/daemon/applyReviewPause.ts
+function applyReviewPause(session, activity2) {
+  const inReview = activity2.kind === "backlog" && activity2.phase !== void 0 && activity2.phase === activity2.totalPhases;
+  if (inReview && !session.reviewStarted) {
+    session.autoAdvance = false;
+    session.reviewStarted = true;
+  } else if (!inReview && session.reviewStarted) {
+    session.reviewStarted = false;
   }
-  return [...byId.values()];
 }
-async function readTranscriptUsage(transcriptPath) {
-  const content = await fs36.promises.readFile(transcriptPath, "utf8");
-  return transcriptUsage(content.split("\n"));
+
+// src/shared/db/getPhaseActiveMs.ts
+import { and as and22, eq as eq42 } from "drizzle-orm";
+async function getPhaseActiveMs(db, itemId2, phaseIdx) {
+  const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
+    and22(eq42(phaseUsage.itemId, itemId2), eq42(phaseUsage.phaseIdx, phaseIdx))
+  );
+  return row?.activeMs ?? 0;
 }
 
-// src/commands/sessions/daemon/persistPhaseTokens.ts
-async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, usedPct, windows) {
+// src/commands/sessions/daemon/loadPhaseActiveMs.ts
+async function loadPhaseActiveMs(itemId2, phaseIdx) {
   try {
-    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
-    const db = await getDb();
-    if (usedPct !== void 0) {
-      await recordPhasePeakContext(db, itemId2, phaseIdx, usedPct);
-      for (const { window, resetsAt } of windows) {
-        await recordPhaseCycleContext(
-          db,
-          itemId2,
-          phaseIdx,
-          window,
-          resetsAt,
-          usedPct
-        );
-      }
-    }
-    const responses = await readTranscriptUsage(transcriptPath);
-    if (responses.length === 0) return;
-    const { tokensUp, tokensDown } = await recordPhaseTranscriptUsage(
-      db,
-      itemId2,
-      phaseIdx,
-      responses
-    );
-    for (const { window, resetsAt } of windows) {
-      await recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown);
-    }
+    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
+      return null;
+    return await getPhaseActiveMs(await getDb(), itemId2, phaseIdx);
   } catch (error) {
-    daemonLog(`phase-tokens persist failed: ${String(error)}`);
+    daemonLog(`phase-active-ms load failed: ${String(error)}`);
+    return null;
   }
 }
 
-// src/commands/sessions/daemon/recordSessionUsage.ts
-function recordSessionUsage(sessions, claudeSessionId, transcriptPath, usedPct, windows) {
-  for (const session of sessions) {
-    if (session.claudeSessionId !== claudeSessionId) continue;
-    session.usedPct = usedPct;
-    const phase = sessionBacklogPhase(session);
-    if (phase && transcriptPath)
-      void persistPhaseTokens(
-        phase.itemId,
-        phase.phaseIdx,
-        transcriptPath,
-        usedPct,
-        windows
-      );
-    void flushPhaseActiveMs(session);
-    return true;
-  }
-  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/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, status3 = session.status) {
-  if (!session.autoRun) return { run: false, reason: null };
-  if (status3 !== "done")
-    return {
-      run: false,
-      reason: `session status is "${status3}", 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;
-  const deps2 = { dismiss, notify: notify2, reuseForRun };
-  const chainsToNextRun = shouldAutoRun(session, status3).run;
-  if (status3 === "done" && session.worktree && !chainsToNextRun) {
-    session.closing = true;
-    daemonLog(
-      `session ${session.id} closing: checking durability of ${session.worktree.path} before reap`
-    );
-    notify2();
-    void resolveCloseDurability(
-      session,
-      () => finishStatusChange(session, "done", exitCode, deps2),
-      notify2
-    );
-    return;
-  }
-  finishStatusChange(session, status3, exitCode, deps2);
-}
-function finishStatusChange(session, status3, exitCode, deps2) {
-  daemonLog(`session ${session.id} status: ${session.status} -> ${status3}`);
-  void flushPhaseActiveMs(session);
-  setStatus2(session, status3);
-  if (status3 !== "stopped") session.undurable = void 0;
-  const autoRun = shouldAutoRun(session);
-  if (autoRun.run) {
-    deps2.reuseForRun(session, autoRun.itemId);
-    deps2.notify();
-    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)) deps2.dismiss(session.id);
-  else deps2.notify();
-}
-
-// 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/emitSessionOutput.ts
-var MAX_SCROLLBACK = 256 * 1024;
-function emitSessionOutput(session, clients, data) {
-  session.scrollback += data;
-  if (session.scrollback.length > MAX_SCROLLBACK) {
-    session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
-  }
-  broadcast(clients, { type: "output", sessionId: session.id, data });
-}
-
-// src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync64 } from "fs";
-function exitReason(session, exitCode) {
-  const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync64(session.cwd))
-    return `${base}: working directory ${session.cwd} no longer exists`;
-  return base;
-}
-
-// src/commands/sessions/daemon/handleFailedResume.ts
-function handleFailedResume(session, exitCode, onStatusChange) {
-  const failed2 = session.restored === true && exitCode !== 0 && session.scrollback.length === 0;
-  if (!failed2) return false;
-  session.error = `resume process exited with code ${exitCode} before producing any output`;
-  daemonLog(
-    `could not resume restored session "${session.name}" (id ${session.id}): ${session.error}`
-  );
-  onStatusChange(session, "error", exitCode);
-  return true;
-}
-
-// src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync65, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
-import { dirname as dirname31 } from "path";
-
-// src/commands/sessions/daemon/applyReviewPause.ts
-function applyReviewPause(session, activity2) {
-  const inReview = activity2.kind === "backlog" && activity2.phase !== void 0 && activity2.phase === activity2.totalPhases;
-  if (inReview && !session.reviewStarted) {
-    session.autoAdvance = false;
-    session.reviewStarted = true;
-  } else if (!inReview && session.reviewStarted) {
-    session.reviewStarted = false;
-  }
-}
-
-// src/shared/db/getPhaseActiveMs.ts
-import { and as and22, eq as eq41 } from "drizzle-orm";
-async function getPhaseActiveMs(db, itemId2, phaseIdx) {
-  const [row] = await db.select({ activeMs: phaseUsage.activeMs }).from(phaseUsage).where(
-    and22(eq41(phaseUsage.itemId, itemId2), eq41(phaseUsage.phaseIdx, phaseIdx))
-  );
-  return row?.activeMs ?? 0;
-}
-
-// src/commands/sessions/daemon/loadPhaseActiveMs.ts
-async function loadPhaseActiveMs(itemId2, phaseIdx) {
-  try {
-    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url)
-      return null;
-    return await getPhaseActiveMs(await getDb(), itemId2, phaseIdx);
-  } catch (error) {
-    daemonLog(`phase-active-ms load failed: ${String(error)}`);
-    return null;
-  }
-}
-
-// src/commands/sessions/daemon/seedRunningMsFromUsage.ts
-async function seedRunningMsFromUsage(session, notify2) {
-  if (session.usageSeeded) return;
-  const phase = sessionBacklogPhase(session);
-  if (!phase) return;
-  session.usageSeeded = true;
-  const priorMs = await loadPhaseActiveMs(phase.itemId, phase.phaseIdx);
-  if (priorMs == null || priorMs <= session.runningMs) return;
-  session.runningMs = priorMs;
-  daemonLog(
-    `session ${session.id} seeded runningMs=${priorMs} from item ${phase.itemId} phase ${phase.phaseIdx} recorded usage`
-  );
-  notify2();
+// src/commands/sessions/daemon/seedRunningMsFromUsage.ts
+async function seedRunningMsFromUsage(session, notify2) {
+  if (session.usageSeeded) return;
+  const phase = sessionBacklogPhase(session);
+  if (!phase) return;
+  session.usageSeeded = true;
+  const priorMs = await loadPhaseActiveMs(phase.itemId, phase.phaseIdx);
+  if (priorMs == null || priorMs <= session.runningMs) return;
+  session.runningMs = priorMs;
+  daemonLog(
+    `session ${session.id} seeded runningMs=${priorMs} from item ${phase.itemId} phase ${phase.phaseIdx} recorded usage`
+  );
+  notify2();
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
@@ -27721,163 +27533,53 @@ function reportSilentFailure(session, clients) {
   );
 }
 
-// src/commands/sessions/daemon/respawnSession.ts
-function respawnSession(session, respawn, status3, clients, onStatusChange) {
-  session.gitWatcher?.close();
-  session.gitWatcher = void 0;
-  session.undurable = void 0;
-  session.pendingDismiss = void 0;
-  session.closing = void 0;
-  session.scrollback = "";
-  session.startedAt = Date.now();
-  session.runningMs = 0;
-  session.runningSince = null;
-  setStatus2(session, status3);
-  session.restored = void 0;
-  session.pty = respawn();
-  if (session.cols && session.rows)
-    try {
-      session.pty?.resize(session.cols, session.rows);
-    } catch {
-    }
-  broadcast(clients, { type: "clear", sessionId: session.id });
-  wirePtyEvents(session, clients, onStatusChange);
-}
-
-// src/commands/sessions/daemon/respawnPlan.ts
-import { randomUUID as randomUUID7 } from "crypto";
+// src/commands/sessions/daemon/watchTranscript.ts
+import { existsSync as existsSync67, watch as watch3 } from "fs";
 
-// src/commands/sessions/daemon/assistResumeArgs.ts
-function assistResumeArgs(session) {
-  const args = ["assist", ...session.assistArgs];
-  return session.claudeSessionId ? [...args, "--resume-session", session.claudeSessionId] : args;
+// src/commands/sessions/shared/findTranscriptPathSync.ts
+import * as fs36 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, "-")
+  );
 }
-
-// src/commands/sessions/daemon/respawnPlan.ts
-function respawnPlan(session) {
-  const { commandType, claudeSessionId, cwd, assistArgs, initialPrompt } = session;
-  if (commandType === "claude") {
-    if (claudeSessionId)
-      return {
-        spawn: () => spawnClaude2({
-          resumeSessionId: claudeSessionId,
-          cwd,
-          sessionId: session.id
-        }),
-        status: "waiting"
-      };
-    if (initialPrompt) return freshClaudePlan(session, initialPrompt, cwd);
-    if (cwd && session.harness !== "pi")
-      return freshClaudePlan(session, void 0, cwd);
+function transcriptPathFor(cwd, claudeSessionId) {
+  return path60.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+}
+function findTranscriptPathSync(cwd, claudeSessionId) {
+  const direct = transcriptPathFor(cwd, claudeSessionId);
+  if (fs36.existsSync(direct)) return direct;
+  const dir = projectDirForCwd(cwd);
+  let files;
+  try {
+    files = fs36.readdirSync(dir);
+  } catch {
     return null;
   }
-  if (commandType === "assist" && assistArgs) {
-    const idle = session.status === "waiting";
-    return {
-      spawn: () => spawnPty(
-        assistResumeArgs({ assistArgs, claudeSessionId }),
-        cwd,
-        session.id,
-        idle ? { ASSIST_RESUME_IDLE: "1" } : void 0
-      ),
-      status: idle ? "waiting" : "running"
-    };
+  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 freshClaudePlan(session, prompt, cwd) {
-  const claudeSessionId = randomUUID7();
-  return {
-    spawn: () => {
-      session.claudeSessionId = claudeSessionId;
-      return spawnClaude2({
-        prompt,
-        cwd,
-        sessionId: session.id,
-        claudeSessionId
-      });
-    },
-    status: prompt ? "running" : "waiting"
-  };
-}
-
-// src/commands/sessions/daemon/restartSession.ts
-function restartSession(session, clients, onStatusChange) {
-  const plan2 = respawnPlan(session);
-  if (!plan2) return false;
-  const via = session.claudeSessionId ? `resume ${session.claudeSessionId}` : "fresh";
-  const respawn = () => {
-    respawnSession(session, plan2.spawn, plan2.status, clients, onStatusChange);
-    daemonLog(`session ${session.id} restarted (${via}): ${session.name}`);
-  };
-  const pty2 = session.pty;
-  const alive = session.status === "running" || session.status === "waiting";
-  if (pty2 && alive) {
-    daemonLog(
-      `session ${session.id} restart requested: killing running process, will resume on exit`
-    );
-    session.pendingRestart = respawn;
-    killPtyTree(pty2);
-  } else {
-    respawn();
-  }
-  return true;
-}
-
-// src/commands/sessions/daemon/restartManagedSession.ts
-function restartManagedSession(sessions, id, clients, onStatusChange) {
-  const s = sessions.get(id);
-  if (!s) {
-    daemonLog(
-      `restart requested for unknown session id=${id} (no live session; ignoring)`
-    );
-    return {
-      ok: false,
-      reason: `Session ${id} is no longer tracked and can't be restarted.`
-    };
-  }
-  daemonLog(`restart requested: id=${id} status=${s.status} (${s.name})`);
-  if (!restartSession(s, clients, onStatusChange)) {
-    daemonLog(`restart for session ${id} did nothing: no respawn plan`);
-    return {
-      ok: false,
-      reason: `Session ${s.name} can't be restarted (no resumable command).`
-    };
+function headContainsSessionId(filePath, claudeSessionId) {
+  let fd;
+  try {
+    fd = fs36.openSync(filePath, "r");
+    const buf = Buffer.alloc(16384);
+    const bytesRead = fs36.readSync(fd, buf, 0, buf.length, 0);
+    return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) fs36.closeSync(fd);
   }
-  return { ok: true };
-}
-
-// src/commands/sessions/daemon/restoreBase.ts
-function restoreBase(id, persisted) {
-  return {
-    id,
-    name: persisted.name,
-    title: persisted.title,
-    subtitle: persisted.subtitle,
-    commandType: persisted.commandType,
-    harness: persisted.harness,
-    scrollback: "",
-    cwd: persisted.cwd,
-    assistArgs: persisted.assistArgs,
-    initialPrompt: persisted.initialPrompt,
-    starred: persisted.starred
-  };
-}
-
-// src/commands/sessions/daemon/errorSession.ts
-function errorSession(id, persisted, error) {
-  return {
-    ...restoreBase(id, persisted),
-    status: "error",
-    startedAt: persisted.startedAt,
-    runningMs: persisted.runningMs ?? 0,
-    runningSince: null,
-    pty: null,
-    runName: persisted.runName,
-    runArgs: persisted.runArgs,
-    error,
-    restored: false
-  };
 }
 
 // src/commands/sessions/shared/normalizeUser.ts
@@ -27994,94 +27696,579 @@ function parseTailEntries(raw) {
   }
   return entries;
 }
-function dropPartialFirstLine(raw, sliced) {
-  if (!sliced) return raw;
-  const newline = raw.indexOf("\n");
-  return newline === -1 ? "" : raw.slice(newline + 1);
+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/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" || session.status === "stopped")
+    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_MS3 = 100;
+function watchTranscript(session, onStatusChange) {
+  if (!session.cwd || !session.claudeSessionId) return;
+  if (session.watchedTranscriptId === session.claudeSessionId) return;
+  const dir = projectDirForCwd(session.cwd);
+  if (!existsSync67(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 = watch3(dir, (_event, changed) => {
+      if (changed && changed !== fileName) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(run4, DEBOUNCE_MS3);
+    });
+  } 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/registerSpawnedSession.ts
+function registerSpawnedSession(session, sessions, clients, onStatusChange, notify2) {
+  sessions.set(session.id, session);
+  wirePtyEvents(session, clients, onStatusChange);
+  notify2();
+  wireSessionWatchers(session, notify2, onStatusChange);
+  logSpawnedSession(session);
+  return session.id;
+}
+
+// src/commands/sessions/daemon/applySetStatus.ts
+function applySetStatus(sessions, id, status3, source, onStatusChange) {
+  const session = sessions.get(id);
+  if (!session) {
+    daemonLog(
+      `set-status for unknown session id=${id} status=${status3} (no live session; ignoring)`
+    );
+    return;
+  }
+  if (session.status === "stopped") {
+    daemonLog(
+      `set-status for stopped session id=${id} status=${status3} (held pending durable close; ignoring)`
+    );
+    return;
+  }
+  if (source === "permission") session.permissionActive = true;
+  if (status3 === "running") session.permissionActive = false;
+  onStatusChange(session, status3);
+}
+
+// src/shared/db/recordPhaseCycleContext.ts
+import { sql as sql21 } from "drizzle-orm";
+async function recordPhaseCycleContext(db, itemId2, phaseIdx, window, resetsAt, pct) {
+  if (pct <= 0) return;
+  await db.insert(phaseCycleContext).values({ itemId: itemId2, phaseIdx, window, resetsAt, peakContextPct: pct }).onConflictDoUpdate({
+    target: [
+      phaseCycleContext.itemId,
+      phaseCycleContext.phaseIdx,
+      phaseCycleContext.window,
+      phaseCycleContext.resetsAt
+    ],
+    set: {
+      peakContextPct: sql21`GREATEST(${phaseCycleContext.peakContextPct}, ${pct})`
+    }
+  });
+}
+
+// src/shared/db/recordPhasePeakContext.ts
+import { sql as sql22 } from "drizzle-orm";
+async function recordPhasePeakContext(db, itemId2, phaseIdx, pct) {
+  await db.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, peakContextPct: pct }).onConflictDoUpdate({
+    target: [phaseUsage.itemId, phaseUsage.phaseIdx],
+    set: {
+      peakContextPct: sql22`GREATEST(${phaseUsage.peakContextPct}, ${pct})`
+    }
+  });
+}
+
+// src/shared/db/recordPhaseTranscriptUsage.ts
+import { sql as sql23 } from "drizzle-orm";
+async function recordPhaseTranscriptUsage(db, itemId2, phaseIdx, responses) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const r of responses) byId.set(r.messageId, r);
+  const unique = [...byId.values()];
+  if (unique.length === 0) return { tokensUp: 0, tokensDown: 0 };
+  return db.transaction(async (tx) => {
+    const inserted = await tx.insert(phaseUsageMessages).values(unique.map((r) => ({ itemId: itemId2, phaseIdx, messageId: r.messageId }))).onConflictDoNothing().returning({ messageId: phaseUsageMessages.messageId });
+    let tokensUp = 0;
+    let tokensDown = 0;
+    for (const { messageId } of inserted) {
+      const r = byId.get(messageId);
+      if (!r) continue;
+      tokensUp += r.outputTokens;
+      tokensDown += r.inputTokens;
+    }
+    if (tokensUp <= 0 && tokensDown <= 0) return { tokensUp: 0, tokensDown: 0 };
+    await tx.insert(phaseUsage).values({ itemId: itemId2, phaseIdx, tokensUp, tokensDown }).onConflictDoUpdate({
+      target: [phaseUsage.itemId, phaseUsage.phaseIdx],
+      set: {
+        tokensUp: sql23`${phaseUsage.tokensUp} + ${tokensUp}`,
+        tokensDown: sql23`${phaseUsage.tokensDown} + ${tokensDown}`
+      }
+    });
+    return { tokensUp, tokensDown };
+  });
+}
+
+// src/shared/db/recordWindowTokens.ts
+import { and as and23, eq as eq43, sql as sql24 } from "drizzle-orm";
+async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
+  if (tokensUp <= 0 && tokensDown <= 0) return;
+  await db.update(usagePeaks).set({
+    tokensUp: sql24`${usagePeaks.tokensUp} + ${tokensUp}`,
+    tokensDown: sql24`${usagePeaks.tokensDown} + ${tokensDown}`
+  }).where(
+    and23(
+      eq43(usagePeaks.window, window),
+      eq43(usagePeaks.resetsAt, resetsAt),
+      eq43(usagePeaks.segment, 0)
+    )
+  );
+}
+
+// src/commands/sessions/shared/transcriptUsage.ts
+import * as fs38 from "fs";
+function transcriptUsage(lines) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant") continue;
+    const id = entry.message?.id;
+    const usage = entry.message?.usage;
+    if (!id || !usage) continue;
+    byId.set(id, {
+      messageId: id,
+      inputTokens: usage.input_tokens ?? 0,
+      outputTokens: usage.output_tokens ?? 0
+    });
+  }
+  return [...byId.values()];
+}
+async function readTranscriptUsage(transcriptPath) {
+  const content = await fs38.promises.readFile(transcriptPath, "utf8");
+  return transcriptUsage(content.split("\n"));
+}
+
+// src/commands/sessions/daemon/persistPhaseTokens.ts
+async function persistPhaseTokens(itemId2, phaseIdx, transcriptPath, usedPct, windows) {
+  try {
+    if (!process.env.ASSIST_DATABASE_URL && !loadConfig().database.url) return;
+    const db = await getDb();
+    if (usedPct !== void 0) {
+      await recordPhasePeakContext(db, itemId2, phaseIdx, usedPct);
+      for (const { window, resetsAt } of windows) {
+        await recordPhaseCycleContext(
+          db,
+          itemId2,
+          phaseIdx,
+          window,
+          resetsAt,
+          usedPct
+        );
+      }
+    }
+    const responses = await readTranscriptUsage(transcriptPath);
+    if (responses.length === 0) return;
+    const { tokensUp, tokensDown } = await recordPhaseTranscriptUsage(
+      db,
+      itemId2,
+      phaseIdx,
+      responses
+    );
+    for (const { window, resetsAt } of windows) {
+      await recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown);
+    }
+  } catch (error) {
+    daemonLog(`phase-tokens persist failed: ${String(error)}`);
+  }
+}
+
+// src/commands/sessions/daemon/recordSessionUsage.ts
+function recordSessionUsage(sessions, claudeSessionId, transcriptPath, usedPct, windows) {
+  for (const session of sessions) {
+    if (session.claudeSessionId !== claudeSessionId) continue;
+    session.usedPct = usedPct;
+    const phase = sessionBacklogPhase(session);
+    if (phase && transcriptPath)
+      void persistPhaseTokens(
+        phase.itemId,
+        phase.phaseIdx,
+        transcriptPath,
+        usedPct,
+        windows
+      );
+    void flushPhaseActiveMs(session);
+    return true;
+  }
+  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/shouldAutoRun.ts
+function shouldAutoRun(session, status3 = session.status) {
+  if (!session.autoRun) return { run: false, reason: null };
+  if (status3 !== "done")
+    return {
+      run: false,
+      reason: `session status is "${status3}", 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/endsStreamLife.ts
+function endsStreamLife(session, status3, sharedWithOtherAgents) {
+  if (status3 !== "done" || !session.worktree) return false;
+  if (shouldAutoRun(session, status3).run) return false;
+  if (!sharedWithOtherAgents(session)) return true;
+  daemonLog(
+    `session ${session.id} done in ${session.worktree.path}: workspace kept, other agents are still working there`
+  );
+  return false;
+}
+
+// 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/applyStatusChange.ts
+function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseForRun, sharedWithOtherAgents = () => false) {
+  if (session.status === status3) return;
+  const deps2 = { dismiss, notify: notify2, reuseForRun };
+  if (endsStreamLife(session, status3, sharedWithOtherAgents)) {
+    session.closing = true;
+    daemonLog(
+      `session ${session.id} closing: checking durability of ${session.worktree?.path} before reap`
+    );
+    notify2();
+    void resolveCloseDurability(
+      session,
+      () => finishStatusChange(session, "done", exitCode, deps2),
+      notify2
+    );
+    return;
+  }
+  finishStatusChange(session, status3, exitCode, deps2);
+}
+function finishStatusChange(session, status3, exitCode, deps2) {
+  daemonLog(`session ${session.id} status: ${session.status} -> ${status3}`);
+  void flushPhaseActiveMs(session);
+  setStatus2(session, status3);
+  if (status3 !== "stopped") session.undurable = void 0;
+  const autoRun = shouldAutoRun(session);
+  if (autoRun.run) {
+    deps2.reuseForRun(session, autoRun.itemId);
+    deps2.notify();
+    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)) deps2.dismiss(session.id);
+  else deps2.notify();
+}
+
+// src/commands/sessions/daemon/makeStatusChangeHandler.ts
+function makeStatusChangeHandler(sessions, dismiss, notify2, reuseForRun) {
+  return (s, status3, exitCode) => applyStatusChange(
+    s,
+    status3,
+    exitCode,
+    dismiss,
+    notify2,
+    reuseForRun,
+    (session) => otherTreeHolders(sessions, session).length > 0
+  );
+}
+
+// src/commands/sessions/daemon/respawnSession.ts
+function respawnSession(session, respawn, status3, clients, onStatusChange) {
+  session.gitWatcher?.close();
+  session.gitWatcher = void 0;
+  session.undurable = void 0;
+  session.pendingDismiss = void 0;
+  session.closing = void 0;
+  session.scrollback = "";
+  session.startedAt = Date.now();
+  session.runningMs = 0;
+  session.runningSince = null;
+  setStatus2(session, status3);
+  session.restored = void 0;
+  session.pty = respawn();
+  if (session.cols && session.rows)
+    try {
+      session.pty?.resize(session.cols, session.rows);
+    } catch {
+    }
+  broadcast(clients, { type: "clear", sessionId: session.id });
+  wirePtyEvents(session, clients, onStatusChange);
+}
+
+// src/commands/sessions/daemon/respawnPlan.ts
+import { randomUUID as randomUUID7 } from "crypto";
+
+// src/commands/sessions/daemon/assistResumeArgs.ts
+function assistResumeArgs(session) {
+  const args = ["assist", ...session.assistArgs];
+  return session.claudeSessionId ? [...args, "--resume-session", session.claudeSessionId] : args;
+}
+
+// src/commands/sessions/daemon/respawnPlan.ts
+function respawnPlan(session) {
+  const { commandType, claudeSessionId, cwd, assistArgs, initialPrompt } = session;
+  if (commandType === "claude") {
+    if (claudeSessionId)
+      return {
+        spawn: () => spawnClaude2({
+          resumeSessionId: claudeSessionId,
+          cwd,
+          sessionId: session.id
+        }),
+        status: "waiting"
+      };
+    if (initialPrompt) return freshClaudePlan(session, initialPrompt, cwd);
+    if (cwd && session.harness !== "pi")
+      return freshClaudePlan(session, void 0, cwd);
+    return null;
+  }
+  if (commandType === "assist" && assistArgs) {
+    const idle = session.status === "waiting";
+    return {
+      spawn: () => spawnPty(
+        assistResumeArgs({ assistArgs, claudeSessionId }),
+        cwd,
+        session.id,
+        idle ? { ASSIST_RESUME_IDLE: "1" } : void 0
+      ),
+      status: idle ? "waiting" : "running"
+    };
+  }
+  return null;
+}
+function freshClaudePlan(session, prompt, cwd) {
+  const claudeSessionId = randomUUID7();
+  return {
+    spawn: () => {
+      session.claudeSessionId = claudeSessionId;
+      return spawnClaude2({
+        prompt,
+        cwd,
+        sessionId: session.id,
+        claudeSessionId
+      });
+    },
+    status: prompt ? "running" : "waiting"
+  };
 }
-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)
+
+// src/commands/sessions/daemon/restartSession.ts
+function restartSession(session, clients, onStatusChange) {
+  const plan2 = respawnPlan(session);
+  if (!plan2) return false;
+  const via = session.claudeSessionId ? `resume ${session.claudeSessionId}` : "fresh";
+  const respawn = () => {
+    respawnSession(session, plan2.spawn, plan2.status, clients, onStatusChange);
+    daemonLog(`session ${session.id} restarted (${via}): ${session.name}`);
+  };
+  const pty2 = session.pty;
+  const alive = session.status === "running" || session.status === "waiting";
+  if (pty2 && alive) {
+    daemonLog(
+      `session ${session.id} restart requested: killing running process, will resume on exit`
     );
-  } catch {
-    return [];
-  } finally {
-    await handle?.close();
+    session.pendingRestart = respawn;
+    killPtyTree(pty2);
+  } else {
+    respawn();
   }
+  return true;
 }
-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)
+
+// src/commands/sessions/daemon/restartManagedSession.ts
+function restartManagedSession(sessions, id, clients, onStatusChange) {
+  const s = sessions.get(id);
+  if (!s) {
+    daemonLog(
+      `restart requested for unknown session id=${id} (no live session; ignoring)`
     );
-  } catch {
-    return [];
-  } finally {
-    if (fd !== void 0) fs37.closeSync(fd);
+    return {
+      ok: false,
+      reason: `Session ${id} is no longer tracked and can't be restarted.`
+    };
+  }
+  daemonLog(`restart requested: id=${id} status=${s.status} (${s.name})`);
+  if (!restartSession(s, clients, onStatusChange)) {
+    daemonLog(`restart for session ${id} did nothing: no respawn plan`);
+    return {
+      ok: false,
+      reason: `Session ${s.name} can't be restarted (no resumable command).`
+    };
   }
+  return { ok: true };
 }
 
-// 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;
+// src/commands/sessions/daemon/restoreBase.ts
+function restoreBase(id, persisted) {
+  return {
+    id,
+    name: persisted.name,
+    title: persisted.title,
+    subtitle: persisted.subtitle,
+    commandType: persisted.commandType,
+    harness: persisted.harness,
+    scrollback: "",
+    cwd: persisted.cwd,
+    assistArgs: persisted.assistArgs,
+    initialPrompt: persisted.initialPrompt,
+    starred: persisted.starred
+  };
 }
-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/errorSession.ts
+function errorSession(id, persisted, error) {
+  return {
+    ...restoreBase(id, persisted),
+    status: "error",
+    startedAt: persisted.startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: null,
+    pty: null,
+    runName: persisted.runName,
+    runArgs: persisted.runArgs,
+    error,
+    restored: false
+  };
 }
 
 // src/commands/sessions/daemon/deriveRestoreStatus.ts
@@ -28297,7 +28484,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -28387,9 +28574,9 @@ function capped(lines) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync67(clone)) {
+  if (!existsSync68(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -28482,7 +28669,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
     if (accounted.has(path71)) continue;
-    if (!existsSync68(path71)) {
+    if (!existsSync69(path71)) {
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
         { path: path71, branch: basename18(path71) }
@@ -28650,86 +28837,23 @@ function startHeldSession(session, sessions, clients, onStatusChange, notify2) {
   notify2();
 }
 
+// src/commands/sessions/daemon/startHeldInTree.ts
+function startHeldInTree(seeded, sessions, clients, onStatusChange, notify2) {
+  const start3 = (session) => startHeldSession(session, sessions, clients, onStatusChange, notify2);
+  start3(seeded);
+  for (const session of sessions.values())
+    if (session !== seeded && session.pendingStart && session.cwd === seeded.cwd)
+      start3(session);
+}
+
 // src/commands/sessions/daemon/treeSpawnContext.ts
 function treeSpawnContext(sessions, spawnWith, notify2, clients, onStatusChange) {
   return {
     sessions,
     spawnWith,
     notify: notify2,
-    startHeld: (session) => startHeldSession(session, sessions, clients, onStatusChange, notify2)
-  };
-}
-
-// src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync69, watch as watch3 } 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" || session.status === "stopped")
-    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_MS3 = 100;
-function watchTranscript(session, onStatusChange) {
-  if (!session.cwd || !session.claudeSessionId) return;
-  if (session.watchedTranscriptId === session.claudeSessionId) return;
-  const dir = projectDirForCwd(session.cwd);
-  if (!existsSync69(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);
+    startHeld: (session) => startHeldInTree(session, sessions, clients, onStatusChange, notify2)
   };
-  try {
-    session.transcriptWatcher = watch3(dir, (_event, changed) => {
-      if (changed && changed !== fileName) return;
-      if (timer) clearTimeout(timer);
-      timer = setTimeout(run4, DEBOUNCE_MS3);
-    });
-  } 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
@@ -28934,8 +29058,11 @@ async function forwardWindowsCreate(conn, state, client, data) {
   }
 }
 function stripOutboundSessionId(data) {
-  if (typeof data.sessionId !== "string") return data;
-  return { ...data, sessionId: stripWindowsSessionId(data.sessionId) };
+  const stripped = { ...data };
+  for (const key of ["sessionId", "joinSessionId"])
+    if (typeof stripped[key] === "string")
+      stripped[key] = stripWindowsSessionId(stripped[key]);
+  return stripped;
 }
 
 // src/commands/sessions/daemon/WindowsProxyState.ts
@@ -29388,6 +29515,46 @@ var WindowsProxy = class {
   }
 };
 
+// src/commands/sessions/daemon/worktree/joinableStream.ts
+function joinableStream(sessions, targetId) {
+  const target = sessions.get(targetId);
+  if (!target) return { reason: "no such session" };
+  if (target.commandType === "run")
+    return { reason: "a server run has no agent stream" };
+  if (target.closing === true) return { reason: "the session is closing" };
+  if (target.status !== "running" && target.status !== "waiting")
+    return { reason: `the session is ${target.status}` };
+  if (!target.cwd) return { reason: "the session has no working directory" };
+  return { session: target };
+}
+
+// src/commands/sessions/daemon/worktree/spawnIntoStream.ts
+function spawnIntoStream(ctx, target, prompt, harness) {
+  const holdUntilSeeded = target.pendingStart !== void 0;
+  const id = ctx.spawnWith(
+    (sid) => createSession(sid, prompt, target.cwd, false, harness, holdUntilSeeded)
+  );
+  const joined = ctx.sessions.get(id);
+  if (joined && target.worktree) joined.worktree = { ...target.worktree };
+  daemonLog(
+    `session ${id} added to the stream of session ${target.id} in ${target.cwd}: no workspace allocated${holdUntilSeeded ? ", held until that workspace finishes seeding" : ""}`
+  );
+  ctx.notify();
+  return id;
+}
+
+// src/commands/sessions/daemon/worktree/addAgentToStream.ts
+function addAgentToStream(ctx, targetId, prompt, harness) {
+  const joinable = joinableStream(ctx.sessions, targetId);
+  if ("reason" in joinable) {
+    daemonLog(
+      `create: cannot add an agent to session ${targetId}: ${joinable.reason}`
+    );
+    return void 0;
+  }
+  return spawnIntoStream(ctx, joinable.session, prompt, harness);
+}
+
 // src/commands/sessions/daemon/createAssistSession.ts
 function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
   const startedAt = Date.now();
@@ -29595,13 +29762,13 @@ var SessionManager = class {
     return restoreAllSessions(this.spawnWith, this.sessions, this.notify);
   }
   drain = () => drainSessions(this.sessions, this.notify);
-  add(session) {
-    this.wire(session);
-    wireSessionWatchers(session, this.notify, this.onStatusChange);
-    logSpawnedSession(session);
-    return session.id;
-  }
-  spawnWith = (create) => this.add(create(sessionLimits.nextId(this.sessions.size, this.idCounter)));
+  spawnWith = (create) => registerSpawnedSession(
+    create(sessionLimits.nextId(this.sessions.size, this.idCounter)),
+    this.sessions,
+    this.clients,
+    this.onStatusChange,
+    this.notify
+  );
   treeCtx() {
     return treeSpawnContext(
       this.sessions,
@@ -29614,6 +29781,9 @@ var SessionManager = class {
   spawn(prompt, cwd, design, harness) {
     return spawnInTree(this.treeCtx(), prompt, cwd, design, harness);
   }
+  addAgent(targetId, prompt, harness) {
+    return addAgentToStream(this.treeCtx(), targetId, prompt, harness);
+  }
   spawnRun(runName, runArgs, cwd, meta) {
     return this.spawnWith(
       (id) => createRunSession(id, runName, runArgs, cwd, meta)
@@ -29629,15 +29799,11 @@ var SessionManager = class {
     return resumeInTree(this.treeCtx(), sessionId, cwd, name);
   }
   onStatusChange = makeStatusChangeHandler(
+    this.sessions,
     (id) => this.dismissSession(id),
     () => this.notify(),
     (session, itemId2) => reuseSessionForRun(session, itemId2, this.clients, this.onStatusChange)
   );
-  wire(session) {
-    this.sessions.set(session.id, session);
-    wirePtyEvents(session, this.clients, this.onStatusChange);
-    this.notify();
-  }
   writeToSession(id, data) {
     writeToSession(this.sessions, id, data, this.onStatusChange);
   }
@@ -29883,16 +30049,20 @@ var lifecycleHandlers = {
 function spawnCreate(m, d) {
   const design = d.design === true;
   const harness = d.harness;
+  const prompt = d.prompt;
   if (design)
     daemonLog(`create: design session (cwd=${d.cwd ?? ""})`);
   if (harness && harness !== "claude")
     daemonLog(`create: ${harness} session (cwd=${d.cwd ?? ""})`);
-  return m.spawn(
-    d.prompt,
-    d.cwd,
-    design,
-    harness
-  );
+  const joinSessionId = design ? void 0 : d.joinSessionId;
+  if (joinSessionId) {
+    const joined = m.addAgent(joinSessionId, prompt, harness);
+    if (joined) return joined;
+    daemonLog(
+      `create: falling back to a fresh isolated session (cwd=${d.cwd ?? ""})`
+    );
+  }
+  return m.spawn(prompt, d.cwd, design, harness);
 }
 
 // src/commands/sessions/daemon/messageHandlers.ts
@@ -30195,7 +30365,7 @@ var sessionsConfigHelp = [
   {
     key: "sessions.includeCommittedChanges",
     setter: "assist config set sessions.includeCommittedChanges true -g",
-    note: "session card counts and /diff span the whole branch (merge-base with the default branch) instead of just uncommitted work (default off)"
+    note: "session card counts and /diff span the whole session (its first commit's parent, else merge-base with the default branch) instead of just uncommitted work (default off)"
   },
   {
     key: "worktree.enabled",