syntaur 0.1.13 → 0.2.0

package/dist/dashboard/server.js

@@ -8,6 +8,40 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/paths.ts
+import { homedir } from "os";
+import { resolve } from "path";
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function syntaurRoot() {
+  const override = process.env.SYNTAUR_HOME;
+  if (override && override.length > 0) {
+    return resolve(expandHome(override));
+  }
+  return resolve(homedir(), ".syntaur");
+}
+function defaultProjectDir() {
+  return resolve(syntaurRoot(), "projects");
+}
+function serversDir() {
+  return resolve(syntaurRoot(), "servers");
+}
+function playbooksDir() {
+  return resolve(syntaurRoot(), "playbooks");
+}
+function todosDir() {
+  return resolve(syntaurRoot(), "todos");
+}
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+  }
+});
+
 // src/lifecycle/types.ts
 var DEFAULT_STATUSES;
 var init_types = __esm({
@@ -184,6 +218,8 @@ function parseAssignmentFrontmatter(fileContent) {
     id: getField2("id") ?? "",
     slug: getField2("slug") ?? "",
     title: getField2("title") ?? "",
+    project: getField2("project"),
+    type: getField2("type"),
     status: getField2("status") ?? "pending",
     priority: getField2("priority") ?? "medium",
     created: getField2("created") ?? "",
@@ -282,10 +318,10 @@ var init_timestamp = __esm({
 });
 
 // src/lifecycle/transitions.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { readFile } from "fs/promises";
-function resolveAssignmentPath(missionDir, assignmentSlug) {
-  return resolve(missionDir, "assignments", assignmentSlug, "assignment.md");
+function resolveAssignmentPath(projectDir, assignmentSlug) {
+  return resolve2(projectDir, "assignments", assignmentSlug, "assignment.md");
 }
 async function readAssignment(filePath) {
   if (!await fileExists(filePath)) {
@@ -295,11 +331,11 @@ async function readAssignment(filePath) {
   const frontmatter = parseAssignmentFrontmatter(content);
   return { content, frontmatter };
 }
-async function checkDependencies(missionDir, dependsOn, terminalStatuses) {
+async function checkDependencies(projectDir, dependsOn, terminalStatuses) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const depSlug of dependsOn) {
-    const depPath = resolveAssignmentPath(missionDir, depSlug);
+    const depPath = resolveAssignmentPath(projectDir, depSlug);
     if (!await fileExists(depPath)) {
       unmet.push(`${depSlug} (file not found)`);
       continue;
@@ -312,8 +348,8 @@ async function checkDependencies(missionDir, dependsOn, terminalStatuses) {
   }
   return { satisfied: unmet.length === 0, unmet };
 }
-async function executeTransition(missionDir, assignmentSlug, command, options = {}) {
-  const filePath = resolveAssignmentPath(missionDir, assignmentSlug);
+async function executeTransition(projectDir, assignmentSlug, command, options = {}) {
+  const filePath = resolveAssignmentPath(projectDir, assignmentSlug);
   const { content, frontmatter } = await readAssignment(filePath);
   const targetStatus = getTargetStatus(frontmatter.status, command, options.transitionTable);
   if (!targetStatus) {
@@ -325,7 +361,7 @@ async function executeTransition(missionDir, assignmentSlug, command, options =
   }
   const warnings = [];
   if (command === "start" && frontmatter.dependsOn.length > 0) {
-    const depCheck = await checkDependencies(missionDir, frontmatter.dependsOn, options.terminalStatuses);
+    const depCheck = await checkDependencies(projectDir, frontmatter.dependsOn, options.terminalStatuses);
     if (!depCheck.satisfied) {
       warnings.push(`Starting with unmet dependencies: ${depCheck.unmet.join(", ")}`);
     }
@@ -374,28 +410,28 @@ var init_lifecycle = __esm({
   }
 });
 
-// src/utils/paths.ts
-import { homedir } from "os";
-import { resolve as resolve2 } from "path";
-function expandHome(p) {
-  if (p.startsWith("~/") || p === "~") {
-    return resolve2(homedir(), p.slice(2));
-  }
-  return p;
-}
-function syntaurRoot() {
-  return resolve2(homedir(), ".syntaur");
-}
-function defaultMissionDir() {
-  return resolve2(syntaurRoot(), "missions");
-}
-var init_paths = __esm({
-  "src/utils/paths.ts"() {
-    "use strict";
-  }
-});
-
 // src/templates/config.ts
+function renderConfig(params) {
+  return `---
+version: "1.0"
+defaultProjectDir: ${params.defaultProjectDir}
+onboarding:
+  completed: false
+agentDefaults:
+  trustLevel: medium
+  autoApprove: false
+backup:
+  repo: null
+  categories: projects, playbooks, todos, servers, config
+  lastBackup: null
+  lastRestore: null
+---
+
+# Syntaur Configuration
+
+Global configuration for the Syntaur CLI.
+`;
+}
 var init_config = __esm({
   "src/templates/config.ts"() {
     "use strict";
@@ -549,6 +585,14 @@ function serializeStatusConfig(statuses) {
   }
   return lines.join("\n");
 }
+function serializeBackupConfig(backup) {
+  const lines = ["backup:"];
+  lines.push(`  repo: ${backup.repo ?? "null"}`);
+  lines.push(`  categories: ${backup.categories}`);
+  lines.push(`  lastBackup: ${backup.lastBackup ?? "null"}`);
+  lines.push(`  lastRestore: ${backup.lastRestore ?? "null"}`);
+  return lines.join("\n");
+}
 function stripTopLevelBlock(fmBlock, key) {
   const blockStart = fmBlock.match(new RegExp(`^${key}:\\s*$`, "m"));
   if (!blockStart) {
@@ -590,8 +634,8 @@ async function writeStatusConfig(statuses) {
   const statusBlock = serializeStatusConfig(statuses);
   if (!await fileExists(configPath)) {
     const content = `---
-version: "1.0"
-defaultMissionDir: ~/missions
+version: "2.0"
+defaultProjectDir: ~/projects
 ${statusBlock}
 ---
 `;
@@ -602,7 +646,7 @@ ${statusBlock}
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
-version: "1.0"
+version: "2.0"
 ${statusBlock}
 ---
 ${existing}`;
@@ -653,6 +697,40 @@ ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+async function updateBackupConfig(backup) {
+  const configPath = resolve3(syntaurRoot(), "config.md");
+  const current = (await readConfig()).backup;
+  const nextBackup = {
+    repo: current?.repo ?? null,
+    categories: current?.categories ?? "projects, playbooks, todos, servers, config",
+    lastBackup: current?.lastBackup ?? null,
+    lastRestore: current?.lastRestore ?? null,
+    ...backup
+  };
+  const backupBlock = serializeBackupConfig(nextBackup);
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${backupBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "backup");
+  const newFm = `${cleanedFm}
+${backupBlock}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 async function readConfig() {
   const configPath = resolve3(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
@@ -664,16 +742,16 @@ async function readConfig() {
     console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
     return { ...DEFAULT_CONFIG };
   }
-  let missionDir = fm["defaultMissionDir"] ? expandHome(String(fm["defaultMissionDir"])) : DEFAULT_CONFIG.defaultMissionDir;
-  if (!isAbsolute(missionDir)) {
+  let projectDir = fm["defaultProjectDir"] ? expandHome(String(fm["defaultProjectDir"])) : DEFAULT_CONFIG.defaultProjectDir;
+  if (!isAbsolute(projectDir)) {
     console.warn(
-      `Warning: config.md defaultMissionDir is not an absolute path ("${fm["defaultMissionDir"]}"), using default`
+      `Warning: config.md defaultProjectDir is not an absolute path ("${fm["defaultProjectDir"]}"), using default`
     );
-    missionDir = DEFAULT_CONFIG.defaultMissionDir;
+    projectDir = DEFAULT_CONFIG.defaultProjectDir;
   }
   return {
     version: fm["version"] || DEFAULT_CONFIG.version,
-    defaultMissionDir: missionDir,
+    defaultProjectDir: projectDir,
     onboarding: {
       completed: fm["onboarding.completed"] === "true"
     },
@@ -695,7 +773,14 @@ async function readConfig() {
         "integrations.codexMarketplacePath"
       )
     },
-    statuses: parseStatusConfig(content)
+    backup: fm["backup.repo"] || fm["backup.categories"] ? {
+      repo: fm["backup.repo"] && fm["backup.repo"] !== "null" ? fm["backup.repo"] : null,
+      categories: fm["backup.categories"] || "projects, playbooks, todos, servers, config",
+      lastBackup: fm["backup.lastBackup"] && fm["backup.lastBackup"] !== "null" ? fm["backup.lastBackup"] : null,
+      lastRestore: fm["backup.lastRestore"] && fm["backup.lastRestore"] !== "null" ? fm["backup.lastRestore"] : null
+    } : null,
+    statuses: parseStatusConfig(content),
+    types: null
   };
 }
 var DEFAULT_CONFIG;
@@ -706,8 +791,8 @@ var init_config2 = __esm({
     init_fs();
     init_config();
     DEFAULT_CONFIG = {
-      version: "1.0",
-      defaultMissionDir: defaultMissionDir(),
+      version: "2.0",
+      defaultProjectDir: defaultProjectDir(),
       onboarding: {
         completed: false
       },
@@ -720,7 +805,9 @@ var init_config2 = __esm({
         codexPluginDir: null,
         codexMarketplacePath: null
       },
-      statuses: null
+      backup: null,
+      statuses: null,
+      types: null
     };
   }
 });
@@ -773,7 +860,7 @@ function parseListField(frontmatter, fieldName) {
   }
   return results;
 }
-function parseMission(fileContent) {
+function parseProject(fileContent) {
   const [fm, body] = extractFrontmatter2(fileContent);
   return {
     id: getField(fm, "id") ?? "",
@@ -804,13 +891,13 @@ function parseStatus(fileContent) {
     }
   }
   return {
-    mission: getField(fm, "mission") ?? "",
+    project: getField(fm, "project") ?? "",
     status: getField(fm, "status") ?? "pending",
     progress,
     needsAttention: {
       blockedCount: parseInt(getNestedField(fm, "needsAttention", "blockedCount") ?? "0", 10),
       failedCount: parseInt(getNestedField(fm, "needsAttention", "failedCount") ?? "0", 10),
-      unansweredQuestions: parseInt(getNestedField(fm, "needsAttention", "unansweredQuestions") ?? "0", 10)
+      openQuestions: parseInt(getNestedField(fm, "needsAttention", "openQuestions") ?? "0", 10)
     },
     body
   };
@@ -852,6 +939,8 @@ function parseAssignmentFull(fileContent) {
     id: getField(fm, "id") ?? "",
     slug: getField(fm, "slug") ?? "",
     title: getField(fm, "title") ?? "",
+    project: getField(fm, "project"),
+    type: getField(fm, "type"),
     status: getField(fm, "status") ?? "pending",
     priority: getField(fm, "priority") ?? "medium",
     assignee: getField(fm, "assignee"),
@@ -971,17 +1060,17 @@ async function getDashboardHelp() {
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     whatIsSyntaur: {
-      summary: "Syntaur is a local-first, markdown-backed agent work system. The dashboard is a live view over mission folders and files on disk.",
+      summary: "Syntaur is a local-first, markdown-backed agent work system. The dashboard is a live view over project folders and files on disk.",
       bullets: [
         "Markdown files are the source of truth.",
-        "The UI reads mission folders, assignment files, and derived indexes from the local filesystem.",
+        "The UI reads project folders, assignment files, and derived indexes from the local filesystem.",
         "Derived underscore-prefixed files are projections, not the canonical edit target."
       ]
     },
     coreConcepts: [
       {
-        term: "Mission",
-        description: "A mission is the higher-level objective. It owns assignments, shared resources, and mission memories."
+        term: "Project",
+        description: "A project is the higher-level objective. It owns assignments, shared resources, and project memories."
       },
       {
         term: "Assignment",
@@ -989,15 +1078,15 @@ async function getDashboardHelp() {
       },
       {
         term: "Resource",
-        description: "A mission-level shared reference file that provides source material or constraints for the work."
+        description: "A project-level shared reference file that provides source material or constraints for the work."
       },
       {
         term: "Memory",
-        description: "A mission-level learning or pattern captured during execution so future assignments can reuse it."
+        description: "A project-level learning or pattern captured during execution so future assignments can reuse it."
       },
       {
         term: "Manifest",
-        description: "A derived navigation file that points agents at the mission overview, indexes, and agent instructions."
+        description: "A derived navigation file that points agents at the project overview, indexes, and agent instructions."
       },
       {
         term: "Derived file",
@@ -1033,12 +1122,12 @@ async function getDashboardHelp() {
     ownershipRules: [
       {
         label: "Human-authored files",
-        files: ["mission.md", "agent.md", "claude.md"],
-        description: "These files define mission intent and instructions. The dashboard treats mission status as derived except for the archive fields."
+        files: ["project.md", "agent.md", "claude.md"],
+        description: "These files define project intent and instructions. The dashboard treats project status as derived except for the archive fields."
       },
       {
         label: "Assignment working files",
-        files: ["assignment.md", "plan.md", "scratchpad.md"],
+        files: ["assignment.md", "plan*.md (optional, versioned)", "scratchpad.md"],
         description: "These are agent-writable files. The dashboard lets you edit the source markdown while preserving unsupported frontmatter keys."
       },
       {
@@ -1060,13 +1149,13 @@ async function getDashboardHelp() {
         href: "/"
       },
       {
-        label: "Missions",
-        description: "Browse, search, filter, and sort the mission directory. Create new missions and drill into mission workspaces.",
-        href: "/missions"
+        label: "Projects",
+        description: "Browse, search, filter, and sort the project directory. Create new projects and drill into project workspaces.",
+        href: "/projects"
       },
       {
         label: "Assignments",
-        description: "Cross-mission kanban board of all assignments. Drag cards between columns to change status, or filter by mission, assignee, or status.",
+        description: "Cross-project kanban board of all assignments. Drag cards between columns to change status, or filter by project, assignee, or status.",
         href: "/assignments"
       },
       {
@@ -1100,14 +1189,14 @@ async function getDashboardHelp() {
         href: "/settings"
       },
       {
-        label: "Mission page",
-        description: "The mission workspace shows health stats, assignment list, dependency graph, shared resources, and memories.",
-        href: "/missions"
+        label: "Project page",
+        description: "The project workspace shows health stats, assignment list, dependency graph, shared resources, and memories.",
+        href: "/projects"
       },
       {
         label: "Assignment page",
         description: "The assignment workspace shows lifecycle actions, plan editor, scratchpad, handoff log, decision records, and agent sessions.",
-        href: "/missions"
+        href: "/projects"
       }
     ],
     faq: [
@@ -1144,16 +1233,16 @@ async function getDashboardHelp() {
         answer: "Syntaur tracks tmux sessions to discover running dev servers, their ports, git branches, and linked assignments. Register sessions on the Servers page or let autodiscovery find them. Pane info refreshes automatically."
       }
     ],
-    firstMissionChecklist: [
+    firstProjectChecklist: [
       {
-        title: "Create the mission",
-        detail: "Describe the overall objective in mission.md, then add tags and archive metadata only when needed.",
+        title: "Create the project",
+        detail: "Describe the overall objective in project.md, then add tags and archive metadata only when needed.",
         command: CLI_COMMANDS[1],
-        href: "/create/mission"
+        href: "/create/project"
       },
       {
         title: "Create at least one assignment",
-        detail: "Break the mission into executable work units with explicit priority and dependencies.",
+        detail: "Break the project into executable work units with explicit priority and dependencies.",
         command: CLI_COMMANDS[2]
       },
       {
@@ -1163,8 +1252,8 @@ async function getDashboardHelp() {
       },
       {
         title: "Use the assignment workspace for execution",
-        detail: "Keep the objective in assignment.md, the implementation plan in plan.md, and transient notes in scratchpad.md.",
-        href: "/missions"
+        detail: "Keep the objective and todos in assignment.md, implementation plans in optional versioned plan files (plan.md, plan-v2.md, ...), and transient notes in scratchpad.md.",
+        href: "/projects"
       },
       {
         title: "Record handoffs and decisions without rewriting history",
@@ -1178,14 +1267,14 @@ async function getDashboardHelp() {
     ],
     links: [
       { label: "Overview", href: "/" },
-      { label: "Mission Directory", href: "/missions" },
+      { label: "Project Directory", href: "/projects" },
       { label: "Assignments Board", href: "/assignments" },
       { label: "Attention Queue", href: "/attention" },
       { label: "Servers", href: "/servers" },
       { label: "Agent Sessions", href: "/agent-sessions" },
       { label: "Playbooks", href: "/playbooks" },
       { label: "Settings", href: "/settings" },
-      { label: "Create Mission", href: "/create/mission" }
+      { label: "Create Project", href: "/create/project" }
     ]
   };
 }
@@ -1207,60 +1296,60 @@ var init_help = __esm({
         example: "syntaur init"
       },
       {
-        command: "syntaur create-mission",
-        description: "Create a new mission folder with the required source and derived files.",
-        example: 'syntaur create-mission "Ship dashboard overhaul"'
+        command: "syntaur create-project",
+        description: "Create a new project folder with the required source and derived files.",
+        example: 'syntaur create-project "Ship dashboard overhaul"'
       },
       {
         command: "syntaur create-assignment",
-        description: "Create a new assignment inside a mission.",
-        example: 'syntaur create-assignment "Implement overview API" --mission ui-overhaul'
+        description: "Create a new assignment inside a project.",
+        example: 'syntaur create-assignment "Implement overview API" --project ui-overhaul'
       },
       {
         command: "syntaur assign",
         description: "Set the assignee for an assignment before work begins.",
-        example: "syntaur assign implement-overview --mission ui-overhaul --agent codex-1"
+        example: "syntaur assign implement-overview --project ui-overhaul --agent codex-1"
       },
       // --- Lifecycle transitions (indices 5-11) ---
       {
         command: "syntaur start",
         description: "Transition an assignment to in_progress.",
-        example: "syntaur start implement-overview --mission ui-overhaul"
+        example: "syntaur start implement-overview --project ui-overhaul"
       },
       {
         command: "syntaur review",
         description: "Move active work into review once implementation is ready for inspection.",
-        example: "syntaur review implement-overview --mission ui-overhaul"
+        example: "syntaur review implement-overview --project ui-overhaul"
       },
       {
         command: "syntaur complete",
         description: "Mark an assignment completed after review or direct completion.",
-        example: "syntaur complete implement-overview --mission ui-overhaul"
+        example: "syntaur complete implement-overview --project ui-overhaul"
       },
       {
         command: "syntaur block",
         description: "Mark an assignment blocked and record the explicit reason.",
-        example: 'syntaur block implement-overview --mission ui-overhaul --reason "Waiting on API spec"'
+        example: 'syntaur block implement-overview --project ui-overhaul --reason "Waiting on API spec"'
       },
       {
         command: "syntaur unblock",
         description: "Move a blocked assignment back to in_progress after the blocker is cleared.",
-        example: "syntaur unblock implement-overview --mission ui-overhaul"
+        example: "syntaur unblock implement-overview --project ui-overhaul"
       },
       {
         command: "syntaur fail",
         description: "Mark an assignment failed when it cannot be completed as planned.",
-        example: "syntaur fail implement-overview --mission ui-overhaul"
+        example: "syntaur fail implement-overview --project ui-overhaul"
       },
       {
         command: "syntaur reopen",
         description: "Reopen a completed or failed assignment back to in_progress.",
-        example: "syntaur reopen implement-overview --mission ui-overhaul"
+        example: "syntaur reopen implement-overview --project ui-overhaul"
       },
       // --- Dashboard (index 12) ---
       {
         command: "syntaur dashboard",
-        description: "Start the local dashboard UI over the mission files on disk.",
+        description: "Start the local dashboard UI over the project files on disk.",
         example: "syntaur dashboard --port 4800"
       },
       // --- Plugin & adapter setup (indices 13-16) ---
@@ -1282,18 +1371,18 @@ var init_help = __esm({
       {
         command: "syntaur setup-adapter",
         description: "Generate adapter instruction files for cursor, codex, or opencode in the current directory.",
-        example: "syntaur setup-adapter cursor --mission ui-overhaul --assignment implement-overview"
+        example: "syntaur setup-adapter cursor --project ui-overhaul --assignment implement-overview"
       },
       // --- Session & server tracking (index 17) ---
       {
         command: "syntaur track-session",
-        description: "Register an agent session, optionally linked to a mission and assignment.",
-        example: "syntaur track-session --agent claude --mission ui-overhaul --assignment implement-overview"
+        description: "Register an agent session, optionally linked to a project and assignment.",
+        example: "syntaur track-session --agent claude --project ui-overhaul --assignment implement-overview"
       },
       // --- Browsing & playbooks (indices 18-20) ---
       {
         command: "syntaur browse",
-        description: "Interactive TUI browser for missions and assignments.",
+        description: "Interactive TUI browser for projects and assignments.",
         example: "syntaur browse"
       },
       {
@@ -1314,14 +1403,14 @@ var init_help = __esm({
         command: CLI_COMMANDS[0]
       },
       {
-        title: "Create a mission",
-        detail: "Use a mission for a higher-level objective. Missions group assignments, shared resources, and memories.",
+        title: "Create a project",
+        detail: "Use a project for a higher-level objective. Projects group assignments, shared resources, and memories.",
         command: CLI_COMMANDS[2],
-        href: "/create/mission"
+        href: "/create/project"
       },
       {
         title: "Create the first assignment",
-        detail: "Assignments are the execution unit. Create one for each concrete chunk of work inside the mission.",
+        detail: "Assignments are the execution unit. Create one for each concrete chunk of work inside the project.",
         command: CLI_COMMANDS[3]
       },
       {
@@ -1336,7 +1425,7 @@ var init_help = __esm({
       },
       {
         title: "Use the dashboard for triage and context",
-        detail: "Overview shows the current queue, mission pages show health, assignment pages show the execution surface.",
+        detail: "Overview shows the current queue, project pages show health, assignment pages show the execution surface.",
         command: CLI_COMMANDS[12],
         href: "/"
       }
@@ -1404,7 +1493,7 @@ function buildSessionContent(opts) {
   if (Object.keys(opts.overrides).length > 0) {
     lines.push("overrides:");
     for (const [key, val] of Object.entries(opts.overrides)) {
-      lines.push(`  "${key}": { mission: "${val.mission}", assignment: "${val.assignment}" }`);
+      lines.push(`  "${key}": { project: "${val.project}", assignment: "${val.assignment}" }`);
     }
   }
   lines.push("---", "");
@@ -1441,10 +1530,10 @@ async function readSessionFile(dir, name) {
   const overridesMatch = frontmatter.match(/^overrides:\n((?:\s+".+\n?)*)/m);
   if (overridesMatch) {
     const overrideLines = overridesMatch[1].matchAll(
-      /^\s+"([^"]+)":\s*\{\s*mission:\s*"([^"]+)",\s*assignment:\s*"([^"]+)"\s*\}/gm
+      /^\s+"([^"]+)":\s*\{\s*project:\s*"([^"]+)",\s*assignment:\s*"([^"]+)"\s*\}/gm
     );
     for (const m of overrideLines) {
-      overrides[m[1]] = { mission: m[2], assignment: m[3] };
+      overrides[m[1]] = { project: m[2], assignment: m[3] };
     }
   }
   const autoField = getField(frontmatter, "auto");
@@ -1646,12 +1735,12 @@ async function getGitInfo(cwd) {
   }
   return { branch: branch || null, worktree: isWorktree };
 }
-async function loadWorkspaceRecords(missionsDir) {
+async function loadWorkspaceRecords(projectsDir) {
   const records = [];
   try {
-    const missions = await listMissions(missionsDir);
-    for (const mission of missions) {
-      const assignmentsDir = resolve5(missionsDir, mission.slug, "assignments");
+    const projects = await listProjects(projectsDir);
+    for (const project of projects) {
+      const assignmentsDir = resolve5(projectsDir, project.slug, "assignments");
       let slugs;
       try {
         slugs = await readdir2(assignmentsDir);
@@ -1665,7 +1754,7 @@ async function loadWorkspaceRecords(missionsDir) {
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
-            missionSlug: mission.slug,
+            projectSlug: project.slug,
             assignmentSlug: aslug,
             assignmentTitle: getField(fm, "title") ?? aslug,
             worktreePath: getNestedField(fm, "workspace", "worktreePath") ?? null,
@@ -1694,14 +1783,14 @@ async function autoLinkPane(cwd, branch, records) {
     if (rec.worktreePath) {
       const normalizedWt = await resolveAndNormalize(rec.worktreePath);
       if (normalizedCwd === normalizedWt) {
-        return { mission: rec.missionSlug, slug: rec.assignmentSlug, title: rec.assignmentTitle };
+        return { project: rec.projectSlug, slug: rec.assignmentSlug, title: rec.assignmentTitle };
       }
     }
   }
   if (branch) {
     for (const rec of records) {
       if (rec.branch && rec.branch === branch) {
-        return { mission: rec.missionSlug, slug: rec.assignmentSlug, title: rec.assignmentTitle };
+        return { project: rec.projectSlug, slug: rec.assignmentSlug, title: rec.assignmentTitle };
       }
     }
   }
@@ -1771,10 +1860,10 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords) {
       let assignment = null;
       if (override) {
         const rec = workspaceRecords.find(
-          (r) => r.missionSlug === override.mission && r.assignmentSlug === override.assignment
+          (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
         );
         assignment = {
-          mission: override.mission,
+          project: override.project,
           slug: override.assignment,
           title: rec?.assignmentTitle ?? override.assignment
         };
@@ -1833,10 +1922,10 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
   let assignment = null;
   if (override) {
     const rec = workspaceRecords.find(
-      (r) => r.missionSlug === override.mission && r.assignmentSlug === override.assignment
+      (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
     );
     assignment = {
-      mission: override.mission,
+      project: override.project,
       slug: override.assignment,
       title: rec?.assignmentTitle ?? override.assignment
     };
@@ -1863,17 +1952,17 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
-async function scanAllSessions(serversDir, missionsDir, options) {
+async function scanAllSessions(serversDir2, projectsDir, options) {
   if (!options?.bypassCache && cache && Date.now() < cache.expiry) {
     return cache.data;
   }
   const tmuxAvailable = await checkTmuxAvailable();
-  const names = await listSessionFiles(serversDir);
+  const names = await listSessionFiles(serversDir2);
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(missionsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
   const sessions = [];
   for (const name of names) {
-    const data = await readSessionFile(serversDir, name);
+    const data = await readSessionFile(serversDir2, name);
     if (!data) continue;
     if (data.kind === "process") {
       sessions.push(await scanProcessSession(data, lsofOutput, workspaceRecords));
@@ -1885,11 +1974,11 @@ async function scanAllSessions(serversDir, missionsDir, options) {
   cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
   return result;
 }
-async function scanSingleSession(serversDir, missionsDir, name) {
-  const data = await readSessionFile(serversDir, name);
+async function scanSingleSession(serversDir2, projectsDir, name) {
+  const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(missionsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
   if (data.kind === "process") {
     return scanProcessSession(data, lsofOutput, workspaceRecords);
   }
@@ -1966,12 +2055,12 @@ async function getStatusConfig() {
 function clearStatusConfigCache() {
   _cachedConfig = null;
 }
-async function listMissions(missionsDir) {
-  const missionRecords = await listMissionRecords(missionsDir);
-  return missionRecords.map((record) => record.summary);
+async function listProjects(projectsDir) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  return projectRecords.map((record) => record.summary);
 }
-async function readWorkspaceRegistry(missionsDir) {
-  const registryPath = resolve6(dirname2(missionsDir), "workspaces.json");
+async function readWorkspaceRegistry(projectsDir) {
+  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
   try {
     const raw = await readFile5(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -1980,20 +2069,20 @@ async function readWorkspaceRegistry(missionsDir) {
     return [];
   }
 }
-async function writeWorkspaceRegistry(missionsDir, workspaces) {
-  const registryPath = resolve6(dirname2(missionsDir), "workspaces.json");
+async function writeWorkspaceRegistry(projectsDir, workspaces) {
+  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
   await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
-async function listWorkspaces(missionsDir) {
-  const [missionRecords, registered] = await Promise.all([
-    listMissionRecords(missionsDir),
-    readWorkspaceRegistry(missionsDir)
+async function listWorkspaces(projectsDir) {
+  const [projectRecords, registered] = await Promise.all([
+    listProjectRecords(projectsDir),
+    readWorkspaceRegistry(projectsDir)
   ]);
   const workspaceSet = new Set(registered);
   let hasUngrouped = false;
-  for (const record of missionRecords) {
-    if (record.mission.workspace) {
-      workspaceSet.add(record.mission.workspace);
+  for (const record of projectRecords) {
+    if (record.project.workspace) {
+      workspaceSet.add(record.project.workspace);
     } else {
       hasUngrouped = true;
     }
@@ -2001,28 +2090,28 @@ async function listWorkspaces(missionsDir) {
   const workspaces = Array.from(workspaceSet).sort();
   return { workspaces, hasUngrouped };
 }
-async function createWorkspace(missionsDir, name) {
-  const registered = await readWorkspaceRegistry(missionsDir);
+async function createWorkspace(projectsDir, name) {
+  const registered = await readWorkspaceRegistry(projectsDir);
   if (!registered.includes(name)) {
     registered.push(name);
     registered.sort();
-    await writeWorkspaceRegistry(missionsDir, registered);
+    await writeWorkspaceRegistry(projectsDir, registered);
   }
 }
-async function deleteWorkspace(missionsDir, name) {
-  const registered = await readWorkspaceRegistry(missionsDir);
+async function deleteWorkspace(projectsDir, name) {
+  const registered = await readWorkspaceRegistry(projectsDir);
   const filtered = registered.filter((w) => w !== name);
-  await writeWorkspaceRegistry(missionsDir, filtered);
+  await writeWorkspaceRegistry(projectsDir, filtered);
 }
-async function getOverview(missionsDir, serversDir) {
-  const missionRecords = await listMissionRecords(missionsDir);
-  const attention = buildAttentionItems(missionRecords);
-  const recentActivity = buildRecentActivity(missionRecords);
+async function getOverview(projectsDir, serversDir2) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  const attention = buildAttentionItems(projectRecords);
+  const recentActivity = buildRecentActivity(projectRecords);
   let serverStats;
-  if (serversDir) {
+  if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir, missionsDir);
+      const servers = await scanAllSessions2(serversDir2, projectsDir);
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
         const totalPorts = servers.sessions.reduce((sum, s) => sum + s.windows.reduce((ws, w) => ws + w.panes.reduce((ps, p) => ps + p.ports.length, 0), 0), 0);
@@ -2038,50 +2127,50 @@ async function getOverview(missionsDir, serversDir) {
   }
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    firstRun: missionRecords.length === 0,
+    firstRun: projectRecords.length === 0,
     stats: {
-      activeMissions: missionRecords.filter((record) => record.summary.status === "active").length,
-      inProgressAssignments: missionRecords.reduce(
+      activeProjects: projectRecords.filter((record) => record.summary.status === "active").length,
+      inProgressAssignments: projectRecords.reduce(
         (total, record) => total + (record.summary.progress["in_progress"] ?? 0),
         0
       ),
-      blockedAssignments: missionRecords.reduce(
+      blockedAssignments: projectRecords.reduce(
         (total, record) => total + (record.summary.progress["blocked"] ?? 0),
         0
       ),
-      reviewAssignments: missionRecords.reduce(
+      reviewAssignments: projectRecords.reduce(
         (total, record) => total + (record.summary.progress["review"] ?? 0),
         0
       ),
-      failedAssignments: missionRecords.reduce(
+      failedAssignments: projectRecords.reduce(
         (total, record) => total + (record.summary.progress["failed"] ?? 0),
         0
       ),
-      staleAssignments: missionRecords.reduce(
+      staleAssignments: projectRecords.reduce(
         (total, record) => total + record.assignments.filter((assignment) => isStale(assignment.updated)).length,
         0
       )
     },
     attention: attention.slice(0, OVERVIEW_ATTENTION_LIMIT),
-    recentMissions: missionRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_MISSIONS_LIMIT),
+    recentProjects: projectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
     recentActivity: recentActivity.slice(0, RECENT_ACTIVITY_LIMIT),
     serverStats
   };
 }
-async function getAttention(missionsDir, serversDir) {
-  const missionRecords = await listMissionRecords(missionsDir);
-  const items = buildAttentionItems(missionRecords);
-  if (serversDir) {
+async function getAttention(projectsDir, serversDir2) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  const items = buildAttentionItems(projectRecords);
+  if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir, missionsDir);
+      const servers = await scanAllSessions2(serversDir2, projectsDir);
       for (const session of servers.sessions) {
         if (!session.alive) {
           items.push({
             id: `server-dead-${session.name}`,
             severity: "low",
-            missionSlug: "",
-            missionTitle: "",
+            projectSlug: "",
+            projectTitle: "",
             assignmentSlug: "",
             assignmentTitle: `tmux: ${session.name}`,
             status: "failed",
@@ -2118,13 +2207,13 @@ async function getAttention(missionsDir, serversDir) {
     items: pagedItems
   };
 }
-async function listAssignmentsBoard(missionsDir) {
-  const missionRecords = await listMissionRecords(missionsDir);
+async function listAssignmentsBoard(projectsDir) {
+  const projectRecords = await listProjectRecords(projectsDir);
   const assignments = await Promise.all(
-    missionRecords.flatMap(
+    projectRecords.flatMap(
       async (record) => Promise.all(
         record.assignments.map(
-          async (assignment) => toAssignmentBoardItem(missionsDir, record, assignment)
+          async (assignment) => toAssignmentBoardItem(projectsDir, record, assignment)
         )
       )
     )
@@ -2137,59 +2226,59 @@ async function listAssignmentsBoard(missionsDir) {
 async function getHelp() {
   return getDashboardHelp();
 }
-async function getEditableDocument(missionsDir, documentType, missionSlug, assignmentSlug) {
-  const filePath = getDocumentPath(missionsDir, documentType, missionSlug, assignmentSlug);
+async function getEditableDocument(projectsDir, documentType, projectSlug, assignmentSlug) {
+  const filePath = getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug);
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
   const content = await readFile5(filePath, "utf-8");
-  const title = getEditableDocumentTitle(documentType, missionSlug, assignmentSlug);
+  const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
     title,
     content,
-    missionSlug,
+    projectSlug,
     assignmentSlug,
     appendOnly: documentType === "handoff" || documentType === "decision-record"
   };
 }
-async function getMissionDetail(missionsDir, slug) {
-  const missionPath = resolve6(missionsDir, slug);
-  const missionMdPath = resolve6(missionPath, "mission.md");
-  if (!await fileExists(missionMdPath)) {
+async function getProjectDetail(projectsDir, slug) {
+  const projectPath = resolve6(projectsDir, slug);
+  const projectMdPath = resolve6(projectPath, "project.md");
+  if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const missionContent = await readFile5(missionMdPath, "utf-8");
-  const mission = parseMission(missionContent);
-  const assignments = await listAssignmentRecords(missionPath);
-  const rollup = buildMissionRollup(mission, assignments);
-  const dependencyGraph = await loadDependencyGraph(missionPath, assignments);
-  const resources = await listResources(missionPath);
-  const memories = await listMemories(missionPath);
-  const updated = getMissionActivityTimestamp(mission.updated, assignments);
+  const projectContent = await readFile5(projectMdPath, "utf-8");
+  const project = parseProject(projectContent);
+  const assignments = await listAssignmentRecords(projectPath);
+  const rollup = buildProjectRollup(project, assignments);
+  const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
+  const resources = await listResources(projectPath);
+  const memories = await listMemories(projectPath);
+  const updated = getProjectActivityTimestamp(project.updated, assignments);
   return {
-    slug: mission.slug || slug,
-    title: mission.title,
+    slug: project.slug || slug,
+    title: project.title,
     status: rollup.status,
-    statusOverride: mission.statusOverride,
-    archived: mission.archived,
-    archivedAt: mission.archivedAt,
-    archivedReason: mission.archivedReason,
-    created: mission.created,
+    statusOverride: project.statusOverride,
+    archived: project.archived,
+    archivedAt: project.archivedAt,
+    archivedReason: project.archivedReason,
+    created: project.created,
     updated,
-    tags: mission.tags,
-    body: mission.body,
+    tags: project.tags,
+    body: project.body,
     progress: rollup.progress,
     needsAttention: rollup.needsAttention,
     assignments: assignments.map(toAssignmentSummary).sort((left, right) => compareTimestamps(right.updated, left.updated)),
     resources,
     memories,
     dependencyGraph,
-    workspace: mission.workspace
+    workspace: project.workspace
   };
 }
-async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
-  const assignmentDir = resolve6(missionsDir, missionSlug, "assignments", assignmentSlug);
+async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
+  const assignmentDir = resolve6(projectsDir, projectSlug, "assignments", assignmentSlug);
   const assignmentMdPath = resolve6(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
@@ -2241,7 +2330,7 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
   }
   const detail = {
     id: assignment.id,
-    missionSlug,
+    projectSlug,
     slug: assignment.slug || assignmentSlug,
     title: assignment.title,
     status: assignment.status,
@@ -2263,16 +2352,16 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
     handoff,
     decisionRecord,
     availableTransitions: await getAvailableTransitions(
-      missionsDir,
-      missionSlug,
+      projectsDir,
+      projectSlug,
       assignmentSlug,
       assignment
     )
   };
-  const selfSlug = `${missionSlug}/${detail.slug}`;
-  const missionRecords = await listMissionRecords(missionsDir);
+  const selfSlug = `${projectSlug}/${detail.slug}`;
+  const projectRecords = await listProjectRecords(projectsDir);
   const reverseLinks = [];
-  for (const mr of missionRecords) {
+  for (const mr of projectRecords) {
     for (const a of mr.assignments) {
       const qualifiedSlug = `${mr.summary.slug}/${a.slug}`;
       if (qualifiedSlug === selfSlug) continue;
@@ -2290,10 +2379,10 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
   const dedupedReverseLinks = reverseLinks.filter((l) => !forwardSet.has(l));
   detail.links = forwardLinks;
   detail.reverseLinks = dedupedReverseLinks;
-  const allMissionAssignments = /* @__PURE__ */ new Map();
-  for (const mr of missionRecords) {
+  const allProjectAssignments = /* @__PURE__ */ new Map();
+  for (const mr of projectRecords) {
     for (const a of mr.assignments) {
-      allMissionAssignments.set(`${mr.summary.slug}/${a.slug}`, {
+      allProjectAssignments.set(`${mr.summary.slug}/${a.slug}`, {
         title: a.title,
         status: a.status
       });
@@ -2302,10 +2391,10 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
   const enrichedLinks = [];
   for (const linkSlug of forwardLinks) {
     const [ms, as] = linkSlug.split("/");
-    const info = allMissionAssignments.get(linkSlug);
+    const info = allProjectAssignments.get(linkSlug);
     enrichedLinks.push({
       slug: linkSlug,
-      missionSlug: ms,
+      projectSlug: ms,
       assignmentSlug: as,
       title: info?.title ?? linkSlug,
       status: info?.status ?? "pending",
@@ -2314,10 +2403,10 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
   }
   for (const linkSlug of dedupedReverseLinks) {
     const [ms, as] = linkSlug.split("/");
-    const info = allMissionAssignments.get(linkSlug);
+    const info = allProjectAssignments.get(linkSlug);
     enrichedLinks.push({
       slug: linkSlug,
-      missionSlug: ms,
+      projectSlug: ms,
       assignmentSlug: as,
       title: info?.title ?? linkSlug,
       status: info?.status ?? "pending",
@@ -2327,51 +2416,51 @@ async function getAssignmentDetail(missionsDir, missionSlug, assignmentSlug) {
   detail.enrichedLinks = enrichedLinks;
   return detail;
 }
-async function listMissionRecords(missionsDir) {
-  if (!await fileExists(missionsDir)) {
+async function listProjectRecords(projectsDir) {
+  if (!await fileExists(projectsDir)) {
     return [];
   }
-  const entries = await readdir3(missionsDir, { withFileTypes: true });
-  const missionDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+  const entries = await readdir3(projectsDir, { withFileTypes: true });
+  const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const records = [];
-  for (const entry of missionDirs) {
-    const missionPath = resolve6(missionsDir, entry.name);
-    const missionMdPath = resolve6(missionPath, "mission.md");
-    if (!await fileExists(missionMdPath)) {
+  for (const entry of projectDirs) {
+    const projectPath = resolve6(projectsDir, entry.name);
+    const projectMdPath = resolve6(projectPath, "project.md");
+    if (!await fileExists(projectMdPath)) {
       continue;
     }
-    const missionContent = await readFile5(missionMdPath, "utf-8");
-    const mission = parseMission(missionContent);
-    const assignments = await listAssignmentRecords(missionPath);
-    const rollup = buildMissionRollup(mission, assignments);
-    const updated = getMissionActivityTimestamp(mission.updated, assignments);
+    const projectContent = await readFile5(projectMdPath, "utf-8");
+    const project = parseProject(projectContent);
+    const assignments = await listAssignmentRecords(projectPath);
+    const rollup = buildProjectRollup(project, assignments);
+    const updated = getProjectActivityTimestamp(project.updated, assignments);
     records.push({
-      missionPath,
-      mission,
+      projectPath,
+      project,
       assignments,
-      dependencyGraph: await loadDependencyGraph(missionPath, assignments),
+      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
       summary: {
-        slug: mission.slug || entry.name,
-        title: mission.title,
+        slug: project.slug || entry.name,
+        title: project.title,
         status: rollup.status,
-        statusOverride: mission.statusOverride,
-        archived: mission.archived,
-        archivedAt: mission.archivedAt,
-        archivedReason: mission.archivedReason,
-        created: mission.created,
+        statusOverride: project.statusOverride,
+        archived: project.archived,
+        archivedAt: project.archivedAt,
+        archivedReason: project.archivedReason,
+        created: project.created,
         updated,
-        tags: mission.tags,
+        tags: project.tags,
         progress: rollup.progress,
         needsAttention: rollup.needsAttention,
-        workspace: mission.workspace
+        workspace: project.workspace
       }
     });
   }
   records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
   return records;
 }
-async function listAssignmentRecords(missionPath) {
-  const assignmentsDir = resolve6(missionPath, "assignments");
+async function listAssignmentRecords(projectPath) {
+  const assignmentsDir = resolve6(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
@@ -2391,8 +2480,8 @@ async function listAssignmentRecords(missionPath) {
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
-async function listResources(missionPath) {
-  const resourcesDir = resolve6(missionPath, "resources");
+async function listResources(projectPath) {
+  const resourcesDir = resolve6(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
@@ -2417,8 +2506,8 @@ async function listResources(missionPath) {
   results.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return results;
 }
-async function listMemories(missionPath) {
-  const memoriesDir = resolve6(missionPath, "memories");
+async function listMemories(projectPath) {
+  const memoriesDir = resolve6(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
@@ -2443,8 +2532,8 @@ async function listMemories(missionPath) {
   results.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return results;
 }
-async function loadDependencyGraph(missionPath, assignments) {
-  const statusPath = resolve6(missionPath, "_status.md");
+async function loadDependencyGraph(projectPath, assignments) {
+  const statusPath = resolve6(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
     const statusContent = await readFile5(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
@@ -2455,23 +2544,23 @@ async function loadDependencyGraph(missionPath, assignments) {
   }
   return buildDependencyGraph(assignments);
 }
-function buildMissionRollup(mission, assignments) {
+function buildProjectRollup(project, assignments) {
   const progress = { total: assignments.length };
-  let unansweredQuestions = 0;
+  let openQuestions = 0;
   for (const assignment of assignments) {
     const s = assignment.status;
     progress[s] = (progress[s] ?? 0) + 1;
-    unansweredQuestions += countPendingAnswers(assignment.body);
+    openQuestions += countPendingAnswers(assignment.body);
   }
   const needsAttention = {
     blockedCount: progress["blocked"] ?? 0,
     failedCount: progress["failed"] ?? 0,
-    unansweredQuestions
+    openQuestions
   };
   let status = "pending";
-  if (mission.statusOverride) {
-    status = mission.statusOverride;
-  } else if (mission.archived) {
+  if (project.statusOverride) {
+    status = project.statusOverride;
+  } else if (project.archived) {
     status = "archived";
   } else if (progress.total > 0 && (progress["completed"] ?? 0) === progress.total) {
     status = "completed";
@@ -2501,16 +2590,16 @@ function toAssignmentSummary(assignment) {
     updated: assignment.updated
   };
 }
-async function toAssignmentBoardItem(missionsDir, missionRecord, assignment) {
+async function toAssignmentBoardItem(projectsDir, projectRecord, assignment) {
   return {
     ...toAssignmentSummary(assignment),
-    missionSlug: missionRecord.summary.slug,
-    missionTitle: missionRecord.summary.title,
+    projectSlug: projectRecord.summary.slug,
+    projectTitle: projectRecord.summary.title,
     blockedReason: assignment.blockedReason,
-    missionWorkspace: missionRecord.mission.workspace,
+    projectWorkspace: projectRecord.project.workspace,
     availableTransitions: await getAvailableTransitions(
-      missionsDir,
-      missionRecord.summary.slug,
+      projectsDir,
+      projectRecord.summary.slug,
       assignment.slug,
       assignment
     )
@@ -2542,18 +2631,18 @@ function buildDependencyGraph(assignments) {
 function findAssignmentStatus(assignments, slug) {
   return assignments.find((assignment) => assignment.slug === slug)?.status ?? "pending";
 }
-async function getAvailableTransitions(missionsDir, missionSlug, assignmentSlug, assignment) {
+async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment) {
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const missionPath = resolve6(missionsDir, missionSlug);
+  const projectPath = resolve6(projectsDir, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
       warning = "No assignee set \u2014 consider assigning before starting.";
     }
     if (definition.command === "start" && assignment.dependsOn.length > 0) {
-      const unmetDependencies = await getUnmetDependencies(missionPath, assignment.dependsOn, config.terminalStatuses);
+      const unmetDependencies = await getUnmetDependencies(projectPath, assignment.dependsOn, config.terminalStatuses);
       if (unmetDependencies.length > 0) {
         warning = `Unmet dependencies: ${unmetDependencies.join(", ")}.`;
       }
@@ -2572,11 +2661,11 @@ async function getAvailableTransitions(missionsDir, missionSlug, assignmentSlug,
   }
   return actions;
 }
-async function getUnmetDependencies(missionPath, dependsOn, terminalStatuses) {
+async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve6(missionPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve6(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
@@ -2589,19 +2678,19 @@ async function getUnmetDependencies(missionPath, dependsOn, terminalStatuses) {
   }
   return unmet;
 }
-function buildAttentionItems(missionRecords) {
+function buildAttentionItems(projectRecords) {
   const items = [];
-  for (const record of missionRecords) {
+  for (const record of projectRecords) {
     for (const assignment of record.assignments) {
       const stale = isStale(assignment.updated);
       const base = {
-        missionSlug: record.summary.slug,
-        missionTitle: record.summary.title,
+        projectSlug: record.summary.slug,
+        projectTitle: record.summary.title,
         assignmentSlug: assignment.slug,
         assignmentTitle: assignment.title,
         status: assignment.status,
         updated: assignment.updated,
-        href: `/missions/${record.summary.slug}/assignments/${assignment.slug}`,
+        href: `/projects/${record.summary.slug}/assignments/${assignment.slug}`,
         blockedReason: assignment.blockedReason,
         stale
       };
@@ -2641,19 +2730,19 @@ function buildAttentionItems(missionRecords) {
   }
   return items.sort(compareAttentionItems);
 }
-function buildRecentActivity(missionRecords) {
+function buildRecentActivity(projectRecords) {
   const activity = [];
-  for (const record of missionRecords) {
+  for (const record of projectRecords) {
     activity.push({
-      id: `mission:${record.summary.slug}`,
-      type: "mission",
+      id: `project:${record.summary.slug}`,
+      type: "project",
       title: record.summary.title,
       updated: record.summary.updated,
-      href: `/missions/${record.summary.slug}`,
-      missionSlug: record.summary.slug,
-      missionTitle: record.summary.title,
+      href: `/projects/${record.summary.slug}`,
+      projectSlug: record.summary.slug,
+      projectTitle: record.summary.title,
       assignmentSlug: null,
-      summary: `Mission status is ${record.summary.status}.`
+      summary: `Project status is ${record.summary.status}.`
     });
     for (const assignment of record.assignments) {
       activity.push({
@@ -2661,9 +2750,9 @@ function buildRecentActivity(missionRecords) {
         type: "assignment",
         title: assignment.title,
         updated: assignment.updated,
-        href: `/missions/${record.summary.slug}/assignments/${assignment.slug}`,
-        missionSlug: record.summary.slug,
-        missionTitle: record.summary.title,
+        href: `/projects/${record.summary.slug}/assignments/${assignment.slug}`,
+        projectSlug: record.summary.slug,
+        projectTitle: record.summary.title,
         assignmentSlug: assignment.slug,
         summary: `Assignment is ${assignment.status} with ${assignment.priority} priority.`
       });
@@ -2698,8 +2787,8 @@ function countPendingAnswers(body) {
   const matches = body.match(/^\*\*A:\*\*\s+pending\s*$/gim);
   return matches ? matches.length : 0;
 }
-function getMissionActivityTimestamp(missionUpdated, assignments) {
-  let latest = missionUpdated;
+function getProjectActivityTimestamp(projectUpdated, assignments) {
+  let latest = projectUpdated;
   for (const assignment of assignments) {
     if (compareTimestamps(assignment.updated, latest) > 0) {
       latest = assignment.updated;
@@ -2707,28 +2796,28 @@ function getMissionActivityTimestamp(missionUpdated, assignments) {
   }
   return latest;
 }
-function getDocumentPath(missionsDir, documentType, missionSlug, assignmentSlug) {
+function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
-    case "mission":
-      return resolve6(missionsDir, missionSlug, "mission.md");
+    case "project":
+      return resolve6(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve6(missionsDir, missionSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve6(missionsDir, missionSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve6(missionsDir, missionSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve6(missionsDir, missionSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve6(missionsDir, missionSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
 }
-function getEditableDocumentTitle(documentType, missionSlug, assignmentSlug) {
+function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
-    case "mission":
-      return `Edit Mission: ${missionSlug}`;
+    case "project":
+      return `Edit Project: ${projectSlug}`;
     case "assignment":
       return `Edit Assignment: ${assignmentSlug || "assignment"}`;
     case "plan":
@@ -2740,18 +2829,18 @@ function getEditableDocumentTitle(documentType, missionSlug, assignmentSlug) {
     case "decision-record":
       return `Append Decision: ${assignmentSlug || "assignment"}`;
     case "playbook":
-      return `Edit Playbook: ${missionSlug}`;
+      return `Edit Playbook: ${projectSlug}`;
     default:
-      return missionSlug;
+      return projectSlug;
   }
 }
-async function listPlaybooks(playbooksDir) {
-  if (!await fileExists(playbooksDir)) return [];
-  const entries = await readdir3(playbooksDir, { withFileTypes: true });
+async function listPlaybooks(playbooksDir2) {
+  if (!await fileExists(playbooksDir2)) return [];
+  const entries = await readdir3(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve6(playbooksDir, entry.name);
+    const filePath = resolve6(playbooksDir2, entry.name);
     const raw = await readFile5(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
@@ -2767,8 +2856,8 @@ async function listPlaybooks(playbooksDir) {
   }
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
-async function getPlaybookDetail(playbooksDir, slug) {
-  const filePath = resolve6(playbooksDir, `${slug}.md`);
+async function getPlaybookDetail(playbooksDir2, slug) {
+  const filePath = resolve6(playbooksDir2, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
   const raw = await readFile5(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
@@ -2783,7 +2872,7 @@ async function getPlaybookDetail(playbooksDir, slug) {
     body: parsed.body
   };
 }
-var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_MISSIONS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, DEFAULT_GRAPH_COLORS;
+var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, DEFAULT_GRAPH_COLORS;
 var init_api = __esm({
   "src/dashboard/api.ts"() {
     "use strict";
@@ -2795,7 +2884,7 @@ var init_api = __esm({
     STALE_ASSIGNMENT_MS = 7 * 24 * 60 * 60 * 1e3;
     ATTENTION_PAGE_LIMIT = 50;
     OVERVIEW_ATTENTION_LIMIT = 6;
-    RECENT_MISSIONS_LIMIT = 6;
+    RECENT_PROJECTS_LIMIT = 6;
     RECENT_ACTIVITY_LIMIT = 12;
     DEFAULT_TRANSITION_DEFINITIONS = [
       {
@@ -3042,13 +3131,13 @@ function serializeLogEntry(entry) {
   if (entry.status) lines.push(`**Status:** ${entry.status}`);
   return lines.join("\n");
 }
-function checklistPath(todosDir, workspace) {
-  return resolve13(todosDir, `${workspace}.md`);
+function checklistPath(todosDir2, workspace) {
+  return resolve13(todosDir2, `${workspace}.md`);
 }
-function logPath(todosDir, workspace) {
-  return resolve13(todosDir, `${workspace}-log.md`);
+function logPath(todosDir2, workspace) {
+  return resolve13(todosDir2, `${workspace}-log.md`);
 }
-function archivePath(todosDir, workspace, interval, now = /* @__PURE__ */ new Date()) {
+function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
   const month = String(now.getMonth() + 1).padStart(2, "0");
   const day = String(now.getDate()).padStart(2, "0");
@@ -3070,32 +3159,32 @@ function archivePath(todosDir, workspace, interval, now = /* @__PURE__ */ new Da
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve13(todosDir, "archive", `${workspace}-${suffix}.md`);
+  return resolve13(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
-async function readChecklist(todosDir, workspace) {
-  const path = checklistPath(todosDir, workspace);
+async function readChecklist(todosDir2, workspace) {
+  const path = checklistPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, archiveInterval: "weekly", items: [] };
   }
   const content = await readFile10(path, "utf-8");
   return parseChecklist(content);
 }
-async function writeChecklist(todosDir, checklist) {
-  await ensureDir(todosDir);
-  const path = checklistPath(todosDir, checklist.workspace);
+async function writeChecklist(todosDir2, checklist) {
+  await ensureDir(todosDir2);
+  const path = checklistPath(todosDir2, checklist.workspace);
   await writeFileForce(path, serializeChecklist(checklist));
 }
-async function readLog(todosDir, workspace) {
-  const path = logPath(todosDir, workspace);
+async function readLog(todosDir2, workspace) {
+  const path = logPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
   const content = await readFile10(path, "utf-8");
   return parseLog(content);
 }
-async function appendLogEntry2(todosDir, workspace, entry) {
-  await ensureDir(todosDir);
-  const path = logPath(todosDir, workspace);
+async function appendLogEntry2(todosDir2, workspace, entry) {
+  await ensureDir(todosDir2);
+  const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
     content = await readFile10(path, "utf-8");
@@ -3132,46 +3221,46 @@ var init_parser2 = __esm({
 });
 
 // src/dashboard/server.ts
+init_paths();
 init_api();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve14 } from "path";
-import { homedir as homedir2 } from "os";
-import { writeFile as writeFile3, unlink as unlink3 } from "fs/promises";
+import { resolve as resolve15 } from "path";
+import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/watcher.ts
 import { watch } from "chokidar";
 import { relative, sep } from "path";
 function createWatcher(options) {
-  const { missionsDir, serversDir, playbooksDir, todosDir, onMessage, debounceMs = 300 } = options;
+  const { projectsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
-  const missionsWatcher = watch(missionsDir, {
+  const projectsWatcher = watch(projectsDir, {
     ignoreInitial: true,
     persistent: true,
     depth: 10,
     ignored: /(^|[\/\\])\../
   });
-  function handleMissionChange(filePath) {
-    const rel = relative(missionsDir, filePath);
+  function handleProjectChange(filePath) {
+    const rel = relative(projectsDir, filePath);
     const parts = rel.split(sep);
     if (parts.length === 0) return;
-    const missionSlug = parts[0];
+    const projectSlug = parts[0];
     let assignmentSlug;
     if (parts.length >= 3 && parts[1] === "assignments") {
       assignmentSlug = parts[2];
     }
-    const debounceKey = assignmentSlug ? `${missionSlug}/${assignmentSlug}` : missionSlug;
+    const debounceKey = assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
     const existing = pendingEvents.get(debounceKey);
     if (existing) clearTimeout(existing);
-    const messageType = assignmentSlug ? "assignment-updated" : "mission-updated";
+    const messageType = assignmentSlug ? "assignment-updated" : "project-updated";
     pendingEvents.set(
       debounceKey,
       setTimeout(() => {
         pendingEvents.delete(debounceKey);
         const message = {
           type: messageType,
-          missionSlug,
+          projectSlug,
           assignmentSlug,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -3179,11 +3268,11 @@ function createWatcher(options) {
       }, debounceMs)
     );
   }
-  missionsWatcher.on("change", handleMissionChange);
-  missionsWatcher.on("add", handleMissionChange);
-  missionsWatcher.on("unlink", handleMissionChange);
+  projectsWatcher.on("change", handleProjectChange);
+  projectsWatcher.on("add", handleProjectChange);
+  projectsWatcher.on("unlink", handleProjectChange);
   let serversWatcher = null;
-  if (serversDir) {
+  if (serversDir2) {
     let handleServerChange2 = function() {
       const debounceKey = "__servers__";
       const existing = pendingEvents.get(debounceKey);
@@ -3201,7 +3290,7 @@ function createWatcher(options) {
       );
     };
     var handleServerChange = handleServerChange2;
-    serversWatcher = watch(serversDir, {
+    serversWatcher = watch(serversDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -3212,7 +3301,7 @@ function createWatcher(options) {
     serversWatcher.on("unlink", handleServerChange2);
   }
   let playbooksWatcher = null;
-  if (playbooksDir) {
+  if (playbooksDir2) {
     let handlePlaybookChange2 = function() {
       const debounceKey = "__playbooks__";
       const existing = pendingEvents.get(debounceKey);
@@ -3230,7 +3319,7 @@ function createWatcher(options) {
       );
     };
     var handlePlaybookChange = handlePlaybookChange2;
-    playbooksWatcher = watch(playbooksDir, {
+    playbooksWatcher = watch(playbooksDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -3241,7 +3330,7 @@ function createWatcher(options) {
     playbooksWatcher.on("unlink", handlePlaybookChange2);
   }
   let todosWatcher = null;
-  if (todosDir) {
+  if (todosDir2) {
     let handleTodoChange2 = function() {
       const debounceKey = "__todos__";
       const existing = pendingEvents.get(debounceKey);
@@ -3259,7 +3348,7 @@ function createWatcher(options) {
       );
     };
     var handleTodoChange = handleTodoChange2;
-    todosWatcher = watch(todosDir, {
+    todosWatcher = watch(todosDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -3275,7 +3364,7 @@ function createWatcher(options) {
         clearTimeout(timeout);
       });
       pendingEvents.clear();
-      await missionsWatcher.close();
+      await projectsWatcher.close();
       if (serversWatcher) await serversWatcher.close();
       if (playbooksWatcher) await playbooksWatcher.close();
       if (todosWatcher) await todosWatcher.close();
@@ -3363,15 +3452,15 @@ init_config();
 // src/templates/manifest.ts
 function renderManifest(params) {
   return `---
-version: "1.0"
-mission: ${params.slug}
+version: "2.0"
+project: ${params.slug}
 generated: "${params.timestamp}"
 ---
 
-# Mission: ${params.slug}
+# Project: ${params.slug}
 
 ## Overview
-- [Mission Overview](./mission.md)
+- [Project Overview](./project.md)
 
 ## Indexes
 - [Assignments](./_index-assignments.md)
@@ -3380,10 +3469,6 @@ generated: "${params.timestamp}"
 - [Status](./_status.md)
 - [Resources](./resources/_index.md)
 - [Memories](./memories/_index.md)
-
-## Config
-- [Agent Instructions](./agent.md)
-- [Claude Code Instructions](./claude.md)
 `;
 }
 
@@ -3398,8 +3483,8 @@ function escapeYamlString(value) {
   return `"${escaped}"`;
 }
 
-// src/templates/mission.ts
-function renderMission(params) {
+// src/templates/project.ts
+function renderProject(params) {
   const safeTitle = escapeYamlString(params.title);
   const workspaceLine = params.workspace ? `
 workspace: ${params.workspace}` : "";
@@ -3420,7 +3505,7 @@ tags: []${workspaceLine}
 
 ## Overview
 
-<!-- Describe the mission goal, context, and success criteria here. -->
+<!-- Describe the project goal, context, and success criteria here. -->
 
 ## Notes
 
@@ -3428,43 +3513,6 @@ tags: []${workspaceLine}
 `;
 }
 
-// src/templates/agent.ts
-function renderAgent(params) {
-  return `---
-mission: ${params.slug}
-updated: "${params.timestamp}"
----
-
-# Agent Instructions
-
-All agents working on this mission must follow these guidelines.
-
-## Conventions
-
-<!-- Coding conventions, naming standards, architectural patterns. -->
-
-## Boundaries
-
-<!-- What agents should NOT do. Files/systems that are off-limits. -->
-
-## Resources
-
-<!-- Links to key resources agents should consult. -->
-`;
-}
-
-// src/templates/claude.ts
-function renderClaude(params) {
-  return `# Claude Code Instructions \u2014 ${params.slug}
-
-Read \`agent.md\` first for universal conventions and boundaries.
-
-## Additional Claude Code Rules
-
-<!-- Add Claude Code-specific rules here. -->
-`;
-}
-
 // src/templates/assignment.ts
 function renderAssignment(params) {
   const safeTitle = escapeYamlString(params.title);
@@ -3472,10 +3520,14 @@ function renderAssignment(params) {
   - ${params.dependsOn.join("\n  - ")}`;
   const linksYaml = params.links.length === 0 ? "links: []" : `links:
   - ${params.links.join("\n  - ")}`;
+  const projectYaml = `project: ${params.project == null ? "null" : params.project}`;
+  const typeYaml = `type: ${params.type ?? "feature"}`;
   return `---
 id: ${params.id}
 slug: ${params.slug}
 title: ${safeTitle}
+${projectYaml}
+${typeYaml}
 status: pending
 priority: ${params.priority}
 created: "${params.timestamp}"
@@ -3505,56 +3557,30 @@ tags: []
 - [ ] <!-- criterion 2 -->
 - [ ] <!-- criterion 3 -->
 
-## Context
-
-<!-- Links to relevant docs, code, or other assignments. -->
-
-## Questions & Answers
+## Todos
 
-No questions yet.
+<!--
+Checklist of work items for this assignment. Items may be simple tasks
+or a markdown link to a plan file (e.g., "- [ ] Execute [plan](./plan.md)").
+When a plan is superseded by a new one, mark the old todo as:
+  - [x] ~~Execute [old plan](./plan.md)~~ (superseded by plan-v2)
+Never delete superseded todos \u2014 preserve the history.
+-->
 
-## Progress
+## Context
 
-No progress yet.
+<!-- Links to relevant docs, code, or other assignments. -->
 
 ## Links
 
-- [Plan](./plan.md)
+- [Progress](./progress.md)
+- [Comments](./comments.md)
 - [Scratchpad](./scratchpad.md)
 - [Handoff](./handoff.md)
 - [Decision Record](./decision-record.md)
 `;
 }
 
-// src/templates/plan.ts
-function renderPlan(params) {
-  return `---
-assignment: ${params.assignmentSlug}
-status: draft
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
----
-
-# Plan: ${params.title}
-
-## Approach
-
-<!-- High-level description of how to accomplish the objective. -->
-
-## Tasks
-
-- [ ] <!-- step 1 -->
-- [ ] <!-- step 2 -->
-- [ ] <!-- step 3 -->
-
-## Risks & Mitigations
-
-| Risk | Mitigation |
-|------|------------|
-| <!-- risk --> | <!-- mitigation --> |
-`;
-}
-
 // src/templates/scratchpad.ts
 function renderScratchpad(params) {
   return `---
@@ -3599,7 +3625,7 @@ No decisions recorded yet.
 // src/templates/index-stubs.ts
 function renderIndexAssignments(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 by_status:
@@ -3619,7 +3645,7 @@ by_status:
 }
 function renderIndexPlans(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 ---
 
@@ -3631,7 +3657,7 @@ generated: "${params.timestamp}"
 }
 function renderIndexDecisions(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 ---
 
@@ -3643,7 +3669,7 @@ generated: "${params.timestamp}"
 }
 function renderStatus(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 status: pending
 progress:
@@ -3657,10 +3683,10 @@ progress:
 needsAttention:
   blockedCount: 0
   failedCount: 0
-  unansweredQuestions: 0
+  openQuestions: 0
 ---
 
-# Mission Status: ${params.title}
+# Project Status: ${params.title}
 
 **Status:** pending
 **Progress:** 0/0 assignments complete
@@ -3682,7 +3708,7 @@ No dependencies yet.
 }
 function renderResourcesIndex(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 ---
@@ -3695,7 +3721,7 @@ total: 0
 }
 function renderMemoriesIndex(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 ---
@@ -3828,13 +3854,13 @@ async function readCurrentDocument(filePath) {
   }
   return readFile6(filePath, "utf-8");
 }
-function createWriteRouter(missionsDir) {
+function createWriteRouter(projectsDir) {
   const router = Router();
-  router.get("/api/templates/mission", (_req, res) => {
-    const content = renderMission({
+  router.get("/api/templates/project", (_req, res) => {
+    const content = renderProject({
       id: generateId(),
-      slug: "my-new-mission",
-      title: "My New Mission",
+      slug: "my-new-project",
+      title: "My New Project",
       timestamp: nowTimestamp()
     });
     res.json({ content });
@@ -3851,20 +3877,20 @@ function createWriteRouter(missionsDir) {
     });
     res.json({ content });
   });
-  router.get("/api/missions/:slug/edit", async (req, res) => {
+  router.get("/api/projects/:slug/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
-    const document = await getEditableDocument(missionsDir, "mission", slug);
+    const document = await getEditableDocument(projectsDir, "project", slug);
     if (!document) {
-      res.status(404).json({ error: `Mission "${slug}" not found` });
+      res.status(404).json({ error: `Project "${slug}" not found` });
       return;
     }
     res.json(document);
   });
-  router.get("/api/missions/:slug/assignments/:aslug/edit", async (req, res) => {
+  router.get("/api/projects/:slug/assignments/:aslug/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
     const document = await getEditableDocument(
-      missionsDir,
+      projectsDir,
       "assignment",
       slug,
       assignmentSlug
@@ -3875,11 +3901,11 @@ function createWriteRouter(missionsDir) {
     }
     res.json(document);
   });
-  router.get("/api/missions/:slug/assignments/:aslug/plan/edit", async (req, res) => {
+  router.get("/api/projects/:slug/assignments/:aslug/plan/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
     const document = await getEditableDocument(
-      missionsDir,
+      projectsDir,
       "plan",
       slug,
       assignmentSlug
@@ -3890,11 +3916,11 @@ function createWriteRouter(missionsDir) {
     }
     res.json(document);
   });
-  router.get("/api/missions/:slug/assignments/:aslug/scratchpad/edit", async (req, res) => {
+  router.get("/api/projects/:slug/assignments/:aslug/scratchpad/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
     const document = await getEditableDocument(
-      missionsDir,
+      projectsDir,
       "scratchpad",
       slug,
       assignmentSlug
@@ -3905,11 +3931,11 @@ function createWriteRouter(missionsDir) {
     }
     res.json(document);
   });
-  router.get("/api/missions/:slug/assignments/:aslug/handoff/edit", async (req, res) => {
+  router.get("/api/projects/:slug/assignments/:aslug/handoff/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
     const document = await getEditableDocument(
-      missionsDir,
+      projectsDir,
       "handoff",
       slug,
       assignmentSlug
@@ -3920,11 +3946,11 @@ function createWriteRouter(missionsDir) {
     }
     res.json(document);
   });
-  router.get("/api/missions/:slug/assignments/:aslug/decision-record/edit", async (req, res) => {
+  router.get("/api/projects/:slug/assignments/:aslug/decision-record/edit", async (req, res) => {
     const slug = getParam(req.params.slug);
     const assignmentSlug = getParam(req.params.aslug);
     const document = await getEditableDocument(
-      missionsDir,
+      projectsDir,
       "decision-record",
       slug,
       assignmentSlug
@@ -3935,7 +3961,7 @@ function createWriteRouter(missionsDir) {
     }
     res.json(document);
   });
-  router.post("/api/missions", async (req, res) => {
+  router.post("/api/projects", async (req, res) => {
     try {
       const content = requireContent(req, res);
       if (!content) {
@@ -3956,52 +3982,50 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const missionDir = resolve7(missionsDir, slug);
-      if (await fileExists(missionDir)) {
-        res.status(409).json({ error: `Mission "${slug}" already exists` });
+      const projectDir = resolve7(projectsDir, slug);
+      if (await fileExists(projectDir)) {
+        res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve7(missionDir, "assignments"));
-      await ensureDir(resolve7(missionDir, "resources"));
-      await ensureDir(resolve7(missionDir, "memories"));
-      await writeFileForce(resolve7(missionDir, "mission.md"), content);
+      await ensureDir(resolve7(projectDir, "assignments"));
+      await ensureDir(resolve7(projectDir, "resources"));
+      await ensureDir(resolve7(projectDir, "memories"));
+      await writeFileForce(resolve7(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve7(missionDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve7(missionDir, "agent.md"), renderAgent({ slug, timestamp })],
-          [resolve7(missionDir, "claude.md"), renderClaude({ slug })],
-          [resolve7(missionDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve7(missionDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve7(missionDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve7(missionDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve7(missionDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve7(missionDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve7(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve7(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve7(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve7(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve7(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve7(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve7(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
         }
       } catch (companionError) {
         try {
-          await rm(missionDir, { recursive: true, force: true });
+          await rm(projectDir, { recursive: true, force: true });
         } catch {
         }
         throw companionError;
       }
       res.status(201).json({ slug });
     } catch (error) {
-      console.error("Error creating mission:", error);
-      res.status(500).json({ error: `Failed to create mission: ${error.message}` });
+      console.error("Error creating project:", error);
+      res.status(500).json({ error: `Failed to create project: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/assignments", async (req, res) => {
+  router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
-      const missionDir = resolve7(missionsDir, missionSlug);
-      const missionMdPath = resolve7(missionDir, "mission.md");
-      if (!await fileExists(missionMdPath)) {
-        res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+      const projectSlug = getParam(req.params.slug);
+      const projectDir = resolve7(projectsDir, projectSlug);
+      const projectMdPath = resolve7(projectDir, "project.md");
+      if (!await fileExists(projectMdPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
       const content = requireContent(req, res);
@@ -4029,20 +4053,18 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve7(missionDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve7(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
-          error: `Assignment "${assignmentSlug}" already exists in mission "${missionSlug}"`
+          error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
         });
         return;
       }
-      const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
       await writeFileForce(resolve7(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve7(assignmentDir, "plan.md"), renderPlan({ assignmentSlug, title, timestamp })],
           [resolve7(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
           [resolve7(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
           [resolve7(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
@@ -4057,51 +4079,51 @@ function createWriteRouter(missionsDir) {
         }
         throw companionError;
       }
-      res.status(201).json({ slug: assignmentSlug, missionSlug });
+      res.status(201).json({ slug: assignmentSlug, projectSlug });
     } catch (error) {
       console.error("Error creating assignment:", error);
       res.status(500).json({ error: `Failed to create assignment: ${error.message}` });
     }
   });
-  router.patch("/api/missions/:slug", async (req, res) => {
+  router.patch("/api/projects/:slug", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
-      const missionPath = resolve7(missionsDir, missionSlug, "mission.md");
-      const currentContent = await readCurrentDocument(missionPath);
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
-        res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
       const nextContentRaw = requireContent(req, res);
       if (!nextContentRaw) {
         return;
       }
-      const current = parseMission(currentContent);
-      const next = parseMission(nextContentRaw);
+      const current = parseProject(currentContent);
+      const next = parseProject(nextContentRaw);
       if (!next.slug || !next.title) {
-        res.status(400).json({ error: "Mission content must include slug and title." });
+        res.status(400).json({ error: "Project content must include slug and title." });
         return;
       }
       if (next.slug !== current.slug) {
-        res.status(400).json({ error: "Mission slug cannot be changed once created." });
+        res.status(400).json({ error: "Project slug cannot be changed once created." });
         return;
       }
       const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
-      await writeFileForce(missionPath, nextContent);
-      const mission = await getMissionDetail(missionsDir, missionSlug);
-      res.json({ mission, content: nextContent });
+      await writeFileForce(projectPath, nextContent);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project, content: nextContent });
     } catch (error) {
-      console.error("Error updating mission:", error);
-      res.status(500).json({ error: `Failed to update mission: ${error.message}` });
+      console.error("Error updating project:", error);
+      res.status(500).json({ error: `Failed to update project: ${error.message}` });
     }
   });
-  router.patch("/api/missions/:slug/assignments/:aslug", async (req, res) => {
+  router.patch("/api/projects/:slug/assignments/:aslug", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const assignmentPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "assignment.md"
@@ -4131,20 +4153,20 @@ function createWriteRouter(missionsDir) {
       }
       nextContent = setTopLevelField(nextContent, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error updating assignment:", error);
       res.status(500).json({ error: `Failed to update assignment: ${error.message}` });
     }
   });
-  router.patch("/api/missions/:slug/assignments/:aslug/acceptance-criteria/:index", async (req, res) => {
+  router.patch("/api/projects/:slug/assignments/:aslug/acceptance-criteria/:index", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const assignmentPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "assignment.md"
@@ -4167,20 +4189,20 @@ function createWriteRouter(missionsDir) {
       }
       const nextContent = setTopLevelField(result.content, "updated", nowTimestamp());
       await writeFileForce(assignmentPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error toggling acceptance criterion:", error);
       res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
     }
   });
-  router.patch("/api/missions/:slug/assignments/:aslug/plan", async (req, res) => {
+  router.patch("/api/projects/:slug/assignments/:aslug/plan", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const planPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "plan.md"
@@ -4205,20 +4227,20 @@ function createWriteRouter(missionsDir) {
       }
       const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
       await writeFileForce(planPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error updating plan:", error);
       res.status(500).json({ error: `Failed to update plan: ${error.message}` });
     }
   });
-  router.patch("/api/missions/:slug/assignments/:aslug/scratchpad", async (req, res) => {
+  router.patch("/api/projects/:slug/assignments/:aslug/scratchpad", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const scratchpadPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "scratchpad.md"
@@ -4243,20 +4265,20 @@ function createWriteRouter(missionsDir) {
       }
       const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
       await writeFileForce(scratchpadPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error updating scratchpad:", error);
       res.status(500).json({ error: `Failed to update scratchpad: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/assignments/:aslug/handoff/entries", async (req, res) => {
+  router.post("/api/projects/:slug/assignments/:aslug/handoff/entries", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const handoffPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "handoff.md"
@@ -4281,20 +4303,20 @@ function createWriteRouter(missionsDir) {
         "No handoffs recorded yet."
       );
       await writeFileForce(handoffPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.status(201).json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error appending handoff entry:", error);
       res.status(500).json({ error: `Failed to append handoff entry: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/assignments/:aslug/decision-record/entries", async (req, res) => {
+  router.post("/api/projects/:slug/assignments/:aslug/decision-record/entries", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const decisionPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "decision-record.md"
@@ -4319,19 +4341,19 @@ function createWriteRouter(missionsDir) {
         "No decisions recorded yet."
       );
       await writeFileForce(decisionPath, nextContent);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.status(201).json({ assignment, content: nextContent });
     } catch (error) {
       console.error("Error appending decision entry:", error);
       res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/move-workspace", async (req, res) => {
+  router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
-      const missionPath = resolve7(missionsDir, missionSlug, "mission.md");
-      if (!await fileExists(missionPath)) {
-        res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
       const { workspace } = req.body || {};
@@ -4339,23 +4361,23 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile6(missionPath, "utf-8");
+      let content = await readFile6(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
-      await writeFileForce(missionPath, content);
-      const mission = await getMissionDetail(missionsDir, missionSlug);
-      res.json({ mission });
+      await writeFileForce(projectPath, content);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
     } catch (error) {
-      console.error("Error moving mission workspace:", error);
+      console.error("Error moving project workspace:", error);
       res.status(500).json({ error: `Failed to move workspace: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/status-override", async (req, res) => {
+  router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
-      const missionPath = resolve7(missionsDir, missionSlug, "mission.md");
-      if (!await fileExists(missionPath)) {
-        res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
       const { status } = req.body || {};
@@ -4365,24 +4387,24 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile6(missionPath, "utf-8");
+      let content = await readFile6(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
-      await writeFileForce(missionPath, content);
-      const mission = await getMissionDetail(missionsDir, missionSlug);
-      res.json({ mission });
+      await writeFileForce(projectPath, content);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
     } catch (error) {
-      console.error("Error setting mission status override:", error);
+      console.error("Error setting project status override:", error);
       res.status(500).json({ error: `Failed to set status override: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/assignments/:aslug/status-override", async (req, res) => {
+  router.post("/api/projects/:slug/assignments/:aslug/status-override", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const assignmentPath = resolve7(
-        missionsDir,
-        missionSlug,
+        projectsDir,
+        projectSlug,
         "assignments",
         assignmentSlug,
         "assignment.md"
@@ -4405,16 +4427,16 @@ function createWriteRouter(missionsDir) {
         content = setTopLevelField(content, "blockedReason", null);
       }
       await writeFileForce(assignmentPath, content);
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment });
     } catch (error) {
       console.error("Error overriding assignment status:", error);
       res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
   });
-  router.post("/api/missions/:slug/assignments/:aslug/transitions/:command", async (req, res) => {
+  router.post("/api/projects/:slug/assignments/:aslug/transitions/:command", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const command = req.params.command;
       const config = await getStatusConfig();
@@ -4423,14 +4445,14 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const missionDir = resolve7(missionsDir, missionSlug);
-      const assignmentPath = resolve7(missionDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve7(projectsDir, projectSlug);
+      const assignmentPath = resolve7(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
       }
       const { reason } = req.body || {};
-      const result = await executeTransition(missionDir, assignmentSlug, command, {
+      const result = await executeTransition(projectDir, assignmentSlug, command, {
         reason: typeof reason === "string" ? reason : void 0,
         transitionTable: config.custom ? config.transitionTable : void 0,
         terminalStatuses: config.custom ? config.terminalStatuses : void 0
@@ -4439,25 +4461,25 @@ function createWriteRouter(missionsDir) {
         res.status(400).json({ error: result.message });
         return;
       }
-      const assignment = await getAssignmentDetail(missionsDir, missionSlug, assignmentSlug);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
       res.json({ assignment, transition: result });
     } catch (error) {
       console.error("Error running assignment transition:", error);
       res.status(500).json({ error: `Failed to transition assignment: ${error.message}` });
     }
   });
-  router.delete("/api/missions/:slug/assignments/:aslug", async (req, res) => {
+  router.delete("/api/projects/:slug/assignments/:aslug", async (req, res) => {
     try {
-      const missionSlug = getParam(req.params.slug);
+      const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve7(missionsDir, missionSlug, "assignments", assignmentSlug);
+      const assignmentDir = resolve7(projectsDir, projectSlug, "assignments", assignmentSlug);
       const assignmentPath = resolve7(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
-        res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in mission "${missionSlug}"` });
+        res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
       }
       await rm(assignmentDir, { recursive: true, force: true });
-      res.json({ deleted: assignmentSlug, missionSlug });
+      res.json({ deleted: assignmentSlug, projectSlug });
     } catch (error) {
       console.error("Error deleting assignment:", error);
       res.status(500).json({ error: `Failed to delete assignment: ${error.message}` });
@@ -4470,11 +4492,11 @@ function createWriteRouter(missionsDir) {
 init_servers();
 init_scanner();
 import { Router as Router2 } from "express";
-function createServersRouter(serversDir, missionsDir) {
+function createServersRouter(serversDir2, projectsDir) {
   const router = Router2();
   router.get("/", async (_req, res) => {
     try {
-      const result = await scanAllSessions(serversDir, missionsDir);
+      const result = await scanAllSessions(serversDir2, projectsDir);
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
@@ -4482,7 +4504,7 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.get("/:name", async (req, res) => {
     try {
-      const session = await scanSingleSession(serversDir, missionsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name);
       if (!session) {
         res.status(404).json({ error: "Session not found" });
         return;
@@ -4500,12 +4522,12 @@ function createServersRouter(serversDir, missionsDir) {
         return;
       }
       const sanitized = sanitizeSessionName(name);
-      const existing = await readSessionFile(serversDir, sanitized);
+      const existing = await readSessionFile(serversDir2, sanitized);
       if (existing) {
         res.status(409).json({ error: `Session "${sanitized}" already registered` });
         return;
       }
-      await registerSession(serversDir, name);
+      await registerSession(serversDir2, name);
       clearScanCache();
       res.status(201).json({ name: sanitized });
     } catch (error) {
@@ -4514,12 +4536,12 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.delete("/:name", async (req, res) => {
     try {
-      const data = await readSessionFile(serversDir, req.params.name);
+      const data = await readSessionFile(serversDir2, req.params.name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      await removeSession(serversDir, req.params.name);
+      await removeSession(serversDir2, req.params.name);
       clearScanCache();
       res.json({ removed: req.params.name });
     } catch (error) {
@@ -4528,12 +4550,12 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.post("/refresh", async (_req, res) => {
     try {
-      const names = await listSessionFiles(serversDir);
+      const names = await listSessionFiles(serversDir2);
       for (const name of names) {
-        await updateLastRefreshed(serversDir, name);
+        await updateLastRefreshed(serversDir2, name);
       }
       clearScanCache();
-      const result = await scanAllSessions(serversDir, missionsDir, { bypassCache: true });
+      const result = await scanAllSessions(serversDir2, projectsDir, { bypassCache: true });
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4541,14 +4563,14 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.post("/:name/refresh", async (req, res) => {
     try {
-      const data = await readSessionFile(serversDir, req.params.name);
+      const data = await readSessionFile(serversDir2, req.params.name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      await updateLastRefreshed(serversDir, req.params.name);
+      await updateLastRefreshed(serversDir2, req.params.name);
       clearScanCache();
-      const session = await scanSingleSession(serversDir, missionsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name);
       res.json(session);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4557,15 +4579,15 @@ function createServersRouter(serversDir, missionsDir) {
   router.patch("/:name/panes/:windowIndex/:paneIndex/assignment", async (req, res) => {
     try {
       const { name, windowIndex, paneIndex } = req.params;
-      const data = await readSessionFile(serversDir, name);
+      const data = await readSessionFile(serversDir2, name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
       const body = req.body;
-      if (body === null || body && body.mission && body.assignment) {
+      if (body === null || body && body.project && body.assignment) {
         await setOverride(
-          serversDir,
+          serversDir2,
           name,
           parseInt(windowIndex, 10),
           parseInt(paneIndex, 10),
@@ -4574,7 +4596,7 @@ function createServersRouter(serversDir, missionsDir) {
         clearScanCache();
         res.json({ updated: true });
       } else {
-        res.status(400).json({ error: "Body must be { mission, assignment } or null" });
+        res.status(400).json({ error: "Body must be { project, assignment } or null" });
       }
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Update failed" });
@@ -4604,7 +4626,7 @@ var SCHEMA_VERSION = "2";
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
   session_id TEXT PRIMARY KEY,
-  mission_slug TEXT,
+  project_slug TEXT,
   assignment_slug TEXT,
   agent TEXT NOT NULL,
   started TEXT NOT NULL,
@@ -4615,8 +4637,8 @@ CREATE TABLE IF NOT EXISTS sessions (
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   updated_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
-CREATE INDEX IF NOT EXISTS idx_sessions_mission ON sessions(mission_slug);
-CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(mission_slug, assignment_slug);
+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);
 CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
@@ -4635,7 +4657,7 @@ function initSessionDb(dbPath) {
     db.exec(`
       CREATE TABLE sessions_v2 (
         session_id TEXT PRIMARY KEY,
-        mission_slug TEXT,
+        project_slug TEXT,
         assignment_slug TEXT,
         agent TEXT NOT NULL,
         started TEXT NOT NULL,
@@ -4646,11 +4668,11 @@ function initSessionDb(dbPath) {
         created_at TEXT NOT NULL DEFAULT (datetime('now')),
         updated_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
-      INSERT INTO sessions_v2 SELECT session_id, mission_slug, assignment_slug, agent, started, ended, status, path, NULL, created_at, updated_at FROM sessions;
+      INSERT INTO sessions_v2 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, NULL, created_at, updated_at FROM sessions;
       DROP TABLE sessions;
       ALTER TABLE sessions_v2 RENAME TO sessions;
-      CREATE INDEX IF NOT EXISTS idx_sessions_mission ON sessions(mission_slug);
-      CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(mission_slug, assignment_slug);
+      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 = '2' WHERE key = 'schema_version';
     `);
@@ -4671,38 +4693,38 @@ function closeSessionDb() {
     db = null;
   }
 }
-async function migrateFromMarkdown(missionsDir) {
+async function migrateFromMarkdown(projectsDir) {
   const database = getSessionDb();
   const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
   if (count.count > 0) return 0;
-  if (!await fileExists(missionsDir)) return 0;
-  const entries = await readdir4(missionsDir, { withFileTypes: true });
+  if (!await fileExists(projectsDir)) return 0;
+  const entries = await readdir4(projectsDir, { withFileTypes: true });
   const allSessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const missionDir = resolve8(missionsDir, entry.name);
-    const indexPath = resolve8(missionDir, "_index-sessions.md");
+    const projectDir = resolve8(projectsDir, entry.name);
+    const indexPath = resolve8(projectDir, "_index-sessions.md");
     if (!await fileExists(indexPath)) continue;
     const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
     allSessions.push(...sessions);
   }
   if (allSessions.length === 0) return 0;
   const insert = database.prepare(`
-    INSERT OR IGNORE INTO sessions (session_id, mission_slug, assignment_slug, agent, started, status, path)
+    INSERT OR IGNORE INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path)
     VALUES (?, ?, ?, ?, ?, ?, ?)
   `);
   const insertAll = database.transaction((sessions) => {
     for (const s of sessions) {
-      insert.run(s.sessionId, s.missionSlug, s.assignmentSlug, s.agent, s.started, s.status, s.path);
+      insert.run(s.sessionId, s.projectSlug, s.assignmentSlug, s.agent, s.started, s.status, s.path);
     }
   });
   insertAll(allSessions);
   console.log(`Migrated ${allSessions.length} sessions from markdown to SQLite.`);
   return allSessions.length;
 }
-async function parseMarkdownSessionsIndex(filePath, missionSlug) {
-  const { readFile: readFile11 } = await import("fs/promises");
-  const raw = await readFile11(filePath, "utf-8");
+async function parseMarkdownSessionsIndex(filePath, projectSlug) {
+  const { readFile: readFile12 } = await import("fs/promises");
+  const raw = await readFile12(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4729,7 +4751,7 @@ async function parseMarkdownSessionsIndex(filePath, missionSlug) {
           started: cells[3],
           status: cells[4] || "active",
           path: cells[5],
-          missionSlug
+          projectSlug
         });
       }
     }
@@ -4741,7 +4763,7 @@ async function parseMarkdownSessionsIndex(filePath, missionSlug) {
 function rowToSession(row) {
   return {
     sessionId: row.session_id,
-    missionSlug: row.mission_slug ?? null,
+    projectSlug: row.project_slug ?? null,
     assignmentSlug: row.assignment_slug ?? null,
     agent: row.agent,
     started: row.started,
@@ -4751,14 +4773,14 @@ function rowToSession(row) {
     description: row.description ?? null
   };
 }
-async function appendSession(_missionDir, session) {
+async function appendSession(_projectDir, session) {
   const db2 = getSessionDb();
   db2.prepare(`
-    INSERT INTO sessions (session_id, mission_slug, assignment_slug, agent, started, status, path, description)
+    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     session.sessionId,
-    session.missionSlug ?? null,
+    session.projectSlug ?? null,
     session.assignmentSlug ?? null,
     session.agent,
     session.started,
@@ -4767,7 +4789,7 @@ async function appendSession(_missionDir, session) {
     session.description ?? null
   );
 }
-async function updateSessionStatus(_missionDir, sessionId, status) {
+async function updateSessionStatus(_projectDir, sessionId, status) {
   const db2 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
   const result = isTerminal ? db2.prepare(
@@ -4777,20 +4799,20 @@ async function updateSessionStatus(_missionDir, sessionId, status) {
   ).run(status, sessionId);
   return result.changes > 0;
 }
-async function listAllSessions(_missionsDir) {
+async function listAllSessions(_projectsDir) {
   const db2 = getSessionDb();
   const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
   return rows.map(rowToSession);
 }
-async function listMissionSessions(_missionsDir, missionSlug, assignmentSlug) {
+async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
   const db2 = getSessionDb();
   if (assignmentSlug) {
     const rows2 = db2.prepare(
-      "SELECT * FROM sessions WHERE mission_slug = ? AND assignment_slug = ? ORDER BY started DESC"
-    ).all(missionSlug, assignmentSlug);
+      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+    ).all(projectSlug, assignmentSlug);
     return rows2.map(rowToSession);
   }
-  const rows = db2.prepare("SELECT * FROM sessions WHERE mission_slug = ? ORDER BY started DESC").all(missionSlug);
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
   return rows.map(rowToSession);
 }
 async function deleteSessions(sessionIds) {
@@ -4801,34 +4823,34 @@ async function deleteSessions(sessionIds) {
   return result.changes;
 }
 var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
-async function readAssignmentStatus(missionDir, assignmentSlug) {
-  const assignmentPath = resolve9(missionDir, "assignments", assignmentSlug, "assignment.md");
+async function readAssignmentStatus(projectDir, assignmentSlug) {
+  const assignmentPath = resolve9(projectDir, "assignments", assignmentSlug, "assignment.md");
   if (!await fileExists(assignmentPath)) return null;
   const raw = await readFile7(assignmentPath, "utf-8");
   const match = raw.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
-async function reconcileActiveSessions(missionsDir) {
+async function reconcileActiveSessions(projectsDir) {
   const db2 = getSessionDb();
-  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND mission_slug IS NOT NULL AND assignment_slug IS NOT NULL").all();
+  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND project_slug IS NOT NULL AND assignment_slug IS NOT NULL").all();
   if (activeSessions.length === 0) return 0;
   const toCheck = /* @__PURE__ */ new Map();
   for (const session of activeSessions) {
-    const slugs = toCheck.get(session.mission_slug) ?? /* @__PURE__ */ new Set();
+    const slugs = toCheck.get(session.project_slug) ?? /* @__PURE__ */ new Set();
     slugs.add(session.assignment_slug);
-    toCheck.set(session.mission_slug, slugs);
+    toCheck.set(session.project_slug, slugs);
   }
   const assignmentStatuses = /* @__PURE__ */ new Map();
-  for (const [missionSlug, slugs] of toCheck) {
-    const missionDir = resolve9(missionsDir, missionSlug);
+  for (const [projectSlug, slugs] of toCheck) {
+    const projectDir = resolve9(projectsDir, projectSlug);
     for (const slug of slugs) {
-      const status = await readAssignmentStatus(missionDir, slug);
-      if (status) assignmentStatuses.set(`${missionSlug}/${slug}`, status);
+      const status = await readAssignmentStatus(projectDir, slug);
+      if (status) assignmentStatuses.set(`${projectSlug}/${slug}`, status);
     }
   }
   let totalUpdated = 0;
   for (const session of activeSessions) {
-    const key = `${session.mission_slug}/${session.assignment_slug}`;
+    const key = `${session.project_slug}/${session.assignment_slug}`;
     const assignmentStatus = assignmentStatuses.get(key);
     if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
     const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
@@ -4840,28 +4862,28 @@ async function reconcileActiveSessions(missionsDir) {
 
 // src/dashboard/api-agent-sessions.ts
 init_fs();
-function createAgentSessionsRouter(missionsDir, broadcast) {
+function createAgentSessionsRouter(projectsDir, broadcast) {
   const router = Router3();
   router.get("/", async (_req, res) => {
     try {
-      await reconcileActiveSessions(missionsDir);
-      const sessions = await listAllSessions(missionsDir);
+      await reconcileActiveSessions(projectsDir);
+      const sessions = await listAllSessions(projectsDir);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to list sessions" });
     }
   });
-  router.get("/:missionSlug", async (req, res) => {
+  router.get("/:projectSlug", async (req, res) => {
     try {
-      const { missionSlug } = req.params;
+      const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const missionDir = resolve10(missionsDir, missionSlug);
-      if (!await fileExists(missionDir)) {
-        res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+      const projectDir = resolve10(projectsDir, projectSlug);
+      if (!await fileExists(projectDir)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      await reconcileActiveSessions(missionsDir);
-      const sessions = await listMissionSessions(missionsDir, missionSlug, assignment);
+      await reconcileActiveSessions(projectsDir);
+      const sessions = await listProjectSessions(projectsDir, projectSlug, assignment);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to list sessions" });
@@ -4869,21 +4891,21 @@ function createAgentSessionsRouter(missionsDir, broadcast) {
   });
   router.post("/", async (req, res) => {
     try {
-      const { missionSlug, assignmentSlug, agent, sessionId, path, description } = req.body;
+      const { projectSlug, assignmentSlug, agent, sessionId, path, description } = req.body;
       if (!agent) {
         res.status(400).json({ error: "agent is required" });
         return;
       }
-      if (missionSlug) {
-        const missionDir = resolve10(missionsDir, missionSlug);
-        if (!await fileExists(missionDir)) {
-          res.status(404).json({ error: `Mission "${missionSlug}" not found` });
+      if (projectSlug) {
+        const projectDir = resolve10(projectsDir, projectSlug);
+        if (!await fileExists(projectDir)) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
       }
       const id = sessionId || randomUUID2();
       const session = {
-        missionSlug: missionSlug || null,
+        projectSlug: projectSlug || null,
         assignmentSlug: assignmentSlug || null,
         agent,
         sessionId: id,
@@ -4954,13 +4976,13 @@ init_parser();
 init_timestamp();
 import { resolve as resolve11 } from "path";
 import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
-async function rebuildPlaybookManifest(playbooksDir) {
-  if (!await fileExists(playbooksDir)) return;
-  const entries = await readdir5(playbooksDir, { withFileTypes: true });
+async function rebuildPlaybookManifest(playbooksDir2) {
+  if (!await fileExists(playbooksDir2)) return;
+  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const raw = await readFile8(resolve11(playbooksDir, entry.name), "utf-8");
+    const raw = await readFile8(resolve11(playbooksDir2, entry.name), "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     rows.push({
@@ -4990,15 +5012,15 @@ async function rebuildPlaybookManifest(playbooksDir) {
     }
   }
   lines.push("");
-  await writeFileForce(resolve11(playbooksDir, "manifest.md"), lines.join("\n"));
+  await writeFileForce(resolve11(playbooksDir2, "manifest.md"), lines.join("\n"));
 }
 
 // src/dashboard/api-playbooks.ts
-function createPlaybooksRouter(playbooksDir) {
+function createPlaybooksRouter(playbooksDir2) {
   const router = Router4();
   router.get("/", async (_req, res) => {
     try {
-      const playbooks = await listPlaybooks(playbooksDir);
+      const playbooks = await listPlaybooks(playbooksDir2);
       res.json({ playbooks, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to list playbooks" });
@@ -5019,7 +5041,7 @@ function createPlaybooksRouter(playbooksDir) {
   });
   router.get("/:slug", async (req, res) => {
     try {
-      const detail = await getPlaybookDetail(playbooksDir, req.params.slug);
+      const detail = await getPlaybookDetail(playbooksDir2, req.params.slug);
       if (!detail) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5031,7 +5053,7 @@ function createPlaybooksRouter(playbooksDir) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5060,14 +5082,14 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(400).json({ error: `Invalid or missing slug: "${slug}"` });
         return;
       }
-      await ensureDir(playbooksDir);
-      const filePath = resolve12(playbooksDir, `${slug}.md`);
+      await ensureDir(playbooksDir2);
+      const filePath = resolve12(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
       }
       await writeFileForce(filePath, content);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.status(201).json({ slug, path: filePath });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to create playbook" });
@@ -5080,13 +5102,13 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
       await writeFileForce(filePath, content);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: req.params.slug, path: filePath });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to update playbook" });
@@ -5098,13 +5120,13 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
       await unlink2(filePath);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.json({ deleted: req.params.slug });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to delete playbook" });
@@ -5134,7 +5156,7 @@ function withLock(workspace, fn) {
   }));
   return next;
 }
-function createTodosRouter(todosDir, broadcast) {
+function createTodosRouter(todosDir2, broadcast) {
   const router = Router5();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -5150,14 +5172,14 @@ function createTodosRouter(todosDir, broadcast) {
   router.param("workspace", validateWorkspace);
   router.get("/", async (_req, res) => {
     try {
-      await ensureDir(todosDir);
-      const files = await readdir6(todosDir).catch(() => []);
+      await ensureDir(todosDir2);
+      const files = await readdir6(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(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         workspaces.push({
           workspace: checklist.workspace,
           archiveInterval: checklist.archiveInterval,
@@ -5173,7 +5195,7 @@ function createTodosRouter(todosDir, broadcast) {
   router.get("/:workspace", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const checklist = await readChecklist(todosDir, workspace);
+      const checklist = await readChecklist(todosDir2, workspace);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
@@ -5193,7 +5215,7 @@ function createTodosRouter(todosDir, broadcast) {
         return;
       }
       const item = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const existingIds = new Set(checklist.items.map((i) => i.id));
         const id = generateUniqueId(existingIds);
         const newItem = {
@@ -5204,7 +5226,7 @@ function createTodosRouter(todosDir, broadcast) {
           session: null
         };
         checklist.items.push(newItem);
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return newItem;
       });
       broadcastUpdate();
@@ -5222,7 +5244,7 @@ function createTodosRouter(todosDir, broadcast) {
         return;
       }
       const items = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
         const reordered = [];
         for (const id of ids) {
@@ -5236,7 +5258,7 @@ function createTodosRouter(todosDir, broadcast) {
           reordered.push(item);
         }
         checklist.items = reordered;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return reordered;
       });
       broadcastUpdate();
@@ -5247,7 +5269,7 @@ function createTodosRouter(todosDir, broadcast) {
   });
   router.get("/:workspace/log", async (req, res) => {
     try {
-      const log = await readLog(todosDir, getWorkspaceParam(req.params.workspace));
+      const log = await readLog(todosDir2, getWorkspaceParam(req.params.workspace));
       res.json(log);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
@@ -5256,12 +5278,12 @@ function createTodosRouter(todosDir, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve15 } = await import("path");
-      const { readFile: readFile11 } = await import("fs/promises");
+      const { resolve: resolve16 } = await import("path");
+      const { readFile: readFile12 } = 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(todosDir, workspace);
-      const log = await readLog(todosDir, 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)
       );
@@ -5272,11 +5294,11 @@ function createTodosRouter(todosDir, broadcast) {
       const toArchive = log.entries.filter(
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
-      const archFile = archivePath2(todosDir, workspace, checklist.archiveInterval);
-      await ensureDir(resolve15(todosDir, "archive"));
+      const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
+      await ensureDir(resolve16(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile11(archFile, "utf-8");
+        archContent = await readFile12(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -5310,7 +5332,7 @@ workspace: ${workspace}
       }
       await writeFileForce2(archFile, archContent);
       checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir, checklist);
+      await writeChecklist(todosDir2, checklist);
       broadcastUpdate();
       res.json({ archived: completedIds.size, logEntries: toArchive.length });
     } catch (error) {
@@ -5319,7 +5341,7 @@ workspace: ${workspace}
   });
   router.get("/:workspace/log/:id", async (req, res) => {
     try {
-      const log = await readLog(todosDir, getWorkspaceParam(req.params.workspace));
+      const log = await readLog(todosDir2, getWorkspaceParam(req.params.workspace));
       const entries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
       res.json({ workspace: log.workspace, entries });
     } catch (error) {
@@ -5329,13 +5351,13 @@ workspace: ${workspace}
   router.get("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const checklist = await readChecklist(todosDir, workspace);
+      const checklist = await readChecklist(todosDir2, workspace);
       const item = checklist.items.find((i) => i.id === req.params.id);
       if (!item) {
         res.status(404).json({ error: `Todo "${req.params.id}" not found` });
         return;
       }
-      const log = await readLog(todosDir, workspace);
+      const log = await readLog(todosDir2, workspace);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
       res.json({ ...item, log: logEntries });
     } catch (error) {
@@ -5346,12 +5368,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         if (req.body.description !== void 0) item.description = req.body.description;
         if (Array.isArray(req.body.tags)) item.tags = req.body.tags;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5368,11 +5390,11 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const deleted = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const idx = checklist.items.findIndex((i) => i.id === req.params.id);
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return true;
       });
       if (!deleted) {
@@ -5389,13 +5411,13 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return { error: "not_found" };
         if (item.status === "in_progress") return { error: "conflict", session: item.session };
         item.status = "in_progress";
         item.session = req.body.session || null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { item: { ...item } };
       });
       if ("error" in result) {
@@ -5416,12 +5438,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "completed";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           itemIds: [item.id],
@@ -5432,7 +5454,7 @@ workspace: ${workspace}
           blockers: null,
           status: null
         };
-        await appendLogEntry2(todosDir, workspace, entry);
+        await appendLogEntry2(todosDir2, workspace, entry);
         return { ...item };
       });
       if (!result) {
@@ -5450,12 +5472,12 @@ workspace: ${workspace}
       const reason = req.body.reason || null;
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "blocked";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           itemIds: [item.id],
@@ -5466,7 +5488,7 @@ workspace: ${workspace}
           blockers: reason,
           status: "blocked"
         };
-        await appendLogEntry2(todosDir, workspace, entry);
+        await appendLogEntry2(todosDir2, workspace, entry);
         return { ...item };
       });
       if (!result) {
@@ -5483,12 +5505,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "open";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5505,12 +5527,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "open";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5526,6 +5548,411 @@ workspace: ${workspace}
   return router;
 }
 
+// src/dashboard/api-backup.ts
+init_config2();
+import { Router as Router6 } from "express";
+
+// src/utils/github-backup.ts
+init_paths();
+init_fs();
+init_config2();
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { cp, mkdtemp, rm as rm2, readFile as readFile11, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
+import { resolve as resolve14, join as join2 } from "path";
+import { tmpdir } from "os";
+var exec2 = promisify2(execFile2);
+var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
+var LOCK_FILE_NAME = ".backup-lock";
+function parseCategoriesStrict(cats) {
+  const unknown = [];
+  const valid = [];
+  for (const cat of cats) {
+    if (VALID_CATEGORIES.includes(cat)) {
+      valid.push(cat);
+    } else {
+      unknown.push(cat);
+    }
+  }
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown categor${unknown.length === 1 ? "y" : "ies"}: ${unknown.map((c) => `"${c}"`).join(", ")}. Valid: ${VALID_CATEGORIES.join(", ")}`
+    );
+  }
+  return valid;
+}
+function validateRepoUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const trimmed = url.trim();
+  return trimmed.startsWith("https://") || trimmed.startsWith("git@");
+}
+async function resolveCategoryPath(category) {
+  switch (category) {
+    case "projects": {
+      const config = await readConfig();
+      return { sourcePath: config.defaultProjectDir, repoPath: "projects", isFile: false };
+    }
+    case "playbooks":
+      return { sourcePath: playbooksDir(), repoPath: "playbooks", isFile: false };
+    case "todos":
+      return { sourcePath: todosDir(), repoPath: "todos", isFile: false };
+    case "servers":
+      return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
+    case "config":
+      return { sourcePath: resolve14(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+  }
+}
+async function checkGitInstalled() {
+  try {
+    await exec2("git", ["--version"]);
+  } catch {
+    throw new Error("git is not installed or not on PATH. Install git and try again.");
+  }
+}
+async function acquireLock() {
+  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  await ensureDir(syntaurRoot());
+  try {
+    const handle = await open(lockPath, "wx");
+    await handle.write(String(process.pid));
+    await handle.close();
+    return lockPath;
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      const pid = await readFile11(lockPath, "utf-8").catch(() => "");
+      throw new Error(
+        `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
+      );
+    }
+    throw err;
+  }
+}
+async function releaseLock(lockPath) {
+  try {
+    await unlink3(lockPath);
+  } catch {
+  }
+}
+async function runGit(args, cwd) {
+  return exec2("git", args, { cwd });
+}
+async function cloneOrInit(repoUrl, destDir) {
+  try {
+    await exec2("git", ["clone", "--depth", "1", repoUrl, destDir]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("Repository not found") || message.includes("does not appear to be a git repository")) {
+      throw new Error(`Repository not found or inaccessible: ${repoUrl}. Check URL and credentials.`);
+    }
+    if (message.includes("Authentication failed") || message.includes("could not read Username")) {
+      throw new Error(`Authentication failed for ${repoUrl}. Check SSH keys or credentials.`);
+    }
+    throw new Error(`git clone failed: ${message}`);
+  }
+}
+async function copyRecursive(src, dest) {
+  if (!await fileExists(src)) return;
+  const s = await stat(src);
+  if (s.isDirectory()) {
+    await ensureDir(dest);
+    await cp(src, dest, { recursive: true, force: true });
+  } else {
+    await ensureDir(resolve14(dest, ".."));
+    await cp(src, dest, { force: true });
+  }
+}
+function resolveCategoriesStrict(csv) {
+  const parts = csv.split(",").map((s) => s.trim()).filter(Boolean);
+  return parseCategoriesStrict(parts);
+}
+async function readSanitizedConfig(configPath) {
+  const content = await readFile11(configPath, "utf-8");
+  return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
+}
+async function backupToGithub(overrides) {
+  await checkGitInstalled();
+  const config = await readConfig();
+  const rawRepo = overrides?.repo ?? config.backup?.repo ?? null;
+  if (!rawRepo) {
+    throw new Error("No backup repo configured. Set it via `syntaur backup config --repo <url>` or the dashboard.");
+  }
+  const repo = rawRepo.trim();
+  if (!validateRepoUrl(repo)) {
+    throw new Error(`Invalid repo URL: "${rawRepo}". Must start with https:// or git@.`);
+  }
+  const categoriesCsv = config.backup?.categories ?? "projects, playbooks, todos, servers, config";
+  const categories = overrides?.categories ?? resolveCategoriesStrict(categoriesCsv);
+  if (categories.length === 0) {
+    throw new Error("No valid backup categories selected.");
+  }
+  const lockPath = await acquireLock();
+  let tmpDir = null;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    tmpDir = await mkdtemp(join2(tmpdir(), "syntaur-backup-"));
+    await cloneOrInit(repo, tmpDir);
+    for (const category of categories) {
+      const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
+      const destPath = join2(tmpDir, repoPath);
+      if (isFile) {
+        await rm2(destPath, { force: true });
+      } else {
+        await rm2(destPath, { recursive: true, force: true });
+      }
+      if (!await fileExists(sourcePath)) {
+        console.warn(`Category "${category}": no local data at ${sourcePath}; backup will reflect deletion.`);
+        continue;
+      }
+      if (category === "config") {
+        const sanitized = await readSanitizedConfig(sourcePath);
+        await ensureDir(resolve14(destPath, ".."));
+        await writeFile3(destPath, sanitized, "utf-8");
+      } else {
+        await copyRecursive(sourcePath, destPath);
+      }
+    }
+    await runGit(["add", "-A"], tmpDir);
+    const { stdout: status } = await runGit(["status", "--porcelain"], tmpDir);
+    if (!status.trim()) {
+      await updateBackupConfig({ lastBackup: timestamp }).catch(() => {
+      });
+      return {
+        success: true,
+        timestamp,
+        message: "No changes to back up.",
+        committed: false
+      };
+    }
+    try {
+      await runGit(["config", "user.email", "syntaur@local"], tmpDir);
+      await runGit(["config", "user.name", "Syntaur Backup"], tmpDir);
+    } catch {
+    }
+    await runGit(["commit", "-m", `Syntaur backup ${timestamp}`], tmpDir);
+    try {
+      await runGit(["push"], tmpDir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("non-fast-forward") || message.includes("rejected")) {
+        throw new Error("Push rejected (non-fast-forward). Pull and resolve manually, or delete remote contents.");
+      }
+      if (message.includes("Authentication") || message.includes("could not read Username")) {
+        throw new Error("Push authentication failed. Check SSH keys or credentials.");
+      }
+      throw new Error(`git push failed: ${message}`);
+    }
+    await updateBackupConfig({ lastBackup: timestamp }).catch(() => {
+    });
+    return {
+      success: true,
+      timestamp,
+      message: `Backed up ${categories.length} categor${categories.length === 1 ? "y" : "ies"} to ${repo}.`,
+      committed: true
+    };
+  } finally {
+    if (tmpDir) {
+      await rm2(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await releaseLock(lockPath);
+  }
+}
+async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
+  if (isFile) {
+    await ensureDir(resolve14(localPath, ".."));
+    await cp(repoSrcPath, localPath, { force: true });
+    return;
+  }
+  const stagingPath = `${localPath}.syntaur-restore-staging`;
+  const backupPath = `${localPath}.syntaur-restore-backup`;
+  await rm2(stagingPath, { recursive: true, force: true });
+  const backupExistsBefore = await fileExists(backupPath);
+  const localExistsBefore = await fileExists(localPath);
+  if (backupExistsBefore) {
+    if (!localExistsBefore) {
+      await rename2(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.`
+      );
+    }
+  }
+  let localMovedAside = false;
+  try {
+    await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
+    const localExists = await fileExists(localPath);
+    if (localExists) {
+      await rename2(localPath, backupPath);
+      localMovedAside = true;
+    }
+    await rename2(stagingPath, localPath);
+    await rm2(backupPath, { recursive: true, force: true }).catch(() => {
+    });
+  } catch (err) {
+    if (localMovedAside && await fileExists(backupPath)) {
+      await rename2(backupPath, localPath).catch(() => {
+      });
+    }
+    await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function restoreFromGithub(overrides) {
+  await checkGitInstalled();
+  const config = await readConfig();
+  const rawRepo = overrides?.repo ?? config.backup?.repo ?? null;
+  if (!rawRepo) {
+    throw new Error("No backup repo configured.");
+  }
+  const repo = rawRepo.trim();
+  if (!validateRepoUrl(repo)) {
+    throw new Error(`Invalid repo URL: "${rawRepo}".`);
+  }
+  const categoriesCsv = config.backup?.categories ?? "projects, playbooks, todos, servers, config";
+  const categories = overrides?.categories ?? resolveCategoriesStrict(categoriesCsv);
+  if (categories.length === 0) {
+    throw new Error("No valid restore categories selected.");
+  }
+  const lockPath = await acquireLock();
+  let tmpDir = null;
+  const restored = [];
+  const failed = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await updateBackupConfig({ lastRestore: timestamp });
+    tmpDir = await mkdtemp(join2(tmpdir(), "syntaur-restore-"));
+    await cloneOrInit(repo, tmpDir);
+    for (const category of categories) {
+      if (category === "config") {
+        console.warn('Skipping "config" on restore (would overwrite local backup settings).');
+        continue;
+      }
+      try {
+        const { sourcePath: localPath, repoPath, isFile } = await resolveCategoryPath(category);
+        const repoSrcPath = join2(tmpDir, repoPath);
+        if (!await fileExists(repoSrcPath)) {
+          console.warn(`Category "${category}" not found in backup repo, skipping.`);
+          continue;
+        }
+        await safeRestoreCategory(localPath, repoSrcPath, isFile);
+        restored.push(category);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to restore "${category}": ${msg}`);
+        failed.push(category);
+      }
+    }
+    const success = failed.length === 0;
+    return {
+      success,
+      timestamp,
+      message: success ? `Restored ${restored.length} categor${restored.length === 1 ? "y" : "ies"} from ${repo}.` : `Partial restore: ${restored.length} succeeded, ${failed.length} failed (${failed.join(", ")}).`,
+      committed: false
+    };
+  } finally {
+    if (tmpDir) {
+      await rm2(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await releaseLock(lockPath);
+  }
+}
+async function getBackupStatus() {
+  const config = await readConfig();
+  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const locked = await fileExists(lockPath);
+  return {
+    repo: config.backup?.repo ?? null,
+    categories: config.backup?.categories ?? "projects, playbooks, todos, servers, config",
+    lastBackup: config.backup?.lastBackup ?? null,
+    lastRestore: config.backup?.lastRestore ?? null,
+    locked
+  };
+}
+
+// src/dashboard/api-backup.ts
+function createBackupRouter() {
+  const router = Router6();
+  router.get("/", async (_req, res) => {
+    try {
+      const status = await getBackupStatus();
+      res.json(status);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.put("/config", async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      const updates = {};
+      if (body.repo !== void 0) {
+        const trimmed = typeof body.repo === "string" ? body.repo.trim() : body.repo;
+        if (trimmed !== null && trimmed !== "" && !validateRepoUrl(trimmed)) {
+          return res.status(400).json({
+            error: `Invalid repo URL. Must start with https:// or git@.`
+          });
+        }
+        updates.repo = trimmed || null;
+      }
+      if (body.categories !== void 0) {
+        let cats;
+        if (Array.isArray(body.categories)) {
+          cats = body.categories.map((s) => String(s).trim()).filter(Boolean);
+        } else if (typeof body.categories === "string") {
+          cats = body.categories.split(",").map((s) => s.trim()).filter(Boolean);
+        } else {
+          return res.status(400).json({ error: "categories must be a string or array" });
+        }
+        if (cats.length === 0) {
+          return res.status(400).json({
+            error: `No categories provided. Valid: ${VALID_CATEGORIES.join(", ")}`
+          });
+        }
+        try {
+          const valid = parseCategoriesStrict(cats);
+          updates.categories = valid.join(", ");
+        } catch (err) {
+          return res.status(400).json({
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      if (Object.keys(updates).length === 0) {
+        return res.status(400).json({ error: "No fields to update" });
+      }
+      await updateBackupConfig(updates);
+      const status = await getBackupStatus();
+      res.json(status);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.post("/push", async (_req, res) => {
+    try {
+      const result = await backupToGithub();
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.post("/pull", async (_req, res) => {
+    try {
+      const result = await restoreFromGithub();
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return router;
+}
+
 // src/dashboard/autodiscovery.ts
 init_scanner();
 init_servers();
@@ -5588,7 +6015,7 @@ async function stopAutodiscovery() {
 function runReconcile() {
   if (activeReconcile || !savedOptions) return;
   const opts = savedOptions;
-  activeReconcile = reconcile(opts.serversDir, opts.missionsDir, opts.excludePids).catch((err) => {
+  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids).catch((err) => {
     console.error("[autodiscovery] reconcile failed:", err);
   }).finally(() => {
     activeReconcile = null;
@@ -5599,10 +6026,10 @@ async function listAllTmuxSessions() {
   if (!output) return [];
   return output.split("\n").filter((line) => line.length > 0);
 }
-async function discoverTmuxSessions(serversDir, missionsDir, existingNames) {
+async function discoverTmuxSessions(serversDir2, projectsDir, existingNames) {
   const tmuxAvailable = await checkTmuxAvailable();
   if (!tmuxAvailable) return false;
-  const workspaceRecords = await loadWorkspaceRecords(missionsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
   if (workspaceRecords.length === 0) return false;
   const sessions = await listAllTmuxSessions();
   let changed = false;
@@ -5627,7 +6054,7 @@ async function discoverTmuxSessions(serversDir, missionsDir, existingNames) {
       }
     }
     if (matched) {
-      await registerAutoSession(serversDir, sessionName, { kind: "tmux" });
+      await registerAutoSession(serversDir2, sessionName, { kind: "tmux" });
       changed = true;
     }
   }
@@ -5643,8 +6070,8 @@ async function getProcessCwd(pid) {
   }
   return null;
 }
-async function discoverProcesses(serversDir, missionsDir, existingFiles, excludePids) {
-  const workspaceRecords = await loadWorkspaceRecords(missionsDir);
+async function discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids) {
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
   if (workspaceRecords.length === 0) return false;
   const lsofOutput = await getLsofOutput();
   if (!lsofOutput) return false;
@@ -5668,7 +6095,7 @@ async function discoverProcesses(serversDir, missionsDir, existingFiles, exclude
     const sanitized = sanitizeSessionName(sessionName);
     if (existingFiles.has(sanitized)) continue;
     const ports = parsePortsForPid(lsofOutput, proc.pid);
-    await registerAutoSession(serversDir, sessionName, {
+    await registerAutoSession(serversDir2, sessionName, {
       kind: "process",
       pid: proc.pid,
       ports: ports.length > 0 ? ports : [proc.port],
@@ -5678,7 +6105,7 @@ async function discoverProcesses(serversDir, missionsDir, existingFiles, exclude
   }
   return changed;
 }
-async function cleanupDeadAutoSessions(serversDir, existingFiles) {
+async function cleanupDeadAutoSessions(serversDir2, existingFiles) {
   let changed = false;
   const removedNames = /* @__PURE__ */ new Set();
   const tmuxAvailable = await checkTmuxAvailable();
@@ -5694,7 +6121,7 @@ async function cleanupDeadAutoSessions(serversDir, existingFiles) {
       continue;
     }
     if (!alive) {
-      await removeSession(serversDir, name);
+      await removeSession(serversDir2, name);
       removedNames.add(name);
       changed = true;
     }
@@ -5709,20 +6136,20 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir, missionsDir, excludePids) {
-  const names = await listSessionFiles(serversDir);
+async function reconcile(serversDir2, projectsDir, excludePids) {
+  const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
-    const data = await readSessionFile(serversDir, name);
+    const data = await readSessionFile(serversDir2, name);
     if (data) existingFiles.set(name, data);
   }
-  const { changed: cleanupChanged, removedNames } = await cleanupDeadAutoSessions(serversDir, existingFiles);
+  const { changed: cleanupChanged, removedNames } = await cleanupDeadAutoSessions(serversDir2, existingFiles);
   for (const name of removedNames) {
     existingFiles.delete(name);
   }
   const existingNames = new Set(existingFiles.keys());
-  const tmuxChanged = await discoverTmuxSessions(serversDir, missionsDir, existingNames);
-  const processChanged = await discoverProcesses(serversDir, missionsDir, existingFiles, excludePids);
+  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir, existingNames);
+  const processChanged = await discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids);
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
@@ -5730,7 +6157,7 @@ async function reconcile(serversDir, missionsDir, excludePids) {
 
 // src/dashboard/server.ts
 function createDashboardServer(options) {
-  const { port, missionsDir, serversDir, playbooksDir, todosDir, serveStaticUi, dashboardDistPath } = options;
+  const { port, projectsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
   const app = express();
   const server = createServer(app);
   const wss = new WebSocketServer({ noServer: true });
@@ -5764,13 +6191,13 @@ function createDashboardServer(options) {
     }
   }
   initSessionDb();
-  migrateFromMarkdown(missionsDir).catch((err) => {
+  migrateFromMarkdown(projectsDir).catch((err) => {
     console.error("Session migration from markdown failed:", err);
   });
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
-      const overview = await getOverview(missionsDir, serversDir);
+      const overview = await getOverview(projectsDir, serversDir2);
       res.json(overview);
     } catch (error) {
       console.error("Error getting overview:", error);
@@ -5779,7 +6206,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/attention", async (_req, res) => {
     try {
-      const attention = await getAttention(missionsDir, serversDir);
+      const attention = await getAttention(projectsDir, serversDir2);
       res.json(attention);
     } catch (error) {
       console.error("Error getting attention queue:", error);
@@ -5846,26 +6273,26 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to reset status config" });
     }
   });
-  app.get("/api/missions", async (req, res) => {
+  app.get("/api/projects", async (req, res) => {
     try {
-      let missions = await listMissions(missionsDir);
+      let projects = await listProjects(projectsDir);
       const workspaceParam = req.query.workspace;
       if (workspaceParam) {
         if (workspaceParam === "_ungrouped") {
-          missions = missions.filter((m) => m.workspace === null);
+          projects = projects.filter((m) => m.workspace === null);
         } else {
-          missions = missions.filter((m) => m.workspace === workspaceParam);
+          projects = projects.filter((m) => m.workspace === workspaceParam);
         }
       }
-      res.json(missions);
+      res.json(projects);
     } catch (error) {
-      console.error("Error listing missions:", error);
-      res.status(500).json({ error: "Failed to list missions" });
+      console.error("Error listing projects:", error);
+      res.status(500).json({ error: "Failed to list projects" });
     }
   });
   app.get("/api/workspaces", async (_req, res) => {
     try {
-      const result = await listWorkspaces(missionsDir);
+      const result = await listWorkspaces(projectsDir);
       res.json(result);
     } catch (error) {
       console.error("Error listing workspaces:", error);
@@ -5879,8 +6306,8 @@ function createDashboardServer(options) {
         res.status(400).json({ error: "Invalid workspace name. Use lowercase letters, numbers, and hyphens." });
         return;
       }
-      await createWorkspace(missionsDir, name);
-      broadcast({ type: "mission-updated", missionSlug: "", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      await createWorkspace(projectsDir, name);
+      broadcast({ type: "project-updated", projectSlug: "", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       res.json({ name });
     } catch (error) {
       console.error("Error creating workspace:", error);
@@ -5889,8 +6316,8 @@ function createDashboardServer(options) {
   });
   app.delete("/api/workspaces/:name", async (req, res) => {
     try {
-      await deleteWorkspace(missionsDir, req.params.name);
-      broadcast({ type: "mission-updated", missionSlug: "", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      await deleteWorkspace(projectsDir, req.params.name);
+      broadcast({ type: "project-updated", projectSlug: "", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       res.json({ ok: true });
     } catch (error) {
       console.error("Error deleting workspace:", error);
@@ -5899,13 +6326,13 @@ function createDashboardServer(options) {
   });
   app.get("/api/assignments", async (req, res) => {
     try {
-      const result = await listAssignmentsBoard(missionsDir);
+      const result = await listAssignmentsBoard(projectsDir);
       const workspaceParam = req.query.workspace;
       if (workspaceParam) {
         if (workspaceParam === "_ungrouped") {
-          result.assignments = result.assignments.filter((a) => a.missionWorkspace === null);
+          result.assignments = result.assignments.filter((a) => a.projectWorkspace === null);
         } else {
-          result.assignments = result.assignments.filter((a) => a.missionWorkspace === workspaceParam);
+          result.assignments = result.assignments.filter((a) => a.projectWorkspace === workspaceParam);
         }
       }
       res.json(result);
@@ -5914,29 +6341,29 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to list assignments" });
     }
   });
-  app.get("/api/missions/:slug", async (req, res) => {
+  app.get("/api/projects/:slug", async (req, res) => {
     try {
-      const detail = await getMissionDetail(missionsDir, req.params.slug);
+      const detail = await getProjectDetail(projectsDir, req.params.slug);
       if (!detail) {
-        res.status(404).json({ error: `Mission "${req.params.slug}" not found` });
+        res.status(404).json({ error: `Project "${req.params.slug}" not found` });
         return;
       }
       res.json(detail);
     } catch (error) {
-      console.error("Error getting mission detail:", error);
-      res.status(500).json({ error: "Failed to get mission detail" });
+      console.error("Error getting project detail:", error);
+      res.status(500).json({ error: "Failed to get project detail" });
     }
   });
-  app.get("/api/missions/:slug/assignments/:aslug", async (req, res) => {
+  app.get("/api/projects/:slug/assignments/:aslug", async (req, res) => {
     try {
       const detail = await getAssignmentDetail(
-        missionsDir,
+        projectsDir,
         req.params.slug,
         req.params.aslug
       );
       if (!detail) {
         res.status(404).json({
-          error: `Assignment "${req.params.aslug}" not found in mission "${req.params.slug}"`
+          error: `Assignment "${req.params.aslug}" not found in project "${req.params.slug}"`
         });
         return;
       }
@@ -5946,15 +6373,16 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to get assignment detail" });
     }
   });
-  app.use(createWriteRouter(missionsDir));
-  app.use("/api/servers", createServersRouter(serversDir, missionsDir));
-  app.use("/api/agent-sessions", createAgentSessionsRouter(missionsDir, broadcast));
-  app.use("/api/playbooks", createPlaybooksRouter(playbooksDir));
-  app.use("/api/todos", createTodosRouter(todosDir, broadcast));
+  app.use(createWriteRouter(projectsDir));
+  app.use("/api/servers", createServersRouter(serversDir2, projectsDir));
+  app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast));
+  app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
+  app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
+  app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     app.use(express.static(dashboardDistPath));
     app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve14(dashboardDistPath, "index.html");
+      const indexPath = resolve15(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -5968,13 +6396,13 @@ function createDashboardServer(options) {
   return {
     async start() {
       watcherHandle = createWatcher({
-        missionsDir,
-        serversDir,
-        playbooksDir,
-        todosDir,
+        projectsDir,
+        serversDir: serversDir2,
+        playbooksDir: playbooksDir2,
+        todosDir: todosDir2,
         onMessage: broadcast
       });
-      startAutodiscovery({ serversDir, missionsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
+      startAutodiscovery({ serversDir: serversDir2, projectsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
@@ -5986,8 +6414,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve14(homedir2(), ".syntaur", "dashboard-port");
-          writeFile3(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve15(syntaurRoot(), "dashboard-port");
+          writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -6000,12 +6428,13 @@ function createDashboardServer(options) {
       }
       closeSessionDb();
       for (const client of clients) {
-        client.close();
+        client.terminate();
       }
       clients.clear();
-      const portFile = resolve14(homedir2(), ".syntaur", "dashboard-port");
-      await unlink3(portFile).catch(() => {
+      const portFile = resolve15(syntaurRoot(), "dashboard-port");
+      await unlink4(portFile).catch(() => {
       });
+      server.closeAllConnections?.();
       return new Promise((resolvePromise) => {
         server.close(() => resolvePromise());
       });