syntaur 0.1.14 → 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,41 +410,11 @@ 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");
-}
-function serversDir() {
-  return resolve2(syntaurRoot(), "servers");
-}
-function playbooksDir() {
-  return resolve2(syntaurRoot(), "playbooks");
-}
-function todosDir() {
-  return resolve2(syntaurRoot(), "todos");
-}
-var init_paths = __esm({
-  "src/utils/paths.ts"() {
-    "use strict";
-  }
-});
-
 // src/templates/config.ts
 function renderConfig(params) {
   return `---
 version: "1.0"
-defaultMissionDir: ${params.defaultMissionDir}
+defaultProjectDir: ${params.defaultProjectDir}
 onboarding:
   completed: false
 agentDefaults:
@@ -416,7 +422,7 @@ agentDefaults:
   autoApprove: false
 backup:
   repo: null
-  categories: missions, playbooks, todos, servers, config
+  categories: projects, playbooks, todos, servers, config
   lastBackup: null
   lastRestore: null
 ---
@@ -628,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}
 ---
 `;
@@ -640,7 +646,7 @@ ${statusBlock}
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
-version: "1.0"
+version: "2.0"
 ${statusBlock}
 ---
 ${existing}`;
@@ -696,18 +702,18 @@ async function updateBackupConfig(backup) {
   const current = (await readConfig()).backup;
   const nextBackup = {
     repo: current?.repo ?? null,
-    categories: current?.categories ?? "missions, playbooks, todos, servers, config",
+    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({ defaultMissionDir: defaultMissionDir() });
+  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: "1.0"
-defaultMissionDir: ${defaultMissionDir()}
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
 ${backupBlock}
 ---
 ${existing}`;
@@ -736,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"
     },
@@ -769,11 +775,12 @@ async function readConfig() {
     },
     backup: fm["backup.repo"] || fm["backup.categories"] ? {
       repo: fm["backup.repo"] && fm["backup.repo"] !== "null" ? fm["backup.repo"] : null,
-      categories: fm["backup.categories"] || "missions, playbooks, todos, servers, config",
+      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)
+    statuses: parseStatusConfig(content),
+    types: null
   };
 }
 var DEFAULT_CONFIG;
@@ -784,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
       },
@@ -799,7 +806,8 @@ var init_config2 = __esm({
         codexMarketplacePath: null
       },
       backup: null,
-      statuses: null
+      statuses: null,
+      types: null
     };
   }
 });
@@ -852,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") ?? "",
@@ -883,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
   };
@@ -931,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"),
@@ -1050,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",
@@ -1068,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",
@@ -1112,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."
       },
       {
@@ -1139,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"
       },
       {
@@ -1179,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: [
@@ -1223,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]
       },
       {
@@ -1242,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",
@@ -1257,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" }
     ]
   };
 }
@@ -1286,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) ---
@@ -1361,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"
       },
       {
@@ -1393,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]
       },
       {
@@ -1415,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: "/"
       }
@@ -1483,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("---", "");
@@ -1520,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");
@@ -1725,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);
@@ -1744,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,
@@ -1773,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 };
       }
     }
   }
@@ -1850,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
         };
@@ -1912,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
     };
@@ -1942,14 +1952,14 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
-async function scanAllSessions(serversDir2, 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(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(serversDir2, name);
@@ -1964,11 +1974,11 @@ async function scanAllSessions(serversDir2, missionsDir, options) {
   cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
   return result;
 }
-async function scanSingleSession(serversDir2, missionsDir, 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);
   }
@@ -2045,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);
@@ -2059,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;
     }
@@ -2080,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, serversDir2) {
-  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 (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir2, 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);
@@ -2117,50 +2127,50 @@ async function getOverview(missionsDir, serversDir2) {
   }
   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, serversDir2) {
-  const missionRecords = await listMissionRecords(missionsDir);
-  const items = buildAttentionItems(missionRecords);
+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(serversDir2, 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",
@@ -2197,13 +2207,13 @@ async function getAttention(missionsDir, serversDir2) {
     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)
         )
       )
     )
@@ -2216,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;
@@ -2320,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,
@@ -2342,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;
@@ -2369,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
       });
@@ -2381,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",
@@ -2393,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",
@@ -2406,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 [];
   }
@@ -2470,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 [];
   }
@@ -2496,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 [];
   }
@@ -2522,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);
@@ -2534,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";
@@ -2580,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
     )
@@ -2621,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(", ")}.`;
       }
@@ -2651,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;
@@ -2668,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
       };
@@ -2720,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({
@@ -2740,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.`
       });
@@ -2777,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;
@@ -2786,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":
@@ -2819,9 +2829,9 @@ 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(playbooksDir2) {
@@ -2862,7 +2872,7 @@ async function getPlaybookDetail(playbooksDir2, 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";
@@ -2874,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 = [
       {
@@ -3211,11 +3221,11 @@ var init_parser2 = __esm({
 });
 
 // src/dashboard/server.ts
+init_paths();
 init_api();
 import express from "express";
 import { createServer } from "http";
 import { resolve as resolve15 } from "path";
-import { homedir as homedir2 } from "os";
 import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -3223,34 +3233,34 @@ import { WebSocketServer, WebSocket } from "ws";
 import { watch } from "chokidar";
 import { relative, sep } from "path";
 function createWatcher(options) {
-  const { missionsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, 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()
         };
@@ -3258,9 +3268,9 @@ 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 (serversDir2) {
     let handleServerChange2 = function() {
@@ -3354,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();
@@ -3442,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)
@@ -3459,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)
 `;
 }
 
@@ -3477,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}` : "";
@@ -3499,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
 
@@ -3507,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);
@@ -3551,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}"
@@ -3584,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 `---
@@ -3678,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:
@@ -3698,7 +3645,7 @@ by_status:
 }
 function renderIndexPlans(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 ---
 
@@ -3710,7 +3657,7 @@ generated: "${params.timestamp}"
 }
 function renderIndexDecisions(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 ---
 
@@ -3722,7 +3669,7 @@ generated: "${params.timestamp}"
 }
 function renderStatus(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 status: pending
 progress:
@@ -3736,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
@@ -3761,7 +3708,7 @@ No dependencies yet.
 }
 function renderResourcesIndex(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 ---
@@ -3774,7 +3721,7 @@ total: 0
 }
 function renderMemoriesIndex(params) {
   return `---
-mission: ${params.slug}
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 ---
@@ -3907,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 });
@@ -3930,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
@@ -3954,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
@@ -3969,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
@@ -3984,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
@@ -3999,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
@@ -4014,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) {
@@ -4035,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);
@@ -4108,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 })]
@@ -4136,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"
@@ -4210,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"
@@ -4246,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"
@@ -4284,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"
@@ -4322,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"
@@ -4360,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"
@@ -4398,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 || {};
@@ -4418,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 || {};
@@ -4444,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"
@@ -4484,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();
@@ -4502,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
@@ -4518,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}` });
@@ -4549,11 +4492,11 @@ function createWriteRouter(missionsDir) {
 init_servers();
 init_scanner();
 import { Router as Router2 } from "express";
-function createServersRouter(serversDir2, missionsDir) {
+function createServersRouter(serversDir2, projectsDir) {
   const router = Router2();
   router.get("/", async (_req, res) => {
     try {
-      const result = await scanAllSessions(serversDir2, missionsDir);
+      const result = await scanAllSessions(serversDir2, projectsDir);
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
@@ -4561,7 +4504,7 @@ function createServersRouter(serversDir2, missionsDir) {
   });
   router.get("/:name", async (req, res) => {
     try {
-      const session = await scanSingleSession(serversDir2, missionsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name);
       if (!session) {
         res.status(404).json({ error: "Session not found" });
         return;
@@ -4612,7 +4555,7 @@ function createServersRouter(serversDir2, missionsDir) {
         await updateLastRefreshed(serversDir2, name);
       }
       clearScanCache();
-      const result = await scanAllSessions(serversDir2, 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" });
@@ -4627,7 +4570,7 @@ function createServersRouter(serversDir2, missionsDir) {
       }
       await updateLastRefreshed(serversDir2, req.params.name);
       clearScanCache();
-      const session = await scanSingleSession(serversDir2, 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" });
@@ -4642,7 +4585,7 @@ function createServersRouter(serversDir2, missionsDir) {
         return;
       }
       const body = req.body;
-      if (body === null || body && body.mission && body.assignment) {
+      if (body === null || body && body.project && body.assignment) {
         await setOverride(
           serversDir2,
           name,
@@ -4653,7 +4596,7 @@ function createServersRouter(serversDir2, 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" });
@@ -4683,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,
@@ -4694,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);
 `;
@@ -4714,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,
@@ -4725,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';
     `);
@@ -4750,36 +4693,36 @@ 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) {
+async function parseMarkdownSessionsIndex(filePath, projectSlug) {
   const { readFile: readFile12 } = await import("fs/promises");
   const raw = await readFile12(filePath, "utf-8");
   const sessions = [];
@@ -4808,7 +4751,7 @@ async function parseMarkdownSessionsIndex(filePath, missionSlug) {
           started: cells[3],
           status: cells[4] || "active",
           path: cells[5],
-          missionSlug
+          projectSlug
         });
       }
     }
@@ -4820,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,
@@ -4830,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,
@@ -4846,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(
@@ -4856,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) {
@@ -4880,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";
@@ -4919,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" });
@@ -4948,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,
@@ -5619,7 +5562,7 @@ import { cp, mkdtemp, rm as rm2, readFile as readFile11, writeFile as writeFile3
 import { resolve as resolve14, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
-var VALID_CATEGORIES = ["missions", "playbooks", "todos", "servers", "config"];
+var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
 var LOCK_FILE_NAME = ".backup-lock";
 function parseCategoriesStrict(cats) {
   const unknown = [];
@@ -5645,9 +5588,9 @@ function validateRepoUrl(url) {
 }
 async function resolveCategoryPath(category) {
   switch (category) {
-    case "missions": {
+    case "projects": {
       const config = await readConfig();
-      return { sourcePath: config.defaultMissionDir, repoPath: "missions", isFile: false };
+      return { sourcePath: config.defaultProjectDir, repoPath: "projects", isFile: false };
     }
     case "playbooks":
       return { sourcePath: playbooksDir(), repoPath: "playbooks", isFile: false };
@@ -5737,7 +5680,7 @@ async function backupToGithub(overrides) {
   if (!validateRepoUrl(repo)) {
     throw new Error(`Invalid repo URL: "${rawRepo}". Must start with https:// or git@.`);
   }
-  const categoriesCsv = config.backup?.categories ?? "missions, playbooks, todos, servers, config";
+  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.");
@@ -5866,7 +5809,7 @@ async function restoreFromGithub(overrides) {
   if (!validateRepoUrl(repo)) {
     throw new Error(`Invalid repo URL: "${rawRepo}".`);
   }
-  const categoriesCsv = config.backup?.categories ?? "missions, playbooks, todos, servers, config";
+  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.");
@@ -5921,7 +5864,7 @@ async function getBackupStatus() {
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
-    categories: config.backup?.categories ?? "missions, playbooks, todos, servers, config",
+    categories: config.backup?.categories ?? "projects, playbooks, todos, servers, config",
     lastBackup: config.backup?.lastBackup ?? null,
     lastRestore: config.backup?.lastRestore ?? null,
     locked
@@ -6072,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;
@@ -6083,10 +6026,10 @@ async function listAllTmuxSessions() {
   if (!output) return [];
   return output.split("\n").filter((line) => line.length > 0);
 }
-async function discoverTmuxSessions(serversDir2, 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;
@@ -6127,8 +6070,8 @@ async function getProcessCwd(pid) {
   }
   return null;
 }
-async function discoverProcesses(serversDir2, 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;
@@ -6193,7 +6136,7 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir2, missionsDir, excludePids) {
+async function reconcile(serversDir2, projectsDir, excludePids) {
   const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
@@ -6205,8 +6148,8 @@ async function reconcile(serversDir2, missionsDir, excludePids) {
     existingFiles.delete(name);
   }
   const existingNames = new Set(existingFiles.keys());
-  const tmuxChanged = await discoverTmuxSessions(serversDir2, missionsDir, existingNames);
-  const processChanged = await discoverProcesses(serversDir2, missionsDir, existingFiles, excludePids);
+  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir, existingNames);
+  const processChanged = await discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids);
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
@@ -6214,7 +6157,7 @@ async function reconcile(serversDir2, missionsDir, excludePids) {
 
 // src/dashboard/server.ts
 function createDashboardServer(options) {
-  const { port, missionsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, 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 });
@@ -6248,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, serversDir2);
+      const overview = await getOverview(projectsDir, serversDir2);
       res.json(overview);
     } catch (error) {
       console.error("Error getting overview:", error);
@@ -6263,7 +6206,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/attention", async (_req, res) => {
     try {
-      const attention = await getAttention(missionsDir, serversDir2);
+      const attention = await getAttention(projectsDir, serversDir2);
       res.json(attention);
     } catch (error) {
       console.error("Error getting attention queue:", error);
@@ -6330,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);
@@ -6363,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);
@@ -6373,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);
@@ -6383,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);
@@ -6398,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;
       }
@@ -6430,9 +6373,9 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to get assignment detail" });
     }
   });
-  app.use(createWriteRouter(missionsDir));
-  app.use("/api/servers", createServersRouter(serversDir2, missionsDir));
-  app.use("/api/agent-sessions", createAgentSessionsRouter(missionsDir, 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());
@@ -6453,13 +6396,13 @@ function createDashboardServer(options) {
   return {
     async start() {
       watcherHandle = createWatcher({
-        missionsDir,
+        projectsDir,
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
         onMessage: broadcast
       });
-      startAutodiscovery({ serversDir: serversDir2, 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") {
@@ -6471,7 +6414,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve15(homedir2(), ".syntaur", "dashboard-port");
+          const portFile = resolve15(syntaurRoot(), "dashboard-port");
           writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -6485,12 +6428,13 @@ function createDashboardServer(options) {
       }
       closeSessionDb();
       for (const client of clients) {
-        client.close();
+        client.terminate();
       }
       clients.clear();
-      const portFile = resolve15(homedir2(), ".syntaur", "dashboard-port");
+      const portFile = resolve15(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
+      server.closeAllConnections?.();
       return new Promise((resolvePromise) => {
         server.close(() => resolvePromise());
       });