@staff0rd/assist 0.431.0 → 0.432.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.431.0",
+  version: "0.432.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -432,6 +432,16 @@ var assistConfigSchema = z2.strictObject({
     promptJira: z2.boolean().default(false)
   }).optional(),
   repos: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional(),
+  worktree: z2.strictObject({
+    enabled: z2.boolean().default(false),
+    root: z2.string().optional(),
+    install: z2.union([z2.boolean(), z2.string()]).default(true),
+    copy: z2.array(z2.string()).default([
+      ".env",
+      "settings.local.json",
+      ".claude/settings.local.json"
+    ])
+  }).optional(),
   run: z2.array(z2.union([runConfigSchema, runLinkSchema])).optional(),
   subtasks: z2.array(
     z2.strictObject({
@@ -1542,6 +1552,7 @@ function warnIfUnexpectedBranch(config) {
   if (!expected) return;
   const current = currentBranch();
   if (current === null || current === expected) return;
+  if (upstreamBranch() === expected) return;
   const line = "\u2500".repeat(64);
   console.warn(
     chalk3.yellow.bold(
@@ -1565,6 +1576,18 @@ function currentBranch() {
     return null;
   }
 }
+function upstreamBranch() {
+  try {
+    const upstream = execSync(
+      "git rev-parse --abbrev-ref --symbolic-full-name @{upstream}",
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const slash = upstream.indexOf("/");
+    return slash === -1 ? upstream || null : upstream.slice(slash + 1) || null;
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/commit/findConflictMarkers.ts
 import { execSync as execSync2 } from "child_process";
@@ -1726,7 +1749,7 @@ function gitRefUrl(kind, ref, cwd) {
 }
 
 // src/commands/commit/collectCommitRefs.ts
-function collectCommitRefs(message) {
+function collectCommitRefs(message2) {
   const refs = [];
   const branch2 = git("rev-parse --abbrev-ref HEAD");
   if (branch2 && branch2 !== "HEAD") {
@@ -1743,7 +1766,7 @@ function collectCommitRefs(message) {
       ref: sha,
       url: gitRefUrl("commit", sha)
     };
-    const subject = message.split("\n", 1)[0];
+    const subject = message2.split("\n", 1)[0];
     if (subject) ref.title = subject;
     refs.push(ref);
   }
@@ -1762,16 +1785,16 @@ function git(args) {
 
 // src/commands/commit/stageAndCommit.ts
 import { execSync as execSync5 } from "child_process";
-function commitStaged(message) {
-  execSync5(`git commit -m ${shellQuote(message)}`, { stdio: "inherit" });
+function commitStaged(message2) {
+  execSync5(`git commit -m ${shellQuote(message2)}`, { stdio: "inherit" });
   return execSync5("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
 }
-function stageAndCommit(files, message) {
+function stageAndCommit(files, message2) {
   const escaped = files.map(shellQuote).join(" ");
   execSync5(`git add ${escaped}`, { stdio: "inherit" });
-  return commitStaged(message);
+  return commitStaged(message2);
 }
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
@@ -1866,34 +1889,34 @@ function backlogRefError(subject, context, ids) {
 // src/commands/commit/validateMessage.ts
 var MAX_MESSAGE_LENGTH = 50;
 var CONVENTIONAL_COMMIT_REGEX = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(!)?(\(.+\))?!?: .+$/;
-function validateMessage(message, config) {
-  if (message.toLowerCase().includes("claude")) {
+function validateMessage(message2, config) {
+  if (message2.toLowerCase().includes("claude")) {
     console.error("Error: Commit message must not reference Claude");
     process.exit(1);
   }
-  const backlogIds = findBacklogRefs(message);
+  const backlogIds = findBacklogRefs(message2);
   if (backlogIds.length > 0) {
     console.error(
       backlogRefError("Commit message", "commit messages", backlogIds)
     );
     process.exit(1);
   }
-  if (config.commit?.conventional && !CONVENTIONAL_COMMIT_REGEX.test(message)) {
+  if (config.commit?.conventional && !CONVENTIONAL_COMMIT_REGEX.test(message2)) {
     console.error(
       "Error: Commit message must follow conventional commit format (e.g., 'feat: add feature', 'fix(scope): fix bug')"
     );
     process.exit(1);
   }
-  if (message.length > MAX_MESSAGE_LENGTH) {
+  if (message2.length > MAX_MESSAGE_LENGTH) {
     console.error(
-      `Error: Commit message must be ${MAX_MESSAGE_LENGTH} characters or less (current: ${message.length})`
+      `Error: Commit message must be ${MAX_MESSAGE_LENGTH} characters or less (current: ${message2.length})`
     );
     process.exit(1);
   }
 }
 
 // src/commands/commit.ts
-async function execCommit(files, message, config) {
+async function execCommit(files, message2, config) {
   try {
     warnIfUnexpectedBranch(config);
     const pulled = Boolean(config.commit?.pull);
@@ -1901,21 +1924,21 @@ async function execCommit(files, message, config) {
       execSync6("git pull --autostash", { stdio: "inherit" });
     }
     abortOnConflicts(files, pulled);
-    const sha = files.length > 0 ? stageAndCommit(files, message) : commitStaged(message);
+    const sha = files.length > 0 ? stageAndCommit(files, message2) : commitStaged(message2);
     console.log(`Committed: ${sha}`);
     if (config.commit?.push) {
       execSync6("git push", { stdio: "inherit" });
       console.log("Pushed to remote");
     }
-    await recordCommitActivity(message);
+    await recordCommitActivity(message2);
     process.exit(0);
   } catch {
     process.exit(1);
   }
 }
-async function recordCommitActivity(message) {
+async function recordCommitActivity(message2) {
   if (resolveSessionItemId() === null) return;
-  await recordSessionRefs(collectCommitRefs(message));
+  await recordSessionRefs(collectCommitRefs(message2));
 }
 async function commit(args) {
   if (args[0] === "status") {
@@ -1928,11 +1951,11 @@ async function commit(args) {
     console.error("Usage: assist commit <message> [files...]");
     process.exit(1);
   }
-  const message = args[0];
+  const message2 = args[0];
   const files = args.slice(1);
   const config = loadConfig();
-  validateMessage(message, config);
-  await execCommit(files, message, config);
+  validateMessage(message2, config);
+  await execCommit(files, message2, config);
 }
 
 // src/commands/coverage.ts
@@ -1970,12 +1993,12 @@ async function exitOnCancel(promise) {
 }
 
 // src/shared/promptMultiselect.ts
-async function promptMultiselect(message, options2) {
+async function promptMultiselect(message2, options2) {
   const { selected } = await exitOnCancel(
     enquirer.prompt({
       type: "multiselect",
       name: "selected",
-      message,
+      message: message2,
       choices: options2.map((opt) => ({
         name: opt.value,
         message: `${opt.name} - ${chalk4.dim(opt.description)}`
@@ -2217,12 +2240,12 @@ import chalk13 from "chalk";
 
 // src/shared/promptConfirm.ts
 import enquirer2 from "enquirer";
-async function promptConfirm(message, initial = true) {
+async function promptConfirm(message2, initial = true) {
   const { confirmed } = await exitOnCancel(
     enquirer2.prompt({
       type: "confirm",
       name: "confirmed",
-      message,
+      message: message2,
       initial,
       // @ts-expect-error - enquirer types don't include symbols but it's supported
       symbols: {
@@ -4532,13 +4555,13 @@ function getSnoreToastPath() {
   return path21.join(notifierPath, "vendor", "snoreToast", "snoretoast-x64.exe");
 }
 function showWindowsNotificationFromWsl(options2) {
-  const { title, message, sound } = options2;
+  const { title, message: message2, sound } = options2;
   const snoreToastPath = getSnoreToastPath();
   try {
     fs16.chmodSync(snoreToastPath, 493);
   } catch {
   }
-  const args = ["-t", title, "-m", message];
+  const args = ["-t", title, "-m", message2];
   if (sound) {
     args.push("-s", "ms-winsoundevent:Notification.Default");
   }
@@ -4552,14 +4575,14 @@ function showWindowsNotificationFromWsl(options2) {
 
 // src/commands/notify/showNotification/index.ts
 function showNotification(options2) {
-  const { title, message, sound } = options2;
+  const { title, message: message2, sound } = options2;
   const platform = detectPlatform();
   if (platform === "wsl") {
-    return showWindowsNotificationFromWsl({ title, message, sound });
+    return showWindowsNotificationFromWsl({ title, message: message2, sound });
   }
   const notificationOptions = {
     title,
-    message,
+    message: message2,
     wait: false
   };
   if (platform === "windows") {
@@ -4581,7 +4604,7 @@ async function notify() {
   }
   const inputData = await readStdin();
   const data = JSON.parse(inputData);
-  const { notification_type, cwd, message } = data;
+  const { notification_type, cwd, message: message2 } = data;
   const projectName = cwd?.split(/[/\\]/).pop() ?? "Unknown Project";
   let title;
   let body;
@@ -4589,7 +4612,7 @@ async function notify() {
   switch (notification_type) {
     case "permission_prompt":
       title = "Claude needs permission";
-      body = `${projectName} - ${message || "Permission required"}`;
+      body = `${projectName} - ${message2 || "Permission required"}`;
       sound = "Alarm";
       break;
     case "idle_prompt":
@@ -4599,7 +4622,7 @@ async function notify() {
       break;
     default:
       title = "Claude Code";
-      body = message ? `${projectName} - ${message}` : projectName;
+      body = message2 ? `${projectName} - ${message2}` : projectName;
       sound = "Default";
   }
   showNotification({ title, message: body, sound });
@@ -4853,8 +4876,8 @@ function readScheduleBlock(crontab) {
 }
 
 // src/commands/backup/scheduleBackup.ts
-function fail(message) {
-  console.error(chalk29.red(message));
+function fail(message2) {
+  console.error(chalk29.red(message2));
   process.exit(1);
 }
 async function scheduleBackup({
@@ -5371,8 +5394,8 @@ function buildArgs(prompt, options2) {
 
 // src/commands/sessions/daemon/appendDaemonLog.ts
 import { appendFileSync } from "fs";
-function appendDaemonLog(message) {
-  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message}`;
+function appendDaemonLog(message2) {
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`;
   try {
     appendFileSync(daemonPaths.log, `${line}
 `);
@@ -6330,10 +6353,10 @@ async function reconcileResumePhase(orm, item, startPhase, resumeSessionId) {
   if (resumedPhaseIdx === void 0 || resumedPhaseIdx === startPhase) {
     return startPhase;
   }
-  const message = `resume reconciliation: currentPhase implied phase ${startPhase + 1} but the resumed conversation ${resumeSessionId} ran phase ${resumedPhaseIdx + 1}; resuming phase ${resumedPhaseIdx + 1} to match the conversation`;
-  appendDaemonLog(`backlog run ${item.id}: ${message}`);
+  const message2 = `resume reconciliation: currentPhase implied phase ${startPhase + 1} but the resumed conversation ${resumeSessionId} ran phase ${resumedPhaseIdx + 1}; resuming phase ${resumedPhaseIdx + 1} to match the conversation`;
+  appendDaemonLog(`backlog run ${item.id}: ${message2}`);
   try {
-    await appendComment(orm, item.id, `Resume reconciled \u2014 ${message}`, {
+    await appendComment(orm, item.id, `Resume reconciled \u2014 ${message2}`, {
       phase: resumedPhaseIdx + 1
     });
   } catch {
@@ -6396,10 +6419,10 @@ async function awaitClaude(done2, context) {
   try {
     return await done2;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message2 = error instanceof Error ? error.message : String(error);
     console.error(
       chalk39.red(`
-Failed to launch Claude for ${context}: ${message}`)
+Failed to launch Claude for ${context}: ${message2}`)
     );
     return CLAUDE_SPAWN_FAILED;
   }
@@ -6425,7 +6448,7 @@ async function isDaemonRunning() {
 
 // src/commands/sessions/daemon/sendToDaemon.ts
 var WRITE_TIMEOUT_MS = 500;
-function sendToDaemon(message) {
+function sendToDaemon(message2) {
   return new Promise((resolve19, reject) => {
     connectToDaemon().then((socket) => {
       const timer = setTimeout(() => {
@@ -6436,7 +6459,7 @@ function sendToDaemon(message) {
         clearTimeout(timer);
         reject(error);
       });
-      socket.write(`${JSON.stringify(message)}
+      socket.write(`${JSON.stringify(message2)}
 `, () => {
         clearTimeout(timer);
         socket.end();
@@ -6462,7 +6485,7 @@ function readSocketLines(socket, onLine) {
 
 // src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
 var ACK_TIMEOUT_MS = 1e3;
-function sendToDaemonAwaitAck(message) {
+function sendToDaemonAwaitAck(message2) {
   return new Promise((resolve19, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
@@ -6486,7 +6509,7 @@ function sendToDaemonAwaitAck(message) {
         "close",
         () => finish(new Error("daemon closed before acknowledging"))
       );
-      socket.write(`${JSON.stringify(message)}
+      socket.write(`${JSON.stringify(message2)}
 `);
     }, reject);
   });
@@ -7223,13 +7246,13 @@ async function findSessionJsonlPath(sessionId) {
 // src/commands/backlog/verifyResumeConversation.ts
 async function verifyResumeConversation(itemId2, resumeSessionId, phaseLabel2) {
   if (await findSessionJsonlPath(resumeSessionId)) return true;
-  const message = `${phaseLabel2}: resume found no conversation for session ${resumeSessionId}; phase not advanced`;
+  const message2 = `${phaseLabel2}: resume found no conversation for session ${resumeSessionId}; phase not advanced`;
   console.error(chalk42.red(`
-${message}`));
-  appendDaemonLog(`backlog run ${itemId2}: ${message}`);
+${message2}`));
+  appendDaemonLog(`backlog run ${itemId2}: ${message2}`);
   try {
     const { orm } = await getReady();
-    await appendComment(orm, itemId2, `Resume failed \u2014 ${message}`);
+    await appendComment(orm, itemId2, `Resume failed \u2014 ${message2}`);
   } catch {
   }
   return false;
@@ -9569,8 +9592,8 @@ async function runRestartItem(item, { runRestartDaemon, reExec }) {
       reExec();
     }
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk57.red(`Restart failed: ${message}`));
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.error(chalk57.red(`Restart failed: ${message2}`));
   }
 }
 
@@ -10120,8 +10143,8 @@ function originToSshUrl(origin) {
 }
 
 // src/commands/backlog/cloneRepo.ts
-function fail2(message) {
-  console.log(chalk66.red(message));
+function fail2(message2) {
+  console.log(chalk66.red(message2));
   process.exitCode = 1;
 }
 async function cloneRepo(originRaw) {
@@ -10777,8 +10800,8 @@ function validateLinkTarget(fromItem, fromNum, toNum, linkType) {
 }
 
 // src/commands/backlog/link.ts
-function fail3(message) {
-  console.log(chalk78.red(message));
+function fail3(message2) {
+  console.log(chalk78.red(message2));
   return void 0;
 }
 function parseLinkType(type) {
@@ -10900,8 +10923,8 @@ Pass the full origin.`
 }
 
 // src/commands/backlog/move-repo/index.ts
-function fail4(message) {
-  console.log(chalk81.red(message));
+function fail4(message2) {
+  console.log(chalk81.red(message2));
   process.exitCode = 1;
 }
 async function moveRepo(oldOriginRaw, newOriginRaw, options2 = {}) {
@@ -11056,11 +11079,11 @@ async function handleLaunchSignal(slashCommand, once) {
       await next({ allowEdits: true, once });
     }
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message2 = error instanceof Error ? error.message : String(error);
     console.error(
       chalk83.yellow(
         `
-Could not complete post-run step (${message}).
+Could not complete post-run step (${message2}).
 This is usually a transient database/network blip \u2014 the work is saved and the session is safe to resume.`
       )
     );
@@ -13168,15 +13191,15 @@ function loadDenyConfig(global) {
 }
 
 // src/commands/deny/denyAdd.ts
-function denyAdd(pattern2, message, options2) {
+function denyAdd(pattern2, message2, options2) {
   const { deny, saveDeny } = loadDenyConfig(options2.global);
   if (deny.some((r) => r.pattern === pattern2)) {
     console.log(chalk110.yellow(`Deny rule already exists for: ${pattern2}`));
     return;
   }
-  deny.push({ pattern: pattern2, message });
+  deny.push({ pattern: pattern2, message: message2 });
   saveDeny(deny);
-  console.log(chalk110.green(`Added deny rule: ${pattern2} \u2192 ${message}`));
+  console.log(chalk110.green(`Added deny rule: ${pattern2} \u2192 ${message2}`));
 }
 
 // src/commands/deny/denyList.ts
@@ -14733,14 +14756,14 @@ function parseGitLogCommits(output, ignore3, afterDate) {
   const commitsByDate = /* @__PURE__ */ new Map();
   for (const line of lines) {
     const [date, hash, ...messageParts] = line.split("|");
-    const message = messageParts.join("|");
+    const message2 = messageParts.join("|");
     if (afterDate && date <= afterDate) {
       continue;
     }
     const files = getCommitFiles(hash);
     if (!shouldIgnoreCommit(files, ignore3)) {
       const existing = commitsByDate.get(date) || [];
-      existing.push({ date, hash, message, files });
+      existing.push({ date, hash, message: message2, files });
       commitsByDate.set(date, existing);
     }
   }
@@ -16353,10 +16376,10 @@ function advisory(count7) {
   const noun = count7 === 1 ? "handover" : "handovers";
   return `${count7} unrecalled ${noun} for this repo. Run /recall to load.`;
 }
-function emit2(message) {
+function emit2(message2) {
   const json = JSON.stringify({
     hookSpecificOutput: { hookEventName: "SessionStart" },
-    systemMessage: message
+    systemMessage: message2
   });
   console.log(json);
   return json;
@@ -16540,11 +16563,11 @@ import { execSync as execSync39 } from "child_process";
 // src/shared/promptInput.ts
 import Enquirer from "enquirer";
 var prompts = Enquirer;
-async function promptInput(name, message, initial) {
-  return exitOnCancel(new prompts.Input({ name, message, initial }).run());
+async function promptInput(name, message2, initial) {
+  return exitOnCancel(new prompts.Input({ name, message: message2, initial }).run());
 }
-async function promptPassword(name, message) {
-  return exitOnCancel(new prompts.Password({ name, message }).run());
+async function promptPassword(name, message2) {
+  return exitOnCancel(new prompts.Password({ name, message: message2 }).run());
 }
 
 // src/commands/jira/jiraAuth.ts
@@ -18021,9 +18044,9 @@ function deleteCommentsCache(prNumber) {
 
 // src/commands/prs/replyToComment.ts
 import { execSync as execSync41 } from "child_process";
-function replyToComment(org, repo, prNumber, commentId, message) {
+function replyToComment(org, repo, prNumber, commentId, message2) {
   execSync41(
-    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
+    `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message2.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
 }
@@ -18071,12 +18094,12 @@ function cleanupCacheIfDone(cache2, prNumber, commentId) {
   );
   if (!hasRemaining) deleteCommentsCache(prNumber);
 }
-function resolveCommentWithReply(commentId, message) {
+function resolveCommentWithReply(commentId, message2) {
   const prNumber = getCurrentPrNumber();
   const { org, repo } = getRepoInfo();
   const cache2 = requireCache(prNumber);
   const comment3 = requireLineComment(cache2, commentId);
-  replyToComment(org, repo, prNumber, commentId, message);
+  replyToComment(org, repo, prNumber, commentId, message2);
   console.log("Reply posted successfully.");
   resolveThread(comment3.threadId);
   console.log("Thread resolved successfully.");
@@ -18099,9 +18122,9 @@ function fixed(commentId, sha) {
     const fullSha = verifySha(sha);
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
-    const message = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
+    const message2 = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
     execSync43("git push", { stdio: "inherit" });
-    resolveCommentWithReply(commentId, message);
+    resolveCommentWithReply(commentId, message2);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -19018,9 +19041,9 @@ function getItemFields(itemId2) {
 
 // src/commands/ravendb/selectOpSecret.ts
 var { Input, Select } = Enquirer2;
-async function selectOne(message, choices) {
+async function selectOne(message2, choices) {
   if (choices.length === 1) return choices[0].value;
-  const selected = await new Select({ name: "choice", message, choices }).run();
+  const selected = await new Select({ name: "choice", message: message2, choices }).run();
   return choices.find((c) => c.name === selected)?.value ?? selected;
 }
 async function selectOpSecret(searchTerm) {
@@ -20735,8 +20758,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename14 = path52.basename(file, path52.extname(file));
-    if (basename14 === "index") continue;
+    const basename17 = path52.basename(file, path52.extname(file));
+    if (basename17 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -21470,9 +21493,9 @@ function postFindings(findings) {
       posted++;
     } catch (error) {
       failed2++;
-      const message = error instanceof Error ? error.message : String(error);
+      const message2 = error instanceof Error ? error.message : String(error);
       console.error(
-        `Failed to post comment on ${finding.file}:${finding.line}: ${message}`
+        `Failed to post comment on ${finding.file}:${finding.line}: ${message2}`
       );
     }
   }
@@ -21491,8 +21514,8 @@ function submitPendingReview(body) {
       console.error("Error: GitHub CLI (gh) is not installed.");
       return;
     }
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Failed to submit review: ${message}`);
+    const message2 = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to submit review: ${message2}`);
   }
 }
 
@@ -22283,10 +22306,10 @@ function messageFor(err, command) {
   return err.message || String(err);
 }
 function handleSpawnError(ctx, err) {
-  const message = messageFor(err, ctx.command);
+  const message2 = messageFor(err, ctx.command);
   const stderr = ctx.stderr ? `${ctx.stderr}
-${message}` : message;
-  if (!ctx.quiet) console.error(`[${ctx.name}] failed: ${message}`);
+${message2}` : message2;
+  if (!ctx.quiet) console.error(`[${ctx.name}] failed: ${message2}`);
   return {
     exitCode: 127,
     stderr,
@@ -25150,8 +25173,8 @@ import { createInterface as createInterface6 } from "readline";
 var RING_CAPACITY = 1e3;
 var ring = [];
 var sink;
-function daemonLog(message) {
-  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message}`);
+function daemonLog(message2) {
+  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`);
 }
 function relayDaemonLog(line) {
   emit3(`[windows] ${line}`);
@@ -25177,7 +25200,7 @@ var persistedSessionSchema = z5.object({
   subtitle: z5.string().optional(),
   commandType: z5.enum(["claude", "run", "assist"]),
   harness: z5.enum(["claude", "codex", "pi"]).optional(),
-  status: z5.enum(["running", "waiting", "done", "error"]).optional(),
+  status: z5.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
   cwd: z5.string(),
   startedAt: z5.number(),
   runningMs: z5.number().optional(),
@@ -25187,7 +25210,8 @@ var persistedSessionSchema = z5.object({
   runArgs: z5.array(z5.string()).optional(),
   assistArgs: z5.array(z5.string()).optional(),
   activity: activitySchema.optional(),
-  starred: z5.boolean().optional()
+  starred: z5.boolean().optional(),
+  undurable: z5.object({ reason: z5.string() }).optional()
 });
 
 // src/commands/sessions/daemon/toPersistedSession.ts
@@ -25208,7 +25232,8 @@ function toPersistedSession(session) {
     runArgs: session.runArgs,
     assistArgs: session.assistArgs,
     activity: session.activity,
-    starred: session.starred
+    starred: session.starred,
+    undurable: session.undurable
   };
 }
 function accumulatedRunningMs(session) {
@@ -25230,7 +25255,7 @@ function savePersistedSessions(sessions) {
 }
 function persistLiveSessions(sessions) {
   const live = [...sessions.values()].filter(
-    (s) => s.pty && s.status !== "done"
+    (s) => (s.pty || s.status === "stopped") && s.status !== "done"
   );
   savePersistedSessions(live.map(toPersistedSession));
   logPersist(live);
@@ -25282,7 +25307,7 @@ function requestDrain(socket) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync26 } from "fs";
+import { mkdirSync as mkdirSync27 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -25385,7 +25410,8 @@ function toSessionInfo({
   starred,
   usedPct,
   design,
-  pendingPrPreview
+  pendingPrPreview,
+  undurable
 }) {
   return {
     id,
@@ -25413,7 +25439,8 @@ function toSessionInfo({
     starred,
     usedPct,
     design,
-    pendingPrPreview
+    pendingPrPreview,
+    undurable
   };
 }
 
@@ -25503,20 +25530,56 @@ var ClientHub = class extends Set {
   };
 };
 
+// src/commands/sessions/daemon/createSession.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/commands/sessions/daemon/resolveRunConfig.ts
+function resolveRunConfig(name, cwd) {
+  try {
+    const { run: run4 } = loadConfigFrom(cwd);
+    const configs = resolveRunConfigs(run4, getConfigDirFrom(cwd));
+    const exact = configs.find((r) => r.name === name);
+    if (exact) return exact;
+    const suffixMatches = configs.filter((r) => r.name.endsWith(`:${name}`));
+    return suffixMatches.length === 1 ? suffixMatches[0] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/sessions/daemon/serverRunMeta.ts
+function serverRunMeta(runName, cwd) {
+  const dir = cwd ?? process.cwd();
+  const config = resolveRunConfig(runName, dir);
+  if (!config?.server) return { server: false };
+  return { server: true, port: config.port, origin: getCurrentOrigin(dir) };
+}
+
+// src/commands/sessions/daemon/readDesignSystemPrompt.ts
+import * as fs35 from "fs";
+import * as path58 from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+var __filename4 = fileURLToPath8(import.meta.url);
+var __dirname6 = path58.dirname(__filename4);
+function readDesignSystemPrompt() {
+  const promptPath = path58.join(__dirname6, "..", "claude", "system-prompt.md");
+  return fs35.readFileSync(promptPath, "utf8");
+}
+
 // src/commands/sessions/daemon/spawnPty.ts
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync57, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path58 from "path";
+import path59 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path58.join(path58.dirname(require4.resolve("node-pty")), "..");
-  const helper = path58.join(
+  const ptyRoot = path59.join(path59.dirname(require4.resolve("node-pty")), "..");
+  const helper = path59.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -25553,62 +25616,6 @@ function shellEscape(s) {
   return `'${s.replace(/'/g, String.raw`'\''`)}'`;
 }
 
-// src/commands/sessions/daemon/createAssistSession.ts
-function createAssistSession(id, assistArgs, cwd, meta) {
-  const startedAt = Date.now();
-  return {
-    id,
-    name: `assist ${assistArgs.join(" ")}`,
-    title: meta?.title,
-    subtitle: meta?.subtitle,
-    commandType: "assist",
-    status: "running",
-    startedAt,
-    runningMs: 0,
-    runningSince: startedAt,
-    pty: spawnPty(["assist", ...assistArgs], cwd, id),
-    scrollback: "",
-    assistArgs,
-    cwd
-  };
-}
-
-// src/commands/sessions/daemon/createSession.ts
-import { randomUUID as randomUUID5 } from "crypto";
-
-// src/commands/sessions/daemon/resolveRunConfig.ts
-function resolveRunConfig(name, cwd) {
-  try {
-    const { run: run4 } = loadConfigFrom(cwd);
-    const configs = resolveRunConfigs(run4, getConfigDirFrom(cwd));
-    const exact = configs.find((r) => r.name === name);
-    if (exact) return exact;
-    const suffixMatches = configs.filter((r) => r.name.endsWith(`:${name}`));
-    return suffixMatches.length === 1 ? suffixMatches[0] : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/commands/sessions/daemon/serverRunMeta.ts
-function serverRunMeta(runName, cwd) {
-  const dir = cwd ?? process.cwd();
-  const config = resolveRunConfig(runName, dir);
-  if (!config?.server) return { server: false };
-  return { server: true, port: config.port, origin: getCurrentOrigin(dir) };
-}
-
-// src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs35 from "fs";
-import * as path59 from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
-var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname6 = path59.dirname(__filename4);
-function readDesignSystemPrompt() {
-  const promptPath = path59.join(__dirname6, "..", "claude", "system-prompt.md");
-  return fs35.readFileSync(promptPath, "utf8");
-}
-
 // src/commands/sessions/daemon/spawnClaude.ts
 function spawnClaude2(opts = {}) {
   return spawnPty(buildArgs3(opts), opts.cwd, opts.sessionId);
@@ -25693,6 +25700,170 @@ function createRunSession(id, runName, runArgs, cwd, meta = serverRunMeta(runNam
   };
 }
 
+// src/commands/sessions/daemon/worktree/reapWorktree.ts
+import { existsSync as existsSync58 } from "fs";
+
+// src/commands/sessions/daemon/worktree/git.ts
+import { execFile as execFile7, execFileSync as execFileSync12 } from "child_process";
+function isWindowsPath(cwd) {
+  return /^[A-Za-z]:[\\/]/.test(cwd);
+}
+function gitInvocation(cwd, args) {
+  const windows = isWindowsPath(cwd);
+  return {
+    file: windows ? "git.exe" : "git",
+    argv: windows ? ["-C", cwd, ...args] : args,
+    options: { encoding: "utf8", ...windows ? {} : { cwd } }
+  };
+}
+function git3(cwd, args) {
+  const { file, argv, options: options2 } = gitInvocation(cwd, args);
+  return new Promise((resolve19, reject) => {
+    execFile7(file, argv, options2, (error, stdout) => {
+      if (error) reject(error);
+      else resolve19(stdout.toString());
+    });
+  });
+}
+async function gitOrNull(cwd, args) {
+  try {
+    return (await git3(cwd, args)).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function gitSync(cwd, args) {
+  const { file, argv, options: options2 } = gitInvocation(cwd, args);
+  return execFileSync12(file, argv, {
+    ...options2,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).toString();
+}
+function gitSyncOrNull(cwd, args) {
+  try {
+    return gitSync(cwd, args).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function listWorktreePaths(cwd) {
+  const out = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
+  if (!out) return [];
+  return out.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim());
+}
+function mainWorktree(cwd) {
+  return listWorktreePaths(cwd)[0] ?? null;
+}
+function listLocalBranches(cwd) {
+  const out = gitSyncOrNull(cwd, [
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]);
+  return out ? out.split("\n").map((line) => line.trim()) : [];
+}
+function gitCommonDir(cwd) {
+  return gitSyncOrNull(cwd, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ]);
+}
+
+// src/commands/sessions/daemon/worktree/treeDurability.ts
+function treeDurability(state) {
+  if (state.dirty) return { durable: false, reason: "uncommitted changes" };
+  if (!state.push && state.localOnlyCommits)
+    return { durable: false, reason: "unpushed commits" };
+  return { durable: true };
+}
+async function hasLocalOnlyCommits(cwd) {
+  const upstream = await gitOrNull(cwd, [
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{upstream}"
+  ]);
+  if (upstream) {
+    const ahead = await gitOrNull(cwd, [
+      "rev-list",
+      "--count",
+      "@{upstream}..HEAD"
+    ]);
+    return Number(ahead ?? "0") > 0;
+  }
+  const remoteBranches = await gitOrNull(cwd, [
+    "branch",
+    "-r",
+    "--contains",
+    "HEAD"
+  ]);
+  return !remoteBranches;
+}
+async function collectTreeState(cwd, push) {
+  const status3 = await gitOrNull(cwd, ["status", "--porcelain"]);
+  return {
+    dirty: status3 !== null,
+    push,
+    localOnlyCommits: await hasLocalOnlyCommits(cwd)
+  };
+}
+function pushOnCommit(cwd) {
+  try {
+    return loadConfigFrom(cwd).commit.push;
+  } catch {
+    return false;
+  }
+}
+async function checkDurability(cwd) {
+  return treeDurability(await collectTreeState(cwd, pushOnCommit(cwd)));
+}
+
+// src/commands/sessions/daemon/worktree/reapWorktree.ts
+async function reapWorktree(worktreePath, force = false) {
+  if (!existsSync58(worktreePath)) {
+    daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
+    return false;
+  }
+  if (!force) {
+    const durability = await checkDurability(worktreePath);
+    if (!durability.durable) {
+      daemonLog(`worktree ${worktreePath} not reaped: ${durability.reason}`);
+      return false;
+    }
+  }
+  const clone = mainWorktree(worktreePath) ?? worktreePath;
+  const branch2 = await gitOrNull(worktreePath, [
+    "symbolic-ref",
+    "--short",
+    "HEAD"
+  ]);
+  try {
+    await git3(clone, [
+      "worktree",
+      "remove",
+      ...force ? ["--force"] : [],
+      worktreePath
+    ]);
+    if (branch2) await deleteBranch(clone, branch2);
+    daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
+    return true;
+  } catch (error) {
+    daemonLog(
+      `worktree ${worktreePath} reap failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+async function deleteBranch(clone, branch2) {
+  const current = await gitOrNull(clone, ["symbolic-ref", "--short", "HEAD"]);
+  if (branch2 === current) return;
+  try {
+    await git3(clone, ["branch", "-D", branch2]);
+  } catch {
+  }
+}
+
 // src/commands/sessions/daemon/dismissSession.ts
 function dismissSession(sessions, id) {
   const s = sessions.get(id);
@@ -25700,10 +25871,12 @@ function dismissSession(sessions, id) {
   if (s.status !== "done") s.pty?.kill();
   s.activityWatcher?.close();
   s.transcriptWatcher?.close();
+  s.gitWatcher?.close();
   removeActivity(s.id);
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
   sessions.delete(id);
   daemonLog(`session ${id} dismissed (${s.name})`);
+  if (s.worktree) void reapWorktree(s.worktree.path);
   return true;
 }
 function drainSessions(sessions, onDrained) {
@@ -25717,6 +25890,113 @@ function drainSessions(sessions, onDrained) {
   return ids.length;
 }
 
+// src/commands/sessions/daemon/killPtyTree.ts
+function killPtyTree(pty2) {
+  if (process.platform === "win32") {
+    pty2.kill();
+    return;
+  }
+  try {
+    process.kill(-pty2.pid, "SIGHUP");
+  } catch {
+    try {
+      pty2.kill();
+    } catch {
+    }
+  }
+}
+
+// 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/worktree/watchGitState.ts
+import { existsSync as existsSync59, watch } from "fs";
+var DEBOUNCE_MS = 500;
+function watchGitState(cwd, onChange) {
+  const common = gitCommonDir(cwd);
+  if (!common || !existsSync59(common)) return void 0;
+  let timer = null;
+  try {
+    return watch(common, { recursive: true }, () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(onChange, DEBOUNCE_MS);
+    });
+  } catch (error) {
+    daemonLog(
+      `git-state watch failed for ${cwd}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+}
+
+// src/commands/sessions/daemon/worktree/resolveDoneDurability.ts
+async function resolveDoneDurability(session, finalize, notify2) {
+  const worktree = session.worktree;
+  if (!worktree) {
+    finalize();
+    return;
+  }
+  const durability = await checkDurability(worktree.path);
+  if (!durability.durable) {
+    holdStopped(session, durability.reason, finalize, notify2);
+    return;
+  }
+  await reapWorktree(worktree.path);
+  session.worktree = void 0;
+  session.undurable = void 0;
+  session.gitWatcher?.close();
+  session.gitWatcher = void 0;
+  finalize();
+}
+function holdStopped(session, reason, finalize, notify2) {
+  if (session.undurable?.reason !== reason)
+    daemonLog(`session ${session.id} stopped; reap blocked: ${reason}`);
+  session.undurable = { reason };
+  setStatus2(session, "stopped");
+  if (!session.gitWatcher && session.worktree)
+    session.gitWatcher = watchGitState(session.worktree.path, () => {
+      if (session.status !== "stopped") return;
+      void resolveDoneDurability(session, finalize, notify2);
+    });
+  notify2();
+}
+
+// src/commands/sessions/daemon/dismissSessionGated.ts
+function dismissSessionGated(sessions, id, notify2, discard = false) {
+  const s = sessions.get(id);
+  if (!s?.worktree) {
+    if (dismissSession(sessions, id)) notify2();
+    return;
+  }
+  const removeCard = () => {
+    if (dismissSession(sessions, id)) notify2();
+  };
+  const discardTree = async () => {
+    if (s.worktree) {
+      await reapWorktree(s.worktree.path, true);
+      s.worktree = void 0;
+    }
+    removeCard();
+  };
+  if (s.pty) {
+    s.pendingDismiss = discard ? () => void discardTree() : () => void resolveDoneDurability(s, removeCard, notify2);
+    daemonLog(
+      `session ${id} ${discard ? "discard" : "dismiss"} requested: killing process tree first`
+    );
+    killPtyTree(s.pty);
+    return;
+  }
+  if (discard) void discardTree();
+  else void resolveDoneDurability(s, removeCard, notify2);
+}
+
 // src/shared/db/recordPhaseActiveMs.ts
 import { sql as sql20 } from "drizzle-orm";
 async function recordPhaseActiveMs(db, itemId2, phaseIdx, activeMs) {
@@ -25897,6 +26177,12 @@ function applySetStatus(sessions, id, status3, source, onStatusChange) {
     );
     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);
@@ -26070,16 +26356,6 @@ function applyUsageRecord(sessions, windows, notify2, claudeSessionId, transcrip
     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) {
@@ -26125,13 +26401,26 @@ function shouldAutoRun(session) {
 // 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 };
+  if (status3 === "done" && session.worktree) {
+    void resolveDoneDurability(
+      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 !== "waiting") session.undurable = void 0;
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
-    reuseForRun(session, autoRun.itemId);
-    notify2();
+    deps2.reuseForRun(session, autoRun.itemId);
+    deps2.notify();
     return;
   }
   if (status3 === "done" && autoRun.reason != null) {
@@ -26139,8 +26428,8 @@ function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseFo
       `session ${session.id} auto-run enabled but skipped (exit ${exitCode ?? "none"}): ${autoRun.reason}`
     );
   }
-  if (shouldAutoDismiss(session, exitCode)) dismiss(session.id);
-  else notify2();
+  if (shouldAutoDismiss(session, exitCode)) deps2.dismiss(session.id);
+  else deps2.notify();
 }
 
 // src/commands/sessions/daemon/makeStatusChangeHandler.ts
@@ -26161,7 +26450,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync58, mkdirSync as mkdirSync25, watch } from "fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
 import { dirname as dirname29 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -26212,7 +26501,7 @@ async function seedRunningMsFromUsage(session, notify2) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-var DEBOUNCE_MS = 50;
+var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path71 = activityPath(session.id);
@@ -26237,12 +26526,12 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     void seedRunningMsFromUsage(session, notify2);
     notify2();
   };
-  session.activityWatcher = watch(dir, (_event, filename) => {
+  session.activityWatcher = watch2(dir, (_event, filename) => {
     if (filename && !path71.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
-    timer = setTimeout(read, DEBOUNCE_MS);
+    timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync58(path71)) read();
+  if (existsSync60(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -26277,6 +26566,15 @@ function handlePtyExit(session, exitCode, onStatusChange) {
     return;
   }
   session.pty = null;
+  if (session.pendingDismiss) {
+    const dismiss = session.pendingDismiss;
+    session.pendingDismiss = void 0;
+    daemonLog(
+      `session ${session.id} ("${session.name}") pty exited (code ${exitCode}) for dismiss; resolving durability now the process is gone`
+    );
+    dismiss();
+    return;
+  }
   if (handleStoppedExit(session, exitCode, onStatusChange)) return;
   refreshActivity(session);
   if (handleFailedResume(session, exitCode, onStatusChange)) return;
@@ -26317,6 +26615,10 @@ function wirePtyEvents(session, clients, onStatusChange) {
 
 // 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.scrollback = "";
   session.startedAt = Date.now();
   session.runningMs = 0;
@@ -26324,6 +26626,11 @@ function respawnSession(session, respawn, status3, clients, onStatusChange) {
   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);
 }
@@ -26405,20 +26712,6 @@ function restartSession(session, clients, onStatusChange) {
   }
   return true;
 }
-function killPtyTree(pty2) {
-  if (process.platform === "win32") {
-    pty2.kill();
-    return;
-  }
-  try {
-    process.kill(-pty2.pid, "SIGHUP");
-  } catch {
-    try {
-      pty2.kill();
-    } catch {
-    }
-  }
-}
 
 // src/commands/sessions/daemon/restartManagedSession.ts
 function restartManagedSession(sessions, id, clients, onStatusChange) {
@@ -26519,9 +26812,9 @@ function normalizeEntry(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 message2 = asRecord2(entry.message);
+  const stopReason = typeof message2?.stop_reason === "string" ? message2.stop_reason : null;
+  const content = message2?.content;
   const toolUses = [];
   if (Array.isArray(content))
     for (const block of content) {
@@ -26699,6 +26992,12 @@ function runningSession(base, persisted, pty2) {
 function waitingSession(base, persisted, pty2) {
   return restoredSession(base, persisted, pty2, "waiting");
 }
+function stoppedSession(base, persisted) {
+  return {
+    ...restoredSession(base, persisted, null, "stopped"),
+    undurable: persisted.undurable
+  };
+}
 function restoredSession(base, persisted, pty2, status3) {
   const startedAt = Date.now();
   return {
@@ -26781,6 +27080,7 @@ function isUpdate(persisted) {
 // src/commands/sessions/daemon/restoreSession.ts
 function restoreSession(id, persisted) {
   const base = restoreBase(id, persisted);
+  if (persisted.status === "stopped") return stoppedSession(base, persisted);
   if (isUpdate(persisted)) return updatedSession(id, persisted);
   const idle = deriveRestoreStatus(persisted) !== "running";
   if (needsWrapperRelaunch(persisted)) {
@@ -26862,27 +27162,6 @@ function restoreAll(spawn12, sessions) {
   });
 }
 
-// src/commands/sessions/daemon/resumeSession.ts
-function resumeSession(id, sessionId, cwd, name) {
-  const startedAt = Date.now();
-  return {
-    id,
-    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
-    commandType: "claude",
-    status: "waiting",
-    startedAt,
-    runningMs: 0,
-    runningSince: null,
-    pty: spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id }),
-    scrollback: "",
-    cwd,
-    /* why: bind the card to the conversation it is resuming so a daemon restart
-     * re-resumes this same transcript, not whichever .jsonl a cwd poller would
-     * have re-discovered (#413). */
-    claudeSessionId: sessionId
-  };
-}
-
 // src/commands/sessions/daemon/retrySession.ts
 function retrySession(session, clients, onStatusChange) {
   const respawn = respawnThunk(session);
@@ -26958,6 +27237,9 @@ function runRetry(sessions, id, replace, deps2) {
 function reuseSessionForRun(session, itemId2, clients, onStatusChange) {
   const assistArgs = ["backlog", "run", String(itemId2)];
   session.pty?.kill();
+  session.gitWatcher?.close();
+  session.gitWatcher = void 0;
+  session.undurable = void 0;
   session.assistArgs = assistArgs;
   session.name = `assist ${assistArgs.join(" ")}`;
   session.commandType = "assist";
@@ -26987,7 +27269,7 @@ function shutdownSessions(sessions) {
 }
 
 // src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync60, watch as watch2 } from "fs";
+import { existsSync as existsSync62, watch as watch3 } from "fs";
 
 // src/commands/sessions/daemon/reconcileTranscriptStatus.ts
 async function resolveTranscriptPath(session) {
@@ -26999,7 +27281,8 @@ async function resolveTranscriptPath(session) {
   return filePath;
 }
 async function reconcileTranscriptStatus(session, onStatusChange) {
-  if (session.status === "done" || session.status === "error") return;
+  if (session.status === "done" || session.status === "error" || session.status === "stopped")
+    return;
   const filePath = await resolveTranscriptPath(session);
   if (!filePath) return;
   const entries = await readTranscriptTail(filePath);
@@ -27016,12 +27299,12 @@ async function reconcileTranscriptStatus(session, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchTranscript.ts
-var DEBOUNCE_MS2 = 100;
+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 (!existsSync60(dir)) return;
+  if (!existsSync62(dir)) return;
   if (session.transcriptWatcher) {
     session.transcriptWatcher.close();
     session.transcriptWatcher = void 0;
@@ -27034,10 +27317,10 @@ function watchTranscript(session, onStatusChange) {
     void reconcileTranscriptStatus(session, onStatusChange);
   };
   try {
-    session.transcriptWatcher = watch2(dir, (_event, changed) => {
+    session.transcriptWatcher = watch3(dir, (_event, changed) => {
       if (changed && changed !== fileName) return;
       if (timer) clearTimeout(timer);
-      timer = setTimeout(run4, DEBOUNCE_MS2);
+      timer = setTimeout(run4, DEBOUNCE_MS3);
     });
   } catch (error) {
     daemonLog(
@@ -27172,19 +27455,19 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync61, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync63, readFileSync as readFileSync49 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync61(sessionsFile)) return false;
+    if (!existsSync63(sessionsFile)) return false;
     const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message2 = error instanceof Error ? error.message : String(error);
     daemonLog(
-      `windows proxy: could not read windows sessions.json: ${message}`
+      `windows proxy: could not read windows sessions.json: ${message2}`
     );
     return false;
   }
@@ -27211,8 +27494,8 @@ async function discoverWindowsSessions(conn) {
   try {
     await conn.ensure();
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: discovery failed: ${message}`);
+    const message2 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: discovery failed: ${message2}`);
   }
 }
 
@@ -27250,11 +27533,11 @@ async function forwardWindowsCreate(conn, state, client, data) {
     state.pendingCreators.push({ client, timer });
     conn.write(stripOutboundSessionId(data));
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: forwardCreate failed: ${message}`);
+    const message2 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: forwardCreate failed: ${message2}`);
     sendTo(client, {
       type: "error",
-      message: `Windows session unavailable: ${message}`
+      message: `Windows session unavailable: ${message2}`
     });
   }
 }
@@ -27289,10 +27572,10 @@ function takePendingCreator(state) {
   clearTimeout(pending.timer);
   return pending.client;
 }
-function failPendingCreators(state, message) {
+function failPendingCreators(state, message2) {
   for (const { client, timer } of state.pendingCreators) {
     clearTimeout(timer);
-    sendTo(client, { type: "error", message });
+    sendTo(client, { type: "error", message: message2 });
   }
   state.pendingCreators = [];
 }
@@ -27432,9 +27715,9 @@ async function healWindowsDaemon() {
   try {
     await runOnWindowsHost("assist update", UPDATE_TIMEOUT_MS);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message2 = error instanceof Error ? error.message : String(error);
     daemonLog(
-      `windows daemon: auto-heal: \`assist update\` failed: ${message}`
+      `windows daemon: auto-heal: \`assist update\` failed: ${message2}`
     );
     throw error;
   }
@@ -27609,11 +27892,11 @@ async function autoHealWindowsDaemon(conn, state, heal, version2) {
     daemonLog("windows proxy: heal complete, reconnecting to windows daemon");
     await conn.ensure();
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    daemonLog(`windows proxy: auto-heal failed: ${message}`);
+    const message2 = error instanceof Error ? error.message : String(error);
+    daemonLog(`windows proxy: auto-heal failed: ${message2}`);
     state.broadcast({
       type: "error",
-      message: `Windows host auto-update failed: ${message}`
+      message: `Windows host auto-update failed: ${message2}`
     });
   }
 }
@@ -27721,6 +28004,335 @@ var WindowsProxy = class {
   }
 };
 
+// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
+import { existsSync as existsSync66 } from "fs";
+import { basename as basename14 } from "path";
+
+// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
+var DISABLED = {
+  enabled: false,
+  install: true,
+  copy: [".env", "settings.local.json", ".claude/settings.local.json"]
+};
+function worktreeConfigFor(cwd) {
+  try {
+    return loadConfigFrom(cwd).worktree ?? DISABLED;
+  } catch {
+    return DISABLED;
+  }
+}
+
+// src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
+function detectExistingWorktree(cwd) {
+  const repoRoot = findRepoRoot(cwd) ?? cwd;
+  if (!worktreeConfigFor(repoRoot).enabled) return void 0;
+  const clone = mainWorktree(repoRoot);
+  if (clone && clone !== repoRoot) return { path: repoRoot, clone };
+  return void 0;
+}
+
+// src/commands/sessions/daemon/worktree/seedWorktree.ts
+import { execFile as execFile8 } from "child_process";
+import { copyFileSync, existsSync as existsSync65, mkdirSync as mkdirSync26 } from "fs";
+import { dirname as dirname30, join as join71 } from "path";
+
+// src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
+import { existsSync as existsSync64 } from "fs";
+import { join as join70 } from "path";
+function detectInstallCommand(repoRoot) {
+  if (!existsSync64(join70(repoRoot, "package.json"))) return null;
+  if (existsSync64(join70(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync64(join70(repoRoot, "yarn.lock"))) return "yarn install";
+  if (existsSync64(join70(repoRoot, "bun.lockb"))) return "bun install";
+  return "npm install";
+}
+function resolveInstallCommand(repoRoot, install) {
+  if (install === false) return null;
+  if (typeof install === "string") return install;
+  return detectInstallCommand(repoRoot);
+}
+
+// src/commands/sessions/daemon/worktree/seedWorktree.ts
+function seedWorktree(worktreePath, clone) {
+  const cfg = worktreeConfigFor(clone);
+  copyConfigFiles(worktreePath, clone, cfg.copy);
+  runInstall(worktreePath, clone, cfg.install);
+}
+function copyConfigFiles(worktreePath, clone, copy) {
+  for (const rel of copy) {
+    const src = join71(clone, rel);
+    if (!existsSync65(src)) continue;
+    const dest = join71(worktreePath, rel);
+    try {
+      mkdirSync26(dirname30(dest), { recursive: true });
+      copyFileSync(src, dest);
+      daemonLog(`worktree ${worktreePath} seeded ${rel}`);
+    } catch (error) {
+      daemonLog(
+        `worktree ${worktreePath} failed to seed ${rel}: ${message(error)}`
+      );
+    }
+  }
+}
+function runInstall(worktreePath, clone, install) {
+  const command = resolveInstallCommand(clone, install);
+  if (!command) return;
+  const windows = /^[A-Za-z]:[\\/]/.test(worktreePath);
+  const shell = windows ? "cmd.exe" : process.env.SHELL ?? "bash";
+  const shellArgs = windows ? ["/c", command] : ["-l", "-c", command];
+  daemonLog(`worktree ${worktreePath} installing deps: ${command}`);
+  execFile8(shell, shellArgs, { cwd: worktreePath }, (error) => {
+    daemonLog(
+      error ? `worktree ${worktreePath} install failed: ${error.message}` : `worktree ${worktreePath} install complete`
+    );
+  });
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/sessions/daemon/worktree/bindNewWorktree.ts
+function boundTreeRoots(sessions) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const session of sessions.values())
+    if (session.cwd) roots.add(findRepoRoot(session.cwd) ?? session.cwd);
+  return roots;
+}
+function bindNewWorktree(session, alloc, notify2) {
+  if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
+    return;
+  session.worktree = { path: alloc.cwd, clone: alloc.clone };
+  if (alloc.created) seedWorktree(alloc.cwd, alloc.clone);
+  notify2();
+}
+function bindRestoredWorktrees(sessions) {
+  for (const session of sessions.values()) {
+    if (session.worktree || !session.cwd) continue;
+    const worktree = detectExistingWorktree(session.cwd);
+    if (worktree) session.worktree = worktree;
+  }
+}
+function bindResumedWorktree(session, cwd, notify2) {
+  if (!session) return;
+  const worktree = detectExistingWorktree(cwd);
+  if (!worktree) return;
+  session.worktree = worktree;
+  notify2();
+}
+
+// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
+var REGISTRY_FILE = "worktrees.json";
+function readWorktreeRegistry() {
+  const data = loadJson(REGISTRY_FILE);
+  return Object.entries(data).map(([path71, record]) => ({ path: path71, ...record }));
+}
+function recordWorktree(path71, clone, origin) {
+  const data = loadJson(REGISTRY_FILE);
+  data[path71] = { clone, origin };
+  saveJson(REGISTRY_FILE, data);
+}
+
+// src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
+function reconcileWorktreesOnRestore(sessions) {
+  bindRestoredWorktrees(sessions);
+  void pruneWorktrees([...sessions.values()].map((s) => s.cwd));
+}
+async function pruneWorktrees(liveCwds) {
+  const accounted = /* @__PURE__ */ new Set();
+  for (const cwd of liveCwds) if (cwd) accounted.add(cwd);
+  for (const s of loadPersistedSessions()) accounted.add(s.cwd);
+  const clonesToPrune = /* @__PURE__ */ new Set();
+  const orphanBranches = [];
+  for (const { path: path71, clone } of readWorktreeRegistry()) {
+    if (accounted.has(path71)) continue;
+    if (!existsSync66(path71)) {
+      clonesToPrune.add(clone);
+      orphanBranches.push({ clone, branch: basename14(path71) });
+      continue;
+    }
+    daemonLog(`worktree ${path71} orphaned across restart; reconciling`);
+    await reapWorktree(path71);
+  }
+  for (const clone of clonesToPrune) {
+    if (!existsSync66(clone)) continue;
+    try {
+      await git3(clone, ["worktree", "prune"]);
+      daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
+    } catch {
+    }
+  }
+  for (const { clone, branch: branch2 } of orphanBranches)
+    if (existsSync66(clone)) await pruneStaleWorktreeBranch(clone, branch2);
+}
+async function pruneStaleWorktreeBranch(clone, branch2) {
+  if (!listLocalBranches(clone).includes(branch2)) return;
+  try {
+    await git3(clone, ["branch", "-d", branch2]);
+    daemonLog(`stale worktree branch ${branch2} pruned from clone ${clone}`);
+  } catch {
+    daemonLog(
+      `stale worktree branch ${branch2} retained (unmerged; surfaced not destroyed) in clone ${clone}`
+    );
+  }
+}
+
+// src/commands/sessions/daemon/worktree/rearmStoppedSessions.ts
+function rearmStoppedSessions(sessions, notify2) {
+  for (const s of sessions.values()) {
+    if (s.status !== "stopped" || !s.worktree) continue;
+    void resolveDoneDurability(
+      s,
+      () => {
+        if (dismissSession(sessions, s.id)) notify2();
+      },
+      notify2
+    );
+  }
+}
+
+// src/commands/sessions/daemon/createAssistSession.ts
+function createAssistSession(id, assistArgs, cwd, meta) {
+  const startedAt = Date.now();
+  return {
+    id,
+    name: `assist ${assistArgs.join(" ")}`,
+    title: meta?.title,
+    subtitle: meta?.subtitle,
+    commandType: "assist",
+    status: "running",
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
+    pty: spawnPty(["assist", ...assistArgs], cwd, id),
+    scrollback: "",
+    assistArgs,
+    cwd
+  };
+}
+
+// src/commands/sessions/daemon/resumeSession.ts
+function resumeSession(id, sessionId, cwd, name) {
+  const startedAt = Date.now();
+  return {
+    id,
+    name: name ? `${name.slice(0, 36)} (R)` : `Resume ${sessionId.slice(0, 8)}`,
+    commandType: "claude",
+    status: "waiting",
+    startedAt,
+    runningMs: 0,
+    runningSince: null,
+    pty: spawnClaude2({ resumeSessionId: sessionId, cwd, sessionId: id }),
+    scrollback: "",
+    cwd,
+    /* why: bind the card to the conversation it is resuming so a daemon restart
+     * re-resumes this same transcript, not whichever .jsonl a cwd poller would
+     * have re-discovered (#413). */
+    claudeSessionId: sessionId
+  };
+}
+
+// src/commands/sessions/daemon/worktree/createWorktree.ts
+import { existsSync as existsSync67 } from "fs";
+import { basename as basename16, dirname as dirname31 } from "path";
+
+// src/commands/sessions/daemon/worktree/planAllocation.ts
+import { basename as basename15, join as join72 } from "path";
+function planAllocation(clone, boundTreeRoots2) {
+  return boundTreeRoots2.has(clone) ? "spill" : "primary";
+}
+function nextWorktreePath(clone, base, isTaken) {
+  const name = basename15(clone);
+  for (let n = 2; n < 1e3; n++) {
+    const candidate = join72(base, `${name}-${n}`);
+    if (!isTaken(candidate)) return candidate;
+  }
+  throw new Error(`no free worktree suffix for ${clone}`);
+}
+
+// src/commands/sessions/daemon/worktree/createWorktree.ts
+function createWorktree(clone, root, boundTreeRoots2) {
+  const base = root ? expandTilde2(root) : dirname31(clone);
+  const registered = new Set(listWorktreePaths(clone));
+  const branches = new Set(listLocalBranches(clone));
+  const path71 = nextWorktreePath(
+    clone,
+    base,
+    (candidate) => registered.has(candidate) || existsSync67(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
+  );
+  const trunk = cloneTrunkBranch(clone);
+  gitSync(clone, ["config", "push.default", "upstream"]);
+  gitSync(clone, [
+    "worktree",
+    "add",
+    "--track",
+    "-b",
+    basename16(path71),
+    path71,
+    `origin/${trunk}`
+  ]);
+  recordWorktree(path71, clone, getCurrentOrigin(clone));
+  daemonLog(
+    `worktree allocated ${path71} (branch ${basename16(path71)} tracking origin/${trunk}) for clone ${clone}`
+  );
+  return path71;
+}
+function cloneTrunkBranch(clone) {
+  const branch2 = gitSyncOrNull(clone, ["symbolic-ref", "--short", "HEAD"]);
+  if (branch2) return branch2;
+  const head = gitSyncOrNull(clone, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (head) {
+    const slash = head.indexOf("/");
+    return slash === -1 ? head : head.slice(slash + 1);
+  }
+  return "main";
+}
+
+// src/commands/sessions/daemon/worktree/allocateTree.ts
+function allocateTree(requestedCwd, boundTreeRoots2) {
+  if (!requestedCwd)
+    return { cwd: requestedCwd, kind: "primary", created: false };
+  const repoRoot = findRepoRoot(requestedCwd) ?? requestedCwd;
+  const cfg = worktreeConfigFor(repoRoot);
+  if (!cfg.enabled)
+    return { cwd: requestedCwd, kind: "primary", created: false };
+  const clone = mainWorktree(repoRoot) ?? repoRoot;
+  if (planAllocation(clone, boundTreeRoots2) === "primary")
+    return { cwd: clone, kind: "primary", created: false, clone };
+  const path71 = createWorktree(clone, cfg.root, boundTreeRoots2);
+  return { cwd: path71, kind: "worktree", created: true, clone };
+}
+
+// src/commands/sessions/daemon/worktree/spawnInTree.ts
+function allocateAndBind(ctx, cwd, create) {
+  const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions));
+  const id = ctx.spawnWith((sid) => create(sid, alloc.cwd));
+  bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify);
+  return id;
+}
+function spawnInTree(ctx, prompt, cwd, design, harness) {
+  return allocateAndBind(
+    ctx,
+    cwd,
+    (sid, resolvedCwd) => createSession(sid, prompt, resolvedCwd, design, harness)
+  );
+}
+function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
+  return allocateAndBind(
+    ctx,
+    cwd,
+    (sid, resolvedCwd) => createAssistSession(sid, assistArgs, resolvedCwd, meta)
+  );
+}
+function resumeInTree(ctx, sessionId, cwd, name) {
+  const id = ctx.spawnWith((sid) => resumeSession(sid, sessionId, cwd, name));
+  bindResumedWorktree(ctx.sessions.get(id), cwd, ctx.notify);
+  return id;
+}
+
 // src/commands/sessions/daemon/watchPromptSubmit.ts
 var CARRIAGE_RETURN = "\r";
 function isPromptSubmit(data) {
@@ -27744,6 +28356,8 @@ function writeToSession(sessions, id, data, onStatusChange) {
 function resizeSession(sessions, id, cols, rows) {
   const s = sessions.get(id);
   if (!s || s.status === "done" || !s.pty) return;
+  s.cols = cols;
+  s.rows = rows;
   try {
     s.pty.resize(cols, rows);
   } catch (error) {
@@ -27818,7 +28432,10 @@ var SessionManager = class {
     );
   }
   restore() {
-    return restoreAll(this.spawnWith, this.sessions);
+    const names = restoreAll(this.spawnWith, this.sessions);
+    reconcileWorktreesOnRestore(this.sessions);
+    rearmStoppedSessions(this.sessions, this.notify);
+    return names;
   }
   drain = () => drainSessions(this.sessions, this.notify);
   add(session) {
@@ -27828,10 +28445,15 @@ var SessionManager = class {
     return session.id;
   }
   spawnWith = (create) => this.add(create(sessionLimits.nextId(this.sessions.size, this.idCounter)));
+  treeCtx() {
+    return {
+      sessions: this.sessions,
+      spawnWith: this.spawnWith,
+      notify: this.notify
+    };
+  }
   spawn(prompt, cwd, design, harness) {
-    return this.spawnWith(
-      (id) => createSession(id, prompt, cwd, design, harness)
-    );
+    return spawnInTree(this.treeCtx(), prompt, cwd, design, harness);
   }
   spawnRun(runName, runArgs, cwd, meta) {
     return this.spawnWith(
@@ -27842,12 +28464,10 @@ var SessionManager = class {
     return liveServerRun(this.sessions, origin, excludeId);
   }
   spawnAssist(assistArgs, cwd, meta) {
-    return this.spawnWith(
-      (id) => createAssistSession(id, assistArgs, cwd, meta)
-    );
+    return spawnAssistInTree(this.treeCtx(), assistArgs, cwd, meta);
   }
   resume(sessionId, cwd, name) {
-    return this.spawnWith((id) => resumeSession(id, sessionId, cwd, name));
+    return resumeInTree(this.treeCtx(), sessionId, cwd, name);
   }
   onStatusChange = makeStatusChangeHandler(
     (id) => this.dismissSession(id),
@@ -27884,7 +28504,10 @@ var SessionManager = class {
     return result;
   }
   dismissSession = (id) => {
-    if (dismissSession(this.sessions, id)) this.notify();
+    dismissSessionGated(this.sessions, id, this.notify);
+  };
+  discardSession = (id) => {
+    dismissSessionGated(this.sessions, id, this.notify, true);
   };
   stopSession(id) {
     stopServerSession(this.sessions, id);
@@ -28165,6 +28788,7 @@ var messageHandlers = {
       sendTo(client, { type: "error", message: result.reason });
   }),
   dismiss: routed((_client, m, d) => m.dismissSession(d.sessionId)),
+  discard: routed((_client, m, d) => m.discardSession(d.sessionId)),
   stop: routed((_client, m, d) => m.stopSession(d.sessionId)),
   "set-autorun": routed(
     (_client, m, d) => m.setAutoRun(d.sessionId, d.enabled)
@@ -28326,7 +28950,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync26(daemonPaths.dir, { recursive: true });
+  mkdirSync27(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -28379,6 +29003,50 @@ function registerSetStatusCommand(cmd) {
   );
 }
 
+// src/commands/sessions/sessionsConfigHelp.ts
+var sessionsConfigHelp = [
+  {
+    key: "sessions.windowsProjectsRoot",
+    setter: "assist config set sessions.windowsProjectsRoot /mnt/c/Users/you/.claude/projects",
+    note: "WSL path to the Windows .claude/projects root to discover"
+  },
+  {
+    key: "sessions.windowsDaemonHost",
+    setter: "assist config set sessions.windowsDaemonHost 127.0.0.1",
+    note: "host the WSL daemon dials to reach the Windows daemon (default: 127.0.0.1)"
+  },
+  {
+    key: "sessions.windowsDaemonPort",
+    setter: "assist config set sessions.windowsDaemonPort 51764",
+    note: "TCP port the Windows daemon listens on (default: 51764)"
+  },
+  {
+    key: "sessions.windowsVersionCheck",
+    setter: "assist config set sessions.windowsVersionCheck block",
+    note: "Windows daemon version mismatch handling: block | warn | off"
+  },
+  {
+    key: "worktree.enabled",
+    setter: "assist config set worktree.enabled true --repo",
+    note: "opt in per repo: spill concurrent sessions into adjacent <clone>-N worktrees (default off)"
+  },
+  {
+    key: "worktree.root",
+    setter: "assist config set worktree.root ~/git --repo",
+    note: "optional; parent dir for <clone>-N worktrees (default: the clone's parent)"
+  },
+  {
+    key: "worktree.install",
+    setter: "assist config set worktree.install true --repo",
+    note: "per-worktree dep install: true auto-detects the package manager, or give an explicit command; false to skip"
+  },
+  {
+    key: "worktree.copy",
+    setter: "assist config set worktree.copy .env,.claude/settings.local.json --repo",
+    note: "gitignored files copied into a new worktree so it can build/run"
+  }
+];
+
 // src/commands/sessions/summarise/index.ts
 import * as fs41 from "fs";
 import chalk204 from "chalk";
@@ -28397,7 +29065,7 @@ function summaryPathFor(jsonlPath2) {
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
@@ -28421,7 +29089,7 @@ function summariseSession(jsonlPath2) {
   }
   const prompt = buildPrompt3(firstMessage, backlogIds);
   try {
-    const output = execFileSync12("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync13("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -28516,28 +29184,7 @@ function registerSessions(program2) {
   );
   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);
   registerSetStatusCommand(cmd);
-  configHelp(cmd, [
-    {
-      key: "sessions.windowsProjectsRoot",
-      setter: "assist config set sessions.windowsProjectsRoot /mnt/c/Users/you/.claude/projects",
-      note: "WSL path to the Windows .claude/projects root to discover"
-    },
-    {
-      key: "sessions.windowsDaemonHost",
-      setter: "assist config set sessions.windowsDaemonHost 127.0.0.1",
-      note: "host the WSL daemon dials to reach the Windows daemon (default: 127.0.0.1)"
-    },
-    {
-      key: "sessions.windowsDaemonPort",
-      setter: "assist config set sessions.windowsDaemonPort 51764",
-      note: "TCP port the Windows daemon listens on (default: 51764)"
-    },
-    {
-      key: "sessions.windowsVersionCheck",
-      setter: "assist config set sessions.windowsVersionCheck block",
-      note: "Windows daemon version mismatch handling: block | warn | off"
-    }
-  ]);
+  configHelp(cmd, sessionsConfigHelp);
 }
 
 // src/commands/statusLine.ts
@@ -28616,9 +29263,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync52, statSync as statSync11 } from "fs";
-import { isAbsolute as isAbsolute2, join as join70, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute2, join as join73, resolve as resolve17 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join70(cwd, ".git");
+  const dotGit = join73(cwd, ".git");
   let stat2;
   try {
     stat2 = statSync11(dotGit);
@@ -28648,7 +29295,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync52(join70(gitDir, "HEAD"), "utf8");
+    head = readFileSync52(join73(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }