syntaur 0.16.0 → 0.16.2

package/dist/index.js

@@ -131,7 +131,6 @@ backup:
   categories: projects, playbooks, todos, servers, config
   lastBackup: null
   lastRestore: null
-terminal: terminal-app
 ---
 
 # Syntaur Configuration
@@ -193,6 +192,12 @@ function parseListField(frontmatter, fieldName) {
   }
   return results;
 }
+function unquoteYamlString(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
 function parseProject(fileContent) {
   const [fm, body] = extractFrontmatter(fileContent);
   const slug = getField(fm, "slug") ?? getField(fm, "mission") ?? "";
@@ -208,6 +213,7 @@ function parseProject(fileContent) {
     updated: getField(fm, "updated") ?? "",
     tags: parseListField(fm, "tags"),
     workspace: getField(fm, "workspace"),
+    repositories: parseListField(fm, "repositories").map(unquoteYamlString),
     externalIds: parseExternalIds(fm),
     body
   };
@@ -700,6 +706,22 @@ var init_agents_schema = __esm({
   }
 });
 
+// src/utils/terminal-schema.ts
+var TERMINAL_CHOICES;
+var init_terminal_schema = __esm({
+  "src/utils/terminal-schema.ts"() {
+    "use strict";
+    TERMINAL_CHOICES = [
+      "terminal-app",
+      "iterm",
+      "ghostty",
+      "alacritty",
+      "warp",
+      "kitty"
+    ];
+  }
+});
+
 // src/utils/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -713,6 +735,7 @@ __export(config_exports, {
   deleteAgentsConfig: () => deleteAgentsConfig,
   deleteHotkeyBindingsConfig: () => deleteHotkeyBindingsConfig,
   deleteStatusConfig: () => deleteStatusConfig,
+  deleteTerminalConfig: () => deleteTerminalConfig,
   deleteThemeConfig: () => deleteThemeConfig,
   getAgents: () => getAgents,
   getAssignmentTypes: () => getAssignmentTypes,
@@ -729,9 +752,11 @@ __export(config_exports, {
   writeAgentsConfig: () => writeAgentsConfig,
   writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
   writeStatusConfig: () => writeStatusConfig,
+  writeTerminalConfig: () => writeTerminalConfig,
   writeThemeConfig: () => writeThemeConfig
 });
 import { readFile as readFile2 } from "fs/promises";
+import { spawnSync } from "child_process";
 import { resolve as resolve3, isAbsolute } from "path";
 function parseAgentCommand(value, agentId) {
   if (typeof value !== "string" || value.trim() === "") {
@@ -1144,6 +1169,52 @@ ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+function stripTopLevelScalar(fmBlock, key) {
+  const lines = fmBlock.split("\n");
+  const keyRegex = new RegExp(`^${key}:\\s*\\S`);
+  const filtered = lines.filter((line) => !keyRegex.test(line));
+  return filtered.join("\n").replace(/\n+$/, "");
+}
+async function writeTerminalConfig(terminal) {
+  const configPath = resolve3(syntaurRoot(), "config.md");
+  const terminalLine = `terminal: ${terminal}`;
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${terminalLine}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelScalar(fmBlock, "terminal");
+  const newFm = `${cleanedFm}
+${terminalLine}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
+async function deleteTerminalConfig() {
+  const configPath = resolve3(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile2(configPath, "utf-8");
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) return;
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelScalar(fmBlock, "terminal");
+  const newContent = `---
+${cleanedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 function parseHotkeyBindingsConfig(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -1839,7 +1910,18 @@ function parseTerminalConfig(value) {
   return trimmed;
 }
 function getTerminal(config) {
-  return config.terminal ?? "terminal-app";
+  if (config.terminal) return config.terminal;
+  if (process.platform === "darwin") return "terminal-app";
+  if (process.platform === "linux") {
+    const order = ["kitty", "alacritty", "warp"];
+    for (const candidate of order) {
+      const result = spawnSync("which", [candidate], { encoding: "utf-8" });
+      if (result.status === 0 && result.stdout.trim().length > 0) {
+        return candidate;
+      }
+    }
+  }
+  return "terminal-app";
 }
 async function updateAgentsConfig(mutation, options = {}) {
   const config = await readConfig();
@@ -1852,7 +1934,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var DEFAULT_ASSIGNMENT_TYPES, TERMINAL_CHOICES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -1862,6 +1944,7 @@ var init_config2 = __esm({
     init_fs_migration();
     init_hotkeysCatalog();
     init_agents_schema();
+    init_terminal_schema();
     DEFAULT_ASSIGNMENT_TYPES = {
       definitions: [
         { id: "feature", label: "Feature" },
@@ -1872,14 +1955,6 @@ var init_config2 = __esm({
       ],
       default: "feature"
     };
-    TERMINAL_CHOICES = [
-      "terminal-app",
-      "iterm",
-      "ghostty",
-      "alacritty",
-      "warp",
-      "kitty"
-    ];
     DEFAULT_CONFIG = {
       version: "2.0",
       defaultProjectDir: defaultProjectDir(),
@@ -2182,10 +2257,17 @@ var init_yaml = __esm({
 });
 
 // src/templates/project.ts
+function renderRepositoriesBlock(repos) {
+  if (!repos || repos.length === 0) {
+    return "repositories: []";
+  }
+  return ["repositories:", ...repos.map((p) => `  - ${escapeYamlString(p)}`)].join("\n");
+}
 function renderProject(params2) {
   const safeTitle = escapeYamlString(params2.title);
   const workspaceLine = params2.workspace ? `
 workspace: ${params2.workspace}` : "";
+  const repositoriesBlock = renderRepositoriesBlock(params2.repositories);
   return `---
 id: ${params2.id}
 slug: ${params2.slug}
@@ -2196,7 +2278,8 @@ archivedReason: null
 created: "${params2.timestamp}"
 updated: "${params2.timestamp}"
 externalIds: []
-tags: []${workspaceLine}
+tags: []
+${repositoriesBlock}${workspaceLine}
 ---
 
 # ${params2.title}
@@ -4924,8 +5007,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile49 } = await import("fs/promises");
-  const raw = await readFile49(filePath, "utf-8");
+  const { readFile: readFile50 } = await import("fs/promises");
+  const raw = await readFile50(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -6114,7 +6197,8 @@ async function getProjectDetail(projectsDir2, slug) {
     resources,
     memories,
     dependencyGraph,
-    workspace: project.workspace
+    workspace: project.workspace,
+    repositories: project.repositories
   };
 }
 async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
@@ -7340,6 +7424,114 @@ var init_api = __esm({
   }
 });
 
+// src/utils/git-worktree.ts
+var git_worktree_exports = {};
+__export(git_worktree_exports, {
+  GitWorktreeError: () => GitWorktreeError,
+  createWorktree: () => createWorktree,
+  createWorktreeAndRecord: () => createWorktreeAndRecord,
+  deleteBranch: () => deleteBranch,
+  formatRollbackError: () => formatRollbackError,
+  removeWorktree: () => removeWorktree
+});
+import { spawn } from "child_process";
+import { readFile as readFile13 } from "fs/promises";
+function run(command, args, cwd) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => stdout += chunk.toString());
+    child.stderr.on("data", (chunk) => stderr += chunk.toString());
+    child.on("error", (err2) => {
+      resolvePromise({ code: -1, stdout, stderr: stderr + String(err2) });
+    });
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? -1, stdout, stderr });
+    });
+  });
+}
+async function createWorktree(opts) {
+  const { repository, branch, worktreePath, parentBranch } = opts;
+  const result = await run(
+    "git",
+    ["-C", repository, "worktree", "add", "-b", branch, worktreePath, parentBranch]
+  );
+  if (result.code !== 0) {
+    throw new GitWorktreeError(
+      `git worktree add failed (exit ${result.code}): ${result.stderr.trim() || "(no stderr)"}`,
+      result.stderr
+    );
+  }
+}
+async function removeWorktree(repository, worktreePath) {
+  const result = await run(
+    "git",
+    ["-C", repository, "worktree", "remove", "--force", worktreePath]
+  );
+  return { ok: result.code === 0, stderr: result.stderr };
+}
+async function deleteBranch(repository, branch) {
+  const result = await run("git", ["-C", repository, "branch", "-D", branch]);
+  return { ok: result.code === 0, stderr: result.stderr };
+}
+async function createWorktreeAndRecord(opts) {
+  const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
+  await createWorktree({ repository, branch, worktreePath, parentBranch });
+  try {
+    const content = await readFile13(assignmentPath, "utf-8");
+    const updated = updateAssignmentWorkspace(content, {
+      repository,
+      worktreePath,
+      branch,
+      parentBranch
+    });
+    await writeFileForce(assignmentPath, updated);
+  } catch (writeErr) {
+    const cleanup = await removeWorktree(repository, worktreePath);
+    const branchCleanup = await deleteBranch(repository, branch);
+    const writeMsg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+    throw new Error(
+      formatRollbackError({
+        writeMsg,
+        worktreePath,
+        branch,
+        worktreeCleanup: cleanup,
+        branchCleanup
+      })
+    );
+  }
+}
+function formatRollbackError(opts) {
+  const { writeMsg, worktreePath, branch, worktreeCleanup, branchCleanup } = opts;
+  const wtMsg = worktreeCleanup.stderr.trim() || "(no stderr)";
+  const brMsg = branchCleanup.stderr.trim() || "(no stderr)";
+  if (!worktreeCleanup.ok && !branchCleanup.ok) {
+    return `Failed to update assignment frontmatter AND failed to clean up both worktree and branch. Write error: ${writeMsg}. Worktree cleanup error: ${wtMsg}. Branch cleanup error: ${brMsg}. Orphan worktree at ${worktreePath} and orphan branch "${branch}" \u2014 remove them manually.`;
+  }
+  if (!worktreeCleanup.ok) {
+    return `Failed to update assignment frontmatter AND failed to clean up worktree. Write error: ${writeMsg}. Worktree cleanup error: ${wtMsg}. Orphan worktree at ${worktreePath} \u2014 remove it manually.`;
+  }
+  if (!branchCleanup.ok) {
+    return `Failed to update assignment frontmatter: ${writeMsg}. Rolled back git worktree at ${worktreePath}, but could not delete branch "${branch}": ${brMsg}. Remove the branch manually.`;
+  }
+  return `Failed to update assignment frontmatter: ${writeMsg}. Rolled back git worktree at ${worktreePath} and branch "${branch}".`;
+}
+var GitWorktreeError;
+var init_git_worktree = __esm({
+  "src/utils/git-worktree.ts"() {
+    "use strict";
+    init_frontmatter();
+    init_fs();
+    GitWorktreeError = class extends Error {
+      constructor(message, stderr) {
+        super(message);
+        this.stderr = stderr;
+      }
+    };
+  }
+});
+
 // src/utils/promote-todos.ts
 var promote_todos_exports = {};
 __export(promote_todos_exports, {
@@ -7512,9 +7704,9 @@ __export(launch_exports, {
   launchAgent: () => launchAgent,
   shellQuote: () => shellQuote
 });
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute3, resolve as resolve37 } from "path";
+import { isAbsolute as isAbsolute4, resolve as resolve39 } from "path";
 function formatFallbackCwdWarning(opts) {
   const missing = [];
   if (!opts.worktreePath) missing.push("worktreePath");
@@ -7535,7 +7727,7 @@ function buildAgentArgv(agent, prompt, env = process.env) {
     const requested = env.SHELL;
     let shell = requested;
     let warning = null;
-    if (!shell || !isAbsolute3(shell)) {
+    if (!shell || !isAbsolute4(shell)) {
       warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
       shell = "/bin/sh";
     }
@@ -7558,8 +7750,8 @@ async function launchAgent(options) {
     console.error(`Assignment not found: ${projectSlug}/${assignmentSlug}`);
     process.exit(1);
   }
-  const projectDir = resolve37(projectsDir2, projectSlug);
-  const assignmentDir = resolve37(projectDir, "assignments", assignmentSlug);
+  const projectDir = resolve39(projectsDir2, projectSlug);
+  const assignmentDir = resolve39(projectDir, "assignments", assignmentSlug);
   const resolvedFromWorkspace = cwdOverride ?? detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null);
   const workspaceDir = resolvedFromWorkspace ?? process.cwd();
   if (!cwdOverride) {
@@ -7571,7 +7763,7 @@ async function launchAgent(options) {
     });
     if (warning) console.warn(warning);
   }
-  const contextDir = resolve37(workspaceDir, ".syntaur");
+  const contextDir = resolve39(workspaceDir, ".syntaur");
   await mkdir6(contextDir, { recursive: true });
   const context = {
     projectSlug,
@@ -7584,7 +7776,7 @@ async function launchAgent(options) {
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFile9(
-    resolve37(contextDir, "context.json"),
+    resolve39(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   const { argv, shellFallbackWarning } = buildAgentArgv(
@@ -7595,7 +7787,7 @@ async function launchAgent(options) {
     console.warn(shellFallbackWarning);
   }
   return new Promise((resolvePromise) => {
-    const child = spawn2(argv.command, argv.args, {
+    const child = spawn3(argv.command, argv.args, {
       cwd: workspaceDir,
       stdio: "inherit"
     });
@@ -7656,9 +7848,9 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
-import { dirname as dirname13, resolve as resolve39, join as join5 } from "path";
+import { dirname as dirname13, resolve as resolve41, join as join5 } from "path";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 function syntaurRootMjs() {
   const override = process.env.SYNTAUR_HOME;
   if (override && override.length > 0) {
@@ -7678,7 +7870,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   }
   const stateRoot = syntaurRootMjs();
   mkdirSync2(stateRoot, { recursive: true });
-  const lockPath = resolve39(stateRoot, "install-url-handler.lock");
+  const lockPath = resolve41(stateRoot, "install-url-handler.lock");
   let lockFd;
   try {
     lockFd = openSync(lockPath, "wx");
@@ -7694,8 +7886,8 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
     throw err2;
   }
   try {
-    const pkgRoot = resolve39(dirname13(fileURLToPath6(import.meta.url)), "..");
-    const cliBin = realpathSync2(resolve39(pkgRoot, "bin/syntaur.js"));
+    const pkgRoot = resolve41(dirname13(fileURLToPath6(import.meta.url)), "..");
+    const cliBin = realpathSync2(resolve41(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
     const bundleParent = join5(
       homedir6(),
@@ -7718,7 +7910,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
       renderAppleScript({ nodeBin, cliBin, installedTerminals }),
       "utf-8"
     );
-    const compile = spawnSync2(
+    const compile = spawnSync6(
       OSACOMPILE,
       ["-o", bundlePath, scriptPath],
       { stdio: "pipe", encoding: "utf-8" }
@@ -7762,7 +7954,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
       ["Add :CFBundleURLTypes:0:CFBundleURLSchemes array", null],
       [`Add :CFBundleURLTypes:0:CFBundleURLSchemes:0 string ${URL_SCHEME}`, null]
     ]);
-    const sign = spawnSync2(
+    const sign = spawnSync6(
       "/usr/bin/codesign",
       ["--force", "--deep", "--sign", "-", bundlePath],
       { stdio: "pipe", encoding: "utf-8" }
@@ -7774,7 +7966,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
       }
       console.warn(`syntaur: ${msg} \u2014 macOS may deny Automation permission.`);
     }
-    const ls = spawnSync2(LSREGISTER, ["-f", bundlePath], {
+    const ls = spawnSync6(LSREGISTER, ["-f", bundlePath], {
       stdio: "pipe",
       encoding: "utf-8"
     });
@@ -7815,10 +8007,11 @@ function detectInstalledTerminals() {
   const installed = /* @__PURE__ */ new Set(["terminal-app"]);
   const bundleIds = {
     iterm: "com.googlecode.iterm2",
-    ghostty: "com.mitchellh.ghostty"
+    ghostty: "com.mitchellh.ghostty",
+    warp: "dev.warp.Warp-Stable"
   };
   for (const [id, bundleId] of Object.entries(bundleIds)) {
-    const r = spawnSync2(
+    const r = spawnSync6(
       "mdfind",
       [`kMDItemCFBundleIdentifier == '${bundleId}'`],
       { encoding: "utf-8" }
@@ -7858,13 +8051,28 @@ function buildTerminalDispatch(installedTerminals) {
     branches.push({
       id: "ghostty",
       block: [
-        '			tell application "Ghostty"',
-        "				activate",
-        "				set newWin to (new window)",
-        "				delay 0.2",
-        "				set t to terminal 1 of selected tab of newWin",
-        "				input text shellCmd to t",
-        '				send key "enter" to t',
+        '			tell application "Ghostty" to activate',
+        "			delay 0.3",
+        '			tell application "System Events"',
+        '				keystroke "n" using command down',
+        "				delay 0.4",
+        "				keystroke shellCmd",
+        "				key code 36",
+        "			end tell"
+      ]
+    });
+  }
+  if (installedTerminals.has("warp")) {
+    branches.push({
+      id: "warp",
+      block: [
+        '			tell application "Warp" to activate',
+        "			delay 0.3",
+        '			tell application "System Events"',
+        '				keystroke "n" using command down',
+        "				delay 0.4",
+        "				keystroke shellCmd",
+        "				key code 36",
         "			end tell"
       ]
     });
@@ -7949,13 +8157,13 @@ function runPlistBuddy(plistPath, steps) {
   for (const step of steps) {
     if (Array.isArray(step)) {
       const [primary, fallback] = step;
-      const a = spawnSync2("/usr/libexec/PlistBuddy", ["-c", primary, plistPath], {
+      const a = spawnSync6("/usr/libexec/PlistBuddy", ["-c", primary, plistPath], {
         stdio: "pipe",
         encoding: "utf-8"
       });
       if (a.status === 0) continue;
       if (fallback === null) continue;
-      const b = spawnSync2("/usr/libexec/PlistBuddy", ["-c", fallback, plistPath], {
+      const b = spawnSync6("/usr/libexec/PlistBuddy", ["-c", fallback, plistPath], {
         stdio: "pipe",
         encoding: "utf-8"
       });
@@ -7965,7 +8173,7 @@ function runPlistBuddy(plistPath, steps) {
         );
       }
     } else {
-      const r = spawnSync2("/usr/libexec/PlistBuddy", ["-c", step, plistPath], {
+      const r = spawnSync6("/usr/libexec/PlistBuddy", ["-c", step, plistPath], {
         stdio: "pipe",
         encoding: "utf-8"
       });
@@ -8500,114 +8708,6 @@ var init_App = __esm({
   }
 });
 
-// src/utils/git-worktree.ts
-var git_worktree_exports = {};
-__export(git_worktree_exports, {
-  GitWorktreeError: () => GitWorktreeError,
-  createWorktree: () => createWorktree,
-  createWorktreeAndRecord: () => createWorktreeAndRecord,
-  deleteBranch: () => deleteBranch,
-  formatRollbackError: () => formatRollbackError,
-  removeWorktree: () => removeWorktree
-});
-import { spawn as spawn4 } from "child_process";
-import { readFile as readFile23 } from "fs/promises";
-function run(command, args, cwd) {
-  return new Promise((resolvePromise) => {
-    const child = spawn4(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => stdout += chunk.toString());
-    child.stderr.on("data", (chunk) => stderr += chunk.toString());
-    child.on("error", (err2) => {
-      resolvePromise({ code: -1, stdout, stderr: stderr + String(err2) });
-    });
-    child.on("close", (code) => {
-      resolvePromise({ code: code ?? -1, stdout, stderr });
-    });
-  });
-}
-async function createWorktree(opts) {
-  const { repository, branch, worktreePath, parentBranch } = opts;
-  const result = await run(
-    "git",
-    ["-C", repository, "worktree", "add", "-b", branch, worktreePath, parentBranch]
-  );
-  if (result.code !== 0) {
-    throw new GitWorktreeError(
-      `git worktree add failed (exit ${result.code}): ${result.stderr.trim() || "(no stderr)"}`,
-      result.stderr
-    );
-  }
-}
-async function removeWorktree(repository, worktreePath) {
-  const result = await run(
-    "git",
-    ["-C", repository, "worktree", "remove", "--force", worktreePath]
-  );
-  return { ok: result.code === 0, stderr: result.stderr };
-}
-async function deleteBranch(repository, branch) {
-  const result = await run("git", ["-C", repository, "branch", "-D", branch]);
-  return { ok: result.code === 0, stderr: result.stderr };
-}
-async function createWorktreeAndRecord(opts) {
-  const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
-  await createWorktree({ repository, branch, worktreePath, parentBranch });
-  try {
-    const content = await readFile23(assignmentPath, "utf-8");
-    const updated = updateAssignmentWorkspace(content, {
-      repository,
-      worktreePath,
-      branch,
-      parentBranch
-    });
-    await writeFileForce(assignmentPath, updated);
-  } catch (writeErr) {
-    const cleanup = await removeWorktree(repository, worktreePath);
-    const branchCleanup = await deleteBranch(repository, branch);
-    const writeMsg = writeErr instanceof Error ? writeErr.message : String(writeErr);
-    throw new Error(
-      formatRollbackError({
-        writeMsg,
-        worktreePath,
-        branch,
-        worktreeCleanup: cleanup,
-        branchCleanup
-      })
-    );
-  }
-}
-function formatRollbackError(opts) {
-  const { writeMsg, worktreePath, branch, worktreeCleanup, branchCleanup } = opts;
-  const wtMsg = worktreeCleanup.stderr.trim() || "(no stderr)";
-  const brMsg = branchCleanup.stderr.trim() || "(no stderr)";
-  if (!worktreeCleanup.ok && !branchCleanup.ok) {
-    return `Failed to update assignment frontmatter AND failed to clean up both worktree and branch. Write error: ${writeMsg}. Worktree cleanup error: ${wtMsg}. Branch cleanup error: ${brMsg}. Orphan worktree at ${worktreePath} and orphan branch "${branch}" \u2014 remove them manually.`;
-  }
-  if (!worktreeCleanup.ok) {
-    return `Failed to update assignment frontmatter AND failed to clean up worktree. Write error: ${writeMsg}. Worktree cleanup error: ${wtMsg}. Orphan worktree at ${worktreePath} \u2014 remove it manually.`;
-  }
-  if (!branchCleanup.ok) {
-    return `Failed to update assignment frontmatter: ${writeMsg}. Rolled back git worktree at ${worktreePath}, but could not delete branch "${branch}": ${brMsg}. Remove the branch manually.`;
-  }
-  return `Failed to update assignment frontmatter: ${writeMsg}. Rolled back git worktree at ${worktreePath} and branch "${branch}".`;
-}
-var GitWorktreeError;
-var init_git_worktree = __esm({
-  "src/utils/git-worktree.ts"() {
-    "use strict";
-    init_frontmatter();
-    init_fs();
-    GitWorktreeError = class extends Error {
-      constructor(message, stderr) {
-        super(message);
-        this.stderr = stderr;
-      }
-    };
-  }
-});
-
 // src/index.ts
 import { Command as Command13, InvalidArgumentError } from "commander";
 
@@ -8765,9 +8865,9 @@ init_create_assignment();
 
 // src/commands/dashboard.ts
 init_config2();
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve25, dirname as dirname7 } from "path";
+import { resolve as resolve27, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -8777,7 +8877,7 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve26 } from "path";
 import { writeFile as writeFile5, unlink as unlink5 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -9312,10 +9412,116 @@ init_slug();
 init_uuid();
 init_timestamp();
 init_fs();
-init_parser();
+init_git_worktree();
 import { Router } from "express";
-import { resolve as resolve18, basename as basename3 } from "path";
-import { rm, readFile as readFile13, open as fsOpen } from "fs/promises";
+import { resolve as resolve20, basename as basename3, isAbsolute as isAbsolute2 } from "path";
+import { rm, readFile as readFile15, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
+import { spawnSync as spawnSync3 } from "child_process";
+
+// src/utils/worktree-defaults.ts
+init_paths();
+import { spawnSync as spawnSync2 } from "child_process";
+import { resolve as resolve18 } from "path";
+function computeWorktreeDefaults(opts) {
+  const repository = opts.existing.repository ?? detectCurrentGitRoot(opts.cwd);
+  const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
+  const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch(opts.cwd) ?? "main";
+  const worktreeBase = repository ? resolve18(repository, ".worktrees", branch) : resolve18(
+    syntaurRoot(),
+    "worktrees",
+    opts.projectSlug || "standalone",
+    opts.assignmentSlug
+  );
+  return {
+    ...repository ? { repository } : {},
+    branch,
+    parentBranch,
+    worktreePath: worktreeBase
+  };
+}
+function detectCurrentGitRoot(cwd) {
+  const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    encoding: "utf-8"
+  });
+  if (result.status !== 0) return void 0;
+  const out = result.stdout.trim();
+  return out.length > 0 ? out : void 0;
+}
+function detectCurrentBranch(cwd) {
+  const result = spawnSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    cwd,
+    encoding: "utf-8"
+  });
+  if (result.status !== 0) return void 0;
+  const out = result.stdout.trim();
+  if (!out || out === "HEAD") return void 0;
+  return out;
+}
+
+// src/dashboard/repository-candidates.ts
+init_fs();
+init_parser();
+import { readdir as readdir10, readFile as readFile14 } from "fs/promises";
+import { resolve as resolve19 } from "path";
+async function getProjectRepositoryCandidates(projectsDir2, projectSlug) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const projectPath = resolve19(projectsDir2, projectSlug, "project.md");
+  if (await fileExists(projectPath)) {
+    const project = parseProject(await readFile14(projectPath, "utf-8"));
+    for (const raw of project.repositories) {
+      const path = raw.trim();
+      if (!path) continue;
+      const abs = resolve19(path);
+      if (seen.has(abs)) continue;
+      seen.add(abs);
+      out.push({ path: abs, source: "project", sourceAssignmentSlug: null });
+    }
+  }
+  const assignmentsDir2 = resolve19(projectsDir2, projectSlug, "assignments");
+  if (await fileExists(assignmentsDir2)) {
+    const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const assignmentMd = resolve19(assignmentsDir2, entry.name, "assignment.md");
+      if (!await fileExists(assignmentMd)) continue;
+      const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+      const repo = parsed.workspace.repository?.trim();
+      if (!repo) continue;
+      const abs = resolve19(repo);
+      if (seen.has(abs)) continue;
+      seen.add(abs);
+      out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
+    }
+  }
+  return out;
+}
+async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignmentId) {
+  if (!await fileExists(assignmentsDir2)) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const entries = await readdir10(assignmentsDir2, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === excludeAssignmentId) continue;
+    const assignmentMd = resolve19(assignmentsDir2, entry.name, "assignment.md");
+    if (!await fileExists(assignmentMd)) continue;
+    const parsed = parseAssignmentFull(await readFile14(assignmentMd, "utf-8"));
+    const repo = parsed.workspace.repository?.trim();
+    if (!repo) continue;
+    const abs = resolve19(repo);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
+  }
+  return out;
+}
+
+// src/dashboard/api-write.ts
+init_parser();
 
 // src/dashboard/acceptance-criteria.ts
 function splitFrontmatter(content) {
@@ -9468,7 +9674,101 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile13(filePath, "utf-8");
+  return readFile15(filePath, "utf-8");
+}
+async function handleWorktreeCreate(req, res, ctx) {
+  if (!await fileExists(ctx.assignmentPath)) {
+    res.status(404).json({ error: "Assignment not found" });
+    return;
+  }
+  const parsed = parseAssignmentFull(await readFile15(ctx.assignmentPath, "utf-8"));
+  if (parsed.workspace.worktreePath) {
+    res.status(409).json({ error: "Worktree already configured for this assignment" });
+    return;
+  }
+  const { repository, branch: bodyBranch, parentBranch: bodyParent } = req.body ?? {};
+  if (typeof repository !== "string" || !repository.trim()) {
+    res.status(400).json({ error: "`repository` is required." });
+    return;
+  }
+  if (!isAbsolute2(repository)) {
+    res.status(400).json({ error: "`repository` must be an absolute path." });
+    return;
+  }
+  try {
+    const st = await fsStat(repository);
+    if (!st.isDirectory()) {
+      res.status(400).json({ error: `Repository path is not a directory: ${repository}` });
+      return;
+    }
+  } catch {
+    res.status(400).json({ error: `Repository path does not exist: ${repository}` });
+    return;
+  }
+  const topLevel = spawnSync3("git", ["-C", repository, "rev-parse", "--show-toplevel"], {
+    encoding: "utf-8"
+  });
+  const topLevelOut = topLevel.stdout.trim();
+  if (topLevel.status !== 0 || !topLevelOut) {
+    res.status(400).json({ error: `Repository path is not a git working tree: ${repository}` });
+    return;
+  }
+  const [requestReal, topLevelReal] = await Promise.all([
+    fsRealpath(repository),
+    fsRealpath(topLevelOut)
+  ]);
+  if (requestReal !== topLevelReal) {
+    res.status(400).json({
+      error: `Repository path must be the git working-tree root. Got ${repository}; the enclosing repo root is ${topLevelOut}.`
+    });
+    return;
+  }
+  const defaults = computeWorktreeDefaults({
+    projectSlug: ctx.projectSlug,
+    assignmentSlug: ctx.assignmentSlug,
+    existing: parsed.workspace,
+    cwd: repository
+  });
+  const branch = typeof bodyBranch === "string" && bodyBranch.trim() ? bodyBranch.trim() : defaults.branch;
+  const parentBranch = typeof bodyParent === "string" && bodyParent.trim() ? bodyParent.trim() : defaults.parentBranch;
+  const worktreePath = resolve20(repository, ".worktrees", branch);
+  try {
+    await fsStat(worktreePath);
+    res.status(409).json({
+      error: `A file or directory already exists at ${worktreePath}. Remove it or choose a different branch.`
+    });
+    return;
+  } catch {
+  }
+  const parentCheck = spawnSync3(
+    "git",
+    ["-C", repository, "rev-parse", "--verify", "--quiet", parentBranch],
+    { encoding: "utf-8" }
+  );
+  if (parentCheck.status !== 0) {
+    res.status(400).json({
+      error: `Parent branch "${parentBranch}" does not exist in ${repository}.`
+    });
+    return;
+  }
+  try {
+    await createWorktreeAndRecord({
+      assignmentPath: ctx.assignmentPath,
+      repository,
+      branch,
+      worktreePath,
+      parentBranch
+    });
+  } catch (error) {
+    if (error instanceof GitWorktreeError) {
+      res.status(400).json({ error: error.message, stderr: error.stderr });
+      return;
+    }
+    res.status(500).json({ error: error.message });
+    return;
+  }
+  const assignment = await ctx.reload();
+  res.json({ assignment });
 }
 function createWriteRouter(projectsDir2, assignmentsDir2, todosDir2) {
   const linkedTodosLookup = todosDir2 ? { todosDir: todosDir2, projectsDir: projectsDir2 } : void 0;
@@ -9697,9 +9997,9 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           });
           return;
         }
-        const folderPath = resolve18(projectDir, folder);
+        const folderPath = resolve20(projectDir, folder);
         await ensureDir(folderPath);
-        const filePath = resolve18(folderPath, `${requestedSlug}.md`);
+        const filePath = resolve20(folderPath, `${requestedSlug}.md`);
         const timestamp = nowTimestamp();
         let content = renderItemStub(kind, {
           slug: requestedSlug,
@@ -9743,14 +10043,14 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve18(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve20(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
         }
         const nextContentRaw = requireContent(req, res);
         if (!nextContentRaw) return;
-        const currentContent = await readFile13(filePath, "utf-8");
+        const currentContent = await readFile15(filePath, "utf-8");
         const frontmatterBlock = extractFrontmatterBlock(currentContent);
         if (!frontmatterBlock) {
           res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
@@ -9779,7 +10079,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve18(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve20(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
@@ -9813,26 +10113,26 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve18(projectsDir2, slug);
+      const projectDir = resolve20(projectsDir2, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve18(projectDir, "assignments"));
-      await ensureDir(resolve18(projectDir, "resources"));
-      await ensureDir(resolve18(projectDir, "memories"));
-      await writeFileForce(resolve18(projectDir, "project.md"), content);
+      await ensureDir(resolve20(projectDir, "assignments"));
+      await ensureDir(resolve20(projectDir, "resources"));
+      await ensureDir(resolve20(projectDir, "memories"));
+      await writeFileForce(resolve20(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve18(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve18(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve18(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve18(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve18(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve18(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve18(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve20(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve20(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve20(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve20(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve20(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve20(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve20(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -9853,8 +10153,8 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve18(projectsDir2, projectSlug);
-      const projectMdPath = resolve18(projectDir, "project.md");
+      const projectDir = resolve20(projectsDir2, projectSlug);
+      const projectMdPath = resolve20(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -9884,7 +10184,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve18(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve20(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -9893,12 +10193,12 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve18(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve20(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve18(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve18(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve18(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve20(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve20(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve20(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -9919,7 +10219,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -9952,7 +10252,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -9995,7 +10295,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10031,7 +10331,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve18(
+      const planPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10069,7 +10369,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve18(
+      const scratchpadPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10107,7 +10407,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve18(
+      const handoffPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10145,7 +10445,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve18(
+      const decisionPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10183,7 +10483,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve18(
+      const commentsPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10201,7 +10501,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile13(commentsPath, "utf-8");
+        currentContent = await readFile15(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -10242,7 +10542,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve18(
+      const commentsPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10258,7 +10558,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile13(commentsPath, "utf-8");
+      const content = await readFile15(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -10293,7 +10593,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -10305,7 +10605,7 @@ ${entry}`;
         });
         return;
       }
-      let content = await readFile13(projectPath, "utf-8");
+      let content = await readFile15(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -10332,31 +10632,129 @@ ${entry}`;
         res.status(400).json({
           error: "Project-nested assignments inherit workspace from their parent project. Move the project instead."
         });
-        return;
+        return;
+      }
+      const { workspaceGroup } = req.body || {};
+      if (workspaceGroup !== null && (typeof workspaceGroup !== "string" || !workspaceGroup.trim() || !isValidSlug(workspaceGroup))) {
+        res.status(400).json({
+          error: "workspaceGroup must be a valid slug (lowercase letters, numbers, hyphens) or null (for ungrouped)."
+        });
+        return;
+      }
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
+      let content = await readFile15(assignmentPath, "utf-8");
+      content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
+      content = setTopLevelField(content, "updated", nowTimestamp());
+      await writeFileForce(assignmentPath, content);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment });
+    } catch (error) {
+      console.error("Error moving assignment workspace:", error);
+      res.status(500).json({ error: `Failed to move workspace: ${error.message}` });
+    }
+  });
+  router.get(
+    "/api/projects/:slug/repository-candidates",
+    async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
+        if (!await fileExists(projectPath)) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const candidates = await getProjectRepositoryCandidates(projectsDir2, projectSlug);
+        res.json({ candidates });
+      } catch (error) {
+        console.error("Error listing repository candidates:", error);
+        res.status(500).json({
+          error: `Failed to list repository candidates: ${error.message}`
+        });
+      }
+    }
+  );
+  router.get(
+    "/api/assignments/:id/repository-candidates",
+    async (req, res) => {
+      try {
+        if (!assignmentsDir2) {
+          res.status(501).json({ error: "Standalone assignments not configured on this server" });
+          return;
+        }
+        const id = getParam(req.params.id);
+        const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+        if (!resolved) {
+          res.status(404).json({ error: `Assignment "${id}" not found` });
+          return;
+        }
+        const candidates = resolved.standalone ? await getStandaloneRepositoryCandidates(assignmentsDir2, id) : await getProjectRepositoryCandidates(projectsDir2, resolved.projectSlug);
+        res.json({ candidates });
+      } catch (error) {
+        console.error("Error listing repository candidates:", error);
+        res.status(500).json({
+          error: `Failed to list repository candidates: ${error.message}`
+        });
+      }
+    }
+  );
+  router.post(
+    "/api/projects/:slug/assignments/:aslug/worktree",
+    async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const assignmentSlug = getParam(req.params.aslug);
+        const assignmentPath = resolve20(
+          projectsDir2,
+          projectSlug,
+          "assignments",
+          assignmentSlug,
+          "assignment.md"
+        );
+        await handleWorktreeCreate(req, res, {
+          assignmentPath,
+          projectSlug,
+          assignmentSlug,
+          reload: () => getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug)
+        });
+      } catch (error) {
+        console.error("Error creating worktree:", error);
+        res.status(500).json({ error: `Failed to create worktree: ${error.message}` });
       }
-      const { workspaceGroup } = req.body || {};
-      if (workspaceGroup !== null && (typeof workspaceGroup !== "string" || !workspaceGroup.trim() || !isValidSlug(workspaceGroup))) {
-        res.status(400).json({
-          error: "workspaceGroup must be a valid slug (lowercase letters, numbers, hyphens) or null (for ungrouped)."
+    }
+  );
+  router.post(
+    "/api/assignments/:id/worktree",
+    async (req, res) => {
+      try {
+        if (!assignmentsDir2) {
+          res.status(501).json({ error: "Standalone assignments not configured on this server" });
+          return;
+        }
+        const id = getParam(req.params.id);
+        const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+        if (!resolved) {
+          res.status(404).json({ error: `Assignment "${id}" not found` });
+          return;
+        }
+        const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
+        const parsedForSlug = parseAssignmentFull(await readFile15(assignmentPath, "utf-8"));
+        const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
+        await handleWorktreeCreate(req, res, {
+          assignmentPath,
+          projectSlug: resolved.projectSlug ?? "",
+          assignmentSlug: assignmentSlugForBranch,
+          reload: () => getAssignmentDetailById(projectsDir2, assignmentsDir2, id)
         });
-        return;
+      } catch (error) {
+        console.error("Error creating worktree:", error);
+        res.status(500).json({ error: `Failed to create worktree: ${error.message}` });
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
-      let content = await readFile13(assignmentPath, "utf-8");
-      content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
-      content = setTopLevelField(content, "updated", nowTimestamp());
-      await writeFileForce(assignmentPath, content);
-      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
-      res.json({ assignment });
-    } catch (error) {
-      console.error("Error moving assignment workspace:", error);
-      res.status(500).json({ error: `Failed to move workspace: ${error.message}` });
     }
-  });
+  );
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve18(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -10368,7 +10766,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile13(projectPath, "utf-8");
+      let content = await readFile15(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -10383,7 +10781,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10401,7 +10799,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile13(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -10419,7 +10817,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve18(
+      const assignmentPath = resolve20(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -10435,7 +10833,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile13(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -10457,8 +10855,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve18(projectsDir2, projectSlug);
-      const assignmentPath = resolve18(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve20(projectsDir2, projectSlug);
+      const assignmentPath = resolve20(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -10485,8 +10883,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve18(projectsDir2, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve18(assignmentDir, "assignment.md");
+      const assignmentDir = resolve20(projectsDir2, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve20(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -10541,7 +10939,7 @@ ${entry}`;
           return;
         }
         const id2 = generateId();
-        const assignmentDir2 = resolve18(assignmentsDir2, id2);
+        const assignmentDir2 = resolve20(assignmentsDir2, id2);
         if (await fileExists(assignmentDir2)) {
           res.status(500).json({ error: "UUID collision \u2014 try again" });
           return;
@@ -10549,25 +10947,25 @@ ${entry}`;
         const timestamp2 = fields.created || nowTimestamp();
         await ensureDir(assignmentDir2);
         const normalizedContent = setTopLevelField(rawContent, "id", id2);
-        await writeFileForce(resolve18(assignmentDir2, "assignment.md"), normalizedContent);
+        await writeFileForce(resolve20(assignmentDir2, "assignment.md"), normalizedContent);
         await writeFileForce(
-          resolve18(assignmentDir2, "scratchpad.md"),
+          resolve20(assignmentDir2, "scratchpad.md"),
           renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "handoff.md"),
+          resolve20(assignmentDir2, "handoff.md"),
           renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "decision-record.md"),
+          resolve20(assignmentDir2, "decision-record.md"),
           renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "progress.md"),
+          resolve20(assignmentDir2, "progress.md"),
           renderProgress({ assignment: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve18(assignmentDir2, "comments.md"),
+          resolve20(assignmentDir2, "comments.md"),
           renderComments({ assignment: id2, timestamp: timestamp2 })
         );
         const detail2 = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id2);
@@ -10585,7 +10983,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve18(assignmentsDir2, id);
+      const assignmentDir = resolve20(assignmentsDir2, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -10605,25 +11003,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve18(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve20(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve18(assignmentDir, "scratchpad.md"),
+        resolve20(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "handoff.md"),
+        resolve20(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "decision-record.md"),
+        resolve20(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "progress.md"),
+        resolve20(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve18(assignmentDir, "comments.md"),
+        resolve20(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
@@ -10751,7 +11149,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -10793,7 +11191,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve18(resolved.assignmentDir, "plan.md");
+      const planPath = resolve20(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -10827,7 +11225,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve18(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve20(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -10861,7 +11259,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve18(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve20(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -10901,7 +11299,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve18(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve20(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -10941,7 +11339,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -10953,7 +11351,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile13(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -10979,7 +11377,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -10989,7 +11387,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile13(assignmentPath, "utf-8");
+      let content = await readFile15(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -11043,9 +11441,9 @@ ${entry}`;
             if (!resolved) {
               throw new Error(`assignment "${item.id}" not found`);
             }
-            assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+            assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
           } else if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string" && item.projectSlug && item.assignmentSlug) {
-            assignmentPath = resolve18(
+            assignmentPath = resolve20(
               projectsDir2,
               item.projectSlug,
               "assignments",
@@ -11058,7 +11456,7 @@ ${entry}`;
           if (!await fileExists(assignmentPath)) {
             throw new Error("assignment file not found");
           }
-          let content = await readFile13(assignmentPath, "utf-8");
+          let content = await readFile15(assignmentPath, "utf-8");
           content = setTopLevelField(content, "status", status);
           content = setTopLevelField(content, "updated", timestamp);
           if (status !== "blocked") {
@@ -11090,7 +11488,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve18(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve20(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -11182,7 +11580,7 @@ function buildBulkItemKey(raw, index) {
   return `#${index}`;
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve18(assignmentDir, "comments.md");
+  const commentsPath = resolve20(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req.body || {};
   if (!body || typeof body !== "string" || !body.trim()) {
     res.status(400).json({ error: "body is required" });
@@ -11194,7 +11592,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile13(commentsPath, "utf-8");
+    currentContent = await readFile15(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -11224,7 +11622,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve18(assignmentDir, "comments.md");
+  const commentsPath = resolve20(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -11234,7 +11632,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile13(commentsPath, "utf-8");
+  const content = await readFile15(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -11381,7 +11779,7 @@ function createServersRouter(serversDir2, projectsDir2, assignmentsDir2) {
 init_agent_sessions();
 init_fs();
 import { Router as Router3 } from "express";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve21 } from "path";
 
 // src/utils/transcript.ts
 import { open } from "fs/promises";
@@ -11479,7 +11877,7 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve19(projectsDir2, projectSlug);
+      const projectDir = resolve21(projectsDir2, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -11509,7 +11907,7 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve19(projectsDir2, projectSlug);
+        const projectDir = resolve21(projectsDir2, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -11833,14 +12231,136 @@ function createAgentsRouter() {
   return router;
 }
 
-// src/dashboard/api-leases.ts
+// src/dashboard/api-launch-preflight.ts
+init_config2();
 import { Router as Router5 } from "express";
 
+// src/utils/terminal-probe.ts
+import { spawnSync as spawnSync4 } from "child_process";
+var APP_BUNDLE_IDS = {
+  "terminal-app": "com.apple.Terminal",
+  iterm: "com.googlecode.iterm2",
+  ghostty: "com.mitchellh.ghostty",
+  warp: "dev.warp.Warp-Stable"
+};
+var CLI_NAMES = {
+  alacritty: "alacritty",
+  kitty: "kitty"
+};
+function probeTerminalInstalled(terminal) {
+  const bundleId = APP_BUNDLE_IDS[terminal];
+  if (bundleId) {
+    const result = spawnSync4(
+      "mdfind",
+      [`kMDItemCFBundleIdentifier == '${bundleId}'`],
+      { encoding: "utf-8" }
+    );
+    if (result.status === 0 && result.stdout.trim().length > 0) {
+      return { ok: true, foundPath: result.stdout.trim().split("\n")[0] };
+    }
+    return { ok: false, reason: "not-installed" };
+  }
+  const cliName = CLI_NAMES[terminal];
+  if (cliName) {
+    const result = spawnSync4("which", [cliName], { encoding: "utf-8" });
+    if (result.status === 0 && result.stdout.trim().length > 0) {
+      return { ok: true, foundPath: result.stdout.trim() };
+    }
+    return { ok: false, reason: "not-installed" };
+  }
+  return { ok: false, reason: "no-probe-available" };
+}
+
+// src/dashboard/api-launch-preflight.ts
+function createLaunchPreflightRouter() {
+  const router = Router5();
+  router.post("/preflight", async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      if (body.terminal !== void 0 && (typeof body.terminal !== "string" || !TERMINAL_CHOICES.includes(body.terminal))) {
+        res.status(400).json({
+          error: `terminal must be one of: ${TERMINAL_CHOICES.join(", ")}`
+        });
+        return;
+      }
+      const config = await readConfig();
+      const terminal = body.terminal ?? getTerminal(config);
+      const probe = probeTerminalInstalled(terminal);
+      if (probe.ok) {
+        const response2 = { ok: true, terminal };
+        res.json(response2);
+        return;
+      }
+      const suggestedFallback = getTerminal({ ...config, terminal: null });
+      const response = {
+        ok: false,
+        terminal,
+        reason: "not-installed",
+        suggestedFallback
+      };
+      res.json(response);
+    } catch (error) {
+      console.error("Error in launch preflight:", error);
+      res.status(500).json({ error: "preflight failed" });
+    }
+  });
+  return router;
+}
+
+// src/dashboard/api-terminal-config.ts
+init_config2();
+import { Router as Router6 } from "express";
+function createTerminalConfigRouter() {
+  const router = Router6();
+  router.get("/", async (_req, res) => {
+    try {
+      const config = await readConfig();
+      res.json({
+        terminal: getTerminal(config),
+        custom: config.terminal !== null
+      });
+    } catch (error) {
+      console.error("Error getting terminal config:", error);
+      res.status(500).json({ error: "Failed to get terminal config" });
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const { terminal } = req.body ?? {};
+      if (typeof terminal !== "string" || !TERMINAL_CHOICES.includes(terminal)) {
+        res.status(400).json({
+          error: `terminal must be one of: ${TERMINAL_CHOICES.join(", ")}`
+        });
+        return;
+      }
+      await writeTerminalConfig(terminal);
+      res.json({ terminal, custom: true });
+    } catch (error) {
+      console.error("Error saving terminal config:", error);
+      res.status(500).json({ error: "Failed to save terminal config" });
+    }
+  });
+  router.delete("/", async (_req, res) => {
+    try {
+      await deleteTerminalConfig();
+      const config = await readConfig();
+      res.json({ terminal: getTerminal(config), custom: false });
+    } catch (error) {
+      console.error("Error resetting terminal config:", error);
+      res.status(500).json({ error: "Failed to reset terminal config" });
+    }
+  });
+  return router;
+}
+
+// src/dashboard/api-leases.ts
+import { Router as Router7 } from "express";
+
 // src/db/leases-db.ts
 init_paths();
 import Database2 from "better-sqlite3";
 import { randomUUID as randomUUID2 } from "crypto";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve22 } from "path";
 var db2 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL2 = `
@@ -11964,7 +12484,7 @@ function isBusyError(err2) {
 }
 function initLeasesDb(dbPath) {
   if (db2) return db2;
-  const finalPath = dbPath ?? resolve20(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve22(syntaurRoot(), "syntaur.db");
   db2 = new Database2(finalPath);
   db2.pragma("journal_mode = WAL");
   db2.pragma("busy_timeout = 5000");
@@ -12465,7 +12985,7 @@ function releaseLeasesByRequestedFor(tag) {
 
 // src/dashboard/api-leases.ts
 function createLeasesRouter(broadcast) {
-  const router = Router5();
+  const router = Router7();
   router.get("/", (_req, res) => {
     try {
       initLeasesDb();
@@ -12527,9 +13047,9 @@ init_timestamp();
 init_fs();
 init_playbook();
 init_playbooks();
-import { Router as Router6 } from "express";
-import { resolve as resolve21 } from "path";
-import { readFile as readFile14 } from "fs/promises";
+import { Router as Router8 } from "express";
+import { resolve as resolve23 } from "path";
+import { readFile as readFile16 } from "fs/promises";
 function statusForPlaybookError(code) {
   switch (code) {
     case "manifest":
@@ -12543,7 +13063,7 @@ function statusForPlaybookError(code) {
   }
 }
 function createPlaybooksRouter(playbooksDir3) {
-  const router = Router6();
+  const router = Router8();
   router.get("/", async (_req, res) => {
     try {
       const playbooks = await listPlaybooks(playbooksDir3);
@@ -12610,8 +13130,8 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve21(playbooksDir3, resolved.filename);
-      const content = await readFile14(filePath, "utf-8");
+      const filePath = resolve23(playbooksDir3, resolved.filename);
+      const content = await readFile16(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -12636,7 +13156,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       await ensureDir(playbooksDir3);
-      const filePath = resolve21(playbooksDir3, `${slug}.md`);
+      const filePath = resolve23(playbooksDir3, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -12660,7 +13180,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve21(playbooksDir3, resolved.filename);
+      const filePath = resolve23(playbooksDir3, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir3);
       res.json({ slug: resolved.slug, path: filePath });
@@ -12707,8 +13227,8 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router7 } from "express";
-import { readdir as readdir10 } from "fs/promises";
+import { Router as Router9 } from "express";
+import { readdir as readdir11 } from "fs/promises";
 import { resolve as resolvePath, dirname as dirname5 } from "path";
 import { rename as rename4, mkdir as mkdir2 } from "fs/promises";
 init_slug();
@@ -12726,7 +13246,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir2) {
-  const router = Router7();
+  const router = Router9();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -12842,7 +13362,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir10(todosDir2).catch(() => []);
+      const files = await readdir11(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -12955,8 +13475,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve70 } = await import("path");
-      const { readFile: readFile49 } = await import("fs/promises");
+      const { resolve: resolve72 } = await import("path");
+      const { readFile: readFile50 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -12972,10 +13492,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve70(todosDir2, "archive"));
+      await ensureDir(resolve72(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile49(archFile, "utf-8");
+        archContent = await readFile50(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -13254,7 +13774,7 @@ workspace: ${workspace}
         const { readConfig: readConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const { readFile: readFile49 } = await import("fs/promises");
+        const { readFile: readFile50 } = await import("fs/promises");
         const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
         const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
         let assignmentRef;
@@ -13275,7 +13795,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile49(assignmentMdPath2, "utf-8");
+        let content = await readFile50(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -13458,9 +13978,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router8 } from "express";
-import { mkdir as mkdir3, readFile as readFile15, rename as rename5 } from "fs/promises";
-import { resolve as resolve22, dirname as dirname6 } from "path";
+import { Router as Router10 } from "express";
+import { mkdir as mkdir3, readFile as readFile17, rename as rename5 } from "fs/promises";
+import { resolve as resolve24, dirname as dirname6 } from "path";
 init_promote_todos();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -13476,7 +13996,7 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir2, slug) {
-  return fileExists(resolve22(projectsDir2, slug, "project.md"));
+  return fileExists(resolve24(projectsDir2, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
@@ -13493,7 +14013,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir3(resolve22(todosDir2, "archive"), { recursive: false });
+    await mkdir3(resolve24(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -13509,7 +14029,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
-  const router = Router8({ mergeParams: true });
+  const router = Router10({ mergeParams: true });
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -13681,7 +14201,7 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
       const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile15(archFile, "utf-8");
+        archContent = await readFile17(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -14125,17 +14645,17 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve22(projectsDir2, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve24(projectsDir2, parts[0], "assignments", parts[1]);
           assignmentRef = `${parts[0]}/${parts[1]}`;
         } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-          assignmentDir = resolve22(assignmentsDirFn(), tg);
+          assignmentDir = resolve24(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath2 = resolve22(assignmentDir, "assignment.md");
+        const assignmentMdPath2 = resolve24(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile15(assignmentMdPath2, "utf-8");
+        let content = await readFile17(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -14327,7 +14847,7 @@ workspace: ${slug}
 
 // src/dashboard/api-backup.ts
 init_config2();
-import { Router as Router9 } from "express";
+import { Router as Router11 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -14335,8 +14855,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile16, writeFile as writeFile4, unlink as unlink4, stat, open as open2, rename as rename6 } from "fs/promises";
-import { resolve as resolve23, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile18, writeFile as writeFile4, unlink as unlink4, stat, open as open2, rename as rename6 } from "fs/promises";
+import { resolve as resolve25, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -14376,7 +14896,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve23(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve25(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -14387,7 +14907,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve23(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve25(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open2(lockPath, "wx");
@@ -14396,7 +14916,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile16(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile18(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -14434,7 +14954,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve23(dest, ".."));
+    await ensureDir(resolve25(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -14443,7 +14963,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile16(configPath, "utf-8");
+  const content = await readFile18(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -14482,7 +15002,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve23(destPath, ".."));
+        await ensureDir(resolve25(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -14536,7 +15056,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve23(localPath, ".."));
+    await ensureDir(resolve25(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -14637,7 +15157,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve23(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve25(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -14650,7 +15170,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router9();
+  const router = Router11();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -14978,7 +15498,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve24(syntaurRoot(), "config.md")
+        resolve26(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir2);
       const summary = summarizeMigration(projectResult, configResult);
@@ -15101,6 +15621,7 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to reset theme config" });
     }
   });
+  app.use("/api/config/terminal", createTerminalConfigRouter());
   app.get("/api/config/hotkeys", async (_req, res) => {
     try {
       const config = await readConfig();
@@ -15486,6 +16007,7 @@ function createDashboardServer(options) {
   app.use("/api/leases", createLeasesRouter(broadcast));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/config/agents", createAgentsRouter());
+  app.use("/api/launch", createLaunchPreflightRouter());
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
   app.get("/api/memories", async (_req, res) => {
     try {
@@ -15510,14 +16032,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve24(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve26(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve24(dashboardDistPath, "index.html");
+      const indexPath = resolve26(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -15541,7 +16063,7 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir3,
         todosDir: todosDir2,
-        dbPath: resolve24(syntaurRoot(), "syntaur.db"),
+        dbPath: resolve26(syntaurRoot(), "syntaur.db"),
         onMessage: broadcast
       });
       startAutodiscovery({ serversDir: serversDir2, projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
@@ -15556,7 +16078,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve24(syntaurRoot(), "dashboard-port");
+          const portFile = resolve26(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -15574,7 +16096,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve24(syntaurRoot(), "dashboard-port");
+      const portFile = resolve26(syntaurRoot(), "dashboard-port");
       await unlink5(portFile).catch(() => {
       });
       server.closeAllConnections?.();
@@ -15654,8 +16176,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve25(dirname7(thisFile), "..");
-  const dashboardDist = resolve25(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve27(dirname7(thisFile), "..");
+  const dashboardDist = resolve27(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
@@ -15669,8 +16191,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve25(packageRoot, "dashboard");
-    const viteBin = resolve25(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve27(packageRoot, "dashboard");
+    const viteBin = resolve27(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -15680,7 +16202,7 @@ async function dashboardCommand(options) {
     }
     console.log(`API server running on http://localhost:${port}`);
     console.log("Starting Vite dev server...");
-    viteProcess = spawn(viteBin, [], {
+    viteProcess = spawn2(viteBin, [], {
       cwd: dashboardDir,
       env: {
         ...process.env,
@@ -15745,7 +16267,7 @@ init_config2();
 init_slug();
 init_lifecycle();
 init_assignment_resolver();
-import { resolve as resolve26 } from "path";
+import { resolve as resolve28 } from "path";
 function resolveLinkedTodosLookup(projectsDir2) {
   return { todosDir: todosDir(), projectsDir: projectsDir2 };
 }
@@ -15759,8 +16281,8 @@ async function runTransition(assignment, command, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve26(baseDir, options.project);
-    const projectMdPath = resolve26(projectDir, "project.md");
+    const projectDir = resolve28(baseDir, options.project);
+    const projectMdPath = resolve28(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -15793,8 +16315,8 @@ async function runAssign(assignment, agent, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve26(baseDir, options.project);
-    const projectMdPath = resolve26(projectDir, "project.md");
+    const projectDir = resolve28(baseDir, options.project);
+    const projectMdPath = resolve28(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -15857,8 +16379,8 @@ init_fs();
 init_config2();
 init_frontmatter();
 init_timestamp();
-import { resolve as resolve27 } from "path";
-import { readdir as readdir11, readFile as readFile17 } from "fs/promises";
+import { resolve as resolve29 } from "path";
+import { readdir as readdir12, readFile as readFile19 } from "fs/promises";
 var PROMOTABLE_STATUSES = /* @__PURE__ */ new Set(["pending"]);
 function objectiveIsFleshedOut(content) {
   const match = content.match(/##\s+Objective\s*\n([\s\S]*?)(?=\n##\s+|$)/);
@@ -15876,15 +16398,15 @@ async function collectCandidates(baseDirs) {
   const candidates = [];
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const projects = await readdir11(baseDir, { withFileTypes: true });
+    const projects = await readdir12(baseDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const directAssignmentMd = resolve27(baseDir, m.name, "assignment.md");
+      const directAssignmentMd = resolve29(baseDir, m.name, "assignment.md");
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
-          const content = await readFile17(directAssignmentMd, "utf-8");
+          const content = await readFile19(directAssignmentMd, "utf-8");
           if (objectiveIsFleshedOut(content) && hasAcceptanceCriteria(content)) {
             candidates.push({
               projectSlug: null,
@@ -15897,17 +16419,17 @@ async function collectCandidates(baseDirs) {
         }
         continue;
       }
-      const assignmentsDir2 = resolve27(baseDir, m.name, "assignments");
+      const assignmentsDir2 = resolve29(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir11(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir12(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentMd = resolve27(assignmentsDir2, a.name, "assignment.md");
+        const assignmentMd = resolve29(assignmentsDir2, a.name, "assignment.md");
         if (!await fileExists(assignmentMd)) continue;
         const fm = await parseSafe(assignmentMd);
         if (!fm || !PROMOTABLE_STATUSES.has(fm.status)) continue;
-        const content = await readFile17(assignmentMd, "utf-8");
+        const content = await readFile19(assignmentMd, "utf-8");
         if (!objectiveIsFleshedOut(content)) continue;
         if (!hasAcceptanceCriteria(content)) continue;
         candidates.push({
@@ -15924,7 +16446,7 @@ async function collectCandidates(baseDirs) {
 }
 async function parseSafe(path) {
   try {
-    const content = await readFile17(path, "utf-8");
+    const content = await readFile19(path, "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -15953,7 +16475,7 @@ async function migrateStatusesCommand(options) {
   const now = nowTimestamp();
   let migrated = 0;
   for (const c2 of candidates) {
-    const content = await readFile17(c2.assignmentMd, "utf-8");
+    const content = await readFile19(c2.assignmentMd, "utf-8");
     const updated = updateAssignmentFile(content, {
       status: c2.toStatus,
       updated: now
@@ -16008,10 +16530,10 @@ init_config2();
 init_fs();
 import {
   cp as cp2,
-  readdir as readdir12,
+  readdir as readdir13,
   symlink,
   lstat,
-  readFile as readFile18,
+  readFile as readFile20,
   readlink,
   rename as rename7,
   rm as rm3,
@@ -16020,20 +16542,20 @@ import {
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve29 } from "path";
+import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute3, relative as relative2, resolve as resolve31 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname8, resolve as resolve28 } from "path";
+import { dirname as dirname8, resolve as resolve30 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
   let currentDir = dirname8(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve28(currentDir, expectedRelativePath);
+    const candidate = resolve30(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve28(currentDir, "..");
+    const parentDir = resolve30(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -16054,25 +16576,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir2();
-  return pluginKind === "claude" ? resolve29(home, ".claude", "plugins", "syntaur") : resolve29(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve31(home, ".claude", "plugins", "syntaur") : resolve31(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve29(homedir2(), ".agents", "plugins", "marketplace.json");
+  return resolve31(homedir2(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve29(homedir2(), ".claude", "plugins", "marketplaces");
+  return resolve31(homedir2(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve29(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve31(homedir2(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve29(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  return resolve31(homedir2(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve29(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve31(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile18(resolve29(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile20(resolve31(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -16080,7 +16602,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile18(pathValue, "utf-8");
+    const raw = await readFile20(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -16088,15 +16610,15 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve29(pluginDir, ".claude-plugin", "plugin.json")
+    resolve31(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve29(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve31(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile18(manifestPath, "utf-8");
+  const raw = await readFile20(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -16106,7 +16628,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile18(markerPath, "utf-8");
+    const raw = await readFile20(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -16119,7 +16641,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve29(dirname9(targetDir), symlinkTarget);
+    const resolvedTarget = resolve31(dirname9(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -16165,7 +16687,7 @@ async function installLink(paths) {
   await ensureDir(dirname9(paths.targetDir));
   await rm3(paths.targetDir, { recursive: true, force: true });
   await ensureDir(dirname9(paths.targetDir));
-  await symlink(resolve29(paths.sourceDir), paths.targetDir, "dir");
+  await symlink(resolve31(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
@@ -16176,16 +16698,16 @@ async function removeInstallMarker(targetDir) {
 }
 function normalizeAbsoluteInstallPath(pathValue, label) {
   const expanded = expandHome(pathValue.trim());
-  if (!isAbsolute2(expanded)) {
+  if (!isAbsolute3(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve29(expanded);
+  return resolve31(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve29(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve31(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -16229,7 +16751,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   }
   if (await fileExists(manifestPath)) {
     try {
-      const prev = await readFile18(manifestPath, "utf-8");
+      const prev = await readFile20(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       await writeFile6(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
@@ -16302,7 +16824,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir12(rootDir, { withFileTypes: true })
+    readdir13(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -16310,8 +16832,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve29(rootDir, entry.name);
-    const manifestPath = resolve29(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve31(rootDir, entry.name);
+    const manifestPath = resolve31(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -16338,11 +16860,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve29(expandHome(installLocation));
+    const candidateRoot = resolve31(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve29(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve31(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -16370,14 +16892,14 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve29(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve31(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw = await readFile18(manifestPath, "utf-8");
+    const raw = await readFile20(manifestPath, "utf-8");
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -16404,7 +16926,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   existing[name].autoUpdate = true;
   await ensureDir(dirname9(manifestPath));
   if (await fileExists(manifestPath)) {
-    const prev = await readFile18(manifestPath, "utf-8");
+    const prev = await readFile20(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     await writeFile6(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
@@ -16418,11 +16940,11 @@ async function ensureKnownClaudeMarketplaceForRoot(options) {
   return registerKnownClaudeMarketplace(options.name, options.rootDir);
 }
 async function setSyntaurPluginEnabled(options) {
-  const settingsPath = resolve29(homedir2(), ".claude", "settings.json");
+  const settingsPath = resolve31(homedir2(), ".claude", "settings.json");
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw = await readFile18(settingsPath, "utf-8");
+    const raw = await readFile20(settingsPath, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -16441,7 +16963,7 @@ async function setSyntaurPluginEnabled(options) {
   await ensureDir(dirname9(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const prev = await readFile18(settingsPath, "utf-8");
+    const prev = await readFile20(settingsPath, "utf-8");
     await writeFile6(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
@@ -16455,9 +16977,9 @@ async function ensureClaudeUserMarketplace() {
   if (existing) {
     return existing;
   }
-  const rootDir = resolve29(getClaudeMarketplacesRoot(), "user-plugins");
-  const manifestPath = resolve29(rootDir, ".claude-plugin", "marketplace.json");
-  await ensureDir(resolve29(rootDir, "plugins"));
+  const rootDir = resolve31(getClaudeMarketplacesRoot(), "user-plugins");
+  const manifestPath = resolve31(rootDir, ".claude-plugin", "marketplace.json");
+  await ensureDir(resolve31(rootDir, "plugins"));
   if (!await fileExists(manifestPath)) {
     const scaffold = {
       plugins: []
@@ -16476,7 +16998,7 @@ async function ensureClaudeUserMarketplace() {
     name: "user-plugins",
     rootDir,
     manifestPath,
-    targetDir: resolve29(rootDir, "plugins", "syntaur")
+    targetDir: resolve31(rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
@@ -16486,7 +17008,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const rootDir = dirname9(pluginsDir);
-  const manifestPath = resolve29(rootDir, ".claude-plugin", "marketplace.json");
+  const manifestPath = resolve31(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
@@ -16502,7 +17024,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve29(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve31(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -16627,7 +17149,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve29(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve31(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -16679,7 +17201,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile18(marketplacePath, "utf-8");
+  const raw = await readFile20(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -16840,13 +17362,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve29(syntaurRoot(), "config.md"));
+  return fileExists(resolve31(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
   await rm3(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve29(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve31(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -16915,24 +17437,24 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile20, readdir as readdir13, mkdir as mkdir4, copyFile, rm as rm4, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve31, relative as relative3, join as join3 } from "path";
+import { readFile as readFile22, readdir as readdir14, mkdir as mkdir4, copyFile, rm as rm4, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve33, relative as relative3, join as join3 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
-import { readFile as readFile19 } from "fs/promises";
-import { resolve as resolve30 } from "path";
+import { readFile as readFile21 } from "fs/promises";
+import { resolve as resolve32 } from "path";
 import { homedir as homedir3 } from "os";
 function settingsPathFor(agent) {
-  if (agent === "claude") return resolve30(homedir3(), ".claude", "settings.json");
+  if (agent === "claude") return resolve32(homedir3(), ".claude", "settings.json");
   return null;
 }
 async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile19(path, "utf-8");
+    const raw = await readFile21(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -16980,16 +17502,16 @@ var KNOWN_SKILL_NAMES = [
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
   const packageRoot = await findPackageRoot("skills");
-  return resolve31(packageRoot, "skills");
+  return resolve33(packageRoot, "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve31(homedir4(), ".claude", "skills");
-  return resolve31(homedir4(), ".codex", "skills");
+  if (target === "claude") return resolve33(homedir4(), ".claude", "skills");
+  return resolve33(homedir4(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir13(dir, { withFileTypes: true });
+    const entries = await readdir14(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = join3(dir, entry.name);
       if (entry.isDirectory()) {
@@ -17004,7 +17526,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile20(a), readFile20(b)]);
+    const [ba, bb] = await Promise.all([readFile22(a), readFile22(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -17013,7 +17535,7 @@ async function filesEqual(a, b) {
 }
 async function copyDir(srcDir, destDir) {
   await mkdir4(destDir, { recursive: true });
-  const entries = await readdir13(srcDir, { withFileTypes: true });
+  const entries = await readdir14(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const src = join3(srcDir, entry.name);
     const dest = join3(destDir, entry.name);
@@ -17067,7 +17589,7 @@ async function installSkillDir(srcDir, destDir, skillName, force) {
   return { skill: skillName, status: "differs-preserved", targetPath: destDir };
 }
 async function discoverSkillNames(sourceDir) {
-  const entries = await readdir13(sourceDir, { withFileTypes: true });
+  const entries = await readdir14(sourceDir, { withFileTypes: true });
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -17126,7 +17648,7 @@ async function uninstallSkills(options) {
     if (await isSymlink(destDir)) continue;
     const skillMd = join3(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile20(skillMd, "utf-8").catch(() => "");
+    const content = await readFile22(skillMd, "utf-8").catch(() => "");
     const match = content.match(/^name:\s*(\S+)\s*$/m);
     if (!match || match[1] !== skill) continue;
     await rm4(destDir, { recursive: true, force: true });
@@ -17315,17 +17837,17 @@ async function installPluginCommand(options) {
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile22, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat2, symlink as symlink2, unlink as unlink7, lstat as lstat3 } from "fs/promises";
-import { resolve as resolve33, dirname as dirname11 } from "path";
+import { readFile as readFile24, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat2, symlink as symlink2, unlink as unlink7, lstat as lstat3 } from "fs/promises";
+import { resolve as resolve35, dirname as dirname11 } from "path";
 import { homedir as homedir5 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile21, writeFile as writeFile7 } from "fs/promises";
-import { resolve as resolve32, dirname as dirname10 } from "path";
-import { spawnSync } from "child_process";
+import { readFile as readFile23, writeFile as writeFile7 } from "fs/promises";
+import { resolve as resolve34, dirname as dirname10 } from "path";
+import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
   { name: "git", preview: "syntaur:main* +2", description: "repo:branch (with dirty marker and ahead/behind)" },
@@ -17345,12 +17867,12 @@ var PRESETS = {
   tracker: { segments: ["git", "assignment", "external", "session"], separator: " \xB7 " }
 };
 function getConfigPath(installRoot) {
-  return resolve32(installRoot, "statusline.config.json");
+  return resolve34(installRoot, "statusline.config.json");
 }
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile21(path, "utf-8");
+    const raw = await readFile23(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
@@ -17439,7 +17961,7 @@ function renderPreview(config, statuslineScript, cwd) {
     model: { display_name: "Opus 4.7" },
     context_window: { used_percentage: 42 }
   };
-  const res = spawnSync("bash", [statuslineScript], {
+  const res = spawnSync5("bash", [statuslineScript], {
     input: JSON.stringify(payload),
     encoding: "utf-8",
     env: {
@@ -17503,7 +18025,7 @@ async function configureStatuslineCommand(options = {}) {
   console.log(`  segments:  ${config.segments.join(", ")}`);
   console.log(`  separator: ${JSON.stringify(config.separator)}`);
   if (config.wrap) console.log(`  wrap:      ${config.wrap}`);
-  const script = options.statuslineScript ?? resolve32(installRoot, "statusline.sh");
+  const script = options.statuslineScript ?? resolve34(installRoot, "statusline.sh");
   if (await fileExists(script)) {
     console.log("");
     console.log("Live preview:");
@@ -17534,11 +18056,11 @@ async function writeDefaultConfigIfMissing(installRoot) {
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
   const here = dirname11(fileURLToPath4(import.meta.url));
-  return resolve33(here, "..", "statusline", "statusline.sh");
+  return resolve35(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw = await readFile22(settingsPath, "utf-8");
+  const raw = await readFile24(settingsPath, "utf-8");
   if (raw.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw);
@@ -17618,12 +18140,12 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve33(homedir5(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve35(homedir5(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
-  const destScript = resolve33(installRoot, "statusline.sh");
-  const confPath = resolve33(installRoot, "statusline.conf");
-  const backupPath = resolve33(installRoot, "statusline.backup.json");
+  const destScript = resolve35(installRoot, "statusline.sh");
+  const confPath = resolve35(installRoot, "statusline.conf");
+  const backupPath = resolve35(installRoot, "statusline.backup.json");
   if (!await fileExists(sourceScript)) {
     throw new Error(
       `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
@@ -17659,7 +18181,7 @@ async function installStatuslineCommand(options = {}) {
     if (parsed) {
       wrapTarget = parsed;
     } else {
-      const wrapperPath = resolve33(installRoot, "statusline-wrapped.sh");
+      const wrapperPath = resolve35(installRoot, "statusline-wrapped.sh");
       const wrapperBody = `#!/usr/bin/env bash
 # Auto-generated by syntaur install-statusline.
 # Executes the previously configured statusLine command.
@@ -17714,19 +18236,19 @@ async function chmodExec(path) {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve33(homedir5(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve35(homedir5(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
-  const destScript = resolve33(installRoot, "statusline.sh");
-  const confPath = resolve33(installRoot, "statusline.conf");
-  const backupPath = resolve33(installRoot, "statusline.backup.json");
-  const wrapperPath = resolve33(installRoot, "statusline-wrapped.sh");
+  const destScript = resolve35(installRoot, "statusline.sh");
+  const confPath = resolve35(installRoot, "statusline.conf");
+  const backupPath = resolve35(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve35(installRoot, "statusline-wrapped.sh");
   const settings = await readSettingsJson(settingsPath);
   const existing = extractExistingCommand(settings);
   const ourCommand = `bash ${destScript}`;
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw = await readFile22(backupPath, "utf-8");
+      const raw = await readFile24(backupPath, "utf-8");
       const parsed = JSON.parse(raw);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -17747,7 +18269,7 @@ async function uninstallStatuslineCommand(options = {}) {
     await writeSettingsJson(settingsPath, settings);
   }
   if (!options.keepScript) {
-    const configPath = resolve33(installRoot, "statusline.config.json");
+    const configPath = resolve35(installRoot, "statusline.config.json");
     for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
       try {
         await rm5(path, { force: true });
@@ -18004,7 +18526,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve34 } from "path";
+import { resolve as resolve36 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -18084,7 +18606,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve34(configuredProjectDir) !== resolve34(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve36(configuredProjectDir) !== resolve36(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -18103,7 +18625,7 @@ init_slug();
 init_cursor_rules();
 init_codex_agents();
 init_opencode_config();
-import { resolve as resolve35 } from "path";
+import { resolve as resolve37 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -18129,19 +18651,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve35(baseDir, options.project);
-  const assignmentDir = resolve35(
+  const projectDir = resolve37(baseDir, options.project);
+  const assignmentDir = resolve37(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve35(projectDir, "project.md");
+  const projectMdPath = resolve37(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath2 = resolve35(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve37(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -18169,15 +18691,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve35(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve35(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve37(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve37(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve35(cwd, "AGENTS.md");
+    const agentsPath = resolve37(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve35(cwd, "opencode.json");
+      const configPath = resolve37(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -18202,7 +18724,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve36 } from "path";
+import { resolve as resolve38 } from "path";
 init_session_db();
 init_agent_sessions();
 async function trackSessionCommand(options) {
@@ -18217,7 +18739,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve36(baseDir, options.project);
+    const projectDir = resolve38(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -18257,6 +18779,7 @@ init_config2();
 init_paths();
 
 // src/launch/url.ts
+init_terminal_schema();
 var OpenUrlError = class extends Error {
   code;
   constructor(code, message) {
@@ -18308,6 +18831,24 @@ function parseOpenUrl(input4) {
       "URL has both `assignment` and `session` query params \u2014 only one is allowed"
     );
   }
+  const terminalVals = url.searchParams.getAll("terminal");
+  if (terminalVals.length > 1) {
+    throw new OpenUrlError(
+      "duplicate-param",
+      "URL has more than one `terminal` query param"
+    );
+  }
+  let terminal;
+  if (terminalVals.length === 1 && terminalVals[0].trim() !== "") {
+    const candidate = terminalVals[0];
+    if (!TERMINAL_CHOICES.includes(candidate)) {
+      throw new OpenUrlError(
+        "bad-terminal",
+        `\`terminal\` query param must be one of: ${TERMINAL_CHOICES.join(", ")}`
+      );
+    }
+    terminal = candidate;
+  }
   if (assignmentVals.length === 1) {
     const id = assignmentVals[0];
     if (id.trim() === "") {
@@ -18316,7 +18857,7 @@ function parseOpenUrl(input4) {
         "`assignment` query param is empty"
       );
     }
-    return { kind: "assignment", id };
+    return { kind: "assignment", id, ...terminal ? { terminal } : {} };
   }
   if (sessionVals.length === 1) {
     const id = sessionVals[0];
@@ -18341,7 +18882,7 @@ function parseOpenUrl(input4) {
       }
       mode = raw;
     }
-    return { kind: "session", id, mode };
+    return { kind: "session", id, mode, ...terminal ? { terminal } : {} };
   }
   throw new OpenUrlError(
     "missing-id",
@@ -18355,11 +18896,11 @@ init_assignment_resolver();
 init_api();
 init_launch();
 init_agent_sessions();
-import { isAbsolute as isAbsolute5 } from "path";
+import { isAbsolute as isAbsolute6 } from "path";
 
 // src/launch/argv.ts
 init_launch();
-import { isAbsolute as isAbsolute4 } from "path";
+import { isAbsolute as isAbsolute5 } from "path";
 var buildFreshArgv = buildAgentArgv;
 function buildSessionArgv(agent, sessionId, mode, env = process.env) {
   const invocation = agent[mode];
@@ -18378,7 +18919,7 @@ function buildSessionArgv(agent, sessionId, mode, env = process.env) {
     const requested = env.SHELL;
     let shell = requested;
     let warning = null;
-    if (!shell || !isAbsolute4(shell)) {
+    if (!shell || !isAbsolute5(shell)) {
       warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
       shell = "/bin/sh";
     }
@@ -18414,7 +18955,7 @@ function pickAgent(config) {
   return agents.find((a) => a.default) ?? agents[0];
 }
 async function resolveLaunchPlan(input4) {
-  const terminal = getTerminal(input4.config);
+  const terminal = input4.terminalOverride ?? getTerminal(input4.config);
   if (input4.kind === "assignment") {
     return resolveAssignmentPlan(input4, terminal);
   }
@@ -18520,10 +19061,10 @@ async function resolveSessionPlan(input4, terminal) {
   };
 }
 function pickCwd(input4) {
-  if (input4.worktreePath && isAbsolute5(input4.worktreePath)) {
+  if (input4.worktreePath && isAbsolute6(input4.worktreePath)) {
     return { cwd: input4.worktreePath, fallbackWarning: null };
   }
-  const workspaceDir = input4.repository && isAbsolute5(input4.repository) ? input4.repository : input4.fallbackPath;
+  const workspaceDir = input4.repository && isAbsolute6(input4.repository) ? input4.repository : input4.fallbackPath;
   const fallbackWarning = formatFallbackCwdWarning({
     assignmentSlug: input4.assignmentSlug,
     workspaceDir,
@@ -18535,7 +19076,7 @@ function pickCwd(input4) {
 
 // src/launch/execute.ts
 init_launch();
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 var TerminalNotFoundError = class extends Error {
   terminal;
   remediation;
@@ -18548,7 +19089,7 @@ var TerminalNotFoundError = class extends Error {
     this.name = "TerminalNotFoundError";
   }
 };
-var realSpawn = (command, args, options) => spawn3(command, args, options);
+var realSpawn = (command, args, options) => spawn4(command, args, options);
 var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["osascript", "open"]);
 var WRAPPER_EXIT_TIMEOUT_MS = 1500;
 async function executeLaunchPlan(plan, spawnFn = realSpawn) {
@@ -18575,7 +19116,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve70, reject) => {
+  await new Promise((resolve72, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -18585,7 +19126,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve70();
+      resolve72();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -18658,19 +19199,19 @@ function buildTerminalInvocation(plan) {
         command: "osascript",
         args: [
           "-e",
-          'tell application "Ghostty"',
+          'tell application "Ghostty" to activate',
           "-e",
-          "activate",
+          "delay 0.3",
           "-e",
-          "set newWin to (new window)",
+          'tell application "System Events"',
           "-e",
-          "delay 0.2",
+          'keystroke "n" using command down',
           "-e",
-          "set t to terminal 1 of selected tab of newWin",
+          "delay 0.4",
           "-e",
-          `input text ${appleScriptString(cdAndRun)} to t`,
+          `keystroke ${appleScriptString(cdAndRun)}`,
           "-e",
-          'send key "enter" to t',
+          "key code 36",
           "-e",
           "end tell"
         ]
@@ -18714,7 +19255,7 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname12, resolve as resolve38, join as join4 } from "path";
+import { dirname as dirname12, resolve as resolve40, join as join4 } from "path";
 import { realpathSync, readFileSync, mkdirSync } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -18740,7 +19281,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile49 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile50 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath3);
   if (resolved === null) {
@@ -18761,7 +19302,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
     const pkgJsonPath = join4(dir, "package.json");
     let raw;
     try {
-      raw = readFile49(pkgJsonPath);
+      raw = readFile50(pkgJsonPath);
     } catch {
       const parent2 = dirname12(dir);
       if (parent2 === dir) break;
@@ -18793,7 +19334,7 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve38(syntaurRoot(), "npx-handler-nudge");
+  return resolve40(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
@@ -18858,7 +19399,8 @@ async function urlCommand(input4, options = {}) {
     mode: parsed.kind === "session" ? parsed.mode : void 0,
     config,
     projectsDir: projectsDir2,
-    assignmentsDir: assignmentsDir()
+    assignmentsDir: assignmentsDir(),
+    terminalOverride: parsed.terminal
   });
   if (plan.fallbackWarning) {
     console.error(plan.fallbackWarning);
@@ -18933,9 +19475,8 @@ function formatInstallUrlHandlerError(err2) {
 init_config2();
 init_paths();
 init_fs();
-import { spawnSync as spawnSync3 } from "child_process";
-import { resolve as resolve40, isAbsolute as isAbsolute6 } from "path";
-import { readFile as readFile24 } from "fs/promises";
+import { resolve as resolve42, isAbsolute as isAbsolute7 } from "path";
+import { readFile as readFile25 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -19004,7 +19545,7 @@ async function pickAgent2(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve40(
+  const assignmentPath = resolve42(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -19014,7 +19555,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile24(assignmentPath, "utf-8");
+  const content = await readFile25(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -19081,44 +19622,10 @@ async function ensureWorktree(opts) {
     worktreePath
   });
 }
-function computeWorktreeDefaults(opts) {
-  const repository = opts.existing.repository ?? detectCurrentGitRoot();
-  const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
-  const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch() ?? "main";
-  const worktreeBase = repository ? resolve40(repository, ".worktrees", branch) : resolve40(
-    syntaurRoot(),
-    "worktrees",
-    opts.projectSlug || "standalone",
-    opts.assignmentSlug
-  );
-  return {
-    ...repository ? { repository } : {},
-    branch,
-    parentBranch,
-    worktreePath: worktreeBase
-  };
-}
-function detectCurrentGitRoot() {
-  const result = spawnSync3("git", ["rev-parse", "--show-toplevel"], {
-    encoding: "utf-8"
-  });
-  if (result.status !== 0) return void 0;
-  const out = result.stdout.trim();
-  return out.length > 0 ? out : void 0;
-}
-function detectCurrentBranch() {
-  const result = spawnSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-    encoding: "utf-8"
-  });
-  if (result.status !== 0) return void 0;
-  const out = result.stdout.trim();
-  if (!out || out === "HEAD") return void 0;
-  return out;
-}
 async function runCreate(opts) {
   const { createWorktreeAndRecord: createWorktreeAndRecord2, GitWorktreeError: GitWorktreeError2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
   const expandedWorktree = expandHome(opts.worktreePath);
-  const absWorktree = isAbsolute6(expandedWorktree) ? expandedWorktree : resolve40(expandedWorktree);
+  const absWorktree = isAbsolute7(expandedWorktree) ? expandedWorktree : resolve42(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -19147,7 +19654,7 @@ init_paths();
 init_fs();
 init_playbook();
 init_playbooks();
-import { resolve as resolve41 } from "path";
+import { resolve as resolve43 } from "path";
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -19160,7 +19667,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve41(dir, `${slug}.md`);
+  const filePath = resolve43(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -19182,8 +19689,8 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir14, readFile as readFile25 } from "fs/promises";
-import { resolve as resolve42 } from "path";
+import { readdir as readdir15, readFile as readFile26 } from "fs/promises";
+import { resolve as resolve44 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -19192,14 +19699,14 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir14(dir, { withFileTypes: true });
+  const entries = await readdir15(dir, { withFileTypes: true });
   const mdFiles = entries.filter(
     (e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md"
   );
   const rows = [];
   for (const entry of mdFiles) {
-    const filePath = resolve42(dir, entry.name);
-    const raw = await readFile25(filePath, "utf-8");
+    const filePath = resolve44(dir, entry.name);
+    const raw = await readFile26(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -19322,8 +19829,8 @@ init_fs();
 init_config2();
 init_slug();
 import { Command } from "commander";
-import { readFile as readFile26 } from "fs/promises";
-import { resolve as resolve43 } from "path";
+import { readFile as readFile27 } from "fs/promises";
+import { resolve as resolve45 } from "path";
 var WORKSPACE_REGEX3 = /^[a-z0-9_][a-z0-9-]*$/;
 async function resolveScope(options) {
   const flagCount = [Boolean(options.project), Boolean(options.workspace), Boolean(options.global)].filter(Boolean).length;
@@ -19335,7 +19842,7 @@ async function resolveScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve43(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve45(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -19656,10 +20163,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve43(todosPath, "archive"));
+    await ensureDir(resolve45(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile26(archFile, "utf-8");
+      archContent = await readFile27(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -19831,12 +20338,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile49 } = await import("fs/promises");
+  const { readFile: readFile50 } = await import("fs/promises");
   const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
   const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
   const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
-  let content = await readFile49(assignmentMdPath2, "utf-8");
+  let content = await readFile50(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -19881,13 +20388,13 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     }
     const planDir = todoPlanDir(todosPath, workspace, id);
     await ensureDir(planDir);
-    const { readdir: readdir24 } = await import("fs/promises");
-    const existingFiles = (await readdir24(planDir).catch(() => [])).filter(
+    const { readdir: readdir25 } = await import("fs/promises");
+    const existingFiles = (await readdir25(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
     if (existingFiles.length === 0) {
-      target = resolve43(planDir, "plan.md");
+      target = resolve45(planDir, "plan.md");
     } else {
       const versions = /* @__PURE__ */ new Set();
       for (const f of existingFiles) {
@@ -19897,7 +20404,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
       }
       let n = 2;
       while (versions.has(n)) n++;
-      target = resolve43(planDir, `plan-v${n}.md`);
+      target = resolve45(planDir, `plan-v${n}.md`);
     }
     if (!await fileExists(target)) {
       const stub = `---
@@ -20086,12 +20593,12 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command3 } from "commander";
-import { readFile as readFile34 } from "fs/promises";
-import { isAbsolute as isAbsolute9, resolve as resolve54 } from "path";
+import { readFile as readFile35 } from "fs/promises";
+import { isAbsolute as isAbsolute10, resolve as resolve56 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { readFile as readFile33 } from "fs/promises";
+import { readFile as readFile34 } from "fs/promises";
 import { dirname as dirname16, join as join8 } from "path";
 
 // src/utils/doctor/context.ts
@@ -20099,11 +20606,11 @@ init_config2();
 init_paths();
 init_fs();
 import Database3 from "better-sqlite3";
-import { resolve as resolve44 } from "path";
+import { resolve as resolve46 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve44(root, "syntaur.db");
+  const dbPath = resolve46(root, "syntaur.db");
   let db4 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -20137,8 +20644,8 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve45, isAbsolute as isAbsolute7 } from "path";
-import { readFile as readFile27, stat as stat3 } from "fs/promises";
+import { resolve as resolve47, isAbsolute as isAbsolute8 } from "path";
+import { readFile as readFile28, stat as stat3 } from "fs/promises";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { dirname as dirname14, join as join6 } from "path";
 var CATEGORY = "env";
@@ -20178,7 +20685,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve45(ctx.syntaurRoot, "config.md");
+    const configPath = resolve47(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -20195,7 +20702,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile27(configPath, "utf-8");
+    const content = await readFile28(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -20232,7 +20739,7 @@ var configValid = {
       };
     }
     const expanded = expandHome(rawProjectDir);
-    if (!isAbsolute7(expanded)) {
+    if (!isAbsolute8(expanded)) {
       return {
         id: this.id,
         category: this.category,
@@ -20475,7 +20982,7 @@ async function readLocalPkg() {
     for (let i = 0; i < 6; i++) {
       const candidate = join6(dir, "package.json");
       try {
-        const text = await readFile27(candidate, "utf-8");
+        const text = await readFile28(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
         dir = dirname14(dir);
@@ -20527,8 +21034,8 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve46 } from "path";
-import { readdir as readdir15, stat as stat4 } from "fs/promises";
+import { resolve as resolve48 } from "path";
+import { readdir as readdir16, stat as stat4 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -20547,7 +21054,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve46(ctx.syntaurRoot, "projects");
+    const p = resolve48(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -20572,7 +21079,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve46(ctx.syntaurRoot, "playbooks");
+    const p = resolve48(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -20597,7 +21104,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve46(ctx.syntaurRoot, "todos");
+    const p = resolve48(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -20628,7 +21135,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve46(ctx.syntaurRoot, "servers");
+    const p = resolve48(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -20659,7 +21166,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir15(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir16(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -20673,7 +21180,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve46(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve48(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -20702,8 +21209,8 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve47 } from "path";
-import { readdir as readdir16, stat as stat5 } from "fs/promises";
+import { resolve as resolve49 } from "path";
+import { readdir as readdir17, stat as stat5 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -20727,15 +21234,15 @@ var PROJECT_MARKERS = ["project.md", "manifest.md", "assignments"];
 async function listProjects2(ctx) {
   const dir = ctx.config.defaultProjectDir;
   if (!await fileExists(dir)) return [];
-  const entries = await readdir16(dir, { withFileTypes: true });
+  const entries = await readdir17(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve47(dir, e.name);
+    const projectDir = resolve49(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve47(projectDir, marker))) {
+      if (await fileExists(resolve49(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -20754,7 +21261,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve47(projectDir, rel);
+        const p = resolve49(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -20764,7 +21271,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve47(projectDir, m)),
+        affected: missing.map((m) => resolve49(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -20787,7 +21294,7 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve47(projectDir, "manifest.md");
+      const manifestPath = resolve49(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
       const manifestMtime = (await stat5(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
@@ -20821,7 +21328,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir16(projectDir, { withFileTypes: true });
+      const entries = await readdir17(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -20836,7 +21343,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve47(projectDir, o)),
+        affected: orphans.map((o) => resolve49(projectDir, o)),
         autoFixable: false
       });
     }
@@ -20846,18 +21353,18 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve47(projectDir, "assignments");
+  const assignmentsRoot = resolve49(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
   try {
-    entries = await readdir16(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir17(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve47(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve49(assignmentsRoot, e.name, "assignment.md");
     try {
       const s = await stat5(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
@@ -20881,8 +21388,8 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve48 } from "path";
-import { readdir as readdir17, readFile as readFile28 } from "fs/promises";
+import { resolve as resolve50 } from "path";
+import { readdir as readdir18, readFile as readFile29 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -20916,20 +21423,20 @@ async function listAssignments(ctx) {
   const result = { withAssignmentMd: [], orphanFolders: [] };
   const projectsDir2 = ctx.config.defaultProjectDir;
   if (await fileExists(projectsDir2)) {
-    const projects = await readdir17(projectsDir2, { withFileTypes: true });
+    const projects = await readdir18(projectsDir2, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve48(projectsDir2, m.name, "assignments");
+      const assignmentsDir2 = resolve50(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir17(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir18(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve48(assignmentsDir2, a.name);
-        const assignmentMd = resolve48(assignmentDir, "assignment.md");
+        const assignmentDir = resolve50(assignmentsDir2, a.name);
+        const assignmentMd = resolve50(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve48(projectsDir2, m.name),
+          projectDir: resolve50(projectsDir2, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -20945,12 +21452,12 @@ async function listAssignments(ctx) {
   }
   const standaloneRoot = assignmentsDir();
   if (await fileExists(standaloneRoot)) {
-    const entries = await readdir17(standaloneRoot, { withFileTypes: true });
+    const entries = await readdir18(standaloneRoot, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve48(standaloneRoot, a.name);
-      const assignmentMd = resolve48(assignmentDir, "assignment.md");
+      const assignmentDir = resolve50(standaloneRoot, a.name);
+      const assignmentMd = resolve50(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneRoot,
         projectSlug: null,
@@ -21028,7 +21535,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -21061,7 +21568,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -21108,12 +21615,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve48(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve48(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve50(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -21123,7 +21630,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve48(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve50(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -21146,7 +21653,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve48(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve50(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -21158,7 +21665,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve48(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve50(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -21191,7 +21698,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -21225,7 +21732,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -21276,13 +21783,13 @@ var draftMissingObjective = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "draft") continue;
       let raw;
       try {
-        raw = await readFile28(path, "utf-8");
+        raw = await readFile29(path, "utf-8");
       } catch {
         continue;
       }
@@ -21315,16 +21822,16 @@ var readyToImplementMissingPlan = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve48(a.assignmentDir, "assignment.md");
+      const path = resolve50(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir17(a.assignmentDir).catch(() => []);
+      const entries = await readdir18(a.assignmentDir).catch(() => []);
       const planFiles = entries.filter((f) => /^plan(?:-v\d+)?\.md$/i.test(f));
       let hasPlanContent = false;
       for (const f of planFiles) {
         try {
-          const c2 = await readFile28(resolve48(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile29(resolve50(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -21340,7 +21847,7 @@ var readyToImplementMissingPlan = {
         title: this.title,
         status: "warn",
         detail: `${label} (status: ready_to_implement) has no plan.md or plan-v<N>.md`,
-        affected: [resolve48(a.assignmentDir, "plan.md")],
+        affected: [resolve50(a.assignmentDir, "plan.md")],
         remediation: {
           kind: "manual",
           suggestion: `Write a plan with '/plan-assignment' (or 'syntaur plan'), then re-mark ready_to_implement`,
@@ -21367,7 +21874,7 @@ var assignmentChecks = [
 ];
 async function parseSafe2(path) {
   try {
-    const content = await readFile28(path, "utf-8");
+    const content = await readFile29(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -21386,7 +21893,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve49 } from "path";
+import { resolve as resolve51 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -21400,7 +21907,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve49(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve51(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -21418,7 +21925,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve49(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve51(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -21430,7 +21937,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve49(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve51(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -21456,7 +21963,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve49(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve51(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -21475,7 +21982,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve49(
+        const assignmentPath = resolve51(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -21527,8 +22034,8 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve50, dirname as dirname15, basename as basename5 } from "path";
-import { readdir as readdir18, readFile as readFile29 } from "fs/promises";
+import { resolve as resolve52, dirname as dirname15, basename as basename5 } from "path";
+import { readdir as readdir19, readFile as readFile30 } from "fs/promises";
 import { homedir as homedir7 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -21591,7 +22098,7 @@ var backupConfigured = {
     if (ctx.config.backup?.repo) return pass6(this);
     const projectsDir2 = ctx.config.defaultProjectDir;
     if (!await fileExists(projectsDir2)) return skipped2(this, "no projects dir");
-    const entries = await readdir18(projectsDir2, { withFileTypes: true });
+    const entries = await readdir19(projectsDir2, { withFileTypes: true });
     const hasProjects = entries.some((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
     if (!hasProjects) return skipped2(this, "no projects yet");
     return {
@@ -21610,10 +22117,10 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve50(homedir7(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve52(homedir7(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw = await readFile29(path, "utf-8");
+    const raw = await readFile30(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -21647,7 +22154,7 @@ var claudeMarketplaceRegistered = {
       };
     }
     const marketplaceRoot = dirname15(pluginsParent);
-    const marketplaceManifest = resolve50(marketplaceRoot, ".claude-plugin", "marketplace.json");
+    const marketplaceManifest = resolve52(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
         id: this.id,
@@ -21666,7 +22173,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile29(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile30(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -21698,7 +22205,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve50(homedir7(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve52(homedir7(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -21738,8 +22245,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve51 } from "path";
-import { readFile as readFile30 } from "fs/promises";
+import { resolve as resolve53 } from "path";
+import { readFile as readFile31 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 function hasAnyAssignmentField(ctx) {
@@ -21751,12 +22258,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve51(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve53(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile30(path, "utf-8");
+    const raw = await readFile31(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -21831,7 +22338,7 @@ var contextAssignmentResolves = {
     if (!exists) return skipped3(this, "no context to resolve");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve51(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve53(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -21860,10 +22367,10 @@ var contextTerminal = {
     if (!exists) return skipped3(this, "no context to check");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve51(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve53(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile30(assignmentMd, "utf-8");
+      const content = await readFile31(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -21917,9 +22424,9 @@ function skipped3(check, reason) {
 
 // src/utils/doctor/checks/agents.ts
 init_config2();
-import { isAbsolute as isAbsolute8 } from "path";
+import { isAbsolute as isAbsolute9 } from "path";
 import { access as access2, constants as fsConstants } from "fs/promises";
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 var CATEGORY8 = "agents";
 var agentsResolvable = {
   id: "agents.commands-resolvable",
@@ -21963,7 +22470,7 @@ async function checkAgent(agent) {
       autoFixable: false
     };
   }
-  if (isAbsolute8(agent.command)) {
+  if (isAbsolute9(agent.command)) {
     try {
       await access2(agent.command, fsConstants.X_OK);
       return { ...base, status: "pass", autoFixable: false };
@@ -21983,7 +22490,7 @@ async function checkAgent(agent) {
       };
     }
   }
-  const result = spawnSync4("which", [agent.command], { encoding: "utf-8" });
+  const result = spawnSync7("which", [agent.command], { encoding: "utf-8" });
   if (result.status === 0 && result.stdout.trim().length > 0) {
     return {
       ...base,
@@ -22008,26 +22515,16 @@ var agentChecks = [agentsResolvable];
 
 // src/utils/doctor/checks/terminal.ts
 init_config2();
+import { spawnSync as spawnSync8 } from "child_process";
+import { readFile as readFile32 } from "fs/promises";
+import { resolve as resolve54 } from "path";
 init_paths();
 init_fs();
-import { spawnSync as spawnSync5 } from "child_process";
-import { readFile as readFile31 } from "fs/promises";
-import { resolve as resolve52 } from "path";
 var CATEGORY9 = "terminal";
-var APP_BUNDLE_IDS = {
-  "terminal-app": "com.apple.Terminal",
-  iterm: "com.googlecode.iterm2",
-  ghostty: "com.mitchellh.ghostty",
-  warp: "dev.warp.Warp-Stable"
-};
-var CLI_NAMES = {
-  alacritty: "alacritty",
-  kitty: "kitty"
-};
 async function readRawTerminalKey() {
-  const configPath = resolve52(syntaurRoot(), "config.md");
+  const configPath = resolve54(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return null;
-  const content = await readFile31(configPath, "utf-8");
+  const content = await readFile32(configPath, "utf-8");
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) return null;
   const line = fmMatch[1].split("\n").find((l) => /^terminal:\s*/.test(l));
@@ -22086,68 +22583,41 @@ var terminalInstalled = {
     const terminal = getTerminal(ctx.config);
     const bundleId = APP_BUNDLE_IDS[terminal];
     const cliName = CLI_NAMES[terminal];
-    if (bundleId) {
-      const result = spawnSync5(
-        "mdfind",
-        [`kMDItemCFBundleIdentifier == '${bundleId}'`],
-        { encoding: "utf-8" }
-      );
-      if (result.status === 0 && result.stdout.trim().length > 0) {
-        return {
-          id: this.id,
-          category: this.category,
-          title: this.title,
-          status: "pass",
-          detail: `found ${terminal} at ${result.stdout.trim().split("\n")[0]}`,
-          autoFixable: false
-        };
-      }
+    const probe = probeTerminalInstalled(terminal);
+    if (probe.reason === "no-probe-available") {
       return {
         id: this.id,
         category: this.category,
         title: this.title,
-        status: "warn",
-        detail: `${terminal} (bundle id ${bundleId}) not found via Spotlight`,
-        remediation: {
-          kind: "manual",
-          suggestion: `Install ${terminal} or change \`terminal:\` in ~/.syntaur/config.md to a different choice`,
-          command: null
-        },
+        status: "skipped",
+        detail: `no install check defined for ${terminal}`,
         autoFixable: false
       };
     }
-    if (cliName) {
-      const result = spawnSync5("which", [cliName], { encoding: "utf-8" });
-      if (result.status === 0 && result.stdout.trim().length > 0) {
-        return {
-          id: this.id,
-          category: this.category,
-          title: this.title,
-          status: "pass",
-          detail: `resolved ${cliName} \u2192 ${result.stdout.trim()}`,
-          autoFixable: false
-        };
-      }
+    if (probe.ok) {
+      const detail2 = bundleId ? `found ${terminal} at ${probe.foundPath}` : `resolved ${cliName} \u2192 ${probe.foundPath}`;
       return {
         id: this.id,
         category: this.category,
         title: this.title,
-        status: "warn",
-        detail: `${cliName} not found on PATH`,
-        remediation: {
-          kind: "manual",
-          suggestion: `Install ${cliName} or change \`terminal:\` in ~/.syntaur/config.md to a different choice`,
-          command: null
-        },
+        status: "pass",
+        detail: detail2,
         autoFixable: false
       };
     }
+    const detail = bundleId ? `${terminal} (bundle id ${bundleId}) not found via Spotlight` : `${cliName} not found on PATH`;
+    const suggestion = bundleId ? `Install ${terminal} or change \`terminal:\` in ~/.syntaur/config.md to a different choice` : `Install ${cliName} or change \`terminal:\` in ~/.syntaur/config.md to a different choice`;
     return {
       id: this.id,
       category: this.category,
       title: this.title,
-      status: "skipped",
-      detail: `no install check defined for ${terminal}`,
+      status: "warn",
+      detail,
+      remediation: {
+        kind: "manual",
+        suggestion,
+        command: null
+      },
       autoFixable: false
     };
   }
@@ -22167,7 +22637,7 @@ var kittyRemoteControl = {
         autoFixable: false
       };
     }
-    const result = spawnSync5("kitty", ["@", "ls"], {
+    const result = spawnSync8("kitty", ["@", "ls"], {
       encoding: "utf-8",
       timeout: 2e3
     });
@@ -22204,13 +22674,13 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve53, join as join7 } from "path";
-import { readdir as readdir19, readFile as readFile32, lstat as lstat4 } from "fs/promises";
+import { resolve as resolve55, join as join7 } from "path";
+import { readdir as readdir20, readFile as readFile33, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve53(homedir8(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve53(homedir8(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve55(homedir8(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve55(homedir8(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -22225,7 +22695,7 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir19(dir, { withFileTypes: true });
+        entries = await readdir20(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -22234,7 +22704,7 @@ var skillsDedupCheck = {
         if (!KNOWN_SKILLS.includes(entry.name)) continue;
         const skillMd = join7(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile32(skillMd, "utf-8").catch(() => "");
+        const content = await readFile33(skillMd, "utf-8").catch(() => "");
         const match = content.match(/^name:\s*(\S+)\s*$/m);
         if (!match || match[1] !== entry.name) continue;
         let isSymlink2 = false;
@@ -22380,7 +22850,7 @@ async function readVersion() {
     let dir = dirname16(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile33(join8(dir, "package.json"), "utf-8");
+        const raw = await readFile34(join8(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
@@ -22477,7 +22947,7 @@ var REQUIRED_WORKSPACE_FIELDS = [
 ];
 var ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
-  const absolute = isAbsolute9(inputPath) ? inputPath : resolve54(cwd, inputPath);
+  const absolute = isAbsolute10(inputPath) ? inputPath : resolve56(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -22490,7 +22960,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile34(absolute, "utf-8");
+    content = await readFile35(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -22814,8 +23284,8 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve55 } from "path";
-import { readFile as readFile35 } from "fs/promises";
+import { resolve as resolve57 } from "path";
+import { readFile as readFile36 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -22845,7 +23315,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve55(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve57(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -22855,13 +23325,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve55(assignmentDir, "comments.md");
+  const commentsPath = resolve57(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile35(commentsPath, "utf-8");
+    currentContent = await readFile36(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -22895,7 +23365,7 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve59, relative as relative4, dirname as dirname17 } from "path";
+import { resolve as resolve61, relative as relative4, dirname as dirname17 } from "path";
 import { copyFile as copyFile3, mkdir as mkdir8, realpath as realpath2, rm as rm10, stat as stat8, writeFile as writeFile11 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 
@@ -22906,15 +23376,15 @@ init_config2();
 init_slug();
 init_assignment_resolver();
 init_parser();
-import { resolve as resolve56 } from "path";
-import { readFile as readFile36 } from "fs/promises";
+import { resolve as resolve58 } from "path";
+import { readFile as readFile37 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 async function readAssignmentFrontmatterId(assignmentDir) {
-  const path = resolve56(assignmentDir, "assignment.md");
+  const path = resolve58(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile36(path, "utf-8");
+    const content = await readFile37(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -22922,10 +23392,10 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   }
 }
 async function readContextJson(cwd) {
-  const path = resolve56(cwd, ".syntaur", "context.json");
+  const path = resolve58(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile36(path, "utf-8");
+    const raw = await readFile37(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -22946,15 +23416,15 @@ async function resolveAssignmentTarget(input4, opts = {}) {
     if (!isValidSlug(input4)) {
       throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
     }
-    const projectDir = resolve56(baseDir, opts.project);
-    const projectMdPath = resolve56(projectDir, "project.md");
+    const projectDir = resolve58(baseDir, opts.project);
+    const projectMdPath = resolve58(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new AssignmentTargetError(
         `Project "${opts.project}" not found at ${projectDir}.`
       );
     }
-    const assignmentDir = resolve56(projectDir, "assignments", input4);
-    const assignmentMdPath2 = resolve56(assignmentDir, "assignment.md");
+    const assignmentDir = resolve58(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve58(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `Assignment "${input4}" not found in project "${opts.project}".`
@@ -22988,7 +23458,7 @@ async function resolveAssignmentTarget(input4, opts = {}) {
   }
   if (ctx.assignmentDir) {
     const dir = expandHome(ctx.assignmentDir);
-    const assignmentMdPath2 = resolve56(dir, "assignment.md");
+    const assignmentMdPath2 = resolve58(dir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment dir: ${dir}.`
@@ -23017,8 +23487,8 @@ async function resolveAssignmentTarget(input4, opts = {}) {
         `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
       );
     }
-    const assignmentDir = resolve56(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
-    const assignmentMdPath2 = resolve56(assignmentDir, "assignment.md");
+    const assignmentDir = resolve58(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve58(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
@@ -23153,7 +23623,7 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn6 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile37, rm as rm7 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile38, rm as rm7 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join10 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
@@ -23216,7 +23686,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile37(castPath, "utf8").catch(() => null);
+    const text = await readFile38(castPath, "utf8").catch(() => null);
     if (text === null) {
       throw new Error(
         `asciinema produced no cast file at ${castPath} (exit ${exitCode}). Try running 'asciinema rec ${castPath}' directly to diagnose.`
@@ -23244,9 +23714,9 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn7 } from "child_process";
-import { mkdir as mkdir7, mkdtemp as mkdtemp4, open as open3, readFile as readFile38, rm as rm8, stat as stat7, unlink as unlink8, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir7, mkdtemp as mkdtemp4, open as open3, readFile as readFile39, rm as rm8, stat as stat7, unlink as unlink8, writeFile as writeFile10 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join11, resolve as resolve57 } from "path";
+import { join as join11, resolve as resolve59 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
   const raw = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
@@ -23267,13 +23737,13 @@ function sigtermWaitMs() {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1e3;
 }
 function pidfilePath() {
-  return resolve57(syntaurRoot(), "recording.pid");
+  return resolve59(syntaurRoot(), "recording.pid");
 }
 function logPath2() {
-  return resolve57(syntaurRoot(), "recording.log");
+  return resolve59(syntaurRoot(), "recording.log");
 }
 function sidecarPath() {
-  return resolve57(syntaurRoot(), "recording.json");
+  return resolve59(syntaurRoot(), "recording.json");
 }
 function ffmpegArgs(device, fps, mp4Path) {
   return [
@@ -23318,7 +23788,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile38(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile39(pidfile, "utf-8").catch(() => "")).trim();
       if (existing.startsWith(STARTING_SENTINEL_PREFIX)) {
         const parentPidRaw = existing.slice(STARTING_SENTINEL_PREFIX.length);
         const parentPid = Number.parseInt(parentPidRaw, 10);
@@ -23420,7 +23890,7 @@ async function startRecording(input4) {
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile38(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile39(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
       acquiredPid = null;
       throw new Error(
         `ffmpeg exited during startup \u2014 likely macOS Screen Recording permission missing. Grant access to your terminal in System Settings \u2192 Privacy & Security \u2192 Screen Recording, then retry. Log: ${log}
@@ -23477,7 +23947,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile38(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile39(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -23487,7 +23957,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile38(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile39(sidecar, "utf-8").catch(() => null);
   if (sidecarRaw === null) {
     throw new Error(
       `No recording sidecar at ${sidecar}. The recording state is inconsistent \u2014 delete ${pidfile} and re-run --start.`
@@ -23552,7 +24022,7 @@ async function stopRecording() {
 // src/db/proof-db.ts
 init_paths();
 import Database4 from "better-sqlite3";
-import { resolve as resolve58 } from "path";
+import { resolve as resolve60 } from "path";
 var db3 = null;
 var PROOF_SCHEMA_VERSION = "1";
 var SCHEMA_SQL3 = `
@@ -23572,7 +24042,7 @@ CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
 function initProofDb(dbPath) {
   if (db3) return db3;
-  const finalPath = dbPath ?? resolve58(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve60(syntaurRoot(), "syntaur.db");
   db3 = new Database4(finalPath);
   db3.pragma("journal_mode = WAL");
   db3.exec(SCHEMA_SQL3);
@@ -23620,7 +24090,7 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile39, rm as rm9 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile40, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join12 } from "path";
 var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
@@ -23684,7 +24154,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile39(wavPath);
+  const audio = await readFile40(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -24000,7 +24470,7 @@ async function captureCommand(target, options = {}) {
     });
   }
   if (options.file) {
-    const expanded = options.file.startsWith("~/") ? resolve59(process.env.HOME ?? "", options.file.slice(2)) : resolve59(options.file);
+    const expanded = options.file.startsWith("~/") ? resolve61(process.env.HOME ?? "", options.file.slice(2)) : resolve61(options.file);
     if (!await fileExists(expanded)) {
       throw new Error(`--file does not exist: ${options.file}`);
     }
@@ -24041,7 +24511,7 @@ async function captureCommand(target, options = {}) {
     }
     initProofDb();
     const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-    const destDir = resolve59(proofDir(resolved.assignmentDir), subdir);
+    const destDir = resolve61(proofDir(resolved.assignmentDir), subdir);
     if (resolvedSource) await mkdir8(destDir, { recursive: true });
     const ext = resolvedSource ? extensionForKind(kind) : null;
     let id = null;
@@ -24050,7 +24520,7 @@ async function captureCommand(target, options = {}) {
     let lastErr = null;
     for (let attempt = 0; attempt < MAX_ID_RETRIES; attempt += 1) {
       const candidate = generateArtifactId();
-      const candidateAbsPath = resolvedSource && ext ? resolve59(destDir, `${candidate}.${ext}`) : null;
+      const candidateAbsPath = resolvedSource && ext ? resolve61(destDir, `${candidate}.${ext}`) : null;
       const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
       try {
         insertArtifact({
@@ -24094,7 +24564,7 @@ async function captureCommand(target, options = {}) {
       }
     }
     if (options.transcribe && kind === "video" && absPath && id) {
-      const sidecarPath2 = resolve59(destDir, `${id}.transcript.md`);
+      const sidecarPath2 = resolve61(destDir, `${id}.transcript.md`);
       if (existsSync3(sidecarPath2)) {
         console.warn(
           `transcript: ${sidecarPath2} already exists, skipping (delete to re-transcribe)`
@@ -24126,7 +24596,7 @@ async function captureCommand(target, options = {}) {
     const tagSuffix = criterionIndex === null ? "untagged" : `criterion ${criterionIndex}`;
     console.log(`Captured artifact ${id} (${kind}) for ${ref} \u2014 ${tagSuffix}.`);
     if (relativeFilePath) {
-      console.log(`  file: ${resolve59(resolved.assignmentDir, relativeFilePath)}`);
+      console.log(`  file: ${resolve61(resolved.assignmentDir, relativeFilePath)}`);
     }
   } catch (err2) {
     if (options.stop && kind === "video" && shelloutCleanup && resolvedSource) {
@@ -24149,8 +24619,8 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command5 } from "commander";
-import { readFile as readFile40, writeFile as writeFile12, rename as rename8, stat as stat9 } from "fs/promises";
-import { resolve as resolve60, relative as relative5, isAbsolute as isAbsolute10, dirname as dirname18 } from "path";
+import { readFile as readFile41, writeFile as writeFile12, rename as rename8, stat as stat9 } from "fs/promises";
+import { resolve as resolve62, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname18 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -24390,11 +24860,11 @@ function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map(), trans
 
 // src/commands/proof.ts
 async function readAssignmentMeta(assignmentDir) {
-  const path = resolve60(assignmentDir, "assignment.md");
+  const path = resolve62(assignmentDir, "assignment.md");
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile40(path, "utf-8");
+  const content = await readFile41(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -24413,7 +24883,7 @@ async function atomicWrite(destPath, content) {
 }
 function isWithin(root, target) {
   const rel = relative5(root, target);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute10(rel);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute11(rel);
 }
 function groupArtifacts(rows, criterionCount) {
   const artifactsByCriterion = /* @__PURE__ */ new Map();
@@ -24441,7 +24911,7 @@ async function loadInlineFiles(rows, assignmentDir) {
   for (const r of rows) {
     if (!r.file_path) continue;
     if (r.kind !== "http" && r.kind !== "text") continue;
-    const abs = resolve60(assignmentDir, r.file_path);
+    const abs = resolve62(assignmentDir, r.file_path);
     if (!isWithin(proofRoot, abs)) {
       out.set(r.file_path, null);
       continue;
@@ -24456,7 +24926,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       continue;
     }
     try {
-      out.set(r.file_path, await readFile40(abs, "utf-8"));
+      out.set(r.file_path, await readFile41(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -24468,14 +24938,14 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
   const proofRoot = proofDir(assignmentDir);
   for (const r of rows) {
     if (r.kind !== "video" || !r.file_path) continue;
-    const videoAbs = resolve60(assignmentDir, r.file_path);
-    const sidecar = resolve60(dirname18(videoAbs), `${r.id}.transcript.md`);
+    const videoAbs = resolve62(assignmentDir, r.file_path);
+    const sidecar = resolve62(dirname18(videoAbs), `${r.id}.transcript.md`);
     if (!isWithin(proofRoot, sidecar)) continue;
     if (!await fileExists(sidecar)) continue;
     const st = await stat9(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile40(sidecar, "utf-8"));
+      out.set(r.id, await readFile41(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -24509,8 +24979,8 @@ async function proofBuildCommand(target, options = {}) {
   };
   const md = renderProofMarkdown(renderParams);
   const html = renderProofHtml(renderParams, inlineFiles, transcriptSidecars);
-  const mdPath = resolve60(resolved.assignmentDir, "proof.md");
-  const htmlPath = resolve60(resolved.assignmentDir, "proof.html");
+  const mdPath = resolve62(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve62(resolved.assignmentDir, "proof.html");
   await atomicWrite(mdPath, md);
   await atomicWrite(htmlPath, html);
   console.log(`Wrote ${htmlPath}`);
@@ -25007,8 +25477,8 @@ init_slug();
 init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
-import { resolve as resolve61 } from "path";
-import { readFile as readFile41 } from "fs/promises";
+import { resolve as resolve63 } from "path";
+import { readFile as readFile42 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -25024,7 +25494,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve61(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve63(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -25034,12 +25504,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath2 = resolve61(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve63(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile41(assignmentMdPath2, "utf-8");
+  let content = await readFile42(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -25052,13 +25522,13 @@ async function requestCommand(target, text, options = {}) {
 init_fs();
 init_paths();
 import { Command as Command7 } from "commander";
-import { readFile as readFile42, readdir as readdir20 } from "fs/promises";
-import { resolve as resolve62 } from "path";
+import { readFile as readFile43, readdir as readdir21 } from "fs/promises";
+import { resolve as resolve64 } from "path";
 async function readContextAssignmentDir(cwd) {
-  const path = resolve62(cwd, ".syntaur", "context.json");
+  const path = resolve64(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile42(path, "utf-8");
+    const raw = await readFile43(path, "utf-8");
     const ctx = JSON.parse(raw);
     if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
       return ctx.assignmentDir;
@@ -25072,9 +25542,9 @@ async function resolveAssignmentDir(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.assignment) {
     if (opts.project) {
-      return resolve62(defaultProjectDir(), opts.project, "assignments", opts.assignment);
+      return resolve64(defaultProjectDir(), opts.project, "assignments", opts.assignment);
     }
-    return resolve62(assignmentsDir(), opts.assignment);
+    return resolve64(assignmentsDir(), opts.assignment);
   }
   const fromCtx = await readContextAssignmentDir(cwd);
   if (fromCtx) return fromCtx;
@@ -25085,7 +25555,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir20(assignmentDir, { withFileTypes: true });
+  const entries = await readdir21(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -25217,7 +25687,7 @@ async function runPlanVersion(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve62(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve64(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
@@ -25229,15 +25699,15 @@ async function runPlanVersion(options) {
   }
   const current = planFiles[planFiles.length - 1];
   const next = nextPlanFileName(current.version);
-  const newPath = resolve62(assignmentDir, next.fileName);
+  const newPath = resolve64(assignmentDir, next.fileName);
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
-  const assignmentMd = await readFile42(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile43(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
-  const oldPlanPath = resolve62(assignmentDir, current.fileName);
-  const oldPlanContent = await readFile42(oldPlanPath, "utf-8");
+  const oldPlanPath = resolve64(assignmentDir, current.fileName);
+  const oldPlanContent = await readFile43(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -25274,26 +25744,26 @@ planCommand.command("version").description(
 // src/commands/session.ts
 init_fs();
 import { Command as Command8 } from "commander";
-import { readFile as readFile43, readdir as readdir21, stat as stat10 } from "fs/promises";
-import { resolve as resolve63 } from "path";
+import { readFile as readFile44, readdir as readdir22, stat as stat10 } from "fs/promises";
+import { resolve as resolve65 } from "path";
 async function readContext(cwd) {
-  const path = resolve63(cwd, ".syntaur", "context.json");
+  const path = resolve65(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile43(path, "utf-8");
+    const raw = await readFile44(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function findLatestSessionSummary(assignmentDir) {
-  const sessionsRoot = resolve63(assignmentDir, "sessions");
+  const sessionsRoot = resolve65(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir21(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir22(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const summaryPath = resolve63(sessionsRoot, entry.name, "summary.md");
+    const summaryPath = resolve65(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
     const st = await stat10(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
@@ -25303,9 +25773,9 @@ async function findLatestSessionSummary(assignmentDir) {
   return best;
 }
 async function findOpenHandoff(assignmentDir) {
-  const handoffPath = resolve63(assignmentDir, "handoff.md");
+  const handoffPath = resolve65(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile43(handoffPath, "utf-8");
+  const content = await readFile44(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
   if (body.length === 0) return null;
   if (/^<!--[\s\S]*-->$/.test(body)) return null;
@@ -25413,13 +25883,13 @@ init_git_worktree();
 init_fs();
 init_paths();
 import { Command as Command9 } from "commander";
-import { readFile as readFile44 } from "fs/promises";
-import { resolve as resolve64 } from "path";
+import { readFile as readFile45 } from "fs/promises";
+import { resolve as resolve66 } from "path";
 async function readContext2(cwd) {
-  const path = resolve64(cwd, ".syntaur", "context.json");
+  const path = resolve66(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile44(path, "utf-8"));
+    return JSON.parse(await readFile45(path, "utf-8"));
   } catch {
     return null;
   }
@@ -25427,7 +25897,7 @@ async function readContext2(cwd) {
 async function resolveAssignmentPath2(opts) {
   if (opts.assignment) {
     if (opts.project) {
-      return resolve64(
+      return resolve66(
         defaultProjectDir(),
         opts.project,
         "assignments",
@@ -25435,10 +25905,10 @@ async function resolveAssignmentPath2(opts) {
         "assignment.md"
       );
     }
-    return resolve64(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve66(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext2(opts.cwd);
-  if (ctx?.assignmentDir) return resolve64(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve66(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -25449,7 +25919,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   }
   const repository = options.repository ?? cwd;
   const parentBranch = options.parentBranch ?? "main";
-  const worktreePath = options.worktreePath ?? resolve64(repository, ".worktrees", options.branch);
+  const worktreePath = options.worktreePath ?? resolve66(repository, ".worktrees", options.branch);
   const assignmentPath = await resolveAssignmentPath2({
     assignment: options.assignment,
     project: options.project,
@@ -25486,13 +25956,13 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command10 } from "commander";
-import { resolve as resolve66 } from "path";
+import { resolve as resolve68 } from "path";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir22, readFile as readFile45 } from "fs/promises";
-import { resolve as resolve65 } from "path";
+import { readdir as readdir23, readFile as readFile46 } from "fs/promises";
+import { resolve as resolve67 } from "path";
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -25501,7 +25971,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir22(dir, { withFileTypes: true });
+  const entries = await readdir23(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -25511,7 +25981,7 @@ function joinList(items) {
   return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
 }
 async function rebuildResourcesIndex(projectDir) {
-  const dir = resolve65(projectDir, "resources");
+  const dir = resolve67(projectDir, "resources");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -25527,7 +25997,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile45(resolve65(dir, fileName), "utf-8");
+    const content = await readFile46(resolve67(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -25537,12 +26007,12 @@ async function rebuildResourcesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve65(dir, "_index.md");
+  const indexPath = resolve67(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 async function rebuildMemoriesIndex(projectDir) {
-  const dir = resolve65(projectDir, "memories");
+  const dir = resolve67(projectDir, "memories");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -25558,7 +26028,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile45(resolve65(dir, fileName), "utf-8");
+    const content = await readFile46(resolve67(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -25568,7 +26038,7 @@ async function rebuildMemoriesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve65(dir, "_index.md");
+  const indexPath = resolve67(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
@@ -25606,8 +26076,8 @@ async function runResourceAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve66(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve66(projectDir, "project.md"))) {
+  const projectDir = resolve68(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve68(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -25616,7 +26086,7 @@ async function runResourceAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid resource slug: "${slug}".`);
   }
-  const filePath = resolve66(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve68(projectDir, "resources", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -25651,7 +26121,7 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command11 } from "commander";
-import { resolve as resolve67 } from "path";
+import { resolve as resolve69 } from "path";
 function nowIso4() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -25686,8 +26156,8 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve67(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve67(projectDir, "project.md"))) {
+  const projectDir = resolve69(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve69(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -25696,7 +26166,7 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid memory slug: "${slug}".`);
   }
-  const filePath = resolve67(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve69(projectDir, "memories", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -25733,8 +26203,8 @@ init_paths();
 init_fs();
 init_frontmatter();
 import { Command as Command12 } from "commander";
-import { readFile as readFile46 } from "fs/promises";
-import { resolve as resolve68 } from "path";
+import { readFile as readFile47 } from "fs/promises";
+import { resolve as resolve70 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -25753,7 +26223,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve68(
+    return resolve70(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -25761,13 +26231,13 @@ function assignmentMdPath(item) {
       "assignment.md"
     );
   }
-  return resolve68(assignmentsDir(), item.id, "assignment.md");
+  return resolve70(assignmentsDir(), item.id, "assignment.md");
 }
 async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile46(path, "utf-8");
+    const content = await readFile47(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -25845,10 +26315,10 @@ var lsCommand = new Command12("ls").description(
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir23 } from "fs/promises";
+import { readdir as readdir24 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir23(projectsDir2, { withFileTypes: true });
+    const entries = await readdir24(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;
@@ -25885,20 +26355,20 @@ async function getDefaultCommandName() {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { readFile as readFile48 } from "fs/promises";
-import { dirname as dirname20, join as join14, resolve as resolve69 } from "path";
+import { readFile as readFile49 } from "fs/promises";
+import { dirname as dirname20, join as join14, resolve as resolve71 } from "path";
 import { spawn as spawn9 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { readFile as readFile47 } from "fs/promises";
+import { readFile as readFile48 } from "fs/promises";
 import { dirname as dirname19, join as join13 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath9(scriptUrl);
     const pkgRoot = dirname19(dirname19(scriptPath));
-    const raw = await readFile47(join13(pkgRoot, "package.json"), "utf-8");
+    const raw = await readFile48(join13(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -25907,7 +26377,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve69(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve71(syntaurRoot(), "npx-install.json");
 var META_ARGS2 = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -25928,7 +26398,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile48(STATE_FILE, "utf-8");
+    const raw = await readFile49(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -25987,7 +26457,7 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join14(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile48(manifestPath, "utf-8");
+    const raw = await readFile49(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {