syntaur 0.27.0 → 0.32.0

package/dist/dashboard/server.js

@@ -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:");
@@ -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",
@@ -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);
@@ -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) {
@@ -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"])
     };
@@ -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();
@@ -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);
@@ -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();
@@ -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;
@@ -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 };