@staff0rd/assist 0.444.1 → 0.446.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.444.1",
+  version: "0.446.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -121,7 +121,7 @@ var package_default = {
 };
 
 // src/commands/commit.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 
 // src/shared/resolveSessionItemId.ts
 var ITEM_ID_ENV = "ASSIST_BACKLOG_ITEM_ID";
@@ -435,6 +435,7 @@ var assistConfigSchema = z2.strictObject({
   repos: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional(),
   worktree: z2.strictObject({
     enabled: z2.boolean().default(false),
+    trunk: z2.boolean().default(false),
     root: z2.string().optional(),
     install: z2.union([z2.boolean(), z2.string()]).default(true),
     commitBeforeManualChecks: z2.boolean().default(false),
@@ -502,7 +503,8 @@ var assistConfigSchema = z2.strictObject({
     windowsDaemonHost: z2.string().optional(),
     // why: TCP port the native Windows daemon listens on for the WSL bridge; defaults to 51764
     windowsDaemonPort: z2.number().optional(),
-    windowsVersionCheck: z2.enum(["block", "warn", "off"]).default("block")
+    windowsVersionCheck: z2.enum(["block", "warn", "off"]).default("block"),
+    includeCommittedChanges: z2.boolean().default(false)
   }).optional(),
   database: z2.strictObject({
     url: z2.string().optional()
@@ -1782,17 +1784,49 @@ function git(args) {
   }
 }
 
-// src/commands/commit/stageAndCommit.ts
+// src/commands/commit/pushCommit.ts
 import { execSync as execSync5 } from "child_process";
+var HEADS_PREFIX = "refs/heads/";
+function pushCommit() {
+  const target = renamedUpstream();
+  const command = target ? `git push ${shellQuote(target.remote)} HEAD:${shellQuote(target.branch)}` : "git push";
+  execSync5(command, { stdio: "inherit" });
+}
+function renamedUpstream() {
+  const branch2 = gitOrNull("git symbolic-ref --short HEAD");
+  if (!branch2) return null;
+  const remote = gitOrNull(
+    `git config --get branch.${shellQuote(branch2)}.remote`
+  );
+  const merge = gitOrNull(
+    `git config --get branch.${shellQuote(branch2)}.merge`
+  );
+  if (!remote || !merge) return null;
+  const upstream = merge.startsWith(HEADS_PREFIX) ? merge.slice(HEADS_PREFIX.length) : merge;
+  return upstream === branch2 ? null : { remote, branch: upstream };
+}
+function gitOrNull(command) {
+  try {
+    return execSync5(command, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/commit/stageAndCommit.ts
+import { execSync as execSync6 } from "child_process";
 function commitStaged(message2) {
-  execSync5(`git commit -m ${shellQuote(message2)}`, { stdio: "inherit" });
-  return execSync5("git rev-parse --short=7 HEAD", {
+  execSync6(`git commit -m ${shellQuote(message2)}`, { stdio: "inherit" });
+  return execSync6("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
 }
 function stageAndCommit(files, message2) {
   const escaped = files.map(shellQuote).join(" ");
-  execSync5(`git add ${escaped}`, { stdio: "inherit" });
+  execSync6(`git add ${escaped}`, { stdio: "inherit" });
   return commitStaged(message2);
 }
 
@@ -1920,13 +1954,13 @@ async function execCommit(files, message2, config) {
     warnIfUnexpectedBranch(config);
     const pulled = Boolean(config.commit?.pull);
     if (pulled) {
-      execSync6("git pull --autostash", { stdio: "inherit" });
+      execSync7("git pull --autostash", { stdio: "inherit" });
     }
     abortOnConflicts(files, pulled);
     const sha = files.length > 0 ? stageAndCommit(files, message2) : commitStaged(message2);
     console.log(`Committed: ${sha}`);
     if (config.commit?.push) {
-      execSync6("git push", { stdio: "inherit" });
+      pushCommit();
       console.log("Pushed to remote");
     }
     await recordCommitActivity(message2);
@@ -1941,7 +1975,7 @@ async function recordCommitActivity(message2) {
 }
 async function commit(args) {
   if (args[0] === "status") {
-    execSync6("git status && echo '---DIFF---' && git diff", {
+    execSync7("git status && echo '---DIFF---' && git diff", {
       stdio: "inherit"
     });
     return;
@@ -1958,9 +1992,9 @@ async function commit(args) {
 }
 
 // src/commands/coverage.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 function coverage() {
-  const output = execSync7(
+  const output = execSync8(
     "npx vitest run --coverage --coverage.include='src/**/*.ts' --coverage.all --coverage.reporter=text 2>&1",
     { encoding: "utf8", timeout: 12e4 }
   );
@@ -2060,7 +2094,7 @@ function findPackageJsonWithVerifyScripts(startDir) {
 }
 
 // src/commands/verify/installPackage.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 import { writeFileSync as writeFileSync2 } from "fs";
 import chalk6 from "chalk";
 function writePackageJson(filePath, pkg) {
@@ -2079,7 +2113,7 @@ function addScript(pkg, name, command) {
 function installPackage(name, cwd) {
   console.log(chalk6.dim(`Installing ${name}...`));
   try {
-    execSync8(`npm install -D ${name}`, { stdio: "inherit", cwd });
+    execSync9(`npm install -D ${name}`, { stdio: "inherit", cwd });
     return true;
   } catch {
     console.error(chalk6.red(`Failed to install ${name}`));
@@ -2323,7 +2357,7 @@ import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync
 import chalk14 from "chalk";
 
 // src/shared/removeEslint/index.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 
 // src/shared/removeEslint/removeEslintConfigFiles.ts
@@ -2358,7 +2392,7 @@ function removeEslint(options2 = {}) {
   const removedConfigFiles = removeEslintConfigFiles();
   if (removedFromPackageJson || removedConfigFiles) {
     console.log("Running npm install...");
-    execSync9("npm install", { stdio: "inherit" });
+    execSync10("npm install", { stdio: "inherit" });
     return true;
   }
   return false;
@@ -3206,11 +3240,11 @@ function lint(options2 = {}) {
 }
 
 // src/commands/new/registerNew/newCli/index.ts
-import { execSync as execSync18 } from "child_process";
+import { execSync as execSync19 } from "child_process";
 import { basename as basename2, resolve as resolve5 } from "path";
 
 // src/commands/verify/blockCodeComments/findComments.ts
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import fs15 from "fs";
 import { minimatch } from "minimatch";
 import { Project as Project2 } from "ts-morph";
@@ -3470,7 +3504,7 @@ function shouldScan(file, ignoreGlobs) {
   return fs15.existsSync(file);
 }
 function findComments(options2) {
-  const diff3 = execSync10("git diff HEAD", {
+  const diff3 = execSync11("git diff HEAD", {
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
   });
@@ -3716,13 +3750,13 @@ Total: ${violations.length} forbidden string(s).`);
 }
 
 // src/commands/verify/hardcodedColors.ts
-import { execSync as execSync11 } from "child_process";
+import { execSync as execSync12 } from "child_process";
 import { minimatch as minimatch3 } from "minimatch";
 var pattern = "0x[0-9a-fA-F]{6}|#[0-9a-fA-F]{3,6}";
 function hardcodedColors() {
   const ignoreGlobs = loadConfig().hardcodedColors?.ignore ?? [];
   try {
-    const output = execSync11(`grep -rEnH '${pattern}' src/`, {
+    const output = execSync12(`grep -rEnH '${pattern}' src/`, {
       encoding: "utf8"
     });
     const lines = output.trim().split("\n").filter((line) => {
@@ -3983,14 +4017,14 @@ function listMigrationFiles(dir) {
 }
 
 // src/commands/verify/migrations/readBaselineMigrations.ts
-import { execSync as execSync12 } from "child_process";
+import { execSync as execSync13 } from "child_process";
 import { basename } from "path";
 var MIGRATION_FILE3 = /^migration\d+[A-Za-z0-9]*\.ts$/;
 function readBaselineMigrations(repoRelativeDir, ref) {
   const baseline = /* @__PURE__ */ new Map();
   let listing;
   try {
-    listing = execSync12(
+    listing = execSync13(
       `git ls-tree -r --name-only "${ref}" -- "${repoRelativeDir}"`,
       { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -4000,7 +4034,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path71) => MIGRATION_FILE3.test(basename(path71)));
   for (const path71 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path71}"`, {
+      const content = execSync13(`git show "${ref}:${path71}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
@@ -4013,10 +4047,10 @@ function readBaselineMigrations(repoRelativeDir, ref) {
 }
 
 // src/commands/verify/migrations/resolveBaselineRef.ts
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync14 } from "child_process";
 function refExists(ref) {
   try {
-    execSync13(`git rev-parse --verify --quiet "${ref}"`, {
+    execSync14(`git rev-parse --verify --quiet "${ref}"`, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     return true;
@@ -4088,10 +4122,10 @@ Total: ${problems.length} violation(s).`);
 }
 
 // src/commands/verify/noVenv.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 function noVenv() {
   try {
-    const output = execSync14(
+    const output = execSync15(
       "find . -type d -name venv -not -path '*/node_modules/*'",
       {
         encoding: "utf8"
@@ -4123,9 +4157,9 @@ Total: ${folders.length} venv folder(s)`);
 import { minimatch as minimatch4 } from "minimatch";
 
 // src/commands/verify/run/getChangedFiles.ts
-import { execSync as execSync15 } from "child_process";
+import { execSync as execSync16 } from "child_process";
 function getChangedFiles() {
-  const output = execSync15("git diff --name-only HEAD", {
+  const output = execSync16("git diff --name-only HEAD", {
     encoding: "utf8"
   }).trim();
   if (output === "") return [];
@@ -4297,25 +4331,25 @@ async function run(options2 = {}) {
 }
 
 // src/commands/new/registerNew/initGit.ts
-import { execSync as execSync16 } from "child_process";
+import { execSync as execSync17 } from "child_process";
 import { writeFileSync as writeFileSync10 } from "fs";
 function initGit() {
   console.log("Initializing git repository...");
-  execSync16("git init", { stdio: "inherit" });
+  execSync17("git init", { stdio: "inherit" });
   writeFileSync10(".gitignore", "dist\nnode_modules\n");
 }
 
 // src/commands/new/registerNew/newCli/initPackageJson.ts
-import { execSync as execSync17 } from "child_process";
+import { execSync as execSync18 } from "child_process";
 function initPackageJson(name) {
   console.log("Initializing package.json...");
-  execSync17("npm init -y", { stdio: "inherit" });
+  execSync18("npm init -y", { stdio: "inherit" });
   console.log("Configuring package.json...");
-  execSync17("npm pkg delete main", { stdio: "inherit" });
-  execSync17("npm pkg set type=module", { stdio: "inherit" });
-  execSync17(`npm pkg set bin.${name}=./dist/index.js`, { stdio: "inherit" });
-  execSync17("npm pkg set scripts.build=tsup", { stdio: "inherit" });
-  execSync17('npm pkg set scripts.start="node dist/index.js"', {
+  execSync18("npm pkg delete main", { stdio: "inherit" });
+  execSync18("npm pkg set type=module", { stdio: "inherit" });
+  execSync18(`npm pkg set bin.${name}=./dist/index.js`, { stdio: "inherit" });
+  execSync18("npm pkg set scripts.build=tsup", { stdio: "inherit" });
+  execSync18('npm pkg set scripts.start="node dist/index.js"', {
     stdio: "inherit"
   });
 }
@@ -4380,8 +4414,8 @@ async function newCli() {
   initGit();
   initPackageJson(name);
   console.log("Installing dependencies...");
-  execSync18("npm install commander", { stdio: "inherit" });
-  execSync18("npm install -D tsup typescript @types/node", {
+  execSync19("npm install commander", { stdio: "inherit" });
+  execSync19("npm install -D tsup typescript @types/node", {
     stdio: "inherit"
   });
   writeCliTemplate(name);
@@ -4390,11 +4424,11 @@ async function newCli() {
 }
 
 // src/commands/new/registerNew/newProject.ts
-import { execSync as execSync20 } from "child_process";
+import { execSync as execSync21 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync13 } from "fs";
 
 // src/commands/deploy/init/index.ts
-import { execSync as execSync19 } from "child_process";
+import { execSync as execSync20 } from "child_process";
 import chalk28 from "chalk";
 import enquirer3 from "enquirer";
 
@@ -4447,7 +4481,7 @@ Created ${WORKFLOW_PATH}`));
 // src/commands/deploy/init/index.ts
 async function ensureNetlifyCli() {
   try {
-    execSync19("netlify sites:create --disable-linking", { stdio: "inherit" });
+    execSync20("netlify sites:create --disable-linking", { stdio: "inherit" });
   } catch (error) {
     if (!(error instanceof Error) || !error.message.includes("command not found"))
       throw error;
@@ -4462,9 +4496,9 @@ async function ensureNetlifyCli() {
       process.exit(1);
     }
     console.log(chalk28.dim("\nInstalling netlify-cli...\n"));
-    execSync19("npm install -g netlify-cli", { stdio: "inherit" });
+    execSync20("npm install -g netlify-cli", { stdio: "inherit" });
     console.log();
-    execSync19("netlify sites:create --disable-linking", { stdio: "inherit" });
+    execSync20("netlify sites:create --disable-linking", { stdio: "inherit" });
   }
 }
 function printSetupInstructions() {
@@ -4507,7 +4541,7 @@ async function init6() {
 // src/commands/new/registerNew/newProject.ts
 async function newProject() {
   console.log("Initializing Vite with react-ts template...");
-  execSync20("npm create vite@latest . -- --template react-ts", {
+  execSync21("npm create vite@latest . -- --template react-ts", {
     stdio: "inherit"
   });
   initGit();
@@ -4698,11 +4732,11 @@ function activityChart(data, range) {
 }
 
 // src/commands/activity/fetchCommitsPerDay.ts
-import { execSync as execSync21 } from "child_process";
+import { execSync as execSync22 } from "child_process";
 function fetchContributions(from, to) {
   const query = `{ viewer { contributionsCollection(from: "${from}T00:00:00Z", to: "${to}T23:59:59Z") { contributionCalendar { weeks { contributionDays { date contributionCount } } } } } }`;
   const jq = ".data.viewer.contributionsCollection.contributionCalendar.weeks[].contributionDays[]";
-  const raw = execSync21(`gh api graphql -f query='${query}' --jq '${jq}'`, {
+  const raw = execSync22(`gh api graphql -f query='${query}' --jq '${jq}'`, {
     encoding: "utf8"
   }).trim();
   if (!raw) return [];
@@ -4789,10 +4823,10 @@ import { join as join10 } from "path";
 import chalk29 from "chalk";
 
 // src/commands/backup/readCrontab.ts
-import { execSync as execSync22 } from "child_process";
+import { execSync as execSync23 } from "child_process";
 function readCrontab() {
   try {
-    return execSync22("crontab -l", {
+    return execSync23("crontab -l", {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -4802,7 +4836,7 @@ function readCrontab() {
 }
 function writeCrontab(content) {
   try {
-    execSync22("crontab -", {
+    execSync23("crontab -", {
       input: content,
       stdio: ["pipe", "ignore", "pipe"]
     });
@@ -5143,7 +5177,7 @@ import chalk46 from "chalk";
 import enquirer5 from "enquirer";
 
 // src/shared/pullIfConfigured.ts
-import { execSync as execSync23 } from "child_process";
+import { execSync as execSync24 } from "child_process";
 import chalk32 from "chalk";
 function pullIfConfigured() {
   const config = loadConfig();
@@ -5157,7 +5191,7 @@ function pullIfConfigured() {
     return;
   }
   try {
-    execSync23("git pull --ff-only", { stdio: "inherit" });
+    execSync24("git pull --ff-only", { stdio: "inherit" });
   } catch {
     console.error(chalk32.red("git pull --ff-only failed; aborting."));
     process.exit(1);
@@ -5165,7 +5199,7 @@ function pullIfConfigured() {
 }
 function hasLocalChanges() {
   try {
-    const status3 = execSync23("git status --porcelain", {
+    const status3 = execSync24("git status --porcelain", {
       encoding: "utf8"
     });
     return status3.trim().length > 0;
@@ -5432,7 +5466,7 @@ function buildArgs(prompt, options2) {
 }
 
 // src/commands/branch/createBranch.ts
-import { execSync as execSync25 } from "child_process";
+import { execSync as execSync26 } from "child_process";
 
 // src/commands/branch/buildBranchName.ts
 function buildBranchName({
@@ -5448,12 +5482,12 @@ function buildBranchName({
 }
 
 // src/commands/branch/resolveDefaultBranch.ts
-import { execSync as execSync24 } from "child_process";
+import { execSync as execSync25 } from "child_process";
 var REMOTE_HEAD_REGEX = /^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m;
 function resolveDefaultBranch(override, cwd) {
   if (override) return override;
   try {
-    const output = execSync24("git ls-remote --symref origin HEAD", {
+    const output = execSync25("git ls-remote --symref origin HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
       cwd
@@ -5477,11 +5511,11 @@ async function createBranch({
     jira,
     slug
   });
-  execSync25("git fetch", { stdio: "inherit" });
+  execSync26("git fetch", { stdio: "inherit" });
   let baseRef;
   if (from) {
     try {
-      execSync25(`git rev-parse --verify ${shellQuote(from)}`, {
+      execSync26(`git rev-parse --verify ${shellQuote(from)}`, {
         stdio: ["pipe", "pipe", "pipe"]
       });
     } catch {
@@ -5491,7 +5525,7 @@ async function createBranch({
   } else {
     baseRef = `origin/${resolveDefaultBranch(config.branch?.defaultBranch)}`;
   }
-  execSync25(`git switch -c ${shellQuote(branchName)} ${shellQuote(baseRef)}`, {
+  execSync26(`git switch -c ${shellQuote(branchName)} ${shellQuote(baseRef)}`, {
     stdio: "inherit"
   });
   await recordBranchActivity(branchName);
@@ -5631,11 +5665,11 @@ function backupLocalBacklogFiles(dir) {
 }
 
 // src/commands/backlog/gitPullBacklog.ts
-import { execSync as execSync26 } from "child_process";
+import { execSync as execSync27 } from "child_process";
 import chalk35 from "chalk";
 function gitPullBacklog(dir) {
   try {
-    execSync26("git pull --ff-only", {
+    execSync27("git pull --ff-only", {
       cwd: dir,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -7925,7 +7959,7 @@ import chalk61 from "chalk";
 import { WebSocketServer } from "ws";
 
 // src/shared/getInstallDir.ts
-import { execSync as execSync27 } from "child_process";
+import { execSync as execSync28 } from "child_process";
 import { dirname as dirname18, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
@@ -7935,7 +7969,7 @@ function getInstallDir() {
 }
 function isGitRepo(dir) {
   try {
-    const result = execSync27("git rev-parse --show-toplevel", {
+    const result = execSync28("git rev-parse --show-toplevel", {
       cwd: dir,
       stdio: "pipe"
     }).toString().trim();
@@ -7952,11 +7986,11 @@ import {
 import chalk57 from "chalk";
 
 // src/lib/openBrowser.ts
-import { execSync as execSync28 } from "child_process";
+import { execSync as execSync29 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync28(cmd, { stdio: "ignore" });
+      execSync29(cmd, { stdio: "ignore" });
       return true;
     } catch {
     }
@@ -8188,7 +8222,7 @@ function git2(cwd, args) {
     });
   });
 }
-async function gitOrNull(cwd, args) {
+async function gitOrNull2(cwd, args) {
   try {
     return (await git2(cwd, args)).trim() || null;
   } catch {
@@ -8847,6 +8881,61 @@ function getCwdParam(req, res) {
   return cwd;
 }
 
+// src/commands/sessions/web/windowsCwdToWslPath.ts
+function windowsCwdToWslPath(cwd) {
+  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
+  if (!match) return cwd;
+  const drive = match[1].toLowerCase();
+  const rest = match[2].replace(/\\/g, "/");
+  return `/mnt/${drive}/${rest}`;
+}
+
+// src/commands/sessions/web/toGitCwd.ts
+function toGitCwd(cwd) {
+  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
+}
+
+// src/commands/sessions/web/resolveDiffBase.ts
+function baseCandidates(defaultBranch) {
+  return [
+    defaultBranch && `origin/${defaultBranch}`,
+    defaultBranch,
+    "origin/main",
+    "origin/master",
+    "main",
+    "master"
+  ].filter((candidate) => Boolean(candidate));
+}
+async function refExists2(cwd, ref) {
+  try {
+    await execGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveDiffBase(cwd) {
+  let defaultBranch;
+  try {
+    const config = loadConfigFrom(toGitCwd(cwd));
+    if (!config.sessions?.includeCommittedChanges) return "HEAD";
+    defaultBranch = config.branch?.defaultBranch;
+  } catch {
+    return "HEAD";
+  }
+  for (const candidate of baseCandidates(defaultBranch)) {
+    if (!await refExists2(cwd, candidate)) continue;
+    try {
+      const base = await execGit(cwd, ["merge-base", "HEAD", candidate]);
+      const sha = base.trim();
+      if (sha) return sha;
+    } catch {
+    }
+    return "HEAD";
+  }
+  return "HEAD";
+}
+
 // src/commands/sessions/web/diff.ts
 var MAX_DIFF_BYTES = 50 * 1024 * 1024;
 async function untrackedFileDiff(cwd, path71) {
@@ -8871,7 +8960,8 @@ async function diff2(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const tracked = await execGit(cwd, ["diff", "HEAD"], {
+    const base = await resolveDiffBase(cwd);
+    const tracked = await execGit(cwd, ["diff", base], {
       maxBuffer: MAX_DIFF_BYTES
     });
     const untracked = await untrackedDiff(cwd);
@@ -8886,22 +8976,6 @@ async function diff2(req, res) {
 // src/commands/sessions/web/fileContent.ts
 import { readFile, stat as stat2 } from "fs/promises";
 import { isAbsolute, relative as relative2, resolve as resolve9 } from "path";
-
-// src/commands/sessions/web/windowsCwdToWslPath.ts
-function windowsCwdToWslPath(cwd) {
-  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
-  if (!match) return cwd;
-  const drive = match[1].toLowerCase();
-  const rest = match[2].replace(/\\/g, "/");
-  return `/mnt/${drive}/${rest}`;
-}
-
-// src/commands/sessions/web/toGitCwd.ts
-function toGitCwd(cwd) {
-  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
-}
-
-// src/commands/sessions/web/fileContent.ts
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 function resolveWithinCwd(cwd, path71) {
   const root = resolve9(toGitCwd(cwd));
@@ -9098,13 +9172,44 @@ function githubUrl(req, res) {
   });
 }
 
+// src/commands/sessions/web/parseDiffNameStatus.ts
+function categorize(code) {
+  switch (code) {
+    case "A":
+    case "C":
+      return "new";
+    case "D":
+      return "deleted";
+    case "M":
+    case "R":
+    case "T":
+    case "U":
+      return "modified";
+    default:
+      return null;
+  }
+}
+function parseDiffNameStatus(output) {
+  const result = { new: [], modified: [], deleted: [] };
+  for (const line of output.split("\n")) {
+    const fields = line.split("	");
+    const status3 = fields[0];
+    if (!status3 || fields.length < 2) continue;
+    const category = categorize(status3[0]);
+    if (!category) continue;
+    const path71 = fields[fields.length - 1];
+    if (path71) result[category].push(path71);
+  }
+  return result;
+}
+
 // src/commands/sessions/web/parseGitStatus.ts
 function extractPath(rest) {
   const arrow = rest.indexOf(" -> ");
   return arrow === -1 ? rest : rest.slice(arrow + 4);
 }
 var UNMERGED_STATES = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
-function categorize(xy) {
+function categorize2(xy) {
   if (xy === "??") return "new";
   if (UNMERGED_STATES.has(xy)) return "modified";
   const codes = xy.replace(/ /g, "");
@@ -9119,23 +9224,45 @@ function parseGitStatus(output) {
   const result = { new: [], modified: [], deleted: [] };
   for (const line of output.split("\n")) {
     if (line.length < 4) continue;
-    const category = categorize(line.slice(0, 2));
+    const category = categorize2(line.slice(0, 2));
     if (category) result[category].push(extractPath(line.slice(3)));
   }
   return result;
 }
 
 // src/commands/sessions/web/gitStatus.ts
+async function untrackedPaths(cwd) {
+  const list5 = await execGit(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  return list5.split("\n").filter(Boolean);
+}
+async function branchCounts(cwd, base) {
+  const output = await execGit(cwd, ["diff", "--name-status", base]);
+  const counts = parseDiffNameStatus(output);
+  counts.new.push(...await untrackedPaths(cwd));
+  return counts;
+}
+async function workingTreeCounts(cwd) {
+  const output = await execGit(cwd, [
+    "status",
+    "--porcelain",
+    "--untracked-files=all"
+  ]);
+  return parseGitStatus(output);
+}
 async function gitStatus(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const output = await execGit(cwd, [
-      "status",
-      "--porcelain",
-      "--untracked-files=all"
-    ]);
-    respondJson(res, 200, parseGitStatus(output));
+    const base = await resolveDiffBase(cwd);
+    respondJson(
+      res,
+      200,
+      base === "HEAD" ? await workingTreeCounts(cwd) : await branchCounts(cwd, base)
+    );
   } catch {
     respondJson(res, 200, { new: [], modified: [], deleted: [] });
   }
@@ -9146,7 +9273,7 @@ import * as os3 from "os";
 import * as path25 from "path";
 
 // src/shared/checkCliAvailable.ts
-import { execSync as execSync29 } from "child_process";
+import { execSync as execSync30 } from "child_process";
 function checkCliAvailable(cli) {
   const binary = cli.split(/\s+/)[0];
   const opts = {
@@ -9154,11 +9281,11 @@ function checkCliAvailable(cli) {
     stdio: ["ignore", "pipe", "pipe"]
   };
   try {
-    execSync29(`command -v ${binary}`, opts);
+    execSync30(`command -v ${binary}`, opts);
     return true;
   } catch {
     try {
-      execSync29(`where ${binary}`, opts);
+      execSync30(`where ${binary}`, opts);
       return true;
     } catch {
       return false;
@@ -9249,8 +9376,8 @@ function subsequenceScore(text17, query) {
 function scoreFilePath(path71, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename18 = path71.slice(path71.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename18, needle);
+  const basename19 = path71.slice(path71.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename19, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
   return subsequenceScore(path71, needle);
 }
@@ -10561,13 +10688,13 @@ async function beginAssociation(id, options2, clearPatch, label2) {
 }
 
 // src/commands/backlog/associate-github/fetchGithubIssueTitle.ts
-import { execSync as execSync30 } from "child_process";
+import { execSync as execSync31 } from "child_process";
 function fetchGithubIssueTitle(issue) {
   const match = /^([^/]+)\/([^#]+)#(\d+)$/.exec(issue);
   if (!match) return void 0;
   const [, owner, repo, number] = match;
   try {
-    const result = execSync30(
+    const result = execSync31(
       `gh issue view ${number} -R ${owner}/${repo} --json title`,
       { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
     );
@@ -10634,12 +10761,12 @@ import chalk66 from "chalk";
 import { eq as eq19 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
-import { execSync as execSync31 } from "child_process";
+import { execSync as execSync32 } from "child_process";
 import chalk65 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
-    result = execSync31(
+    result = execSync32(
       `acli jira workitem view ${issueKey} -f ${fields} --json`,
       { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -14721,10 +14848,10 @@ function formatResultLine(entry, failing) {
 }
 
 // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
-import { execSync as execSync32 } from "child_process";
+import { execSync as execSync33 } from "child_process";
 import path28 from "path";
 function git3(command) {
-  return execSync32(command, { encoding: "utf8" });
+  return execSync33(command, { encoding: "utf8" });
 }
 function toAbsolute(root, repoRelative) {
   return path28.resolve(root, repoRelative);
@@ -15298,7 +15425,7 @@ function loadBlogSkipDays(repoName) {
 }
 
 // src/commands/devlog/shared.ts
-import { execSync as execSync33 } from "child_process";
+import { execSync as execSync34 } from "child_process";
 import chalk134 from "chalk";
 
 // src/shared/getRepoName.ts
@@ -15390,7 +15517,7 @@ function loadAllDevlogLatestDates() {
 // src/commands/devlog/shared.ts
 function getCommitFiles(hash) {
   try {
-    const output = execSync33(`git show --name-only --format="" ${hash}`, {
+    const output = execSync34(`git show --name-only --format="" ${hash}`, {
       encoding: "utf8"
     });
     return output.trim().split("\n").filter(Boolean);
@@ -15486,11 +15613,11 @@ function list3(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execFileSync as execFileSync4, execSync as execSync34 } from "child_process";
+import { execFileSync as execFileSync4, execSync as execSync35 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
-    const content = execSync34(`git show ${hash}:package.json`, {
+    const content = execSync35(`git show ${hash}:package.json`, {
       encoding: "utf8"
     });
     const pkg = JSON.parse(content);
@@ -15663,7 +15790,7 @@ function next2(options2) {
 }
 
 // src/commands/devlog/repos/index.ts
-import { execSync as execSync35 } from "child_process";
+import { execSync as execSync36 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
 import chalk138 from "chalk";
@@ -15698,7 +15825,7 @@ function getStatus(lastPush, lastDevlog) {
   return lastDevlog < lastPush ? "outdated" : "ok";
 }
 function fetchRepos(days, all) {
-  const json = execSync35(
+  const json = execSync36(
     "gh repo list staff0rd --json name,pushedAt,isArchived --limit 200",
     { encoding: "utf8" }
   );
@@ -16078,7 +16205,7 @@ async function deps(csprojPath, options2) {
 }
 
 // src/commands/dotnet/getChangedCsFiles.ts
-import { execSync as execSync36 } from "child_process";
+import { execSync as execSync37 } from "child_process";
 var SCOPE_ALL = "all";
 var SCOPE_BASE = "base:";
 var SCOPE_COMMIT = "commit:";
@@ -16102,7 +16229,7 @@ function getChangedCsFiles(scope) {
   } else {
     cmd = "git diff --name-only HEAD";
   }
-  const output = execSync36(cmd, { encoding: "utf8" }).trim();
+  const output = execSync37(cmd, { encoding: "utf8" }).trim();
   if (output === "") return [];
   return output.split("\n").filter((f) => f.toLowerCase().endsWith(".cs"));
 }
@@ -16300,14 +16427,14 @@ function parseInspectReport(json) {
 }
 
 // src/commands/dotnet/runInspectCode.ts
-import { execSync as execSync37 } from "child_process";
+import { execSync as execSync38 } from "child_process";
 import { existsSync as existsSync40, readFileSync as readFileSync35, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import path35 from "path";
 import chalk148 from "chalk";
 function assertJbInstalled() {
   try {
-    execSync37("jb inspectcode --version", { stdio: "pipe" });
+    execSync38("jb inspectcode --version", { stdio: "pipe" });
   } catch {
     console.error(chalk148.red("jb is not installed. Install with:"));
     console.error(
@@ -16321,7 +16448,7 @@ function runInspectCode(slnPath, include, swea) {
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
-    execSync37(
+    execSync38(
       `jb inspectcode "${slnPath}" -o="${reportPath}"${includeFlag}${sweaFlag} --verbosity=OFF`,
       { stdio: "pipe" }
     );
@@ -16342,7 +16469,7 @@ function runInspectCode(slnPath, include, swea) {
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
-import { execSync as execSync38 } from "child_process";
+import { execSync as execSync39 } from "child_process";
 import chalk149 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
@@ -16353,7 +16480,7 @@ function resolveMsbuildPath() {
 function assertMsbuildInstalled() {
   const msbuild = resolveMsbuildPath();
   try {
-    execSync38(`"${msbuild}" -version`, { stdio: "pipe" });
+    execSync39(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
     console.error(chalk149.red(`msbuild not found at: ${msbuild}`));
     console.error(
@@ -16379,7 +16506,7 @@ function runRoslynInspect(slnPath) {
   const msbuild = resolveMsbuildPath();
   let output;
   try {
-    output = execSync38(
+    output = execSync39(
       `"${msbuild}" "${slnPath}" -t:Build -v:minimal -maxcpucount -p:EnforceCodeStyleInBuild=true -p:RunAnalyzersDuringBuild=true 2>&1`,
       { encoding: "utf8", stdio: "pipe", maxBuffer: 50 * 1024 * 1024 }
     );
@@ -17226,7 +17353,7 @@ function acceptanceCriteria(issueKey) {
 }
 
 // src/commands/jira/jiraAuth.ts
-import { execSync as execSync39 } from "child_process";
+import { execSync as execSync40 } from "child_process";
 
 // src/shared/promptInput.ts
 import Enquirer from "enquirer";
@@ -17261,7 +17388,7 @@ async function jiraAuth() {
       console.error("All fields are required.");
       process.exit(1);
     }
-    execSync39(`acli jira auth login --site ${site} --email "${email}" --token`, {
+    execSync40(`acli jira auth login --site ${site} --email "${email}" --token`, {
       encoding: "utf8",
       input: token,
       stdio: ["pipe", "inherit", "inherit"]
@@ -17352,71 +17479,434 @@ function registerRefineLaunch(program2, resumeFlag) {
 }
 
 // src/commands/reviewPrComments.ts
-import { execFileSync as execFileSync6 } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
+
+// src/commands/review/checkoutPr.ts
+import { execFileSync as execFileSync6 } from "child_process";
 import chalk155 from "chalk";
-async function reviewPrComments(number) {
-  if (number) {
-    try {
-      execFileSync6("gh", ["pr", "checkout", number], { stdio: "inherit" });
-    } catch {
-      console.error(chalk155.red(`gh pr checkout ${number} failed; aborting.`));
-      process.exit(1);
-    }
+
+// src/commands/sessions/daemon/daemonLog.ts
+var RING_CAPACITY = 1e3;
+var ring = [];
+var sink;
+function daemonLog(message2) {
+  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`);
+}
+function relayDaemonLog(line) {
+  emit3(`[windows] ${line}`);
+}
+function emit3(line) {
+  console.log(line);
+  ring.push(line);
+  if (ring.length > RING_CAPACITY) ring.shift();
+  sink?.(line);
+}
+function setDaemonLogSink(next3) {
+  sink = next3;
+}
+function recentDaemonLogLines() {
+  return [...ring];
+}
+
+// src/commands/sessions/daemon/worktree/createWorktree.ts
+import { existsSync as existsSync43 } from "fs";
+import { basename as basename12, dirname as dirname23 } from "path";
+
+// src/commands/sessions/daemon/worktree/planAllocation.ts
+import { basename as basename11, join as join46 } from "path";
+function planAllocation(clone, boundTreeRoots2) {
+  return boundTreeRoots2.has(clone) ? "spill" : "primary";
+}
+function nextWorktreePath(clone, base, isTaken) {
+  const name = basename11(clone);
+  for (let n = 2; n < 1e3; n++) {
+    const candidate = join46(base, `${name}-${n}`);
+    if (!isTaken(candidate)) return candidate;
   }
-  const claudeSessionId = randomUUID4();
-  emitActivity({
-    kind: "command",
-    name: "review-pr-comments",
-    claudeSessionId
-  });
-  const { done: done2 } = spawnClaude("/review-pr-comments", {
-    permissionMode: "acceptEdits",
-    sessionId: claudeSessionId
-  });
-  await done2;
+  throw new Error(`no free worktree suffix for ${clone}`);
 }
 
-// src/commands/registerLaunch.ts
-var RESUME_SESSION_FLAG = "Resume an interrupted Claude session (used by the sessions daemon on restart)";
-function registerNext(program2) {
-  program2.command("next").argument("[id]", "Backlog item ID to run first").description("Alias for backlog next").option("--once", "Exit after the first completed item run").action(
-    (id, opts) => next({ allowEdits: true, once: opts.once }, id)
-  );
+// src/commands/sessions/daemon/worktree/worktreeStartPoint.ts
+function worktreeStartPoint(clone, trunk) {
+  const branch2 = trunk ? cloneTrunkBranch(clone) : remoteDefaultBranch(clone);
+  const ref = `origin/${branch2}`;
+  if (gitSyncOrNull(clone, ["rev-parse", "--verify", "--quiet", ref]))
+    return { ref, track: trunk };
+  return { ref: "HEAD", track: false };
 }
-function registerDescriptionLaunch(program2, name, slashCommand, description, alias) {
-  const command = program2.command(name).argument(
-    "[description]",
-    `Text to forward to the /${slashCommand} slash command`
-  ).description(description).option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
-    (text17, opts) => launchMode(slashCommand, {
-      once: opts.once,
-      description: text17,
-      resumeSessionId: opts.resumeSession
-    })
-  );
-  if (alias) command.alias(alias);
+function cloneTrunkBranch(clone) {
+  return cloneHead(clone) ?? remoteDefaultBranch(clone);
 }
-function registerReviewPrComments(program2) {
-  program2.command("review-pr-comments").argument("[number]", "PR number to check out first").description("Launch Claude in /review-pr-comments mode (single session)").action((number) => reviewPrComments(number));
+function remoteDefaultBranch(clone) {
+  const head = gitSyncOrNull(clone, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (!head) return cloneHead(clone) ?? "main";
+  const slash = head.indexOf("/");
+  return slash === -1 ? head : head.slice(slash + 1);
 }
-function registerLaunch(program2) {
-  registerNext(program2);
-  registerDescriptionLaunch(
-    program2,
-    "draft",
-    "draft",
-    "Launch Claude in /draft mode, chain into next on /next signal",
-    "feat"
+function cloneHead(clone) {
+  return gitSyncOrNull(clone, ["symbolic-ref", "--short", "HEAD"]);
+}
+
+// src/commands/sessions/daemon/worktree/createWorktree.ts
+function createWorktree(clone, strategy, boundTreeRoots2) {
+  const base = strategy.root ? expandTilde2(strategy.root) : dirname23(clone);
+  const registered = new Set(listWorktreePaths(clone));
+  const branches = new Set(listLocalBranches(clone));
+  const path71 = nextWorktreePath(
+    clone,
+    base,
+    (candidate) => registered.has(candidate) || existsSync43(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename12(candidate))
   );
-  registerDescriptionLaunch(
-    program2,
-    "bug",
-    "bug",
-    "Launch Claude in /bug mode, chain into next on /next signal"
+  const start3 = worktreeStartPoint(clone, strategy.trunk);
+  gitSync(clone, [
+    "worktree",
+    "add",
+    start3.track ? "--track" : "--no-track",
+    "-b",
+    basename12(path71),
+    path71,
+    start3.ref
+  ]);
+  recordWorktree(path71, clone, getCurrentOrigin(clone));
+  daemonLog(
+    start3.track ? `worktree allocated ${path71} (branch ${basename12(path71)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path71} (branch ${basename12(path71)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  registerReviewPrComments(program2);
-  registerRefineLaunch(program2, RESUME_SESSION_FLAG);
+  return path71;
+}
+
+// src/commands/sessions/daemon/worktree/treeDurability.ts
+import { existsSync as existsSync44 } from "fs";
+function treeDurability(state) {
+  if (state.dirty) return { durable: false, reason: "uncommitted changes" };
+  if (state.localOnlyCommits)
+    return { durable: false, reason: "unpushed commits" };
+  return { durable: true };
+}
+function* durabilityProbes() {
+  const status3 = yield ["status", "--porcelain"];
+  if (!status3.ok)
+    return { durable: false, reason: `tree state unreadable: ${status3.error}` };
+  const upstream = yield [
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{upstream}"
+  ];
+  let localOnlyCommits;
+  if (upstream.ok && upstream.out) {
+    const ahead = yield ["rev-list", "--count", "@{upstream}..HEAD"];
+    localOnlyCommits = !ahead.ok || Number(ahead.out) > 0;
+  } else {
+    const remoteBranches = yield ["branch", "-r", "--contains", "HEAD"];
+    localOnlyCommits = !remoteBranches.ok || remoteBranches.out === "";
+  }
+  return treeDurability({ dirty: status3.out !== "", localOnlyCommits });
+}
+async function checkDurability(cwd) {
+  if (!existsSync44(cwd)) return { durable: true };
+  const probes = durabilityProbes();
+  let step = probes.next();
+  while (!step.done) step = probes.next(await gitResult(cwd, step.value));
+  return step.value;
+}
+function checkDurabilitySync(cwd) {
+  if (!existsSync44(cwd)) return { durable: true };
+  const probes = durabilityProbes();
+  let step = probes.next();
+  while (!step.done) step = probes.next(gitSyncResult(cwd, step.value));
+  return step.value;
+}
+
+// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
+var DISABLED = {
+  enabled: false,
+  trunk: false,
+  install: true,
+  commitBeforeManualChecks: false,
+  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/allocateTree.ts
+function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
+  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" && !wouldDisturbWorkInProgress(clone, options2.forCheckout === true))
+    return { cwd: clone, kind: "primary", created: false, clone };
+  const path71 = createWorktree(
+    clone,
+    { root: cfg.root, trunk: cfg.trunk },
+    boundTreeRoots2
+  );
+  return { cwd: path71, kind: "worktree", created: true, clone };
+}
+function wouldDisturbWorkInProgress(clone, forCheckout) {
+  if (!forCheckout) return false;
+  const durability = checkDurabilitySync(clone);
+  if (durability.durable) return false;
+  daemonLog(
+    `tree ${clone} not used for a PR checkout: ${durability.reason} \u2014 spilling to a worktree`
+  );
+  return true;
+}
+
+// src/commands/sessions/daemon/persistedSessionSchema.ts
+import { z as z6 } from "zod";
+var persistedSessionSchema = z6.object({
+  name: z6.string(),
+  title: z6.string().optional(),
+  subtitle: z6.string().optional(),
+  commandType: z6.enum(["claude", "run", "assist"]),
+  harness: z6.enum(["claude", "codex", "pi"]).optional(),
+  status: z6.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
+  cwd: z6.string(),
+  startedAt: z6.number(),
+  runningMs: z6.number().optional(),
+  claudeSessionId: z6.string().optional(),
+  initialPrompt: z6.string().optional(),
+  runName: z6.string().optional(),
+  runArgs: z6.array(z6.string()).optional(),
+  assistArgs: z6.array(z6.string()).optional(),
+  activity: activitySchema.optional(),
+  starred: z6.boolean().optional(),
+  undurable: z6.object({ reason: z6.string(), removesTree: z6.boolean().optional() }).optional()
+});
+
+// src/commands/sessions/daemon/toPersistedSession.ts
+function toPersistedSession(session) {
+  return {
+    name: session.name,
+    title: session.title,
+    subtitle: session.subtitle,
+    commandType: session.commandType,
+    harness: session.harness,
+    status: session.status,
+    cwd: session.cwd ?? process.cwd(),
+    startedAt: session.startedAt,
+    runningMs: accumulatedRunningMs(session),
+    claudeSessionId: session.claudeSessionId,
+    initialPrompt: session.initialPrompt,
+    runName: session.runName,
+    runArgs: session.runArgs,
+    assistArgs: session.assistArgs,
+    activity: session.activity,
+    starred: session.starred,
+    undurable: session.undurable
+  };
+}
+function accumulatedRunningMs(session) {
+  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
+}
+
+// src/commands/sessions/daemon/loadPersistedSessions.ts
+var SESSIONS_FILE = "sessions.json";
+function loadPersistedSessions() {
+  const data = loadJson(SESSIONS_FILE);
+  if (!Array.isArray(data)) return [];
+  return data.flatMap((entry) => {
+    const parsed = persistedSessionSchema.safeParse(entry);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function savePersistedSessions(sessions) {
+  saveJson(SESSIONS_FILE, sessions);
+}
+function persistLiveSessions(sessions) {
+  const live = [...sessions.values()].filter(
+    (s) => (s.pty || s.status === "stopped") && s.status !== "done"
+  );
+  savePersistedSessions(live.map(toPersistedSession));
+  logPersist(live);
+}
+var lastPersistSignature = "";
+function logPersist(live) {
+  const signature = live.map((s) => `${s.id}:${s.status}`).join(",");
+  if (signature === lastPersistSignature) return;
+  lastPersistSignature = signature;
+  daemonLog(
+    live.length > 0 ? `persisted ${live.length} session(s): ${live.map((s) => s.name).join(", ")}` : "persisted 0 sessions (sessions.json cleared)"
+  );
+}
+
+// src/commands/sessions/daemon/worktree/persistedTreeRoots.ts
+function persistedTreeRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  for (const { cwd } of loadPersistedSessions()) {
+    if (cwd) roots.add(findRepoRoot(cwd) ?? cwd);
+  }
+  return roots;
+}
+
+// src/commands/sessions/daemon/worktree/seedWorktree.ts
+import { execFile as execFile8 } from "child_process";
+import { copyFileSync, existsSync as existsSync46, mkdirSync as mkdirSync16 } from "fs";
+import { dirname as dirname24, join as join48 } from "path";
+
+// src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
+import { existsSync as existsSync45 } from "fs";
+import { join as join47 } from "path";
+function detectInstallCommand(repoRoot) {
+  if (!existsSync45(join47(repoRoot, "package.json"))) return null;
+  if (existsSync45(join47(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync45(join47(repoRoot, "yarn.lock"))) return "yarn install";
+  if (existsSync45(join47(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, onSeeded = () => {
+}) {
+  const cfg = worktreeConfigFor(clone);
+  copyConfigFiles(worktreePath, clone, cfg.copy);
+  runInstall(worktreePath, clone, cfg.install, onSeeded);
+}
+function copyConfigFiles(worktreePath, clone, copy) {
+  for (const rel of copy) {
+    const src = join48(clone, rel);
+    if (!existsSync46(src)) continue;
+    const dest = join48(worktreePath, rel);
+    try {
+      mkdirSync16(dirname24(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, onSeeded) {
+  const command = resolveInstallCommand(clone, install);
+  if (!command) {
+    onSeeded();
+    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`
+    );
+    onSeeded();
+  });
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/review/moveToPrCheckoutTree.ts
+function placedByDaemon() {
+  return process.env.ASSIST_SESSION === "1";
+}
+function seed(worktreePath, clone) {
+  console.log(`Preparing ${worktreePath}\u2026`);
+  return new Promise(
+    (resolve20) => seedWorktree(worktreePath, clone, resolve20)
+  );
+}
+async function moveToPrCheckoutTree() {
+  if (placedByDaemon()) return;
+  const from = process.cwd();
+  const alloc = allocateTree(from, persistedTreeRoots(), {
+    forCheckout: true
+  });
+  if (!alloc.cwd || alloc.cwd === from) return;
+  process.chdir(alloc.cwd);
+  console.log(`Checking the PR out in ${alloc.cwd}`);
+  appendDaemonLog(`pr checkout placed in ${alloc.cwd} (invoked from ${from})`);
+  if (alloc.created && alloc.clone) await seed(alloc.cwd, alloc.clone);
+}
+
+// src/commands/review/checkoutPr.ts
+async function checkoutPr(number) {
+  await moveToPrCheckoutTree();
+  try {
+    execFileSync6("gh", ["pr", "checkout", number], { stdio: "inherit" });
+  } catch {
+    console.error(chalk155.red(`gh pr checkout ${number} failed; aborting.`));
+    process.exit(1);
+  }
+}
+
+// src/commands/reviewPrComments.ts
+async function reviewPrComments(number) {
+  if (number) await checkoutPr(number);
+  const claudeSessionId = randomUUID4();
+  emitActivity({
+    kind: "command",
+    name: "review-pr-comments",
+    claudeSessionId
+  });
+  const { done: done2 } = spawnClaude("/review-pr-comments", {
+    permissionMode: "acceptEdits",
+    sessionId: claudeSessionId
+  });
+  await done2;
+}
+
+// src/commands/registerLaunch.ts
+var RESUME_SESSION_FLAG = "Resume an interrupted Claude session (used by the sessions daemon on restart)";
+function registerNext(program2) {
+  program2.command("next").argument("[id]", "Backlog item ID to run first").description("Alias for backlog next").option("--once", "Exit after the first completed item run").action(
+    (id, opts) => next({ allowEdits: true, once: opts.once }, id)
+  );
+}
+function registerDescriptionLaunch(program2, name, slashCommand, description, alias) {
+  const command = program2.command(name).argument(
+    "[description]",
+    `Text to forward to the /${slashCommand} slash command`
+  ).description(description).option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
+    (text17, opts) => launchMode(slashCommand, {
+      once: opts.once,
+      description: text17,
+      resumeSessionId: opts.resumeSession
+    })
+  );
+  if (alias) command.alias(alias);
+}
+function registerReviewPrComments(program2) {
+  program2.command("review-pr-comments").argument("[number]", "PR number to check out first").description("Launch Claude in /review-pr-comments mode (single session)").action((number) => reviewPrComments(number));
+}
+function registerLaunch(program2) {
+  registerNext(program2);
+  registerDescriptionLaunch(
+    program2,
+    "draft",
+    "draft",
+    "Launch Claude in /draft mode, chain into next on /next signal",
+    "feat"
+  );
+  registerDescriptionLaunch(
+    program2,
+    "bug",
+    "bug",
+    "Launch Claude in /bug mode, chain into next on /next signal"
+  );
+  registerReviewPrComments(program2);
+  registerRefineLaunch(program2, RESUME_SESSION_FLAG);
 }
 
 // src/commands/registerList.ts
@@ -17431,13 +17921,13 @@ function registerList(program2) {
 }
 
 // src/commands/mermaid/index.ts
-import { mkdirSync as mkdirSync16, readdirSync as readdirSync9 } from "fs";
+import { mkdirSync as mkdirSync17, readdirSync as readdirSync9 } from "fs";
 import { resolve as resolve13 } from "path";
 import chalk158 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync37, writeFileSync as writeFileSync31 } from "fs";
-import { basename as basename11, extname as extname2, resolve as resolve12 } from "path";
+import { basename as basename13, extname as extname2, resolve as resolve12 } from "path";
 import chalk157 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -17464,7 +17954,7 @@ async function renderBlock(krokiUrl, source) {
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   const content = readFileSync37(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename11(file, extname2(file));
+  const stem = basename13(file, extname2(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -17500,7 +17990,7 @@ function extractMermaidBlocks(markdown) {
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
   const outDir = resolve13(process.cwd(), options2.out ?? ".");
-  mkdirSync16(outDir, { recursive: true });
+  mkdirSync17(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
@@ -17547,7 +18037,7 @@ function registerMermaid(program2) {
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname24 } from "path";
+import { dirname as dirname26 } from "path";
 import chalk160 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
@@ -17626,15 +18116,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join47 } from "path";
+import { join as join50 } from "path";
 import chalk159 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname23, join as join46 } from "path";
+import { dirname as dirname25, join as join49 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-var moduleDir = dirname23(fileURLToPath6(import.meta.url));
+var moduleDir = dirname25(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
-  return join46(moduleDir, "commands", "netcap", "netcap-extension");
+  return join49(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -17649,7 +18139,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join47(dir, "background.js");
+  const file = join50(dir, "background.js");
   const source = await readFile3(file, "utf8");
   await writeFile3(
     file,
@@ -17689,20 +18179,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute2, join as join49, resolve as resolve14 } from "path";
+import { isAbsolute as isAbsolute2, join as join52, resolve as resolve14 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir19 } from "os";
-import { join as join48 } from "path";
+import { join as join51 } from "path";
 function defaultCapturePath() {
-  return join48(homedir19(), ".assist", "netcap", "capture.jsonl");
+  return join51(homedir19(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute2(out) ? out : resolve14(process.cwd(), out);
-  return join49(dir, "capture.jsonl");
+  return join52(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -17710,7 +18200,7 @@ async function netcap(options2) {
   const port = Number(options2.port);
   const outPath = resolveNetcapOutPath(options2.out);
   const filter = options2.filter ?? "";
-  await mkdir4(dirname24(outPath), { recursive: true });
+  await mkdir4(dirname26(outPath), { recursive: true });
   const extensionPath = await prepareExtensionForLoad(port, filter);
   let count7 = 0;
   const handler = createNetcapHandler({
@@ -17749,7 +18239,7 @@ netcap stopped \u2014 captured ${count7} ${count7 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync32 } from "fs";
-import { join as join50 } from "path";
+import { join as join53 } from "path";
 import chalk161 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
@@ -18194,7 +18684,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join50(captureFile, "..", "posts.json");
+  const outFile = join53(captureFile, "..", "posts.json");
   writeFileSync32(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -18346,7 +18836,7 @@ function registerPrompts(program2) {
 }
 
 // src/commands/prs/shared.ts
-import { execSync as execSync40 } from "child_process";
+import { execSync as execSync41 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -18364,12 +18854,12 @@ function getRepoInfo() {
   const preferred = getPreferredRemoteRepo();
   if (preferred) return preferred;
   const repoInfo = JSON.parse(
-    execSync40("gh repo view --json owner,name", { encoding: "utf8" })
+    execSync41("gh repo view --json owner,name", { encoding: "utf8" })
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
 function getCurrentBranch2() {
-  return execSync40("git rev-parse --abbrev-ref HEAD", {
+  return execSync41("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -18377,7 +18867,7 @@ function viewCurrentPr(fields) {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch2();
   return JSON.parse(
-    execSync40(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
+    execSync41(`gh pr view ${branch2} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf8"
     })
   );
@@ -18679,24 +19169,24 @@ function edit(options2) {
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync43 } from "child_process";
+import { execSync as execSync44 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync42 } from "child_process";
+import { execSync as execSync43 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync33 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join52 } from "path";
+import { join as join55 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync43, readFileSync as readFileSync39, unlinkSync as unlinkSync13 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync39, unlinkSync as unlinkSync13 } from "fs";
+import { join as join54 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join51(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join54(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (!existsSync43(cachePath)) {
+  if (!existsSync47(cachePath)) {
     return null;
   }
   const content = readFileSync39(cachePath, "utf8");
@@ -18704,16 +19194,16 @@ function loadCommentsCache(prNumber) {
 }
 function deleteCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
-  if (existsSync43(cachePath)) {
+  if (existsSync47(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
 }
 
 // src/commands/prs/replyToComment.ts
-import { execSync as execSync41 } from "child_process";
+import { execSync as execSync42 } from "child_process";
 function replyToComment(org, repo, prNumber, commentId, message2) {
-  execSync41(
+  execSync42(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message2.replace(/"/g, String.raw`\"`)}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
@@ -18722,10 +19212,10 @@ function replyToComment(org, repo, prNumber, commentId, message2) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join52(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join55(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync33(queryFile, mutation);
   try {
-    execSync42(
+    execSync43(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
@@ -18777,7 +19267,7 @@ function resolveCommentWithReply(commentId, message2) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync43(`git rev-parse --verify ${sha}`, {
+    return execSync44(`git rev-parse --verify ${sha}`, {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -18791,7 +19281,7 @@ function fixed(commentId, sha) {
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
     const message2 = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
-    execSync43("git push", { stdio: "inherit" });
+    pushCommit();
     resolveCommentWithReply(commentId, message2);
   } catch (error) {
     if (isGhNotInstalled(error)) {
@@ -18804,21 +19294,21 @@ function fixed(commentId, sha) {
 }
 
 // src/commands/prs/listComments/index.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync17, writeFileSync as writeFileSync35 } from "fs";
-import { join as join54 } from "path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync18, writeFileSync as writeFileSync35 } from "fs";
+import { join as join57 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync44 } from "child_process";
+import { execSync as execSync45 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync34 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join53 } from "path";
+import { join as join56 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join53(tmpdir7(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join56(tmpdir7(), `gh-query-${Date.now()}.graphql`);
   writeFileSync34(queryFile, THREAD_QUERY);
   try {
-    const result = execSync44(
+    const result = execSync45(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf8" }
     );
@@ -18840,9 +19330,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync45 } from "child_process";
+import { execSync as execSync46 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync45(`gh api --paginate ${endpoint}`, {
+  const result = execSync46(`gh api --paginate ${endpoint}`, {
     encoding: "utf8"
   });
   if (!result.trim()) return [];
@@ -18929,16 +19419,16 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join54(process.cwd(), ".assist");
-  if (!existsSync44(assistDir)) {
-    mkdirSync17(assistDir, { recursive: true });
+  const assistDir = join57(process.cwd(), ".assist");
+  if (!existsSync48(assistDir)) {
+    mkdirSync18(assistDir, { recursive: true });
   }
   const cacheData = {
     prNumber,
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join54(assistDir, `pr-${prNumber}-comments.yaml`);
+  const cachePath = join57(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync35(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
@@ -18971,7 +19461,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join54(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join57(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -18981,7 +19471,7 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync46 } from "child_process";
+import { execSync as execSync47 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer9 from "enquirer";
@@ -19088,7 +19578,7 @@ async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
     const { org, repo } = getRepoInfo();
-    const result = execSync46(
+    const result = execSync47(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100 -R ${org}/${repo}`,
       { encoding: "utf8" }
     );
@@ -19159,16 +19649,16 @@ function buildCreateArgs(title, body, options2) {
 }
 
 // src/commands/prs/readSessionPrRef.ts
-import { execSync as execSync47 } from "child_process";
+import { execSync as execSync48 } from "child_process";
 function readSessionPrRef() {
   try {
-    const branch2 = execSync47("git rev-parse --abbrev-ref HEAD", {
+    const branch2 = execSync48("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!branch2 || branch2 === "HEAD") return null;
     const pr = JSON.parse(
-      execSync47(`gh pr view ${branch2} --json number,title,url,state`, {
+      execSync48(`gh pr view ${branch2} --json number,title,url,state`, {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       })
@@ -19296,7 +19786,7 @@ function reply(commentId, body) {
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync48 } from "child_process";
+import { execSync as execSync49 } from "child_process";
 function validateReason(reason2) {
   const lowerReason = reason2.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -19313,7 +19803,7 @@ function validateShaReferences(reason2) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync48(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync49(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -19590,10 +20080,10 @@ import chalk168 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync49 } from "child_process";
+import { execSync as execSync50 } from "child_process";
 import chalk167 from "chalk";
 function opExec(args) {
-  return execSync49(`op ${args}`, {
+  return execSync50(`op ${args}`, {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -19745,7 +20235,7 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync50 } from "child_process";
+import { execSync as execSync51 } from "child_process";
 import chalk172 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
@@ -19753,7 +20243,7 @@ function resolveOpSecret(reference) {
     process.exit(1);
   }
   try {
-    return execSync50(`op read "${reference}"`, {
+    return execSync51(`op read "${reference}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -20017,7 +20507,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync51 } from "child_process";
+import { execSync as execSync52 } from "child_process";
 import fs25 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
@@ -20067,7 +20557,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync51("git diff --cached --name-only", {
+    const staged = execSync52("git diff --cached --name-only", {
       encoding: "utf8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -20075,7 +20565,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync51("git diff --name-only", { encoding: "utf8" });
+    const unstaged = execSync52("git diff --name-only", { encoding: "utf8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -21342,8 +21832,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename18 = path52.basename(file, path52.extname(file));
-    if (basename18 === "index") continue;
+    const basename19 = path52.basename(file, path52.extname(file));
+    if (basename19 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -21649,9 +22139,6 @@ function registerRefactor(program2) {
   registerRestructure(refactorCommand);
 }
 
-// src/commands/review/review.ts
-import { execFileSync as execFileSync9 } from "child_process";
-
 // src/commands/review/annotateDiffWithLineNumbers.ts
 var FILE_HEADER2 = /^\+\+\+ (?:b\/)?(.+)$/;
 var HUNK_HEADER2 = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
@@ -21766,28 +22253,28 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir20 } from "os";
-import { basename as basename12, join as join55 } from "path";
+import { basename as basename14, join as join58 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join55(
+  const reviewDir = join58(
     homedir20(),
     ".assist",
     "reviews",
-    basename12(repoRoot),
+    basename14(repoRoot),
     key
   );
   return {
     reviewDir,
-    requestPath: join55(reviewDir, "request.md"),
-    claudePath: join55(reviewDir, "claude.md"),
-    codexPath: join55(reviewDir, "codex.md"),
-    synthesisPath: join55(reviewDir, "synthesis.md")
+    requestPath: join58(reviewDir, "request.md"),
+    claudePath: join58(reviewDir, "claude.md"),
+    codexPath: join58(reviewDir, "codex.md"),
+    synthesisPath: join58(reviewDir, "synthesis.md")
   };
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync52 } from "child_process";
+import { execSync as execSync53 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync52(
+  const out = execSync53(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -21818,14 +22305,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync55 } from "child_process";
+import { execSync as execSync56 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync53 } from "child_process";
+import { execSync as execSync54 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync53(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync54(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -21840,19 +22327,19 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync53(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync54(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync53(`git diff ${baseSha}...${headSha}`, {
+  return execSync54(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
 // src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync54 } from "child_process";
+import { execSync as execSync55 } from "child_process";
 function getCurrentBranch3() {
-  return execSync54("git rev-parse --abbrev-ref HEAD", {
+  return execSync55("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
 }
@@ -21860,7 +22347,7 @@ function fetchPrDiffInfo() {
   const { org, repo } = getRepoInfo();
   const branch2 = getCurrentBranch3();
   const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
-  const raw = execSync54(
+  const raw = execSync55(
     `gh pr list --state open --head ${branch2} --json ${fields} -R ${org}/${repo}`,
     {
       encoding: "utf8",
@@ -21885,7 +22372,7 @@ function fetchPrDiffInfo() {
 }
 function fetchPrChangedFiles(prNumber) {
   const { org, repo } = getRepoInfo();
-  const out = execSync54(
+  const out = execSync55(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
     {
       encoding: "utf8",
@@ -21897,11 +22384,11 @@ function fetchPrChangedFiles(prNumber) {
 
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch2 = execSync55("git rev-parse --abbrev-ref HEAD", {
+  const branch2 = execSync56("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf8"
   }).trim();
-  const sha = execSync55("git rev-parse HEAD", { encoding: "utf8" }).trim();
-  const shortSha = execSync55("git rev-parse --short=7 HEAD", {
+  const sha = execSync56("git rev-parse HEAD", { encoding: "utf8" }).trim();
+  const shortSha = execSync56("git rev-parse --short=7 HEAD", {
     encoding: "utf8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -22319,14 +22806,14 @@ async function handlePostSynthesis(synthesisPath, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync18, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync19, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
   for (const path71 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync45(path71)) unlinkSync16(path71);
+    if (existsSync49(path71)) unlinkSync16(path71);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
-  mkdirSync18(paths.reviewDir, { recursive: true });
+  mkdirSync19(paths.reviewDir, { recursive: true });
   if (force) clearReviewFiles(paths);
   writeFileSync36(paths.requestPath, requestBody);
 }
@@ -22607,7 +23094,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync47, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync51, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -23027,7 +23514,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync46, unlinkSync as unlinkSync17 } from "fs";
+import { existsSync as existsSync50, unlinkSync as unlinkSync17 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -23079,7 +23566,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync46(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync50(spec.outputPath)) {
     unlinkSync17(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -23225,7 +23712,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync47(paths.synthesisPath)) {
+  if (anyFresh && existsSync51(paths.synthesisPath)) {
     unlinkSync18(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -23346,20 +23833,13 @@ function validateOptions(options2) {
     process.exit(1);
   }
 }
-function checkoutPr(number) {
-  try {
-    execFileSync9("gh", ["pr", "checkout", number], { stdio: "inherit" });
-  } catch {
-    console.error(`gh pr checkout ${number} failed; aborting.`);
-    process.exit(1);
-  }
-}
 async function review(options2 = {}) {
   validateOptions(options2);
-  const repoRoot = resolveRepoRoot();
+  const invokedIn = resolveRepoRoot();
   emitActivity({ kind: "command", name: "review" });
-  if (options2.number) checkoutPr(options2.number);
-  await reviewPr(repoRoot, options2);
+  if (!options2.number) return reviewPr(invokedIn, options2);
+  await checkoutPr(options2.number);
+  return reviewPr(resolveRepoRoot(), options2);
 }
 
 // src/commands/registerReview.ts
@@ -24105,27 +24585,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync48, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync52, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join59 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync48(vttDir)) return;
+  if (!existsSync52(vttDir)) return;
   for (const entry of readdirSync10(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync8(join56(vttDir, entry)).isDirectory()) continue;
+    if (statSync8(join59(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync49,
-  mkdirSync as mkdirSync19,
+  existsSync as existsSync53,
+  mkdirSync as mkdirSync20,
   readFileSync as readFileSync42,
   renameSync as renameSync2,
   writeFileSync as writeFileSync38
 } from "fs";
-import { basename as basename13, join as join57 } from "path";
+import { basename as basename15, join as join60 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text17) {
@@ -24338,9 +24818,9 @@ function convertVttToMarkdown(inputPath) {
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join57(vttDir, "processed");
-  mkdirSync19(processedDir, { recursive: true });
-  renameSync2(sourcePath, join57(processedDir, filename));
+  const processedDir = join60(vttDir, "processed");
+  mkdirSync20(processedDir, { recursive: true });
+  renameSync2(sourcePath, join60(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -24349,20 +24829,20 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename13(file);
-  const sourcePath = join57(vttDir, filename);
-  if (!existsSync49(sourcePath)) {
+  const filename = basename15(file);
+  const sourcePath = join60(vttDir, filename);
+  if (!existsSync53(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename13(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename15(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join57(transcriptsDir, client);
-  mkdirSync19(formattedDir, { recursive: true });
-  const formattedPath = join57(formattedDir, outputName);
+  const formattedDir = join60(transcriptsDir, client);
+  mkdirSync20(formattedDir, { recursive: true });
+  const formattedPath = join60(formattedDir, outputName);
   writeFileSync38(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join57(summaryDir, client, outputName);
+  const summaryPath = join60(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -24482,45 +24962,45 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { join as join59 } from "path";
+import { join as join62 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir21 } from "os";
-import { dirname as dirname26, join as join58 } from "path";
+import { dirname as dirname28, join as join61 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
-var __dirname5 = dirname26(fileURLToPath7(import.meta.url));
-var VOICE_DIR = join58(homedir21(), ".assist", "voice");
+var __dirname5 = dirname28(fileURLToPath7(import.meta.url));
+var VOICE_DIR = join61(homedir21(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join58(VOICE_DIR, "voice.pid"),
-  log: join58(VOICE_DIR, "voice.log"),
-  venv: join58(VOICE_DIR, ".venv"),
-  lock: join58(VOICE_DIR, "voice.lock")
+  pid: join61(VOICE_DIR, "voice.pid"),
+  log: join61(VOICE_DIR, "voice.log"),
+  venv: join61(VOICE_DIR, ".venv"),
+  lock: join61(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join58(__dirname5, "commands", "voice", "python");
+  return join61(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join58(voicePaths.venv, "Scripts", "python.exe") : join58(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join61(voicePaths.venv, "Scripts", "python.exe") : join61(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join58(getLockDir(), "voice.lock");
+  return join61(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join59(getPythonDir(), "list_devices.py");
+  const script = join62(getPythonDir(), "list_devices.py");
   spawnSync6(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync50, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync54, readFileSync as readFileSync43 } from "fs";
 function logs(options2) {
-  if (!existsSync50(voicePaths.log)) {
+  if (!existsSync54(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -24547,13 +25027,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { mkdirSync as mkdirSync21 } from "fs";
-import { join as join61 } from "path";
+import { mkdirSync as mkdirSync22 } from "fs";
+import { join as join64 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync56 } from "child_process";
-import { existsSync as existsSync51, mkdirSync as mkdirSync20, readFileSync as readFileSync44, writeFileSync as writeFileSync39 } from "fs";
-import { join as join60 } from "path";
+import { execSync as execSync57 } from "child_process";
+import { existsSync as existsSync55, mkdirSync as mkdirSync21, readFileSync as readFileSync44, writeFileSync as writeFileSync39 } from "fs";
+import { join as join63 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -24564,7 +25044,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync51(lockFile)) return;
+  if (!existsSync55(lockFile)) return;
   try {
     const lock2 = JSON.parse(readFileSync44(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
@@ -24577,10 +25057,10 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync51(getVenvPython())) return;
+  if (existsSync55(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync56(
+  execSync57(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -24590,7 +25070,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync20(join60(lockFile, ".."), { recursive: true });
+  mkdirSync21(join63(lockFile, ".."), { recursive: true });
   writeFileSync39(
     lockFile,
     JSON.stringify({
@@ -24603,10 +25083,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync21(voicePaths.dir, { recursive: true });
+  mkdirSync22(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join61(getPythonDir(), "setup_models.py");
+  const script = join64(getPythonDir(), "setup_models.py");
   const result = spawnSync7(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -24619,8 +25099,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdirSync as mkdirSync22, writeFileSync as writeFileSync40 } from "fs";
-import { join as join62 } from "path";
+import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync40 } from "fs";
+import { join as join65 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -24653,12 +25133,12 @@ function spawnBackground(python, script, env) {
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync22(voicePaths.dir, { recursive: true });
+  mkdirSync23(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join62(getPythonDir(), "voice_daemon.py");
+  const script = join65(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -24668,7 +25148,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync52, readFileSync as readFileSync45 } from "fs";
+import { existsSync as existsSync56, readFileSync as readFileSync45 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -24678,12 +25158,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count7) {
-  if (!existsSync52(voicePaths.log)) return [];
+  if (!existsSync56(voicePaths.log)) return [];
   const lines = readFileSync45(voicePaths.log, "utf8").trim().split("\n");
   return lines.slice(-count7);
 }
 function status2() {
-  if (!existsSync52(voicePaths.pid)) {
+  if (!existsSync56(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -24706,9 +25186,9 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync53, readFileSync as readFileSync46, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync46, unlinkSync as unlinkSync19 } from "fs";
 function stop2() {
-  if (!existsSync53(voicePaths.pid)) {
+  if (!existsSync57(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -24725,7 +25205,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync53(lockFile)) unlinkSync19(lockFile);
+    if (existsSync57(lockFile)) unlinkSync19(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -24947,9 +25427,9 @@ async function auth() {
 }
 
 // src/commands/roam/postRoamActivity.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 import { readdirSync as readdirSync11, readFileSync as readFileSync47, statSync as statSync9 } from "fs";
-import { join as join63 } from "path";
+import { join as join66 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -24958,7 +25438,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path71 = join63(roamDir, name);
+    const path71 = join66(roamDir, name);
     try {
       return { path: path71, mtimeMs: statSync9(path71).mtimeMs };
     } catch {
@@ -24970,7 +25450,7 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join63(appData, "Roam"));
+  const portFile = findPortFile(join66(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -24980,7 +25460,7 @@ function postRoamActivity(app, event) {
   }
   const url = `http://127.0.0.1:${port}/api/v1/activity/${app}/${event}?pid=${app === "codex" ? 99998 : 99999}`;
   try {
-    execFileSync10("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
+    execFileSync9("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
       stdio: "ignore"
     });
   } catch {
@@ -25188,11 +25668,11 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync57 } from "child_process";
+import { execSync as execSync58 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync57(cmd, { stdio: "inherit", cwd });
+      execSync58(cmd, { stdio: "inherit", cwd });
     } catch (error) {
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
@@ -25201,16 +25681,16 @@ function runPreCommands(pre, cwd) {
 }
 
 // src/commands/run/spawnRunCommand.ts
-import { execFileSync as execFileSync11, spawn as spawn8 } from "child_process";
-import { existsSync as existsSync54 } from "fs";
-import { dirname as dirname27, join as join64, resolve as resolve15 } from "path";
+import { execFileSync as execFileSync10, spawn as spawn8 } from "child_process";
+import { existsSync as existsSync58 } from "fs";
+import { dirname as dirname29, join as join67, resolve as resolve15 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync11("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve15(dirname27(gitPath), "..");
-    const gitBash = join64(gitRoot, "bin", "bash.exe");
-    if (existsSync54(gitBash)) return gitBash;
+    const gitPath = execFileSync10("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitRoot = resolve15(dirname29(gitPath), "..");
+    const gitBash = join67(gitRoot, "bin", "bash.exe");
+    if (existsSync58(gitBash)) return gitBash;
   } catch {
   }
   return command;
@@ -25297,8 +25777,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync41 } from "fs";
-import { join as join65 } from "path";
+import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync41 } from "fs";
+import { join as join68 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -25359,15 +25839,15 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join65(".claude", "commands");
-  mkdirSync23(dir, { recursive: true });
+  const dir = join68(".claude", "commands");
+  mkdirSync24(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join65(dir, `${name}.md`);
+  const filePath = join68(dir, `${name}.md`);
   writeFileSync41(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -25423,8 +25903,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync55, unlinkSync as unlinkSync20 } from "fs";
-import { join as join66 } from "path";
+import { existsSync as existsSync59, unlinkSync as unlinkSync20 } from "fs";
+import { join as join69 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -25439,8 +25919,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join66(".claude", "commands", `${name}.md`);
-  if (existsSync55(filePath)) {
+  const filePath = join69(".claude", "commands", `${name}.md`);
+  if (existsSync59(filePath)) {
     unlinkSync20(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -25493,10 +25973,10 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync56, mkdirSync as mkdirSync24, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
+import { execSync as execSync59 } from "child_process";
+import { existsSync as existsSync60, mkdirSync as mkdirSync25, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join67, resolve as resolve17 } from "path";
+import { join as join70, resolve as resolve17 } from "path";
 import chalk206 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -25626,17 +26106,17 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync56(outputDir)) {
-    mkdirSync24(outputDir, { recursive: true });
+  if (!existsSync60(outputDir)) {
+    mkdirSync25(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve17(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join67(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join70(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync42(scriptPath, captureWindowPs1, "utf8");
   try {
-    execSync58(
+    execSync59(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" }
     );
@@ -25660,11 +26140,11 @@ function screenshot(processName) {
 }
 
 // src/commands/sessions/daemon/listDaemonPids.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function listDaemonPids() {
   if (process.platform === "win32") return [];
   try {
-    const out = execFileSync12("ps", ["-eo", "pid=,args="], {
+    const out = execFileSync11("ps", ["-eo", "pid=,args="], {
       encoding: "utf8"
     });
     return out.split("\n").filter((line) => line.includes("assist") && / daemon run\b/.test(line)).map((line) => Number.parseInt(line.trim(), 10)).filter((pid) => Number.isInteger(pid));
@@ -25709,163 +26189,62 @@ function applyLine(result, pending, line) {
   }
 }
 
-// src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync48 } from "fs";
-function reportStolenSocket(socketPid) {
-  if (!socketPid) return;
-  const filePid = readPidFile();
-  if (filePid === void 0 || filePid === socketPid) return;
-  console.error(
-    `Warning: daemon.pid records PID ${filePid} but the socket is owned by PID ${socketPid} (stolen socket)`
-  );
-}
-function readPidFile() {
-  try {
-    const pid = Number.parseInt(
-      readFileSync48(daemonPaths.pid, "utf8").trim(),
-      10
-    );
-    return Number.isInteger(pid) ? pid : void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/commands/sessions/daemon/daemonStatus.ts
-async function daemonStatus() {
-  let socket;
-  try {
-    socket = await connectToDaemon();
-  } catch {
-    console.log("Sessions daemon is not running");
-    reportStrays(listDaemonPids());
-    return;
-  }
-  const { pid, sessions } = await queryDaemon(socket);
-  socket.destroy();
-  console.log(`Sessions daemon is running${pid ? ` (PID ${pid})` : ""}`);
-  reportStolenSocket(pid);
-  reportStrays(listDaemonPids().filter((p) => p !== pid));
-  if (sessions.length === 0) {
-    console.log("No sessions");
-    return;
-  }
-  for (const session of sessions) {
-    const restored = session.restored === false ? " (not restored)" : "";
-    console.log(`  [${session.status}] ${session.name}${restored}`);
-  }
-}
-function reportStrays(pids) {
-  if (pids.length === 0) return;
-  console.error(
-    `Warning: stray daemon process(es) detected: ${pids.join(", ")}`
-  );
-}
-
-// src/commands/sessions/daemon/drainDaemon.ts
-import { createInterface as createInterface6 } from "readline";
-
-// src/commands/sessions/daemon/daemonLog.ts
-var RING_CAPACITY = 1e3;
-var ring = [];
-var sink;
-function daemonLog(message2) {
-  emit3(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message2}`);
-}
-function relayDaemonLog(line) {
-  emit3(`[windows] ${line}`);
-}
-function emit3(line) {
-  console.log(line);
-  ring.push(line);
-  if (ring.length > RING_CAPACITY) ring.shift();
-  sink?.(line);
-}
-function setDaemonLogSink(next3) {
-  sink = next3;
-}
-function recentDaemonLogLines() {
-  return [...ring];
-}
-
-// src/commands/sessions/daemon/persistedSessionSchema.ts
-import { z as z6 } from "zod";
-var persistedSessionSchema = z6.object({
-  name: z6.string(),
-  title: z6.string().optional(),
-  subtitle: z6.string().optional(),
-  commandType: z6.enum(["claude", "run", "assist"]),
-  harness: z6.enum(["claude", "codex", "pi"]).optional(),
-  status: z6.enum(["running", "waiting", "done", "error", "stopped"]).optional(),
-  cwd: z6.string(),
-  startedAt: z6.number(),
-  runningMs: z6.number().optional(),
-  claudeSessionId: z6.string().optional(),
-  initialPrompt: z6.string().optional(),
-  runName: z6.string().optional(),
-  runArgs: z6.array(z6.string()).optional(),
-  assistArgs: z6.array(z6.string()).optional(),
-  activity: activitySchema.optional(),
-  starred: z6.boolean().optional(),
-  undurable: z6.object({ reason: z6.string(), removesTree: z6.boolean().optional() }).optional()
-});
-
-// src/commands/sessions/daemon/toPersistedSession.ts
-function toPersistedSession(session) {
-  return {
-    name: session.name,
-    title: session.title,
-    subtitle: session.subtitle,
-    commandType: session.commandType,
-    harness: session.harness,
-    status: session.status,
-    cwd: session.cwd ?? process.cwd(),
-    startedAt: session.startedAt,
-    runningMs: accumulatedRunningMs(session),
-    claudeSessionId: session.claudeSessionId,
-    initialPrompt: session.initialPrompt,
-    runName: session.runName,
-    runArgs: session.runArgs,
-    assistArgs: session.assistArgs,
-    activity: session.activity,
-    starred: session.starred,
-    undurable: session.undurable
-  };
-}
-function accumulatedRunningMs(session) {
-  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
-}
-
-// src/commands/sessions/daemon/loadPersistedSessions.ts
-var SESSIONS_FILE = "sessions.json";
-function loadPersistedSessions() {
-  const data = loadJson(SESSIONS_FILE);
-  if (!Array.isArray(data)) return [];
-  return data.flatMap((entry) => {
-    const parsed = persistedSessionSchema.safeParse(entry);
-    return parsed.success ? [parsed.data] : [];
-  });
+// src/commands/sessions/daemon/reportStolenSocket.ts
+import { readFileSync as readFileSync48 } from "fs";
+function reportStolenSocket(socketPid) {
+  if (!socketPid) return;
+  const filePid = readPidFile();
+  if (filePid === void 0 || filePid === socketPid) return;
+  console.error(
+    `Warning: daemon.pid records PID ${filePid} but the socket is owned by PID ${socketPid} (stolen socket)`
+  );
 }
-function savePersistedSessions(sessions) {
-  saveJson(SESSIONS_FILE, sessions);
+function readPidFile() {
+  try {
+    const pid = Number.parseInt(
+      readFileSync48(daemonPaths.pid, "utf8").trim(),
+      10
+    );
+    return Number.isInteger(pid) ? pid : void 0;
+  } catch {
+    return void 0;
+  }
 }
-function persistLiveSessions(sessions) {
-  const live = [...sessions.values()].filter(
-    (s) => (s.pty || s.status === "stopped") && s.status !== "done"
-  );
-  savePersistedSessions(live.map(toPersistedSession));
-  logPersist(live);
+
+// src/commands/sessions/daemon/daemonStatus.ts
+async function daemonStatus() {
+  let socket;
+  try {
+    socket = await connectToDaemon();
+  } catch {
+    console.log("Sessions daemon is not running");
+    reportStrays(listDaemonPids());
+    return;
+  }
+  const { pid, sessions } = await queryDaemon(socket);
+  socket.destroy();
+  console.log(`Sessions daemon is running${pid ? ` (PID ${pid})` : ""}`);
+  reportStolenSocket(pid);
+  reportStrays(listDaemonPids().filter((p) => p !== pid));
+  if (sessions.length === 0) {
+    console.log("No sessions");
+    return;
+  }
+  for (const session of sessions) {
+    const restored = session.restored === false ? " (not restored)" : "";
+    console.log(`  [${session.status}] ${session.name}${restored}`);
+  }
 }
-var lastPersistSignature = "";
-function logPersist(live) {
-  const signature = live.map((s) => `${s.id}:${s.status}`).join(",");
-  if (signature === lastPersistSignature) return;
-  lastPersistSignature = signature;
-  daemonLog(
-    live.length > 0 ? `persisted ${live.length} session(s): ${live.map((s) => s.name).join(", ")}` : "persisted 0 sessions (sessions.json cleared)"
+function reportStrays(pids) {
+  if (pids.length === 0) return;
+  console.error(
+    `Warning: stray daemon process(es) detected: ${pids.join(", ")}`
   );
 }
 
+// src/commands/sessions/daemon/drainDaemon.ts
+import { createInterface as createInterface6 } from "readline";
+
 // src/commands/sessions/daemon/clearPersistedSessionsOnDrain.ts
 function clearPersistedSessionsOnDrain() {
   const held = loadPersistedSessions().filter((s) => s.status === "stopped");
@@ -26213,7 +26592,7 @@ function readDesignSystemPrompt() {
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync57, statSync as statSync10 } from "fs";
+import { chmodSync, existsSync as existsSync61, statSync as statSync10 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path59 from "path";
 var require4 = createRequire3(import.meta.url);
@@ -26228,7 +26607,7 @@ function ensureSpawnHelperExecutable() {
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync57(helper)) return;
+  if (!existsSync61(helper)) return;
   const mode = statSync10(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -26387,7 +26766,8 @@ function otherTreeHolders(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync62 } from "fs";
+import { basename as basename16 } from "path";
 
 // src/commands/sessions/daemon/worktree/removeTree.ts
 async function removeTree(clone, worktreePath, force) {
@@ -26424,63 +26804,9 @@ function reason(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync58 } from "fs";
-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 };
-}
-function* durabilityProbes(cwd) {
-  const status3 = yield ["status", "--porcelain"];
-  if (!status3.ok)
-    return { durable: false, reason: `tree state unreadable: ${status3.error}` };
-  const upstream = yield [
-    "rev-parse",
-    "--abbrev-ref",
-    "--symbolic-full-name",
-    "@{upstream}"
-  ];
-  let localOnlyCommits;
-  if (upstream.ok && upstream.out) {
-    const ahead = yield ["rev-list", "--count", "@{upstream}..HEAD"];
-    localOnlyCommits = !ahead.ok || Number(ahead.out) > 0;
-  } else {
-    const remoteBranches = yield ["branch", "-r", "--contains", "HEAD"];
-    localOnlyCommits = !remoteBranches.ok || remoteBranches.out === "";
-  }
-  return treeDurability({
-    dirty: status3.out !== "",
-    push: pushOnCommit(cwd),
-    localOnlyCommits
-  });
-}
-function pushOnCommit(cwd) {
-  try {
-    return loadConfigFrom(cwd).commit.push;
-  } catch {
-    return false;
-  }
-}
-async function checkDurability(cwd) {
-  if (!existsSync58(cwd)) return { durable: true };
-  const probes = durabilityProbes(cwd);
-  let step = probes.next();
-  while (!step.done) step = probes.next(await gitResult(cwd, step.value));
-  return step.value;
-}
-function checkDurabilitySync(cwd) {
-  if (!existsSync58(cwd)) return { durable: true };
-  const probes = durabilityProbes(cwd);
-  let step = probes.next();
-  while (!step.done) step = probes.next(gitSyncResult(cwd, step.value));
-  return step.value;
-}
-
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync59(worktreePath)) {
+  if (!existsSync62(worktreePath)) {
     daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
     return false;
   }
@@ -26492,23 +26818,23 @@ async function reapWorktree(worktreePath, force = false) {
     }
   }
   const clone = mainWorktree(worktreePath) ?? worktreePath;
-  const branch2 = await gitOrNull(worktreePath, [
-    "symbolic-ref",
-    "--short",
-    "HEAD"
-  ]);
   if (!await removeTree(clone, worktreePath, force)) return false;
-  if (branch2) await deleteBranch(clone, branch2);
+  await deleteWorktreeBranch(clone, basename16(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return true;
 }
-async function deleteBranch(clone, branch2) {
-  const current = await gitOrNull(clone, ["symbolic-ref", "--short", "HEAD"]);
+async function deleteWorktreeBranch(clone, branch2) {
+  if (!listLocalBranches(clone).includes(branch2)) return;
+  const current = await gitOrNull2(clone, ["symbolic-ref", "--short", "HEAD"]);
   if (branch2 === current) return;
   try {
     await git2(clone, ["branch", "-D", branch2]);
-  } catch {
+    daemonLog(`worktree branch ${branch2} deleted from clone ${clone}`);
+  } catch (error) {
+    daemonLog(
+      `worktree branch ${branch2} retained in clone ${clone}: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 
@@ -26534,21 +26860,6 @@ function dismissSession(sessions, id) {
   return true;
 }
 
-// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
-var DISABLED = {
-  enabled: false,
-  install: true,
-  commitBeforeManualChecks: false,
-  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/closeGateApplies.ts
 function closeGateApplies(sessions, session) {
   if (otherTreeHolders(sessions, session).length > 0) return false;
@@ -26570,12 +26881,12 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync60, watch } from "fs";
+import { existsSync as existsSync63, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync60(common)) return void 0;
+  if (!common || !existsSync63(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -27167,10 +27478,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 function exitReason(session, exitCode) {
   const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync61(session.cwd))
+  if (session.cwd && !existsSync64(session.cwd))
     return `${base}: working directory ${session.cwd} no longer exists`;
   return base;
 }
@@ -27188,8 +27499,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync62, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
-import { dirname as dirname29 } from "path";
+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) {
@@ -27243,9 +27554,9 @@ var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
   const path71 = activityPath(session.id);
-  const dir = dirname29(path71);
+  const dir = dirname31(path71);
   try {
-    mkdirSync25(dir, { recursive: true });
+    mkdirSync26(dir, { recursive: true });
   } catch {
     return;
   }
@@ -27269,7 +27580,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync62(path71)) read();
+  if (existsSync65(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -27929,8 +28240,8 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync67 } from "fs";
-import { basename as basename15 } from "path";
+import { existsSync as existsSync68 } from "fs";
+import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -27958,71 +28269,6 @@ function detectExistingWorktree(cwd) {
   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, onSeeded = () => {
-}) {
-  const cfg = worktreeConfigFor(clone);
-  copyConfigFiles(worktreePath, clone, cfg.copy);
-  runInstall(worktreePath, clone, cfg.install, onSeeded);
-}
-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, onSeeded) {
-  const command = resolveInstallCommand(clone, install);
-  if (!command) {
-    onSeeded();
-    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`
-    );
-    onSeeded();
-  });
-}
-function message(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/commands/sessions/daemon/worktree/bindNewWorktree.ts
 function bindNewWorktree(session, alloc, notify2, startHeld = () => {
 }) {
@@ -28084,9 +28330,9 @@ function capped(lines) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync66 } from "fs";
+import { existsSync as existsSync67 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync66(clone)) {
+  if (!existsSync67(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -28122,7 +28368,7 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename14 } from "path";
+import { basename as basename17 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason2, held } = recovered;
   let id;
@@ -28145,7 +28391,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason2, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename14(orphan.path)}`,
+    name: `recovered ${basename17(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -28179,10 +28425,10 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
     if (accounted.has(path71)) continue;
-    if (!existsSync67(path71)) {
+    if (!existsSync68(path71)) {
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path71, branch: basename15(path71) }
+        { path: path71, branch: basename18(path71) }
       ]);
       continue;
     }
@@ -28358,7 +28604,7 @@ function treeSpawnContext(sessions, spawnWith, notify2, clients, onStatusChange)
 }
 
 // src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync68, watch as watch3 } from "fs";
+import { existsSync as existsSync69, watch as watch3 } from "fs";
 
 // src/commands/sessions/daemon/reconcileTranscriptStatus.ts
 async function resolveTranscriptPath(session) {
@@ -28393,7 +28639,7 @@ function watchTranscript(session, onStatusChange) {
   if (!session.cwd || !session.claudeSessionId) return;
   if (session.watchedTranscriptId === session.claudeSessionId) return;
   const dir = projectDirForCwd(session.cwd);
-  if (!existsSync68(dir)) return;
+  if (!existsSync69(dir)) return;
   if (session.transcriptWatcher) {
     session.transcriptWatcher.close();
     session.transcriptWatcher = void 0;
@@ -28544,13 +28790,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync69, readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync70, readFileSync as readFileSync50 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync69(sessionsFile)) return false;
+    if (!existsSync70(sessionsFile)) return false;
     const data = JSON.parse(readFileSync50(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -29129,81 +29375,6 @@ function resumeSession(id, sessionId, cwd, name) {
   };
 }
 
-// src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync70 } from "fs";
-import { basename as basename17, dirname as dirname31 } from "path";
-
-// src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename16, join as join72 } from "path";
-function planAllocation(clone, boundTreeRoots2) {
-  return boundTreeRoots2.has(clone) ? "spill" : "primary";
-}
-function nextWorktreePath(clone, base, isTaken) {
-  const name = basename16(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) || existsSync70(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename17(candidate))
-  );
-  const trunk = cloneTrunkBranch(clone);
-  gitSync(clone, ["config", "push.default", "upstream"]);
-  gitSync(clone, [
-    "worktree",
-    "add",
-    "--track",
-    "-b",
-    basename17(path71),
-    path71,
-    `origin/${trunk}`
-  ]);
-  recordWorktree(path71, clone, getCurrentOrigin(clone));
-  daemonLog(
-    `worktree allocated ${path71} (branch ${basename17(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/boundTreeRoots.ts
 function boundTreeRoots(sessions) {
   const roots = /* @__PURE__ */ new Set();
@@ -29228,9 +29399,17 @@ function holdsTree(session, root) {
   return !durability.durable;
 }
 
+// src/commands/sessions/daemon/worktree/isPrCheckoutArgs.ts
+var CHECKOUT_COMMANDS = /* @__PURE__ */ new Set(["review", "review-pr-comments"]);
+function isPrCheckoutArgs(args) {
+  const [command, ...rest] = args;
+  if (!command || !CHECKOUT_COMMANDS.has(command)) return false;
+  return rest.some((arg) => /^[1-9]\d*$/.test(arg));
+}
+
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
-function allocateAndBind(ctx, cwd, create) {
-  const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions));
+function allocateAndBind(ctx, cwd, create, options2 = {}) {
+  const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions), options2);
   const needsSeeding = alloc.kind === "worktree" && alloc.created === true;
   const id = ctx.spawnWith((sid) => create(sid, alloc.cwd, needsSeeding));
   bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify, ctx.startHeld);
@@ -29247,7 +29426,8 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
   return allocateAndBind(
     ctx,
     cwd,
-    (sid, resolvedCwd, holdUntilSeeded) => createAssistSession(sid, assistArgs, resolvedCwd, meta, holdUntilSeeded)
+    (sid, resolvedCwd, holdUntilSeeded) => createAssistSession(sid, assistArgs, resolvedCwd, meta, holdUntilSeeded),
+    { forCheckout: isPrCheckoutArgs(assistArgs) }
   );
 }
 function resumeInTree(ctx, sessionId, cwd, name) {
@@ -29955,11 +30135,21 @@ var sessionsConfigHelp = [
     setter: "assist config set sessions.windowsVersionCheck block",
     note: "Windows daemon version mismatch handling: block | warn | off"
   },
+  {
+    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)"
+  },
   {
     key: "worktree.enabled",
     setter: "assist config set worktree.enabled true -g --repo",
     note: "opt in per repo: spill concurrent sessions into adjacent <clone>-N worktrees (default off)"
   },
+  {
+    key: "worktree.trunk",
+    setter: "assist config set worktree.trunk true -g --repo",
+    note: "trunk-based: a spilled worktree lands on the mainline (default off: it starts off the remote default with no mainline tracking, so the session raises its own branch and PR)"
+  },
   {
     key: "worktree.root",
     setter: "assist config set worktree.root ~/git -g --repo",
@@ -30000,7 +30190,7 @@ function summaryPathFor(jsonlPath2) {
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
@@ -30024,7 +30214,7 @@ function summariseSession(jsonlPath2) {
   }
   const prompt = buildPrompt3(firstMessage, backlogIds);
   try {
-    const output = execFileSync13("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync12("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -30586,7 +30776,7 @@ function syncCommands(claudeDir, targetBase) {
 }
 
 // src/commands/update.ts
-import { execSync as execSync59 } from "child_process";
+import { execSync as execSync60 } from "child_process";
 import * as path70 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
@@ -30610,7 +30800,7 @@ function isGlobalNpmInstall(dir) {
     if (resolved.split(path70.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync59("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync60("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return resolved.toLowerCase().startsWith(path70.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -30621,18 +30811,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync59("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync60("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync59("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync60("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync59("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync60("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync59("assist sync", { stdio: "inherit" });
+    execSync60("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync59("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync60("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync59("assist sync", { stdio: "inherit" });
+    execSync60("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."