syntaur 0.26.0 → 0.31.0

package/dist/dashboard/server.js

@@ -169,8 +169,8 @@ function extractFrontmatter(fileContent) {
   const body = fileContent.slice(match[0].length);
   return [frontmatterBlock, body];
 }
-function parseSimpleValue(raw) {
-  const trimmed = raw.trim();
+function parseSimpleValue(raw2) {
+  const trimmed = raw2.trim();
   if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
     return trimmed.slice(1, -1);
@@ -468,8 +468,8 @@ function extractFrontmatter2(fileContent) {
   const body = fileContent.slice(match[0].length).trim();
   return [frontmatterBlock, body];
 }
-function parseSimpleValue2(raw) {
-  const trimmed = raw.trim();
+function parseSimpleValue2(raw2) {
+  const trimmed = raw2.trim();
   if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
     return trimmed.slice(1, -1);
@@ -1500,8 +1500,8 @@ ${key}: ${formatted}${content.slice(closingIdx)}`;
 function readFrontmatterField(content, key) {
   const match = content.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
   if (!match) return null;
-  const raw = match[1].trim().replace(/^['"]|['"]$/g, "");
-  return raw === "" || raw === "null" ? null : raw;
+  const raw2 = match[1].trim().replace(/^['"]|['"]$/g, "");
+  return raw2 === "" || raw2 === "null" ? null : raw2;
 }
 async function migrateLegacyArchivedProjects(projectsDir) {
   const result = { reconciled: [] };
@@ -1771,9 +1771,9 @@ function normalizeHiddenList(input) {
   if (!Array.isArray(input)) return [];
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const raw of input) {
-    if (typeof raw !== "string") continue;
-    const name = raw.trim();
+  for (const raw2 of input) {
+    if (typeof raw2 !== "string") continue;
+    const name = raw2.trim();
     if (name.length === 0) continue;
     if (name.length > MAX_WORKSPACE_NAME_LENGTH) continue;
     if (/[\r\n]/.test(name)) continue;
@@ -1798,9 +1798,11 @@ __export(config_exports, {
   AgentConfigError: () => AgentConfigError,
   BUILTIN_AGENTS: () => BUILTIN_AGENTS,
   DEFAULT_ASSIGNMENT_TYPES: () => DEFAULT_ASSIGNMENT_TYPES,
+  DEFAULT_STATUS_COLORS: () => DEFAULT_STATUS_COLORS,
   PROMPT_ARG_POSITIONS: () => PROMPT_ARG_POSITIONS,
   TERMINAL_CHOICES: () => TERMINAL_CHOICES,
   TerminalConfigError: () => TerminalConfigError,
+  buildDefaultStatusConfig: () => buildDefaultStatusConfig,
   deleteAgentsConfig: () => deleteAgentsConfig,
   deleteHotkeyBindingsConfig: () => deleteHotkeyBindingsConfig,
   deleteStatusConfig: () => deleteStatusConfig,
@@ -1811,8 +1813,11 @@ __export(config_exports, {
   getAssignmentTypes: () => getAssignmentTypes,
   getTerminal: () => getTerminal,
   parseAgentCommand: () => parseAgentCommand,
+  parseStatusConfig: () => parseStatusConfig,
   parseTerminalConfig: () => parseTerminalConfig,
   readConfig: () => readConfig,
+  serializeStatusConfig: () => serializeStatusConfig,
+  toTitleCase: () => toTitleCase,
   updateAgentsConfig: () => updateAgentsConfig,
   updateBackupConfig: () => updateBackupConfig,
   updateIntegrationConfig: () => updateIntegrationConfig,
@@ -2058,6 +2063,24 @@ function parseStatusConfig(content) {
     transitions
   };
 }
+function toTitleCase(s) {
+  return s.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function buildDefaultStatusConfig() {
+  return {
+    statuses: DEFAULT_STATUSES.map((id) => ({
+      id,
+      label: toTitleCase(id),
+      color: DEFAULT_STATUS_COLORS[id] ?? "gray",
+      terminal: id === "completed" || id === "failed"
+    })),
+    order: [...DEFAULT_STATUSES],
+    transitions: Array.from(DEFAULT_TRANSITION_TABLE.entries()).map(([key, to]) => {
+      const [from, command] = key.split(":");
+      return { from, command, to };
+    })
+  };
+}
 function serializeStatusConfig(statuses) {
   const lines = [];
   lines.push("statuses:");
@@ -2152,13 +2175,13 @@ function parsePlaybooksConfig(fmBlock) {
       continue;
     }
     if (currentSection === "disabled" && indent >= 4 && trimmed.startsWith("- ")) {
-      const raw = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
-      if (raw.length === 0) continue;
-      if (/\s/.test(raw)) {
-        console.warn(`Warning: config.md playbooks.disabled entry "${raw}" contains whitespace, ignoring`);
+      const raw2 = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
+      if (raw2.length === 0) continue;
+      if (/\s/.test(raw2)) {
+        console.warn(`Warning: config.md playbooks.disabled entry "${raw2}" contains whitespace, ignoring`);
         continue;
       }
-      disabled.push(raw);
+      disabled.push(raw2);
       continue;
     }
   }
@@ -2438,9 +2461,9 @@ function serializeHotkeyBindingsConfig(cfg) {
 async function writeHotkeyBindingsConfig(cfg) {
   const cleaned = {};
   for (const kind of BINDABLE_ACTION_KINDS) {
-    const raw = cfg.bindings[kind];
-    if (typeof raw !== "string" || raw.trim() === "") continue;
-    const canonical = canonicalizeCombo(raw);
+    const raw2 = cfg.bindings[kind];
+    if (typeof raw2 !== "string" || raw2.trim() === "") continue;
+    const canonical = canonicalizeCombo(raw2);
     if (!canonical) continue;
     if (isReservedCombo(canonical)) continue;
     cleaned[kind] = canonical;
@@ -3127,7 +3150,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -3135,6 +3158,7 @@ var init_config2 = __esm({
     init_fs();
     init_config();
     init_fs_migration();
+    init_lifecycle();
     init_hotkeysCatalog();
     init_agents_schema();
     init_terminal_schema();
@@ -3182,6 +3206,14 @@ var init_config2 = __esm({
     AUTO_CREATE_WORKTREE_VALUES = ["skip", "ask", "always"];
     AgentConfigError = class extends Error {
     };
+    DEFAULT_STATUS_COLORS = {
+      pending: "slate",
+      in_progress: "teal",
+      blocked: "amber",
+      review: "violet",
+      completed: "emerald",
+      failed: "rose"
+    };
     KNOWN_AGENT_SCALAR_FIELDS = /* @__PURE__ */ new Set([
       "id",
       "label",
@@ -3237,8 +3269,8 @@ async function resolvePlaybookSlug(playbooksDir2, slug) {
   for (const entry of entries) {
     if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
     const filePath = resolve7(playbooksDir2, entry.name);
-    const raw = await readFile6(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile6(filePath, "utf-8");
+    const parsed = parsePlaybook(raw2);
     const canonical = parsed.slug || entry.name.replace(/\.md$/, "");
     if (canonical === slug) {
       return { filename: entry.name, slug: canonical, parsed };
@@ -3285,8 +3317,8 @@ async function rebuildPlaybookManifest(playbooksDir2) {
   const rows = [];
   for (const entry of entries) {
     if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
-    const raw = await readFile6(resolve7(playbooksDir2, entry.name), "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile6(resolve7(playbooksDir2, entry.name), "utf-8");
+    const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     if (disabledSet.has(slug)) continue;
     rows.push({
@@ -3363,8 +3395,8 @@ async function renamePlaybook(playbooksDir2, oldSlug, newSlug) {
       );
     }
   }
-  const raw = await readFile6(oldPath, "utf-8");
-  let next = setFrontmatterField2(raw, "slug", newSlug);
+  const raw2 = await readFile6(oldPath, "utf-8");
+  let next = setFrontmatterField2(raw2, "slug", newSlug);
   next = setFrontmatterField2(next, "updated", `"${nowTimestamp()}"`);
   await writeFileForce(newPath, next);
   if (!renamedInPlace) {
@@ -4040,6 +4072,37 @@ function initSessionDb(dbPath) {
         UPDATE meta SET value = '4' WHERE key = 'schema_version';
       `);
     }
+    const vBeforeV5 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV5 === "4") {
+      database.exec(`
+        CREATE TABLE sessions_v5 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          transcript_path TEXT,
+          pid INTEGER,
+          pid_started_at TEXT,
+          original_head_sha TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v5
+          SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, transcript_path, pid, pid_started_at, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v5 RENAME TO sessions;
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '5' WHERE key = 'schema_version';
+      `);
+    }
   });
   runMigrations.exclusive();
   db.exec(POST_MIGRATION_INDEXES_SQL);
@@ -4090,9 +4153,9 @@ async function migrateFromMarkdown(projectsDir) {
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
   const { readFile: readFile21 } = await import("fs/promises");
-  const raw = await readFile21(filePath, "utf-8");
+  const raw2 = await readFile21(filePath, "utf-8");
   const sessions = [];
-  const lines = raw.split("\n");
+  const lines = raw2.split("\n");
   let inTable = false;
   let headerSeen = false;
   for (const line of lines) {
@@ -4131,7 +4194,7 @@ var init_session_db = __esm({
     init_paths();
     init_fs();
     db = null;
-    SCHEMA_VERSION = "4";
+    SCHEMA_VERSION = "5";
     SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
   session_id TEXT PRIMARY KEY,
@@ -4146,6 +4209,7 @@ CREATE TABLE IF NOT EXISTS sessions (
   transcript_path TEXT,
   pid INTEGER,
   pid_started_at TEXT,
+  original_head_sha TEXT,
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   updated_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
@@ -4175,25 +4239,27 @@ function rowToSession(row) {
     description: row.description ?? null,
     transcriptPath: row.transcript_path ?? null,
     pid: row.pid ?? null,
-    pidStartedAt: row.pid_started_at ?? null
+    pidStartedAt: row.pid_started_at ?? null,
+    originalHeadSha: row.original_head_sha ?? null
   };
 }
 async function appendSession(_projectDir, session) {
   const db4 = getSessionDb();
   db4.prepare(`
-    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path, pid, pid_started_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path, pid, pid_started_at, original_head_sha)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
-      project_slug    = COALESCE(NULLIF(excluded.project_slug, ''),    project_slug),
-      assignment_slug = COALESCE(NULLIF(excluded.assignment_slug, ''), assignment_slug),
-      agent           = excluded.agent,
-      status          = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
-      path            = COALESCE(NULLIF(excluded.path, ''),            path),
-      description     = COALESCE(NULLIF(excluded.description, ''),     description),
-      transcript_path = COALESCE(NULLIF(excluded.transcript_path, ''), transcript_path),
-      pid             = COALESCE(excluded.pid,                         pid),
-      pid_started_at  = COALESCE(NULLIF(excluded.pid_started_at, ''),  pid_started_at),
-      updated_at      = datetime('now')
+      project_slug      = COALESCE(NULLIF(excluded.project_slug, ''),      project_slug),
+      assignment_slug   = COALESCE(NULLIF(excluded.assignment_slug, ''),   assignment_slug),
+      agent             = excluded.agent,
+      status            = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
+      path              = COALESCE(NULLIF(excluded.path, ''),              path),
+      description       = COALESCE(NULLIF(excluded.description, ''),       description),
+      transcript_path   = COALESCE(NULLIF(excluded.transcript_path, ''),   transcript_path),
+      pid               = COALESCE(excluded.pid,                           pid),
+      pid_started_at    = COALESCE(NULLIF(excluded.pid_started_at, ''),    pid_started_at),
+      original_head_sha = COALESCE(NULLIF(original_head_sha, ''), NULLIF(excluded.original_head_sha, '')),
+      updated_at        = datetime('now')
   `).run(
     session.sessionId,
     session.projectSlug ?? null,
@@ -4205,7 +4271,8 @@ async function appendSession(_projectDir, session) {
     session.description ?? null,
     session.transcriptPath ?? null,
     session.pid ?? null,
-    session.pidStartedAt ?? null
+    session.pidStartedAt ?? null,
+    session.originalHeadSha ?? null
   );
 }
 async function updateSessionStatus(_projectDir, sessionId, status) {
@@ -4248,8 +4315,8 @@ async function deleteSessions(sessionIds) {
 }
 async function readAssignmentStatusFromPath(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
-  const raw = await readFile8(assignmentMdPath, "utf-8");
-  const match = raw.match(/^status:\s*(.+)$/m);
+  const raw2 = await readFile8(assignmentMdPath, "utf-8");
+  const match = raw2.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
 async function readAssignmentStatus(projectDir, assignmentSlug) {
@@ -4393,8 +4460,8 @@ async function listSessionFiles(dir) {
 async function readSessionFile(dir, name) {
   const filePath = resolve11(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile9(filePath, "utf-8");
-  const [frontmatter] = extractFrontmatter2(raw);
+  const raw2 = await readFile9(filePath, "utf-8");
+  const [frontmatter] = extractFrontmatter2(raw2);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
   const registered = getField(frontmatter, "registered") ?? "";
@@ -4522,8 +4589,8 @@ function scanKey(serversDir2, projectsDir, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve29) => {
-    const timer2 = setTimeout(resolve29, ms);
+  return new Promise((resolve30) => {
+    const timer2 = setTimeout(resolve30, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -5063,9 +5130,6 @@ async function computeStandaloneRecords(assignmentsDir2) {
   records.sort((left, right) => compareTimestamps(right.record.updated, left.record.updated));
   return records;
 }
-function toTitleCase(s) {
-  return s.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
 function getTransitionDefinitions(config) {
   if (!config.custom) return DEFAULT_TRANSITION_DEFINITIONS;
   const seen = /* @__PURE__ */ new Set();
@@ -5101,19 +5165,12 @@ async function getStatusConfig() {
       terminalStatuses: terminalSet.size > 0 ? terminalSet : /* @__PURE__ */ new Set(["completed", "failed"])
     };
   } else {
+    const def = buildDefaultStatusConfig();
     _cachedConfig = {
       custom: false,
-      statuses: DEFAULT_STATUSES.map((id) => ({
-        id,
-        label: toTitleCase(id),
-        color: DEFAULT_STATUS_COLORS[id] ?? "gray",
-        terminal: id === "completed" || id === "failed"
-      })),
-      order: [...DEFAULT_STATUSES],
-      transitions: Array.from(DEFAULT_TRANSITION_TABLE.entries()).map(([key, to]) => {
-        const [from, command] = key.split(":");
-        return { from, command, to };
-      }),
+      statuses: def.statuses,
+      order: def.order,
+      transitions: def.transitions,
       transitionTable: DEFAULT_TRANSITION_TABLE,
       terminalStatuses: /* @__PURE__ */ new Set(["completed", "failed"])
     };
@@ -5130,8 +5187,8 @@ async function listProjects(projectsDir) {
 async function readWorkspaceRegistry(projectsDir) {
   const registryPath = resolve13(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw = await readFile10(registryPath, "utf-8");
-    const parsed = JSON.parse(raw);
+    const raw2 = await readFile10(registryPath, "utf-8");
+    const parsed = JSON.parse(raw2);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
     return [];
@@ -5219,8 +5276,8 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
       const path = resolve13(projectsDir, slug, "project.md");
-      const raw = await readFile10(path, "utf-8");
-      let next = clearFrontmatterField(raw, "workspace");
+      const raw2 = await readFile10(path, "utf-8");
+      let next = clearFrontmatterField(raw2, "workspace");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
       rewroteFiles = true;
@@ -5228,8 +5285,8 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
       const path = resolve13(opts.assignmentsDir, id, "assignment.md");
-      const raw = await readFile10(path, "utf-8");
-      let next = clearFrontmatterField(raw, "workspaceGroup");
+      const raw2 = await readFile10(path, "utf-8");
+      let next = clearFrontmatterField(raw2, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
       rewroteFiles = true;
@@ -6679,8 +6736,8 @@ async function listPlaybooks(playbooksDir2) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
     const filePath = resolve13(playbooksDir2, entry.name);
-    const raw = await readFile10(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile10(filePath, "utf-8");
+    const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
       slug,
@@ -6713,7 +6770,7 @@ async function getPlaybookDetail(playbooksDir2, slug) {
     enabled
   };
 }
-var WorkspaceBlockedError, STALE_ASSIGNMENT_MS, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, RECENT_SESSIONS_LIMIT, NEWEST_CREATED_LIMIT, SEGMENT_DISPLAY_CAP, STALE_LIMIT_DEFAULT, STALE_LIMIT_MAX, TERMINAL_STATUSES2, STATUS_TO_SEGMENT, HERO_PRIORITY, projectRecordsCache, standaloneRecordsCache, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
+var WorkspaceBlockedError, STALE_ASSIGNMENT_MS, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, RECENT_SESSIONS_LIMIT, NEWEST_CREATED_LIMIT, SEGMENT_DISPLAY_CAP, STALE_LIMIT_DEFAULT, STALE_LIMIT_MAX, TERMINAL_STATUSES2, STATUS_TO_SEGMENT, HERO_PRIORITY, projectRecordsCache, standaloneRecordsCache, DEFAULT_TRANSITION_DEFINITIONS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
 var init_api = __esm({
   "src/dashboard/api.ts"() {
     "use strict";
@@ -6828,14 +6885,6 @@ var init_api = __esm({
         requiresReason: false
       }
     ];
-    DEFAULT_STATUS_COLORS = {
-      pending: "slate",
-      in_progress: "teal",
-      blocked: "amber",
-      review: "violet",
-      completed: "emerald",
-      failed: "rose"
-    };
     _cachedConfig = null;
     REFERENCED_BY_LIMIT = 50;
     migratedProjectsDirs = /* @__PURE__ */ new Set();
@@ -6904,8 +6953,8 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve28 } from "path";
-import { writeFile as writeFile6, unlink as unlink6 } from "fs/promises";
+import { resolve as resolve29 } from "path";
+import { writeFile as writeFile7, unlink as unlink7 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/session-liveness.ts
@@ -6991,7 +7040,18 @@ function enrichSessions(sessions, agents, deps) {
 
 // src/dashboard/watcher.ts
 import { watch } from "chokidar";
-import { basename as basename2, dirname as dirname3, relative, sep } from "path";
+import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, relative, sep } from "path";
+var defaultPathApi = { relative, isAbsolute: isAbsolute2 };
+function ignoreDotSegmentsBelow(root, pathApi = defaultPathApi) {
+  return (p) => {
+    const rel = pathApi.relative(root, p);
+    if (!rel) return false;
+    if (pathApi.isAbsolute(rel)) return false;
+    const parts = rel.split(/[\\/]/);
+    if (parts[0] === "..") return false;
+    return parts.some((segment) => segment.startsWith("."));
+  };
+}
 function createWatcher(options) {
   const { projectsDir, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, dbPath, onMessage, debounceMs = 300 } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
@@ -6999,7 +7059,7 @@ function createWatcher(options) {
     ignoreInitial: true,
     persistent: true,
     depth: 10,
-    ignored: /(^|[\/\\])\../
+    ignored: ignoreDotSegmentsBelow(projectsDir)
   });
   function handleProjectChange(filePath) {
     const rel = relative(projectsDir, filePath);
@@ -7068,7 +7128,7 @@ function createWatcher(options) {
       ignoreInitial: true,
       persistent: true,
       depth: 5,
-      ignored: /(^|[\/\\])\../
+      ignored: ignoreDotSegmentsBelow(assignmentsDir2)
     });
     standaloneWatcher.on("change", handleStandaloneChange2);
     standaloneWatcher.on("add", handleStandaloneChange2);
@@ -7097,7 +7157,7 @@ function createWatcher(options) {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
-      ignored: /(^|[\/\\])\../
+      ignored: ignoreDotSegmentsBelow(serversDir2)
     });
     serversWatcher.on("change", handleServerChange2);
     serversWatcher.on("add", handleServerChange2);
@@ -7126,7 +7186,7 @@ function createWatcher(options) {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
-      ignored: /(^|[\/\\])\../
+      ignored: ignoreDotSegmentsBelow(playbooksDir2)
     });
     playbooksWatcher.on("change", handlePlaybookChange2);
     playbooksWatcher.on("add", handlePlaybookChange2);
@@ -7155,7 +7215,7 @@ function createWatcher(options) {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
-      ignored: /(^|[\/\\])\../
+      ignored: ignoreDotSegmentsBelow(todosDir2)
     });
     todosWatcher.on("change", handleTodoChange2);
     todosWatcher.on("add", handleTodoChange2);
@@ -7187,7 +7247,7 @@ function createWatcher(options) {
       ignoreInitial: true,
       persistent: true,
       depth: 0,
-      ignored: /(^|[\/\\])\../
+      ignored: ignoreDotSegmentsBelow(dbDir)
     });
     leasesDbWatcher.on("change", handleDbChange2);
     leasesDbWatcher.on("add", handleDbChange2);
@@ -7379,15 +7439,15 @@ async function readViewPrefsFile() {
   if (!await fileExists(path)) {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
-  let raw;
+  let raw2;
   try {
-    raw = await readFile11(path, "utf-8");
+    raw2 = await readFile11(path, "utf-8");
   } catch {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(raw2);
   } catch {
     await backupCorrupt(path);
     return { ...DEFAULT_VIEW_PREFS_FILE };
@@ -7592,15 +7652,15 @@ async function readSavedViewsFile() {
   if (!await fileExists(path)) {
     return cloneDefault();
   }
-  let raw;
+  let raw2;
   try {
-    raw = await readFile12(path, "utf-8");
+    raw2 = await readFile12(path, "utf-8");
   } catch {
     return cloneDefault();
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(raw2);
   } catch {
     await backupCorrupt2(path);
     return cloneDefault();
@@ -7909,7 +7969,7 @@ function createDashboardLayoutRouter() {
 init_lifecycle();
 init_slug();
 import { Router as Router2 } from "express";
-import { resolve as resolve18, basename as basename3, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve18, basename as basename3, isAbsolute as isAbsolute4 } 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";
 
@@ -7928,6 +7988,20 @@ init_frontmatter();
 init_fs();
 import { spawn } from "child_process";
 import { readFile as readFile13 } from "fs/promises";
+
+// src/launch/cwd.ts
+import { existsSync, statSync as statSync2 } from "fs";
+import { isAbsolute as isAbsolute3 } from "path";
+function isExistingDir(p) {
+  if (!p || !isAbsolute3(p)) return false;
+  try {
+    return existsSync(p) && statSync2(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/git-worktree.ts
 function run(command, args, cwd) {
   return new Promise((resolvePromise) => {
     const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
@@ -7962,11 +8036,11 @@ async function createWorktree(opts) {
     );
   }
 }
-async function removeWorktree(repository, worktreePath) {
-  const result = await run(
-    "git",
-    ["-C", repository, "worktree", "remove", "--force", worktreePath]
-  );
+async function removeWorktree(repository, worktreePath, opts = {}) {
+  const args = ["-C", repository, "worktree", "remove"];
+  if (opts.force) args.push("--force");
+  args.push(worktreePath);
+  const result = await run("git", args);
   return { ok: result.code === 0, stderr: result.stderr };
 }
 async function deleteBranch(repository, branch) {
@@ -8007,6 +8081,82 @@ async function detectDefaultBranch(repository) {
   }
   return branches[0] ?? null;
 }
+async function captureHeadSha(dir) {
+  const result = await run("git", ["-C", dir, "rev-parse", "HEAD"]);
+  if (result.code !== 0) return null;
+  const sha = result.stdout.trim();
+  return sha.length > 0 ? sha : null;
+}
+async function branchCheckedOutAt(repository, branch) {
+  const result = await run("git", ["-C", repository, "worktree", "list", "--porcelain"]);
+  if (result.code !== 0) return null;
+  let currentPath = null;
+  for (const line of result.stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      currentPath = line.slice("worktree ".length).trim();
+    } else if (line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length).trim();
+      if (ref === `refs/heads/${branch}` && currentPath) return currentPath;
+    }
+  }
+  return null;
+}
+async function recreateWorktree(opts) {
+  const { repository, worktreePath, branch } = opts;
+  const originalHeadSha = opts.originalHeadSha ?? null;
+  await run("git", ["-C", repository, "worktree", "prune"]);
+  const add = async (args) => {
+    const result = await run("git", ["-C", repository, "worktree", "add", ...args]);
+    if (result.code !== 0) {
+      throw new GitWorktreeError(
+        `git worktree add failed (exit ${result.code}): ${result.stderr.trim() || "(no stderr)"}`,
+        result.stderr
+      );
+    }
+  };
+  const refExists = async (ref) => {
+    const result = await run("git", [
+      "-C",
+      repository,
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      ref
+    ]);
+    return result.code === 0;
+  };
+  if (branch && (await listBranches(repository)).includes(branch)) {
+    const checkedOutAt = await branchCheckedOutAt(repository, branch);
+    if (!checkedOutAt || checkedOutAt === worktreePath || !isExistingDir(checkedOutAt)) {
+      await add([worktreePath, branch]);
+      return { baseUsed: branch, exact: true, branch };
+    }
+    const detachBase = originalHeadSha && await refExists(`${originalHeadSha}^{commit}`) ? originalHeadSha : `refs/heads/${branch}`;
+    await add(["--detach", worktreePath, detachBase]);
+    return { baseUsed: detachBase, exact: detachBase === originalHeadSha, branch: null };
+  }
+  let baseUsed = null;
+  if (originalHeadSha && await refExists(`${originalHeadSha}^{commit}`)) {
+    baseUsed = originalHeadSha;
+  } else if (branch && await refExists(`refs/remotes/origin/${branch}`)) {
+    baseUsed = `refs/remotes/origin/${branch}`;
+  } else {
+    baseUsed = await detectDefaultBranch(repository);
+  }
+  if (!baseUsed) {
+    throw new GitWorktreeError(
+      `recreateWorktree: no base ref to recreate ${worktreePath} (no original sha, no origin/${branch ?? "<none>"}, no default branch)`,
+      ""
+    );
+  }
+  const exact = baseUsed === originalHeadSha;
+  if (branch) {
+    await add(["-b", branch, worktreePath, baseUsed]);
+    return { baseUsed, exact, branch };
+  }
+  await add(["--detach", worktreePath, baseUsed]);
+  return { baseUsed, exact, branch: null };
+}
 async function createWorktreeAndRecord(opts) {
   const { assignmentPath, repository, branch, worktreePath, parentBranch } = opts;
   await createWorktree({ repository, branch, worktreePath, parentBranch });
@@ -8020,7 +8170,7 @@ async function createWorktreeAndRecord(opts) {
     });
     await writeFileForce(assignmentPath, updated);
   } catch (writeErr) {
-    const cleanup = await removeWorktree(repository, worktreePath);
+    const cleanup = await removeWorktree(repository, worktreePath, { force: true });
     const branchCleanup = await deleteBranch(repository, branch);
     const writeMsg = writeErr instanceof Error ? writeErr.message : String(writeErr);
     throw new Error(
@@ -8121,6 +8271,154 @@ function validateBranchName(name) {
   return null;
 }
 
+// src/dashboard/recreate-target.ts
+init_api();
+init_agent_sessions();
+async function resolveRecreateTarget(deps, target) {
+  const { projectsDir, assignmentsDir: assignmentsDir2 } = deps;
+  if (target.kind === "assignment") {
+    const detail = "id" in target ? await getAssignmentDetailById(projectsDir, assignmentsDir2, target.id) : await getAssignmentDetail(
+      projectsDir,
+      target.projectSlug,
+      target.assignmentSlug
+    );
+    if (!detail) return null;
+    const worktreePath2 = detail.workspace.worktreePath ?? "";
+    const repository2 = detail.workspace.repository ?? null;
+    const branch2 = detail.workspace.branch ?? null;
+    const missing2 = worktreePath2 !== "" && !isExistingDir(worktreePath2);
+    return {
+      kind: "assignment",
+      id: detail.id,
+      projectSlug: detail.projectSlug ?? null,
+      assignmentSlug: detail.slug,
+      worktreePath: worktreePath2,
+      repository: repository2,
+      branch: branch2,
+      originalHeadSha: null,
+      missing: missing2,
+      recreatable: missing2 && isExistingDir(repository2)
+    };
+  }
+  const session = getSessionById(target.id);
+  if (!session) return null;
+  let repository = null;
+  let branch = null;
+  let assignmentWorktreePath = "";
+  if (session.projectSlug && session.assignmentSlug) {
+    const detail = await getAssignmentDetail(
+      projectsDir,
+      session.projectSlug,
+      session.assignmentSlug
+    );
+    if (detail) {
+      repository = detail.workspace.repository ?? null;
+      branch = detail.workspace.branch ?? null;
+      assignmentWorktreePath = detail.workspace.worktreePath ?? "";
+    }
+  } else if (session.assignmentSlug) {
+    const detail = await getAssignmentDetailById(
+      projectsDir,
+      assignmentsDir2,
+      session.assignmentSlug
+    );
+    if (detail) {
+      repository = detail.workspace.repository ?? null;
+      branch = detail.workspace.branch ?? null;
+      assignmentWorktreePath = detail.workspace.worktreePath ?? "";
+    }
+  }
+  const worktreePath = session.path || assignmentWorktreePath;
+  const missing = worktreePath !== "" && !isExistingDir(worktreePath);
+  return {
+    kind: "session",
+    id: session.sessionId,
+    projectSlug: session.projectSlug ?? null,
+    assignmentSlug: session.assignmentSlug ?? null,
+    worktreePath,
+    repository,
+    branch,
+    originalHeadSha: session.originalHeadSha ?? null,
+    missing,
+    recreatable: missing && isExistingDir(repository)
+  };
+}
+
+// src/dashboard/worktree-recreate.ts
+async function recreateForTarget(deps, target) {
+  const t = await resolveRecreateTarget(deps, target);
+  if (!t) return { status: "not-found" };
+  if (t.worktreePath === "") return { status: "no-path" };
+  if (isExistingDir(t.worktreePath)) {
+    return { status: "already-exists", branch: t.branch };
+  }
+  if (!t.repository) return { status: "no-repo" };
+  const repoCheck = await assertRepoRoot(t.repository);
+  if (!repoCheck.ok) {
+    return { status: "bad-repo", httpStatus: repoCheck.status, error: repoCheck.error };
+  }
+  const key = `recreate:${t.worktreePath}`;
+  if (worktreeInFlight.has(key)) return { status: "in-flight" };
+  worktreeInFlight.add(key);
+  try {
+    const r = await recreateWorktree({
+      repository: repoCheck.repo,
+      worktreePath: t.worktreePath,
+      branch: t.branch,
+      originalHeadSha: t.originalHeadSha
+    });
+    return { status: "recreated", baseUsed: r.baseUsed, exact: r.exact, branch: r.branch };
+  } finally {
+    worktreeInFlight.delete(key);
+  }
+}
+function recreateOutcomeToHttp(outcome) {
+  switch (outcome.status) {
+    case "not-found":
+      return { httpStatus: 404, body: { error: "Target not found." } };
+    case "no-path":
+      return {
+        httpStatus: 422,
+        body: { error: "No recorded worktree path to recreate." }
+      };
+    case "no-repo":
+      return {
+        httpStatus: 422,
+        body: {
+          error: "Cannot recreate: no repository on record for this worktree."
+        }
+      };
+    case "bad-repo":
+      return { httpStatus: outcome.httpStatus, body: { error: outcome.error } };
+    case "in-flight":
+      return {
+        httpStatus: 409,
+        body: { error: "A recreate is already in progress for this worktree." }
+      };
+    case "already-exists":
+      return {
+        httpStatus: 200,
+        body: {
+          ok: true,
+          alreadyExisted: true,
+          baseUsed: outcome.branch ?? "HEAD",
+          exact: true,
+          branch: outcome.branch
+        }
+      };
+    case "recreated":
+      return {
+        httpStatus: 200,
+        body: {
+          ok: true,
+          baseUsed: outcome.baseUsed,
+          exact: outcome.exact,
+          branch: outcome.branch
+        }
+      };
+  }
+}
+
 // src/dashboard/repository-candidates.ts
 init_fs();
 init_parser();
@@ -8145,8 +8443,8 @@ async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
   const projectPath = resolve17(projectsDir, 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();
+    for (const raw2 of project.repositories) {
+      const path = raw2.trim();
       if (!path) continue;
       const abs = resolve17(path);
       if (seen.has(abs)) continue;
@@ -8807,7 +9105,7 @@ async function assertRepoRoot(repoInput) {
     return { ok: false, status: 400, error: "`repository` is required." };
   }
   const repo = repoInput.trim();
-  if (!isAbsolute2(repo)) {
+  if (!isAbsolute4(repo)) {
     return { ok: false, status: 400, error: "`repository` must be an absolute path." };
   }
   try {
@@ -10046,6 +10344,45 @@ ${entry}`;
       }
     }
   );
+  router.post(
+    "/api/projects/:slug/assignments/:aslug/worktree/recreate",
+    async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const assignmentSlug = getParam(req.params.aslug);
+        const outcome = await recreateForTarget(
+          { projectsDir, assignmentsDir: assignmentsDir2 ?? "" },
+          { kind: "assignment", projectSlug, assignmentSlug }
+        );
+        const { httpStatus, body } = recreateOutcomeToHttp(outcome);
+        res.status(httpStatus).json(body);
+      } catch (error) {
+        console.error("Error recreating worktree:", error);
+        res.status(500).json({ error: `Failed to recreate worktree: ${error.message}` });
+      }
+    }
+  );
+  router.post(
+    "/api/assignments/:id/worktree/recreate",
+    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 outcome = await recreateForTarget(
+          { projectsDir, assignmentsDir: assignmentsDir2 },
+          { kind: "assignment", id }
+        );
+        const { httpStatus, body } = recreateOutcomeToHttp(outcome);
+        res.status(httpStatus).json(body);
+      } catch (error) {
+        console.error("Error recreating worktree:", error);
+        res.status(500).json({ error: `Failed to recreate worktree: ${error.message}` });
+      }
+    }
+  );
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
@@ -11308,6 +11645,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
       const recordedPath = derivedPath ?? path ?? "";
       const pid = typeof rawPid === "number" && Number.isFinite(rawPid) && rawPid > 0 ? rawPid : null;
       const pidStartedAt = pid !== null ? captureProcessStartedAt(pid) : null;
+      const originalHeadSha = isExistingDir(recordedPath) ? await captureHeadSha(recordedPath) : null;
       const session = {
         projectSlug: projectSlug || null,
         assignmentSlug: assignmentSlug || null,
@@ -11319,7 +11657,8 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
         description: description || null,
         transcriptPath: transcriptPath || null,
         pid,
-        pidStartedAt
+        pidStartedAt,
+        originalHeadSha
       };
       await appendSession("", session);
       broadcast?.({ type: "agent-sessions-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -11328,6 +11667,21 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Registration failed" });
     }
   });
+  router.post("/:sessionId/worktree/recreate", async (req, res) => {
+    try {
+      const { sessionId } = req.params;
+      const outcome = await recreateForTarget(
+        { projectsDir, assignmentsDir: assignmentsDir2 ?? "" },
+        { kind: "session", id: sessionId }
+      );
+      const { httpStatus, body } = recreateOutcomeToHttp(outcome);
+      res.status(httpStatus).json(body);
+    } catch (error) {
+      res.status(500).json({
+        error: error instanceof Error ? error.message : "Failed to recreate worktree"
+      });
+    }
+  });
   router.patch("/:sessionId", async (req, res) => {
     try {
       const { sessionId } = req.params;
@@ -11459,8 +11813,8 @@ function mapAgentErrorToFieldErrors(err) {
   }
   return { error: message };
 }
-function coerceAgentRow(raw, index) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+function coerceAgentRow(raw2, index) {
+  if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) {
     return {
       ok: false,
       status: 400,
@@ -11470,7 +11824,7 @@ function coerceAgentRow(raw, index) {
       }
     };
   }
-  const entry = raw;
+  const entry = raw2;
   if (typeof entry.id !== "string" || entry.id.length === 0) {
     return {
       ok: false,
@@ -11579,14 +11933,14 @@ function createAgentsRouter() {
   });
   router.put("/", async (req, res) => {
     try {
-      const raw = req.body && typeof req.body === "object" ? req.body : {};
-      if (!Array.isArray(raw.agents)) {
+      const raw2 = req.body && typeof req.body === "object" ? req.body : {};
+      if (!Array.isArray(raw2.agents)) {
         res.status(400).json({ error: "agents must be an array" });
         return;
       }
       const cleaned = [];
-      for (let i = 0; i < raw.agents.length; i++) {
-        const result = coerceAgentRow(raw.agents[i], i);
+      for (let i = 0; i < raw2.agents.length; i++) {
+        const result = coerceAgentRow(raw2.agents[i], i);
         if (!result.ok) {
           res.status(result.status).json(result.body);
           return;
@@ -11628,7 +11982,7 @@ import { Router as Router6 } from "express";
 
 // src/utils/terminal-probe.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 var APP_BUNDLE_IDS = {
@@ -11650,12 +12004,12 @@ function defaultApplicationsDirs() {
 }
 function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const fixed = APP_FIXED_PATHS[terminal];
-  if (fixed && existsSync(fixed)) return fixed;
+  if (fixed && existsSync2(fixed)) return fixed;
   const bundleName = APP_BUNDLE_NAMES[terminal];
   if (bundleName) {
     for (const dir of dirs) {
       const candidate = join2(dir, bundleName);
-      if (existsSync(candidate)) return candidate;
+      if (existsSync2(candidate)) return candidate;
     }
   }
   return null;
@@ -11692,50 +12046,6 @@ function probeTerminalInstalled(terminal, opts = {}) {
   return { ok: false, reason: "no-probe-available" };
 }
 
-// src/dashboard/api-launch-preflight.ts
-init_api();
-
-// src/launch/cwd.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
-import { isAbsolute as isAbsolute3 } from "path";
-function isExistingDir(p) {
-  if (!p || !isAbsolute3(p)) return false;
-  try {
-    return existsSync2(p) && statSync2(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function resolveWorkspaceCwd(input) {
-  const { worktreePath, repository, branch, assignmentSlug } = input;
-  if (isExistingDir(worktreePath)) {
-    return { cwd: worktreePath, fallbackWarning: null, invalidReason: null };
-  }
-  if (isExistingDir(repository)) {
-    const fallbackWarning = worktreePath ? `syntaur: workspace.worktreePath ${worktreePath} is not an existing directory for ${assignmentSlug} \u2014 launching in ${repository}` : formatFallbackCwdWarning({
-      assignmentSlug,
-      workspaceDir: repository,
-      worktreePath,
-      branch
-    });
-    return { cwd: repository, fallbackWarning, invalidReason: null };
-  }
-  const shown = (p) => p && p.trim().length > 0 ? p : "(unset)";
-  return {
-    cwd: null,
-    fallbackWarning: null,
-    invalidReason: `workspace path invalid for ${assignmentSlug}: tried worktreePath ${shown(worktreePath)} and repository ${shown(repository)} \u2014 neither is an existing directory`
-  };
-}
-function formatFallbackCwdWarning(opts) {
-  const missing = [];
-  if (!opts.worktreePath) missing.push("worktreePath");
-  if (!opts.branch) missing.push("branch");
-  if (missing.length === 0) return null;
-  const fields = missing.map((m) => `workspace.${m}`).join(" and ");
-  return `syntaur: ${fields} not set for ${opts.assignmentSlug} \u2014 launching in ${opts.workspaceDir}`;
-}
-
 // src/dashboard/api-launch-preflight.ts
 function createLaunchPreflightRouter(projectsDir, assignmentsDir2) {
   const router = Router6();
@@ -11763,29 +12073,44 @@ function createLaunchPreflightRouter(projectsDir, assignmentsDir2) {
         return;
       }
       const target = body.target;
-      if (target && target.kind === "assignment" && typeof target.id === "string") {
-        const detail = await getAssignmentDetailById(
-          projectsDir,
-          assignmentsDir2,
-          target.id
+      if (target && (target.kind === "assignment" || target.kind === "session") && typeof target.id === "string") {
+        const resolved = await resolveRecreateTarget(
+          { projectsDir, assignmentsDir: assignmentsDir2 },
+          target.kind === "assignment" ? { kind: "assignment", id: target.id } : { kind: "session", id: target.id }
         );
-        if (detail) {
-          const picked = resolveWorkspaceCwd({
-            worktreePath: detail.workspace.worktreePath,
-            repository: detail.workspace.repository,
-            branch: detail.workspace.branch,
-            assignmentSlug: detail.slug
-          });
-          if (picked.cwd === null) {
-            const response2 = {
-              ok: false,
-              terminal,
-              reason: "workspace-path-invalid",
-              message: picked.invalidReason ?? "This assignment has no valid workspace directory."
-            };
-            res.json(response2);
-            return;
-          }
+        if (resolved && resolved.missing) {
+          const response2 = resolved.recreatable ? {
+            ok: false,
+            terminal,
+            reason: "workspace-path-invalid",
+            message: `Worktree ${resolved.worktreePath} was deleted.`,
+            recreate: {
+              kind: resolved.kind,
+              id: resolved.id,
+              projectSlug: resolved.projectSlug,
+              assignmentSlug: resolved.assignmentSlug,
+              deletedPath: resolved.worktreePath,
+              repository: resolved.repository,
+              branch: resolved.branch
+            }
+          } : {
+            ok: false,
+            terminal,
+            reason: "workspace-path-invalid",
+            message: `Worktree ${resolved.worktreePath} was deleted and can't be auto-recreated (no repository on record). Set a valid workspace for this assignment, then try again.`
+          };
+          res.json(response2);
+          return;
+        }
+        if (resolved && resolved.kind === "assignment" && resolved.worktreePath === "" && !isExistingDir(resolved.repository)) {
+          const response2 = {
+            ok: false,
+            terminal,
+            reason: "workspace-path-invalid",
+            message: "This assignment has no valid workspace directory. Set a repository or worktree, then try again."
+          };
+          res.json(response2);
+          return;
         }
       }
       const response = { ok: true, terminal };
@@ -12186,18 +12511,18 @@ function buildAffectedResponse(id, list) {
 function isString(x) {
   return typeof x === "string" && x.length > 0;
 }
-function parseResolutions(raw) {
-  if (raw === void 0) {
+function parseResolutions(raw2) {
+  if (raw2 === void 0) {
     return { resolutions: [], malformed: null, duplicateIds: null };
   }
-  if (!Array.isArray(raw)) {
+  if (!Array.isArray(raw2)) {
     return { resolutions: [], malformed: "resolutions must be an array", duplicateIds: null };
   }
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const dups = /* @__PURE__ */ new Set();
-  for (let i = 0; i < raw.length; i++) {
-    const r = raw[i];
+  for (let i = 0; i < raw2.length; i++) {
+    const r = raw2[i];
     if (!r || typeof r !== "object") {
       return { resolutions: [], malformed: `resolutions[${i}] must be an object`, duplicateIds: null };
     }
@@ -13173,10 +13498,10 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router13 } from "express";
-import { readdir as readdir10 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname5 } from "path";
-import { rename as rename5, mkdir as mkdir2 } from "fs/promises";
+import { Router as Router14 } from "express";
+import { readdir as readdir11 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname6 } from "path";
+import { rename as rename6, mkdir as mkdir3 } from "fs/promises";
 init_slug();
 
 // src/utils/promote-todos.ts
@@ -13515,6 +13840,331 @@ async function promoteTodosToNewAssignment(groups, options) {
 
 // src/dashboard/api-todos.ts
 init_api();
+
+// src/dashboard/todo-attachments-routes.ts
+import { raw } from "express";
+
+// src/todos/attachments.ts
+import { mkdir as mkdir2, readdir as readdir10, stat, rename as rename5, rm as rm3, unlink as unlink5, writeFile as writeFile5, cp } from "fs/promises";
+import { resolve as resolve25, basename as basename4, dirname as dirname5, extname } from "path";
+
+// src/utils/proof-artifact-id.ts
+import { randomBytes as randomBytes2 } from "crypto";
+function generateArtifactId() {
+  const ts = Date.now().toString(36);
+  const rand = randomBytes2(2).toString("hex");
+  return `${ts}-${rand}`;
+}
+
+// src/todos/attachments.ts
+var SCOPE_RE = /^[a-z0-9_][a-z0-9-]*$/;
+var TODO_ID_RE = /^[a-f0-9]{4}$/;
+var ATTACHMENT_ID_RE = /^[a-z0-9]+-[0-9a-f]{4}$/;
+var AttachmentValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AttachmentValidationError";
+  }
+};
+function assertScope(scopeId) {
+  if (!SCOPE_RE.test(scopeId)) throw new AttachmentValidationError(`Invalid scope id: "${scopeId}"`);
+}
+function assertTodoId(todoId) {
+  if (!TODO_ID_RE.test(todoId)) throw new AttachmentValidationError(`Invalid todo id: "${todoId}"`);
+}
+function assertAttachmentId(attachmentId) {
+  if (!ATTACHMENT_ID_RE.test(attachmentId)) {
+    throw new AttachmentValidationError(`Invalid attachment id: "${attachmentId}"`);
+  }
+}
+var EXT_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  log: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  csv: "text/csv",
+  html: "text/html",
+  htm: "text/html",
+  xml: "application/xml",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  zip: "application/zip"
+};
+function mimeForName(name) {
+  const ext = extname(name).slice(1).toLowerCase();
+  return EXT_MIME[ext] ?? "application/octet-stream";
+}
+var SAFE_INLINE_MIME = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "application/pdf",
+  "text/plain"
+]);
+function isSafeInlineMime(mime) {
+  return SAFE_INLINE_MIME.has(mime);
+}
+function sanitizeAttachmentName(name) {
+  let n = basename4(name || "").replace(/["'\\/]/g, "_");
+  n = Array.from(n, (ch) => {
+    const code = ch.charCodeAt(0);
+    return code < 32 || code === 127 ? "_" : ch;
+  }).join("");
+  n = n.trim();
+  if (!n || n === "." || n === "..") n = "file";
+  if (n.length > 120) {
+    const ext = extname(n);
+    n = n.slice(0, Math.max(1, 120 - ext.length)) + ext;
+  }
+  return n;
+}
+function attachmentsRootDir(todosDir2) {
+  return resolve25(todosDir2, "attachments");
+}
+function attachmentDirFor(todosDir2, scopeId, todoId) {
+  assertScope(scopeId);
+  assertTodoId(todoId);
+  return resolve25(attachmentsRootDir(todosDir2), scopeId, todoId);
+}
+async function dirExists(p) {
+  try {
+    return (await stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes) {
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  await mkdir2(dir, { recursive: true });
+  const id = generateArtifactId();
+  const filename = sanitizeAttachmentName(originalName);
+  await writeFile5(resolve25(dir, `${id}__${filename}`), bytes);
+  return {
+    id,
+    filename,
+    mime: mimeForName(filename),
+    size: bytes.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function listAttachments(todosDir2, scopeId, todoId) {
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  let names;
+  try {
+    names = await readdir10(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const stored of names) {
+    const sep2 = stored.indexOf("__");
+    if (sep2 <= 0) continue;
+    const id = stored.slice(0, sep2);
+    if (!ATTACHMENT_ID_RE.test(id)) continue;
+    const filename = stored.slice(sep2 + 2);
+    try {
+      const st = await stat(resolve25(dir, stored));
+      if (!st.isFile()) continue;
+      out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
+    } catch {
+    }
+  }
+  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return out;
+}
+async function readScopeAttachments(todosDir2, scopeId) {
+  assertScope(scopeId);
+  const scopeDir = resolve25(attachmentsRootDir(todosDir2), scopeId);
+  let todoIds;
+  try {
+    todoIds = await readdir10(scopeDir);
+  } catch {
+    return {};
+  }
+  const result = {};
+  for (const todoId of todoIds) {
+    if (!TODO_ID_RE.test(todoId)) continue;
+    const list = await listAttachments(todosDir2, scopeId, todoId);
+    if (list.length) result[todoId] = list;
+  }
+  return result;
+}
+async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
+  assertAttachmentId(attachmentId);
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  let names;
+  try {
+    names = await readdir10(dir);
+  } catch {
+    return null;
+  }
+  const prefix = `${attachmentId}__`;
+  const stored = names.find((n) => n.startsWith(prefix));
+  if (!stored) return null;
+  const filename = stored.slice(prefix.length);
+  return { path: resolve25(dir, stored), filename, mime: mimeForName(filename) };
+}
+async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
+  const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
+  if (!resolved) return false;
+  await unlink5(resolved.path);
+  return true;
+}
+async function deleteAllAttachments(todosDir2, scopeId, todoId) {
+  await rm3(attachmentDirFor(todosDir2, scopeId, todoId), { recursive: true, force: true });
+}
+async function attachmentMoveConflict(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId, todoId) {
+  const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
+  const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
+  return await dirExists(src) && await dirExists(dst);
+}
+async function moveAttachments(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId, todoId) {
+  const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
+  if (!await dirExists(src)) return;
+  const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
+  await mkdir2(dirname5(dst), { recursive: true });
+  try {
+    await rename5(src, dst);
+  } catch (err) {
+    if (err?.code === "EXDEV") {
+      await cp(src, dst, { recursive: true });
+      await rm3(src, { recursive: true, force: true });
+    } else {
+      throw err;
+    }
+  }
+}
+
+// src/dashboard/todo-attachments-routes.ts
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+function headerValue(req, name) {
+  const v = req.headers[name];
+  return Array.isArray(v) ? v[0] : v;
+}
+function paramStr(v) {
+  return Array.isArray(v) ? v[0] ?? "" : v ?? "";
+}
+function sendError(res, err) {
+  if (err instanceof AttachmentValidationError) {
+    res.status(400).json({ error: err.message });
+    return;
+  }
+  res.status(500).json({ error: err instanceof Error ? err.message : "Attachment operation failed" });
+}
+function contentDisposition(filename, inline) {
+  const disp = inline ? "inline" : "attachment";
+  const asciiFallback = Array.from(filename, (ch) => {
+    const code = ch.charCodeAt(0);
+    return code >= 32 && code <= 126 && ch !== '"' && ch !== "\\" ? ch : "_";
+  }).join("");
+  return `${disp}; filename="${asciiFallback}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}
+function installTodoAttachmentRoutes(router, prefix, opts) {
+  router.post(
+    `${prefix}/attachments`,
+    raw({ type: () => true, limit: MAX_UPLOAD_BYTES }),
+    async (req, res) => {
+      try {
+        const rawName = headerValue(req, "x-attachment-filename");
+        let filename = "file";
+        if (rawName) {
+          try {
+            filename = decodeURIComponent(rawName);
+          } catch {
+            res.status(400).json({ error: "Invalid x-attachment-filename header" });
+            return;
+          }
+        }
+        const body = req.body;
+        if (!Buffer.isBuffer(body) || body.length === 0) {
+          res.status(400).json({ error: "Empty upload body" });
+          return;
+        }
+        const scope = opts.resolveScope(req);
+        const result = await opts.withScopeLock(req, async () => {
+          if (!await opts.todoExists(scope)) return null;
+          return writeAttachment(scope.todosDir, scope.scopeId, scope.todoId, filename, body);
+        });
+        if (!result) {
+          res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+          return;
+        }
+        opts.onChange(req);
+        res.status(201).json(result);
+      } catch (err) {
+        sendError(res, err);
+      }
+    }
+  );
+  router.get(`${prefix}/attachments/:attachmentId`, async (req, res) => {
+    try {
+      const scope = opts.resolveScope(req);
+      const attachmentId = paramStr(req.params.attachmentId);
+      const resolved = await opts.withScopeLock(req, async () => {
+        if (!await opts.todoExists(scope)) return { notFound: true };
+        return {
+          file: await resolveAttachmentFile(scope.todosDir, scope.scopeId, scope.todoId, attachmentId)
+        };
+      });
+      if ("notFound" in resolved) {
+        res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+        return;
+      }
+      if (!resolved.file) {
+        res.status(404).json({ error: `Attachment "${attachmentId}" not found` });
+        return;
+      }
+      const { path, filename, mime } = resolved.file;
+      const inline = isSafeInlineMime(mime);
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("Content-Type", inline ? mime : "application/octet-stream");
+      res.setHeader("Content-Disposition", contentDisposition(filename, inline));
+      res.sendFile(path, (err) => {
+        if (err && !res.headersSent) res.status(500).end();
+      });
+    } catch (err) {
+      sendError(res, err);
+    }
+  });
+  router.delete(`${prefix}/attachments/:attachmentId`, async (req, res) => {
+    try {
+      const scope = opts.resolveScope(req);
+      const attachmentId = paramStr(req.params.attachmentId);
+      const result = await opts.withScopeLock(req, async () => {
+        if (!await opts.todoExists(scope)) return { notFound: true };
+        return { deleted: await deleteAttachment(scope.todosDir, scope.scopeId, scope.todoId, attachmentId) };
+      });
+      if ("notFound" in result) {
+        res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+        return;
+      }
+      if (!result.deleted) {
+        res.status(404).json({ error: `Attachment "${attachmentId}" not found` });
+        return;
+      }
+      opts.onChange(req);
+      res.json({ deleted: attachmentId });
+    } catch (err) {
+      sendError(res, err);
+    }
+  });
+}
+
+// src/dashboard/api-todos.ts
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -13528,7 +14178,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir) {
-  const router = Router13();
+  const router = Router14();
   installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -13545,6 +14195,19 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
     next();
   }
   router.param("workspace", validateWorkspace);
+  installTodoAttachmentRoutes(router, "/:workspace/:id", {
+    resolveScope: (req) => ({
+      todosDir: todosDir2,
+      scopeId: getWorkspaceParam(req.params.workspace),
+      todoId: getWorkspaceParam(req.params.id)
+    }),
+    withScopeLock: (req, fn) => wsLock(getWorkspaceParam(req.params.workspace), fn),
+    todoExists: async (scope) => {
+      const checklist = await readChecklist(scope.todosDir, scope.scopeId);
+      return checklist.items.some((i) => i.id === scope.todoId);
+    },
+    onChange: () => broadcastUpdate()
+  });
   router.post("/promote-bulk", async (req, res) => {
     try {
       const { groups, mode, target, title, type, priority, keepSource } = req.body ?? {};
@@ -13649,17 +14312,18 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   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;
         if (!file.endsWith(".md") || file.endsWith("-log.md")) continue;
         const workspace = file.replace(".md", "");
         const checklist = await readChecklist(todosDir2, workspace);
+        const attachmentsByTodo = await readScopeAttachments(todosDir2, checklist.workspace);
         workspaces.push({
           workspace: checklist.workspace,
           archiveInterval: checklist.archiveInterval,
-          items: checklist.items,
+          items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
           counts: computeCounts(checklist.items)
         });
       }
@@ -13672,10 +14336,11 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
+      const attachmentsByTodo = await readScopeAttachments(todosDir2, workspace);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
-        items: checklist.items,
+        items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
         counts: computeCounts(checklist.items)
       });
     } catch (error) {
@@ -13763,63 +14428,68 @@ 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: resolve29 } = await import("path");
+      const { resolve: resolve30 } = await import("path");
       const { readFile: readFile21 } = 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);
-      const log = await readLog(todosDir2, workspace);
-      const completedIds = new Set(
-        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
-      );
-      if (completedIds.size === 0) {
-        res.json({ archived: 0, message: "No completed items to archive" });
-        return;
-      }
-      const toArchive = log.entries.filter(
-        (e) => e.itemIds.every((id) => completedIds.has(id))
-      );
-      const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve29(todosDir2, "archive"));
-      let archContent = "";
-      if (await fileExists(archFile)) {
-        archContent = await readFile21(archFile, "utf-8");
-        archContent = archContent.trimEnd() + "\n\n";
-      } else {
-        archContent = `---
+      const outcome = await wsLock(workspace, async () => {
+        const checklist = await readChecklist(todosDir2, workspace);
+        const log = await readLog(todosDir2, workspace);
+        const completedIds = new Set(
+          checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+        );
+        if (completedIds.size === 0) {
+          return { archived: 0, message: "No completed items to archive" };
+        }
+        const toArchive = log.entries.filter(
+          (e) => e.itemIds.every((id) => completedIds.has(id))
+        );
+        const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
+        await ensureDir(resolve30(todosDir2, "archive"));
+        let archContent = "";
+        if (await fileExists(archFile)) {
+          archContent = await readFile21(archFile, "utf-8");
+          archContent = archContent.trimEnd() + "\n\n";
+        } else {
+          archContent = `---
 workspace: ${workspace}
 ---
 
 # Archive
 
 `;
-      }
-      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
-      for (const item of completedItems) {
-        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+        }
+        const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+        for (const item of completedItems) {
+          archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
 `;
-      }
-      archContent += "\n";
-      for (const entry of toArchive) {
-        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+        }
+        archContent += "\n";
+        for (const entry of toArchive) {
+          archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
 `;
-        if (entry.items) archContent += `**Items:** ${entry.items}
+          if (entry.items) archContent += `**Items:** ${entry.items}
 `;
-        if (entry.session) archContent += `**Session:** ${entry.session}
+          if (entry.session) archContent += `**Session:** ${entry.session}
 `;
-        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+          if (entry.branch) archContent += `**Branch:** ${entry.branch}
 `;
-        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+          if (entry.summary) archContent += `**Summary:** ${entry.summary}
 `;
-        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+          if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
 `;
-        archContent += "\n";
-      }
-      await writeFileForce2(archFile, archContent);
-      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir2, checklist);
-      broadcastUpdate();
-      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+          archContent += "\n";
+        }
+        await writeFileForce2(archFile, archContent);
+        checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+        await writeChecklist(todosDir2, checklist);
+        for (const id of completedIds) {
+          await deleteAllAttachments(todosDir2, workspace, id);
+        }
+        return { archived: completedIds.size, logEntries: toArchive.length };
+      });
+      if (outcome.archived > 0) broadcastUpdate();
+      res.json(outcome);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to archive" });
     }
@@ -13844,7 +14514,8 @@ workspace: ${workspace}
       }
       const log = await readLog(todosDir2, workspace);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
-      res.json({ ...item, log: logEntries });
+      const attachments = await listAttachments(todosDir2, workspace, item.id);
+      res.json({ ...item, attachments, log: logEntries });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
     }
@@ -13881,6 +14552,7 @@ workspace: ${workspace}
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
         await writeChecklist(todosDir2, checklist);
+        await deleteAllAttachments(todosDir2, workspace, req.params.id);
         return true;
       });
       if (!deleted) {
@@ -14192,15 +14864,22 @@ workspace: ${workspace}
           return { status: 409, error: "id already exists in target" };
         }
         const item = sourceChecklist.items[idx];
+        let newPlanDir = null;
         if (item.planDir) {
-          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          newPlanDir = todoPlanDir(target.todosPath, target.id, id);
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir2(dirname5(newPlanDir), { recursive: true });
-          await rename5(item.planDir, newPlanDir);
+        }
+        if (await attachmentMoveConflict(todosDir2, sourceWs, target.todosPath, target.id, id)) {
+          return { status: 409, error: "attachments already exist in target" };
+        }
+        if (item.planDir && newPlanDir) {
+          await mkdir3(dirname6(newPlanDir), { recursive: true });
+          await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
+        await moveAttachments(todosDir2, sourceWs, target.todosPath, target.id, id);
         sourceChecklist.items.splice(idx, 1);
         targetChecklist.items.push(item);
         await writeChecklist(todosDir2, sourceChecklist);
@@ -14273,9 +14952,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router14 } from "express";
-import { mkdir as mkdir3, readFile as readFile18, rename as rename6 } from "fs/promises";
-import { resolve as resolve25, dirname as dirname6 } from "path";
+import { Router as Router15 } from "express";
+import { mkdir as mkdir4, readFile as readFile18, rename as rename7 } from "fs/promises";
+import { resolve as resolve26, dirname as dirname7 } from "path";
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -14291,12 +14970,12 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir, slug) {
-  return fileExists(resolve25(projectsDir, slug, "project.md"));
+  return fileExists(resolve26(projectsDir, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
   try {
-    await mkdir3(todosDir2, { recursive: false });
+    await mkdir4(todosDir2, { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -14308,7 +14987,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir3(resolve25(todosDir2, "archive"), { recursive: false });
+    await mkdir4(resolve26(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -14324,7 +15003,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
-  const router = Router14({ mergeParams: true });
+  const router = Router15({ mergeParams: true });
   installRecordsInvalidation(router);
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -14341,6 +15020,18 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
     next();
   }
   router.use(validateProjectId);
+  installTodoAttachmentRoutes(router, "/:id", {
+    resolveScope: (req) => {
+      const slug = getProjectIdParam(params(req).projectId);
+      return { todosDir: projectTodosDir(projectsDir, slug), scopeId: slug, todoId: params(req).id ?? "" };
+    },
+    withScopeLock: (req, fn) => projLock(getProjectIdParam(params(req).projectId), fn),
+    todoExists: async (scope) => {
+      const checklist = await readChecklist(scope.todosDir, scope.scopeId);
+      return checklist.items.some((i) => i.id === scope.todoId);
+    },
+    onChange: (req) => broadcastUpdate(getProjectIdParam(params(req).projectId))
+  });
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam(params(req).projectId);
@@ -14350,10 +15041,11 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
       }
       const todosDir2 = projectTodosDir(projectsDir, slug);
       const checklist = await readChecklist(todosDir2, slug);
+      const attachmentsByTodo = await readScopeAttachments(todosDir2, slug);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
-        items: checklist.items,
+        items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
         counts: computeCounts(checklist.items)
       });
     } catch (error) {
@@ -14481,61 +15173,71 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
         notFound(res, slug);
         return;
       }
-      const todosDir2 = projectTodosDir(projectsDir, slug);
-      await ensureProjectTodosDir(projectsDir, slug);
-      const checklist = await readChecklist(todosDir2, slug);
-      const log = await readLog(todosDir2, slug);
-      const completedIds = new Set(
-        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
-      );
-      if (completedIds.size === 0) {
-        res.json({ archived: 0, message: "No completed items to archive" });
-        return;
-      }
-      const toArchive = log.entries.filter(
-        (e) => e.itemIds.every((id) => completedIds.has(id))
-      );
-      const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
-      let archContent = "";
-      if (await fileExists(archFile)) {
-        archContent = await readFile18(archFile, "utf-8");
-        archContent = archContent.trimEnd() + "\n\n";
-      } else {
-        archContent = `---
+      const outcome = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const log = await readLog(todosDir2, slug);
+        const completedIds = new Set(
+          checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+        );
+        if (completedIds.size === 0) {
+          return { archived: 0, message: "No completed items to archive" };
+        }
+        const toArchive = log.entries.filter(
+          (e) => e.itemIds.every((id) => completedIds.has(id))
+        );
+        const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
+        let archContent = "";
+        if (await fileExists(archFile)) {
+          archContent = await readFile18(archFile, "utf-8");
+          archContent = archContent.trimEnd() + "\n\n";
+        } else {
+          archContent = `---
 workspace: ${slug}
 ---
 
 # Archive
 
 `;
-      }
-      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
-      for (const item of completedItems) {
-        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+        }
+        const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+        for (const item of completedItems) {
+          archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
 `;
-      }
-      archContent += "\n";
-      for (const entry of toArchive) {
-        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+        }
+        archContent += "\n";
+        for (const entry of toArchive) {
+          archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
 `;
-        if (entry.items) archContent += `**Items:** ${entry.items}
+          if (entry.items) archContent += `**Items:** ${entry.items}
 `;
-        if (entry.session) archContent += `**Session:** ${entry.session}
+          if (entry.session) archContent += `**Session:** ${entry.session}
 `;
-        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+          if (entry.branch) archContent += `**Branch:** ${entry.branch}
 `;
-        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+          if (entry.summary) archContent += `**Summary:** ${entry.summary}
 `;
-        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+          if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
 `;
-        archContent += "\n";
+          archContent += "\n";
+        }
+        await writeFileForce(archFile, archContent);
+        checklist.workspace = slug;
+        checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+        await writeChecklist(todosDir2, checklist);
+        for (const id of completedIds) {
+          await deleteAllAttachments(todosDir2, slug, id);
+        }
+        return { archived: completedIds.size, logEntries: toArchive.length };
+      });
+      if (outcome === "gone") {
+        notFound(res, slug);
+        return;
       }
-      await writeFileForce(archFile, archContent);
-      checklist.workspace = slug;
-      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir2, checklist);
-      broadcastUpdate(slug);
-      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+      if (outcome.archived > 0) broadcastUpdate(slug);
+      res.json(outcome);
     } catch (error) {
       if (error.code === "PROJECT_GONE") {
         notFound(res, getProjectIdParam(params(req).projectId));
@@ -14575,7 +15277,8 @@ workspace: ${slug}
       }
       const log = await readLog(todosDir2, slug);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
-      res.json({ ...item, log: logEntries });
+      const attachments = await listAttachments(todosDir2, slug, item.id);
+      res.json({ ...item, attachments, log: logEntries });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
     }
@@ -14631,11 +15334,13 @@ workspace: ${slug}
         await ensureProjectTodosDir(projectsDir, slug);
         const todosDir2 = projectTodosDir(projectsDir, slug);
         const checklist = await readChecklist(todosDir2, slug);
-        const idx = checklist.items.findIndex((i) => i.id === (params(req).id ?? ""));
+        const targetId = params(req).id ?? "";
+        const idx = checklist.items.findIndex((i) => i.id === targetId);
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
         checklist.workspace = slug;
         await writeChecklist(todosDir2, checklist);
+        await deleteAllAttachments(todosDir2, slug, targetId);
         return true;
       });
       if (deleted === "gone") {
@@ -14945,15 +15650,15 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve25(projectsDir, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve26(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 = resolve25(assignmentsDirFn(), tg);
+          assignmentDir = resolve26(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath = resolve25(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolve26(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
         let content = await readFile18(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
@@ -15083,15 +15788,22 @@ workspace: ${slug}
           return { status: 409, error: "id already exists in target" };
         }
         const item = sourceChecklist.items[idx];
+        let newPlanDir = null;
         if (item.planDir) {
-          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          newPlanDir = todoPlanDir(target.todosPath, target.id, id);
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir3(dirname6(newPlanDir), { recursive: true });
-          await rename6(item.planDir, newPlanDir);
+        }
+        if (await attachmentMoveConflict(sourceTodosDir, sourceSlug, target.todosPath, target.id, id)) {
+          return { status: 409, error: "attachments already exist in target" };
+        }
+        if (item.planDir && newPlanDir) {
+          await mkdir4(dirname7(newPlanDir), { recursive: true });
+          await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
+        await moveAttachments(sourceTodosDir, sourceSlug, target.todosPath, target.id, id);
         sourceChecklist.items.splice(idx, 1);
         targetChecklist.items.push(item);
         sourceChecklist.workspace = sourceSlug;
@@ -15150,33 +15862,33 @@ workspace: ${slug}
 }
 
 // src/dashboard/api-bundles.ts
-import { Router as Router15 } from "express";
-import { readdir as readdir11 } from "fs/promises";
+import { Router as Router16 } from "express";
+import { readdir as readdir12 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
 init_fs();
 init_paths();
 init_parser2();
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 import { readFile as readFile19 } from "fs/promises";
 var BUNDLE_ID_REGEX = /^[a-f0-9]{4}$/;
 var SCOPE_VALUES = /* @__PURE__ */ new Set(["workspace", "project", "global"]);
 var SCOPE_ID_REGEX = /^[a-z0-9_][a-z0-9_-]*$/;
 var BUNDLE_LINE_REGEX = /^- b:([a-f0-9]{4})\s+<([^>]*)>\s*$/;
-function parseScopeToken(raw) {
-  const idx = raw.indexOf(":");
+function parseScopeToken(raw2) {
+  const idx = raw2.indexOf(":");
   if (idx < 0) return null;
-  const scopeRaw = raw.slice(0, idx);
-  const scopeId = raw.slice(idx + 1);
+  const scopeRaw = raw2.slice(0, idx);
+  const scopeId = raw2.slice(idx + 1);
   if (!SCOPE_VALUES.has(scopeRaw)) return null;
   if (!scopeId) return null;
   if (!SCOPE_ID_REGEX.test(scopeId)) return null;
   return { scope: scopeRaw, scopeId };
 }
-function parseTodosToken(raw) {
-  if (!raw) return [];
-  return raw.split(",").map((s) => s.trim()).filter((s) => BUNDLE_ID_REGEX.test(s));
+function parseTodosToken(raw2) {
+  if (!raw2) return [];
+  return raw2.split(",").map((s) => s.trim()).filter((s) => BUNDLE_ID_REGEX.test(s));
 }
 function parseBundleLine(line) {
   const match = line.match(BUNDLE_LINE_REGEX);
@@ -15261,7 +15973,7 @@ function annotate(bundle, items) {
 }
 function createBundlesRouter(todosDir2, broadcast) {
   void broadcast;
-  const router = Router15();
+  const router = Router16();
   function validateWorkspace(req, res, next) {
     const workspace = getWorkspaceParam2(req.params.workspace);
     if (workspace && !WORKSPACE_REGEX3.test(workspace)) {
@@ -15275,7 +15987,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir11(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir12(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -15327,8 +16039,8 @@ function createBundlesRouter(todosDir2, broadcast) {
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router16 } from "express";
-import { resolve as resolve26 } from "path";
+import { Router as Router17 } from "express";
+import { resolve as resolve27 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
   const members = bundle.todoIds.map((id) => items.find((i) => i.id === id)).filter((i) => i !== void 0);
@@ -15357,7 +16069,7 @@ function notFound2(res, slug) {
 }
 function createProjectBundlesRouter(projectsDir, broadcast) {
   void broadcast;
-  const router = Router16({ mergeParams: true });
+  const router = Router17({ mergeParams: true });
   function validateProjectId(req, res, next) {
     const slug = getProjectIdParam2(req.params.projectId);
     if (!slug || !isValidSlug(slug)) {
@@ -15370,7 +16082,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam2(req.params.projectId);
-      const projectMd = resolve26(projectsDir, slug, "project.md");
+      const projectMd = resolve27(projectsDir, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -15391,7 +16103,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
 init_config2();
 init_api();
 init_scanner();
-import { Router as Router17 } from "express";
+import { Router as Router18 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -15399,8 +16111,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm3, readFile as readFile20, writeFile as writeFile5, unlink as unlink5, stat, open as open2, rename as rename7 } from "fs/promises";
-import { resolve as resolve27, join as join3 } from "path";
+import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile20, writeFile as writeFile6, unlink as unlink6, stat as stat2, open as open2, rename as rename8 } from "fs/promises";
+import { resolve as resolve28, join as join3 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -15440,7 +16152,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve27(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve28(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -15451,7 +16163,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve27(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve28(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open2(lockPath, "wx");
@@ -15470,7 +16182,7 @@ async function acquireLock() {
 }
 async function releaseLock(lockPath) {
   try {
-    await unlink5(lockPath);
+    await unlink6(lockPath);
   } catch {
   }
 }
@@ -15493,13 +16205,13 @@ async function cloneOrInit(repoUrl, destDir) {
 }
 async function copyRecursive(src, dest) {
   if (!await fileExists(src)) return;
-  const s = await stat(src);
+  const s = await stat2(src);
   if (s.isDirectory()) {
     await ensureDir(dest);
-    await cp(src, dest, { recursive: true, force: true });
+    await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve27(dest, ".."));
-    await cp(src, dest, { force: true });
+    await ensureDir(resolve28(dest, ".."));
+    await cp2(src, dest, { force: true });
   }
 }
 function resolveCategoriesStrict(csv) {
@@ -15536,9 +16248,9 @@ async function backupToGithub(overrides) {
       const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
       const destPath = join3(tmpDir, repoPath);
       if (isFile) {
-        await rm3(destPath, { force: true });
+        await rm4(destPath, { force: true });
       } else {
-        await rm3(destPath, { recursive: true, force: true });
+        await rm4(destPath, { recursive: true, force: true });
       }
       if (!await fileExists(sourcePath)) {
         console.warn(`Category "${category}": no local data at ${sourcePath}; backup will reflect deletion.`);
@@ -15546,8 +16258,8 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve27(destPath, ".."));
-        await writeFile5(destPath, sanitized, "utf-8");
+        await ensureDir(resolve28(destPath, ".."));
+        await writeFile6(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -15592,7 +16304,7 @@ async function backupToGithub(overrides) {
     };
   } finally {
     if (tmpDir) {
-      await rm3(tmpDir, { recursive: true, force: true }).catch(() => {
+      await rm4(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
     await releaseLock(lockPath);
@@ -15600,18 +16312,18 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve27(localPath, ".."));
-    await cp(repoSrcPath, localPath, { force: true });
+    await ensureDir(resolve28(localPath, ".."));
+    await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
   const stagingPath = `${localPath}.syntaur-restore-staging`;
   const backupPath = `${localPath}.syntaur-restore-backup`;
-  await rm3(stagingPath, { recursive: true, force: true });
+  await rm4(stagingPath, { recursive: true, force: true });
   const backupExistsBefore = await fileExists(backupPath);
   const localExistsBefore = await fileExists(localPath);
   if (backupExistsBefore) {
     if (!localExistsBefore) {
-      await rename7(backupPath, localPath);
+      await rename8(backupPath, localPath);
     } else {
       throw new Error(
         `Cannot restore "${localPath}": a stale crash-recovery backup exists at ${backupPath} while the current path also exists. Inspect both and remove the one you don't need, then retry.`
@@ -15620,21 +16332,21 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   }
   let localMovedAside = false;
   try {
-    await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
+    await cp2(repoSrcPath, stagingPath, { recursive: true, force: true });
     const localExists = await fileExists(localPath);
     if (localExists) {
-      await rename7(localPath, backupPath);
+      await rename8(localPath, backupPath);
       localMovedAside = true;
     }
-    await rename7(stagingPath, localPath);
-    await rm3(backupPath, { recursive: true, force: true }).catch(() => {
+    await rename8(stagingPath, localPath);
+    await rm4(backupPath, { recursive: true, force: true }).catch(() => {
     });
   } catch (err) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename7(backupPath, localPath).catch(() => {
+      await rename8(backupPath, localPath).catch(() => {
       });
     }
-    await rm3(stagingPath, { recursive: true, force: true }).catch(() => {
+    await rm4(stagingPath, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   }
@@ -15693,7 +16405,7 @@ async function restoreFromGithub(overrides) {
     };
   } finally {
     if (tmpDir) {
-      await rm3(tmpDir, { recursive: true, force: true }).catch(() => {
+      await rm4(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
     await releaseLock(lockPath);
@@ -15701,7 +16413,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve27(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve28(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -15714,7 +16426,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router17();
+  const router = Router18();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -16049,7 +16761,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve28(syntaurRoot(), "config.md")
+        resolve29(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -16150,8 +16862,8 @@ function createDashboardServer(options) {
   });
   app.put("/api/config/hotkeys", async (req, res) => {
     try {
-      const raw = req.body && typeof req.body === "object" ? req.body : {};
-      const incoming = raw.bindings;
+      const raw2 = req.body && typeof req.body === "object" ? req.body : {};
+      const incoming = raw2.bindings;
       if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) {
         res.status(400).json({ error: "bindings must be an object keyed by action kind" });
         return;
@@ -16567,14 +17279,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve28(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve29(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 = resolve28(dashboardDistPath, "index.html");
+      const indexPath = resolve29(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -16598,7 +17310,7 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
-        dbPath: resolve28(syntaurRoot(), "syntaur.db"),
+        dbPath: resolve29(syntaurRoot(), "syntaur.db"),
         onMessage: broadcast
       });
       startAutodiscovery({ serversDir: serversDir2, projectsDir, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
@@ -16613,8 +17325,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve28(syntaurRoot(), "dashboard-port");
-          writeFile6(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve29(syntaurRoot(), "dashboard-port");
+          writeFile7(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -16632,8 +17344,8 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve28(syntaurRoot(), "dashboard-port");
-      await unlink6(portFile).catch(() => {
+      const portFile = resolve29(syntaurRoot(), "dashboard-port");
+      await unlink7(portFile).catch(() => {
       });
       server.closeAllConnections?.();
       return new Promise((resolvePromise) => {