syntaur 0.16.0 → 0.16.2

package/dist/dashboard/server.js

@@ -294,6 +294,62 @@ function updateAssignmentFile(fileContent, updates) {
   }
   return result;
 }
+function findWorkspaceBlock(fmBlock) {
+  const headerMatch = fmBlock.match(/^workspace:\s*$/m);
+  if (!headerMatch) return null;
+  const headerStart = fmBlock.indexOf(headerMatch[0]);
+  const bodyStart = headerStart + headerMatch[0].length + 1;
+  const after = fmBlock.slice(bodyStart);
+  const lines = after.split("\n");
+  let consumed = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) {
+      consumed += line.length + 1;
+      continue;
+    }
+    if (line[0] !== " ") break;
+    consumed += line.length + 1;
+  }
+  const bodyEnd = Math.min(bodyStart + consumed, fmBlock.length);
+  return { headerStart, bodyStart, bodyEnd };
+}
+function updateAssignmentWorkspace(fileContent, partial) {
+  const fmMatch = fileContent.match(/^(---\n)([\s\S]*?)(\n---)/);
+  if (!fmMatch) {
+    throw new Error("No frontmatter found in assignment file. Expected --- delimiters.");
+  }
+  const fmBlock = fmMatch[2];
+  const fields = ["repository", "worktreePath", "branch", "parentBranch"];
+  const block = findWorkspaceBlock(fmBlock);
+  let newFm = fmBlock;
+  if (block) {
+    let body = fmBlock.slice(block.bodyStart, block.bodyEnd);
+    for (const field of fields) {
+      if (!(field in partial)) continue;
+      const value = partial[field] ?? null;
+      const formatted = formatYamlValue(value);
+      const lineRegex = new RegExp(`^(\\s+${field}:)\\s*.*$`, "m");
+      if (lineRegex.test(body)) {
+        body = body.replace(lineRegex, `$1 ${formatted}`);
+      } else {
+        const trimmed = body.replace(/\n+$/, "");
+        body = `${trimmed}${trimmed.length > 0 ? "\n" : ""}  ${field}: ${formatted}
+`;
+      }
+    }
+    newFm = fmBlock.slice(0, block.bodyStart) + body + fmBlock.slice(block.bodyEnd);
+  } else {
+    const lines = ["workspace:"];
+    for (const field of fields) {
+      const value = field in partial ? partial[field] ?? null : null;
+      lines.push(`  ${field}: ${formatYamlValue(value)}`);
+    }
+    newFm = `${fmBlock.replace(/\n+$/, "")}
+${lines.join("\n")}`;
+  }
+  return `${fmMatch[1]}${newFm}${fmMatch[3]}${fileContent.slice(fmMatch[0].length)}`;
+}
 var init_frontmatter = __esm({
   "src/lifecycle/frontmatter.ts"() {
     "use strict";
@@ -407,6 +463,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] = extractFrontmatter2(fileContent);
   const slug = getField(fm, "slug") ?? getField(fm, "mission") ?? "";
@@ -422,6 +484,7 @@ function parseProject(fileContent) {
     updated: getField(fm, "updated") ?? "",
     tags: parseListField(fm, "tags"),
     workspace: getField(fm, "workspace"),
+    repositories: parseListField(fm, "repositories").map(unquoteYamlString),
     externalIds: parseExternalIds2(fm),
     body
   };
@@ -1319,7 +1382,6 @@ backup:
   categories: projects, playbooks, todos, servers, config
   lastBackup: null
   lastRestore: null
-terminal: terminal-app
 ---
 
 # Syntaur Configuration
@@ -1588,6 +1650,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, {
@@ -1601,6 +1679,7 @@ __export(config_exports, {
   deleteAgentsConfig: () => deleteAgentsConfig,
   deleteHotkeyBindingsConfig: () => deleteHotkeyBindingsConfig,
   deleteStatusConfig: () => deleteStatusConfig,
+  deleteTerminalConfig: () => deleteTerminalConfig,
   deleteThemeConfig: () => deleteThemeConfig,
   getAgents: () => getAgents,
   getAssignmentTypes: () => getAssignmentTypes,
@@ -1617,9 +1696,11 @@ __export(config_exports, {
   writeAgentsConfig: () => writeAgentsConfig,
   writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
   writeStatusConfig: () => writeStatusConfig,
+  writeTerminalConfig: () => writeTerminalConfig,
   writeThemeConfig: () => writeThemeConfig
 });
 import { readFile as readFile4 } from "fs/promises";
+import { spawnSync } from "child_process";
 import { resolve as resolve6, isAbsolute } from "path";
 function parseAgentCommand(value, agentId) {
   if (typeof value !== "string" || value.trim() === "") {
@@ -2032,6 +2113,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 = resolve6(syntaurRoot(), "config.md");
+  const terminalLine = `terminal: ${terminal}`;
+  const existing = await fileExists(configPath) ? await readFile4(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 = resolve6(syntaurRoot(), "config.md");
+  if (!await fileExists(configPath)) return;
+  const existing = await readFile4(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;
@@ -2727,7 +2854,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();
@@ -2740,7 +2878,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";
@@ -2750,6 +2888,7 @@ var init_config2 = __esm({
     init_fs_migration();
     init_hotkeysCatalog();
     init_agents_schema();
+    init_terminal_schema();
     DEFAULT_ASSIGNMENT_TYPES = {
       definitions: [
         { id: "feature", label: "Feature" },
@@ -2760,14 +2899,6 @@ var init_config2 = __esm({
       ],
       default: "feature"
     };
-    TERMINAL_CHOICES = [
-      "terminal-app",
-      "iterm",
-      "ghostty",
-      "alacritty",
-      "warp",
-      "kitty"
-    ];
     DEFAULT_CONFIG = {
       version: "2.0",
       defaultProjectDir: defaultProjectDir(),
@@ -3705,8 +3836,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile16 } = await import("fs/promises");
-  const raw = await readFile16(filePath, "utf-8");
+  const { readFile: readFile18 } = await import("fs/promises");
+  const raw = await readFile18(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4895,7 +5026,8 @@ async function getProjectDetail(projectsDir, slug) {
     resources,
     memories,
     dependencyGraph,
-    workspace: project.workspace
+    workspace: project.workspace,
+    repositories: project.repositories
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
@@ -6175,7 +6307,7 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve24 } from "path";
 import { writeFile as writeFile5, unlink as unlink5 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -6708,8 +6840,9 @@ function withTwoLocks(keyA, keyB, fn) {
 init_lifecycle();
 init_slug();
 import { Router } from "express";
-import { resolve as resolve15, basename as basename3 } from "path";
-import { rm, readFile as readFile12, open as fsOpen } from "fs/promises";
+import { resolve as resolve17, basename as basename3, isAbsolute as isAbsolute2 } from "path";
+import { rm, readFile as readFile14, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/utils/uuid.ts
 import { randomUUID } from "crypto";
@@ -6720,6 +6853,203 @@ function generateId() {
 // src/dashboard/api-write.ts
 init_timestamp();
 init_fs();
+
+// src/utils/git-worktree.ts
+init_frontmatter();
+init_fs();
+import { spawn } from "child_process";
+import { readFile as readFile12 } 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", (err) => {
+      resolvePromise({ code: -1, stdout, stderr: stderr + String(err) });
+    });
+    child.on("close", (code) => {
+      resolvePromise({ code: code ?? -1, stdout, stderr });
+    });
+  });
+}
+var GitWorktreeError = class extends Error {
+  constructor(message, stderr) {
+    super(message);
+    this.stderr = 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 readFile12(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}".`;
+}
+
+// src/utils/worktree-defaults.ts
+init_paths();
+import { spawnSync as spawnSync2 } from "child_process";
+import { resolve as resolve15 } 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 ? resolve15(repository, ".worktrees", branch) : resolve15(
+    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 readdir9, readFile as readFile13 } from "fs/promises";
+import { resolve as resolve16 } from "path";
+async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const projectPath = resolve16(projectsDir, projectSlug, "project.md");
+  if (await fileExists(projectPath)) {
+    const project = parseProject(await readFile13(projectPath, "utf-8"));
+    for (const raw of project.repositories) {
+      const path = raw.trim();
+      if (!path) continue;
+      const abs = resolve16(path);
+      if (seen.has(abs)) continue;
+      seen.add(abs);
+      out.push({ path: abs, source: "project", sourceAssignmentSlug: null });
+    }
+  }
+  const assignmentsDir2 = resolve16(projectsDir, projectSlug, "assignments");
+  if (await fileExists(assignmentsDir2)) {
+    const entries = await readdir9(assignmentsDir2, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const assignmentMd = resolve16(assignmentsDir2, entry.name, "assignment.md");
+      if (!await fileExists(assignmentMd)) continue;
+      const parsed = parseAssignmentFull(await readFile13(assignmentMd, "utf-8"));
+      const repo = parsed.workspace.repository?.trim();
+      if (!repo) continue;
+      const abs = resolve16(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 readdir9(assignmentsDir2, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === excludeAssignmentId) continue;
+    const assignmentMd = resolve16(assignmentsDir2, entry.name, "assignment.md");
+    if (!await fileExists(assignmentMd)) continue;
+    const parsed = parseAssignmentFull(await readFile13(assignmentMd, "utf-8"));
+    const repo = parsed.workspace.repository?.trim();
+    if (!repo) continue;
+    const abs = resolve16(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
@@ -6809,10 +7139,17 @@ function escapeYamlString(value) {
 }
 
 // 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}
@@ -6823,7 +7160,8 @@ archivedReason: null
 created: "${params2.timestamp}"
 updated: "${params2.timestamp}"
 externalIds: []
-tags: []${workspaceLine}
+tags: []
+${repositoriesBlock}${workspaceLine}
 ---
 
 # ${params2.title}
@@ -7266,7 +7604,101 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile12(filePath, "utf-8");
+  return readFile14(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 readFile14(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 = resolve17(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(projectsDir, assignmentsDir2, todosDir2) {
   const linkedTodosLookup = todosDir2 ? { todosDir: todosDir2, projectsDir } : void 0;
@@ -7495,9 +7927,9 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           });
           return;
         }
-        const folderPath = resolve15(projectDir, folder);
+        const folderPath = resolve17(projectDir, folder);
         await ensureDir(folderPath);
-        const filePath = resolve15(folderPath, `${requestedSlug}.md`);
+        const filePath = resolve17(folderPath, `${requestedSlug}.md`);
         const timestamp = nowTimestamp();
         let content = renderItemStub(kind, {
           slug: requestedSlug,
@@ -7541,14 +7973,14 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve15(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve17(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 readFile12(filePath, "utf-8");
+        const currentContent = await readFile14(filePath, "utf-8");
         const frontmatterBlock = extractFrontmatterBlock(currentContent);
         if (!frontmatterBlock) {
           res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
@@ -7577,7 +8009,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve15(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve17(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
@@ -7611,26 +8043,26 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve15(projectsDir, slug);
+      const projectDir = resolve17(projectsDir, 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(resolve15(projectDir, "assignments"));
-      await ensureDir(resolve15(projectDir, "resources"));
-      await ensureDir(resolve15(projectDir, "memories"));
-      await writeFileForce(resolve15(projectDir, "project.md"), content);
+      await ensureDir(resolve17(projectDir, "assignments"));
+      await ensureDir(resolve17(projectDir, "resources"));
+      await ensureDir(resolve17(projectDir, "memories"));
+      await writeFileForce(resolve17(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve15(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve15(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve15(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve15(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve15(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve15(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve15(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve17(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve17(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve17(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve17(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve17(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve17(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve17(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -7651,8 +8083,8 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve15(projectsDir, projectSlug);
-      const projectMdPath = resolve15(projectDir, "project.md");
+      const projectDir = resolve17(projectsDir, projectSlug);
+      const projectMdPath = resolve17(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -7682,7 +8114,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve15(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve17(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -7691,12 +8123,12 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve15(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve17(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve15(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve15(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve15(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve17(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve17(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve17(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -7717,7 +8149,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve15(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve17(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -7750,7 +8182,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve15(
+      const assignmentPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7793,7 +8225,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve15(
+      const assignmentPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7829,7 +8261,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve15(
+      const planPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7867,7 +8299,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve15(
+      const scratchpadPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7905,7 +8337,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve15(
+      const handoffPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7943,7 +8375,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve15(
+      const decisionPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7981,7 +8413,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve15(
+      const commentsPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -7999,7 +8431,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile12(commentsPath, "utf-8");
+        currentContent = await readFile14(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -8040,7 +8472,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve15(
+      const commentsPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -8056,7 +8488,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile12(commentsPath, "utf-8");
+      const content = await readFile14(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -8091,7 +8523,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve15(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve17(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -8103,7 +8535,7 @@ ${entry}`;
         });
         return;
       }
-      let content = await readFile12(projectPath, "utf-8");
+      let content = await readFile14(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -8139,8 +8571,8 @@ ${entry}`;
         });
         return;
       }
-      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
-      let content = await readFile12(assignmentPath, "utf-8");
+      const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -8151,10 +8583,108 @@ ${entry}`;
       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 = resolve17(projectsDir, projectSlug, "project.md");
+        if (!await fileExists(projectPath)) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const candidates = await getProjectRepositoryCandidates(projectsDir, 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(projectsDir, assignmentsDir2, id);
+        if (!resolved) {
+          res.status(404).json({ error: `Assignment "${id}" not found` });
+          return;
+        }
+        const candidates = resolved.standalone ? await getStandaloneRepositoryCandidates(assignmentsDir2, id) : await getProjectRepositoryCandidates(projectsDir, 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 = resolve17(
+          projectsDir,
+          projectSlug,
+          "assignments",
+          assignmentSlug,
+          "assignment.md"
+        );
+        await handleWorktreeCreate(req, res, {
+          assignmentPath,
+          projectSlug,
+          assignmentSlug,
+          reload: () => getAssignmentDetail(projectsDir, projectSlug, assignmentSlug)
+        });
+      } catch (error) {
+        console.error("Error creating worktree:", error);
+        res.status(500).json({ error: `Failed to create worktree: ${error.message}` });
+      }
+    }
+  );
+  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(projectsDir, assignmentsDir2, id);
+        if (!resolved) {
+          res.status(404).json({ error: `Assignment "${id}" not found` });
+          return;
+        }
+        const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
+        const parsedForSlug = parseAssignmentFull(await readFile14(assignmentPath, "utf-8"));
+        const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
+        await handleWorktreeCreate(req, res, {
+          assignmentPath,
+          projectSlug: resolved.projectSlug ?? "",
+          assignmentSlug: assignmentSlugForBranch,
+          reload: () => getAssignmentDetailById(projectsDir, assignmentsDir2, id)
+        });
+      } catch (error) {
+        console.error("Error creating worktree:", error);
+        res.status(500).json({ error: `Failed to create worktree: ${error.message}` });
+      }
+    }
+  );
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve15(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve17(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -8166,7 +8696,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile12(projectPath, "utf-8");
+      let content = await readFile14(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -8181,7 +8711,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve15(
+      const assignmentPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -8199,7 +8729,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile12(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -8217,7 +8747,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve15(
+      const assignmentPath = resolve17(
         projectsDir,
         projectSlug,
         "assignments",
@@ -8233,7 +8763,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile12(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -8255,8 +8785,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve15(projectsDir, projectSlug);
-      const assignmentPath = resolve15(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve17(projectsDir, projectSlug);
+      const assignmentPath = resolve17(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -8283,8 +8813,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve15(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve15(assignmentDir, "assignment.md");
+      const assignmentDir = resolve17(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve17(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -8339,7 +8869,7 @@ ${entry}`;
           return;
         }
         const id2 = generateId();
-        const assignmentDir2 = resolve15(assignmentsDir2, id2);
+        const assignmentDir2 = resolve17(assignmentsDir2, id2);
         if (await fileExists(assignmentDir2)) {
           res.status(500).json({ error: "UUID collision \u2014 try again" });
           return;
@@ -8347,25 +8877,25 @@ ${entry}`;
         const timestamp2 = fields.created || nowTimestamp();
         await ensureDir(assignmentDir2);
         const normalizedContent = setTopLevelField(rawContent, "id", id2);
-        await writeFileForce(resolve15(assignmentDir2, "assignment.md"), normalizedContent);
+        await writeFileForce(resolve17(assignmentDir2, "assignment.md"), normalizedContent);
         await writeFileForce(
-          resolve15(assignmentDir2, "scratchpad.md"),
+          resolve17(assignmentDir2, "scratchpad.md"),
           renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve15(assignmentDir2, "handoff.md"),
+          resolve17(assignmentDir2, "handoff.md"),
           renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve15(assignmentDir2, "decision-record.md"),
+          resolve17(assignmentDir2, "decision-record.md"),
           renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve15(assignmentDir2, "progress.md"),
+          resolve17(assignmentDir2, "progress.md"),
           renderProgress({ assignment: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve15(assignmentDir2, "comments.md"),
+          resolve17(assignmentDir2, "comments.md"),
           renderComments({ assignment: id2, timestamp: timestamp2 })
         );
         const detail2 = await getAssignmentDetailById(projectsDir, assignmentsDir2, id2);
@@ -8383,7 +8913,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve15(assignmentsDir2, id);
+      const assignmentDir = resolve17(assignmentsDir2, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -8403,25 +8933,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve15(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve17(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve15(assignmentDir, "scratchpad.md"),
+        resolve17(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve15(assignmentDir, "handoff.md"),
+        resolve17(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve15(assignmentDir, "decision-record.md"),
+        resolve17(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve15(assignmentDir, "progress.md"),
+        resolve17(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve15(assignmentDir, "comments.md"),
+        resolve17(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir, assignmentsDir2, id);
@@ -8549,7 +9079,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -8591,7 +9121,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve15(resolved.assignmentDir, "plan.md");
+      const planPath = resolve17(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -8625,7 +9155,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve15(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve17(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -8659,7 +9189,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve15(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve17(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -8699,7 +9229,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve15(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve17(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -8739,7 +9269,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -8751,7 +9281,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile12(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -8777,7 +9307,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -8787,7 +9317,7 @@ ${entry}`;
         res.status(400).json({ error: validation.error });
         return;
       }
-      let content = await readFile12(assignmentPath, "utf-8");
+      let content = await readFile14(assignmentPath, "utf-8");
       content = setTopLevelField(content, "assignee", validation.value);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, content);
@@ -8841,9 +9371,9 @@ ${entry}`;
             if (!resolved) {
               throw new Error(`assignment "${item.id}" not found`);
             }
-            assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
+            assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
           } else if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string" && item.projectSlug && item.assignmentSlug) {
-            assignmentPath = resolve15(
+            assignmentPath = resolve17(
               projectsDir,
               item.projectSlug,
               "assignments",
@@ -8856,7 +9386,7 @@ ${entry}`;
           if (!await fileExists(assignmentPath)) {
             throw new Error("assignment file not found");
           }
-          let content = await readFile12(assignmentPath, "utf-8");
+          let content = await readFile14(assignmentPath, "utf-8");
           content = setTopLevelField(content, "status", status);
           content = setTopLevelField(content, "updated", timestamp);
           if (status !== "blocked") {
@@ -8888,7 +9418,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve17(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -8980,7 +9510,7 @@ function buildBulkItemKey(raw, index) {
   return `#${index}`;
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve15(assignmentDir, "comments.md");
+  const commentsPath = resolve17(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" });
@@ -8992,7 +9522,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile12(commentsPath, "utf-8");
+    currentContent = await readFile14(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -9022,7 +9552,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve15(assignmentDir, "comments.md");
+  const commentsPath = resolve17(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -9032,7 +9562,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile12(commentsPath, "utf-8");
+  const content = await readFile14(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -9179,7 +9709,7 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir2) {
 init_agent_sessions();
 init_fs();
 import { Router as Router3 } from "express";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve18 } from "path";
 
 // src/utils/transcript.ts
 import { open } from "fs/promises";
@@ -9277,7 +9807,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve16(projectsDir, projectSlug);
+      const projectDir = resolve18(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -9307,7 +9837,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve16(projectsDir, projectSlug);
+        const projectDir = resolve18(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -9631,14 +10161,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 resolve17 } from "path";
+import { resolve as resolve19 } from "path";
 var db2 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL2 = `
@@ -9725,7 +10377,7 @@ function isBusyError(err) {
 }
 function initLeasesDb(dbPath) {
   if (db2) return db2;
-  const finalPath = dbPath ?? resolve17(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve19(syntaurRoot(), "syntaur.db");
   db2 = new Database2(finalPath);
   db2.pragma("journal_mode = WAL");
   db2.pragma("busy_timeout = 5000");
@@ -9814,7 +10466,7 @@ function forceReleaseLease(lease_id) {
 
 // src/dashboard/api-leases.ts
 function createLeasesRouter(broadcast) {
-  const router = Router5();
+  const router = Router7();
   router.get("/", (_req, res) => {
     try {
       initLeasesDb();
@@ -9874,9 +10526,9 @@ init_parser();
 init_slug();
 init_timestamp();
 init_fs();
-import { Router as Router6 } from "express";
-import { resolve as resolve18 } from "path";
-import { readFile as readFile13 } from "fs/promises";
+import { Router as Router8 } from "express";
+import { resolve as resolve20 } from "path";
+import { readFile as readFile15 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
   switch (code) {
@@ -9891,7 +10543,7 @@ function statusForPlaybookError(code) {
   }
 }
 function createPlaybooksRouter(playbooksDir2) {
-  const router = Router6();
+  const router = Router8();
   router.get("/", async (_req, res) => {
     try {
       const playbooks = await listPlaybooks(playbooksDir2);
@@ -9958,8 +10610,8 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve18(playbooksDir2, resolved.filename);
-      const content = await readFile13(filePath, "utf-8");
+      const filePath = resolve20(playbooksDir2, resolved.filename);
+      const content = await readFile15(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -9984,7 +10636,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve18(playbooksDir2, `${slug}.md`);
+      const filePath = resolve20(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -10008,7 +10660,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve18(playbooksDir2, resolved.filename);
+      const filePath = resolve20(playbooksDir2, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: resolved.slug, path: filePath });
@@ -10055,8 +10707,8 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router7 } from "express";
-import { readdir as readdir9 } from "fs/promises";
+import { Router as Router9 } from "express";
+import { readdir as readdir10 } from "fs/promises";
 import { resolve as resolvePath, dirname as dirname4 } from "path";
 import { rename as rename4, mkdir as mkdir2 } from "fs/promises";
 init_slug();
@@ -10067,7 +10719,7 @@ init_parser2();
 // src/commands/create-assignment.ts
 init_slug();
 init_timestamp();
-import { resolve as resolve19 } from "path";
+import { resolve as resolve21 } from "path";
 init_paths();
 init_fs();
 init_config2();
@@ -10145,14 +10797,14 @@ async function createAssignmentCommand(title, options) {
   if (options.oneOff) {
     const standaloneRoot = assignmentsDir();
     folderName = id;
-    assignmentDir = resolve19(standaloneRoot, folderName);
+    assignmentDir = resolve21(standaloneRoot, folderName);
     projectSlug = null;
     await ensureDir(standaloneRoot);
   } else {
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
     projectSlug = options.project;
-    const projectDir = resolve19(baseDir, projectSlug);
-    const projectMdPath = resolve19(projectDir, "project.md");
+    const projectDir = resolve21(baseDir, projectSlug);
+    const projectMdPath = resolve21(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(
         `Project "${projectSlug}" not found at ${projectDir}.
@@ -10160,9 +10812,9 @@ Run 'syntaur create-project' first or use --one-off.`
       );
     }
     if (dependsOn.length > 0) {
-      const depDirBase = resolve19(projectDir, "assignments");
+      const depDirBase = resolve21(projectDir, "assignments");
       for (const dep of dependsOn) {
-        const depDir = resolve19(depDirBase, dep);
+        const depDir = resolve21(depDirBase, dep);
         if (!await fileExists(depDir)) {
           console.warn(
             `Warning: dependency "${dep}" does not exist in project "${projectSlug}" yet.`
@@ -10171,7 +10823,7 @@ Run 'syntaur create-project' first or use --one-off.`
       }
     }
     folderName = assignmentSlug;
-    assignmentDir = resolve19(projectDir, "assignments", folderName);
+    assignmentDir = resolve21(projectDir, "assignments", folderName);
   }
   if (await fileExists(assignmentDir)) {
     throw new Error(
@@ -10183,7 +10835,7 @@ Use --slug to specify a different slug.`
   const companionAssignmentRef = projectSlug === null ? id : assignmentSlug;
   const files = [
     [
-      resolve19(assignmentDir, "assignment.md"),
+      resolve21(assignmentDir, "assignment.md"),
       renderAssignment({
         id,
         slug: assignmentSlug,
@@ -10201,35 +10853,35 @@ Use --slug to specify a different slug.`
       })
     ],
     [
-      resolve19(assignmentDir, "scratchpad.md"),
+      resolve21(assignmentDir, "scratchpad.md"),
       renderScratchpad({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve19(assignmentDir, "handoff.md"),
+      resolve21(assignmentDir, "handoff.md"),
       renderHandoff({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve19(assignmentDir, "decision-record.md"),
+      resolve21(assignmentDir, "decision-record.md"),
       renderDecisionRecord({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve19(assignmentDir, "progress.md"),
+      resolve21(assignmentDir, "progress.md"),
       renderProgress({
         assignment: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve19(assignmentDir, "comments.md"),
+      resolve21(assignmentDir, "comments.md"),
       renderComments({
         assignment: companionAssignmentRef,
         timestamp
@@ -10394,7 +11046,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir) {
-  const router = Router7();
+  const router = Router9();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -10510,7 +11162,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir9(todosDir2).catch(() => []);
+      const files = await readdir10(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -10623,8 +11275,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve23 } = await import("path");
-      const { readFile: readFile16 } = await import("fs/promises");
+      const { resolve: resolve25 } = await import("path");
+      const { readFile: readFile18 } = 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);
@@ -10640,10 +11292,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve23(todosDir2, "archive"));
+      await ensureDir(resolve25(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile16(archFile, "utf-8");
+        archContent = await readFile18(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -10922,7 +11574,7 @@ workspace: ${workspace}
         const { readConfig: readConfig2 } = 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: readFile16 } = await import("fs/promises");
+        const { readFile: readFile18 } = 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;
@@ -10943,7 +11595,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile16(assignmentMdPath, "utf-8");
+        let content = await readFile18(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -11126,9 +11778,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router8 } from "express";
-import { mkdir as mkdir3, readFile as readFile14, rename as rename5 } from "fs/promises";
-import { resolve as resolve20, dirname as dirname5 } from "path";
+import { Router as Router10 } from "express";
+import { mkdir as mkdir3, readFile as readFile16, rename as rename5 } from "fs/promises";
+import { resolve as resolve22, dirname as dirname5 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -11143,7 +11795,7 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir, slug) {
-  return fileExists(resolve20(projectsDir, slug, "project.md"));
+  return fileExists(resolve22(projectsDir, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
@@ -11160,7 +11812,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir3(resolve20(todosDir2, "archive"), { recursive: false });
+    await mkdir3(resolve22(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -11176,7 +11828,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir, 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() });
   }
@@ -11348,7 +12000,7 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
       const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile14(archFile, "utf-8");
+        archContent = await readFile16(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -11792,17 +12444,17 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve20(projectsDir, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve22(projectsDir, 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 = resolve20(assignmentsDirFn(), tg);
+          assignmentDir = resolve22(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath = resolve20(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolve22(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile14(assignmentMdPath, "utf-8");
+        let content = await readFile16(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -11994,7 +12646,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();
@@ -12002,8 +12654,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 readFile15, writeFile as writeFile4, unlink as unlink4, stat, open as open2, rename as rename6 } from "fs/promises";
-import { resolve as resolve21, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile17, 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 { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -12043,7 +12695,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve21(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve23(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -12054,7 +12706,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve21(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve23(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open2(lockPath, "wx");
@@ -12063,7 +12715,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile15(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile17(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.`
       );
@@ -12101,7 +12753,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve21(dest, ".."));
+    await ensureDir(resolve23(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -12110,7 +12762,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile15(configPath, "utf-8");
+  const content = await readFile17(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -12149,7 +12801,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve21(destPath, ".."));
+        await ensureDir(resolve23(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -12203,7 +12855,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve21(localPath, ".."));
+    await ensureDir(resolve23(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -12304,7 +12956,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve21(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve23(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -12317,7 +12969,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();
@@ -12645,7 +13297,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve22(syntaurRoot(), "config.md")
+        resolve24(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -12768,6 +13420,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();
@@ -13153,6 +13806,7 @@ function createDashboardServer(options) {
   app.use("/api/leases", createLeasesRouter(broadcast));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2));
   app.use("/api/config/agents", createAgentsRouter());
+  app.use("/api/launch", createLaunchPreflightRouter());
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
   app.get("/api/memories", async (_req, res) => {
     try {
@@ -13177,14 +13831,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve22(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve24(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 = resolve22(dashboardDistPath, "index.html");
+      const indexPath = resolve24(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -13208,7 +13862,7 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
-        dbPath: resolve22(syntaurRoot(), "syntaur.db"),
+        dbPath: resolve24(syntaurRoot(), "syntaur.db"),
         onMessage: broadcast
       });
       startAutodiscovery({ serversDir: serversDir2, projectsDir, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
@@ -13223,7 +13877,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve22(syntaurRoot(), "dashboard-port");
+          const portFile = resolve24(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -13241,7 +13895,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve22(syntaurRoot(), "dashboard-port");
+      const portFile = resolve24(syntaurRoot(), "dashboard-port");
       await unlink5(portFile).catch(() => {
       });
       server.closeAllConnections?.();