syntaur 0.3.0 → 0.4.0

package/dist/dashboard/server.js

@@ -484,9 +484,144 @@ var init_config = __esm({
   }
 });
 
+// src/utils/fs-migration.ts
+import { readdir, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+async function migrateLegacyProjectFiles(projectsDir) {
+  const result = {
+    renamedProjectFiles: [],
+    legacyExtras: []
+  };
+  if (!await fileExists(projectsDir)) return result;
+  let entries;
+  try {
+    entries = await readdir(projectsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectDir = resolve3(projectsDir, entry.name);
+    const legacy = resolve3(projectDir, "mission.md");
+    const target = resolve3(projectDir, "project.md");
+    try {
+      if (await fileExists(legacy) && !await fileExists(target)) {
+        await rename2(legacy, target);
+        result.renamedProjectFiles.push(`${entry.name}/mission.md`);
+      }
+    } catch {
+      continue;
+    }
+    for (const stale of ["agent.md", "claude.md"]) {
+      try {
+        if (await fileExists(resolve3(projectDir, stale))) {
+          result.legacyExtras.push(`${entry.name}/${stale}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function migrateLegacyConfig(configPath) {
+  const result = {
+    renamedField: false,
+    renamedDir: false,
+    resolvedProjectsDir: null
+  };
+  if (!await fileExists(configPath)) return result;
+  let content;
+  try {
+    content = await readFile2(configPath, "utf-8");
+  } catch {
+    return result;
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!fmMatch) return result;
+  const fmBlock = fmMatch[1];
+  const afterFm = content.slice(fmMatch[0].length);
+  const missionLineRe = /^(\s*)defaultMissionDir\s*:\s*(.*)$/m;
+  const missionLineMatch = fmBlock.match(missionLineRe);
+  const hasProjectLine = /^\s*defaultProjectDir\s*:/m.test(fmBlock);
+  let newFmBlock = fmBlock;
+  let missionValue = null;
+  if (missionLineMatch) {
+    missionValue = missionLineMatch[2].trim();
+    if (!hasProjectLine) {
+      newFmBlock = fmBlock.replace(
+        missionLineRe,
+        `$1defaultProjectDir: ${missionValue}`
+      );
+      result.renamedField = true;
+    } else {
+      newFmBlock = fmBlock.replace(missionLineRe, "").replace(/\n{2,}/g, "\n");
+      result.renamedField = true;
+    }
+  }
+  const projectLineRe = /^\s*defaultProjectDir\s*:\s*(.*)$/m;
+  const projectLineMatch = newFmBlock.match(projectLineRe);
+  const projectsDirRaw = projectLineMatch ? projectLineMatch[1].trim().replace(/^['"]|['"]$/g, "") : missionValue;
+  const expand = (p) => p.startsWith("~") ? resolve3(process.env.HOME ?? "/", p.slice(p.startsWith("~/") ? 2 : 1)) : p;
+  let resolvedProjectsDir = projectsDirRaw ? expand(projectsDirRaw) : null;
+  if (resolvedProjectsDir && resolvedProjectsDir.endsWith("/missions")) {
+    const siblingProjectsDir = resolvedProjectsDir.replace(/\/missions$/, "/projects");
+    if (await fileExists(resolvedProjectsDir) && !await fileExists(siblingProjectsDir)) {
+      try {
+        await rename2(resolvedProjectsDir, siblingProjectsDir);
+        const newValue = projectsDirRaw.endsWith("/missions") ? projectsDirRaw.replace(/\/missions$/, "/projects") : siblingProjectsDir;
+        newFmBlock = newFmBlock.replace(
+          projectLineRe,
+          `defaultProjectDir: ${newValue}`
+        );
+        resolvedProjectsDir = siblingProjectsDir;
+        result.renamedDir = true;
+      } catch {
+      }
+    }
+  }
+  result.resolvedProjectsDir = resolvedProjectsDir;
+  if (result.renamedField || result.renamedDir) {
+    const newContent = `---
+${newFmBlock.replace(/\n+$/, "")}
+---
+${afterFm.startsWith("\n") ? afterFm.slice(1) : afterFm}`;
+    try {
+      await writeFile2(configPath, newContent, "utf-8");
+    } catch {
+      result.renamedField = false;
+      result.renamedDir = false;
+    }
+  }
+  return result;
+}
+function summarizeMigration(project, config) {
+  const parts = [];
+  if (project.renamedProjectFiles.length > 0) {
+    const firstThree = project.renamedProjectFiles.map((p) => p.split("/")[0]).slice(0, 3).join(", ");
+    const more = project.renamedProjectFiles.length > 3 ? ` and ${project.renamedProjectFiles.length - 3} more` : "";
+    parts.push(
+      `renamed mission.md \u2192 project.md in ${project.renamedProjectFiles.length} project${project.renamedProjectFiles.length === 1 ? "" : "s"} (${firstThree}${more})`
+    );
+  }
+  if (config?.renamedField) parts.push("updated config defaultMissionDir \u2192 defaultProjectDir");
+  if (config?.renamedDir) parts.push("renamed projects directory on disk");
+  if (project.legacyExtras.length > 0) {
+    parts.push(
+      `${project.legacyExtras.length} legacy agent.md / claude.md file${project.legacyExtras.length === 1 ? "" : "s"} left in place (no longer read)`
+    );
+  }
+  return parts.length ? `[syntaur] legacy migration: ${parts.join("; ")}` : "";
+}
+var init_fs_migration = __esm({
+  "src/utils/fs-migration.ts"() {
+    "use strict";
+    init_fs();
+  }
+});
+
 // src/utils/config.ts
-import { readFile as readFile2 } from "fs/promises";
-import { resolve as resolve3, isAbsolute } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve4, isAbsolute } from "path";
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -673,10 +808,10 @@ function parseOptionalAbsolutePath(value, fieldName) {
     );
     return null;
   }
-  return resolve3(expanded);
+  return resolve4(expanded);
 }
 async function writeStatusConfig(statuses) {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   const statusBlock = serializeStatusConfig(statuses);
   if (!await fileExists(configPath)) {
     const content = `---
@@ -688,7 +823,7 @@ ${statusBlock}
     await writeFileForce(configPath, content);
     return;
   }
-  const existing = await readFile2(configPath, "utf-8");
+  const existing = await readFile3(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -730,9 +865,9 @@ ${statusBlock}
   await writeFileForce(configPath, newContent);
 }
 async function deleteStatusConfig() {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return;
-  const existing = await readFile2(configPath, "utf-8");
+  const existing = await readFile3(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) return;
   const fmBlock = fmMatch[2];
@@ -744,7 +879,7 @@ ${cleanedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateBackupConfig(backup) {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   const current = (await readConfig()).backup;
   const nextBackup = {
     repo: current?.repo ?? null,
@@ -754,7 +889,7 @@ async function updateBackupConfig(backup) {
     ...backup
   };
   const backupBlock = serializeBackupConfig(nextBackup);
-  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -778,11 +913,15 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function readConfig() {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
-  const content = await readFile2(configPath, "utf-8");
+  if (!migratedConfigPaths.has(configPath)) {
+    migratedConfigPaths.add(configPath);
+    await migrateLegacyConfig(configPath);
+  }
+  const content = await readFile3(configPath, "utf-8");
   const fm = parseFrontmatter(content);
   if (Object.keys(fm).length === 0) {
     console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
@@ -829,13 +968,14 @@ async function readConfig() {
     types: null
   };
 }
-var DEFAULT_CONFIG;
+var DEFAULT_CONFIG, migratedConfigPaths;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
     init_paths();
     init_fs();
     init_config();
+    init_fs_migration();
     DEFAULT_CONFIG = {
       version: "2.0",
       defaultProjectDir: defaultProjectDir(),
@@ -855,6 +995,7 @@ var init_config2 = __esm({
       statuses: null,
       types: null
     };
+    migratedConfigPaths = /* @__PURE__ */ new Set();
   }
 });
 
@@ -908,9 +1049,10 @@ function parseListField(frontmatter, fieldName) {
 }
 function parseProject(fileContent) {
   const [fm, body] = extractFrontmatter2(fileContent);
+  const slug = getField(fm, "slug") ?? getField(fm, "mission") ?? "";
   return {
     id: getField(fm, "id") ?? "",
-    slug: getField(fm, "slug") ?? "",
+    slug,
     title: getField(fm, "title") ?? "",
     archived: getField(fm, "archived") === "true",
     archivedAt: getField(fm, "archivedAt"),
@@ -1143,13 +1285,13 @@ var init_parser = __esm({
 });
 
 // src/utils/assignment-resolver.ts
-import { resolve as resolve4 } from "path";
-import { readdir, readFile as readFile3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
 async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
   let standaloneMatch = null;
   let projectMatch = null;
-  const standaloneDir = resolve4(assignmentsDir, id);
-  const standalonePath = resolve4(standaloneDir, "assignment.md");
+  const standaloneDir = resolve5(assignmentsDir, id);
+  const standalonePath = resolve5(standaloneDir, "assignment.md");
   if (await fileExists(standalonePath)) {
     standaloneMatch = {
       assignmentDir: standaloneDir,
@@ -1161,24 +1303,24 @@ async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
   }
   if (await fileExists(projectsDir)) {
     try {
-      const projects = await readdir(projectsDir, { withFileTypes: true });
+      const projects = await readdir2(projectsDir, { withFileTypes: true });
       for (const p of projects) {
         if (!p.isDirectory()) continue;
         if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
-        const assignmentsPath = resolve4(projectsDir, p.name, "assignments");
+        const assignmentsPath = resolve5(projectsDir, p.name, "assignments");
         if (!await fileExists(assignmentsPath)) continue;
-        const entries = await readdir(assignmentsPath, { withFileTypes: true });
+        const entries = await readdir2(assignmentsPath, { withFileTypes: true });
         for (const a of entries) {
           if (!a.isDirectory()) continue;
-          const aPath = resolve4(assignmentsPath, a.name, "assignment.md");
+          const aPath = resolve5(assignmentsPath, a.name, "assignment.md");
           if (!await fileExists(aPath)) continue;
           try {
-            const content = await readFile3(aPath, "utf-8");
+            const content = await readFile4(aPath, "utf-8");
             const [fm] = extractFrontmatter2(content);
             const fileId = getField(fm, "id");
             if (fileId === id) {
               projectMatch = {
-                assignmentDir: resolve4(assignmentsPath, a.name),
+                assignmentDir: resolve5(assignmentsPath, a.name),
                 projectSlug: p.name,
                 assignmentSlug: a.name,
                 id,
@@ -1542,8 +1684,8 @@ var init_help = __esm({
       // --- Session & server tracking (index 17) ---
       {
         command: "syntaur track-session",
-        description: "Register an agent session, optionally linked to a project and assignment.",
-        example: "syntaur track-session --agent claude --project ui-overhaul --assignment implement-overview"
+        description: "Register an agent session. Requires --session-id from the agent runtime (real, not generated). Pass --transcript-path for the rollout/transcript file. --project and --assignment are optional.",
+        example: "syntaur track-session --agent claude --session-id <real-id> --transcript-path <path> --project ui-overhaul --assignment implement-overview"
       },
       // --- Browsing & playbooks (indices 18-20) ---
       {
@@ -1626,8 +1768,8 @@ var init_help = __esm({
 });
 
 // src/dashboard/servers.ts
-import { readdir as readdir2, readFile as readFile4, unlink } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { readdir as readdir3, readFile as readFile5, unlink } from "fs/promises";
+import { resolve as resolve6 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1675,18 +1817,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve5(dir, `${name}.md`), content);
+  await writeFileForce(resolve6(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir2(dir);
+  const entries = await readdir3(dir);
   return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
 }
 async function readSessionFile(dir, name) {
-  const filePath = resolve5(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve6(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile4(filePath, "utf-8");
+  const raw = await readFile5(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter2(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1726,7 +1868,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve5(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve6(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1735,7 +1877,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve5(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve6(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1747,7 +1889,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve5(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve6(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1764,7 +1906,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve5(dir, `${name}.md`), content);
+  await writeFileForce(resolve6(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1796,8 +1938,8 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve6 } from "path";
-import { realpath, readdir as readdir3, readFile as readFile5 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { realpath, readdir as readdir4, readFile as readFile6 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -1892,8 +2034,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve6(cwd, commonDir));
-      const resolvedGit = await realpath(resolve6(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve7(cwd, commonDir));
+      const resolvedGit = await realpath(resolve7(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -1906,17 +2048,17 @@ async function loadWorkspaceRecords(projectsDir, assignmentsDir) {
   try {
     const projects = await listProjects(projectsDir);
     for (const project of projects) {
-      const projectAssignmentsDir = resolve6(projectsDir, project.slug, "assignments");
+      const projectAssignmentsDir = resolve7(projectsDir, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir3(projectAssignmentsDir);
+        slugs = await readdir4(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve6(projectAssignmentsDir, aslug, "assignment.md");
+        const aFile = resolve7(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile5(aFile, "utf-8");
+          const raw = await readFile6(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -1935,12 +2077,12 @@ async function loadWorkspaceRecords(projectsDir, assignmentsDir) {
   }
   if (assignmentsDir) {
     try {
-      const entries = await readdir3(assignmentsDir);
+      const entries = await readdir4(assignmentsDir);
       for (const id of entries) {
         if (id.startsWith(".") || id.startsWith("_")) continue;
-        const aFile = resolve6(assignmentsDir, id, "assignment.md");
+        const aFile = resolve7(assignmentsDir, id, "assignment.md");
         try {
-          const raw = await readFile5(aFile, "utf-8");
+          const raw = await readFile6(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -2188,20 +2330,20 @@ var init_scanner = __esm({
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir4, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve7, dirname as dirname2 } from "path";
+import { readdir as readdir5, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve8, dirname as dirname2 } from "path";
 async function listStandaloneRecords(assignmentsDir) {
   if (!assignmentsDir) return [];
   if (!await fileExists(assignmentsDir)) return [];
-  const entries = await readdir4(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve7(assignmentsDir, entry.name);
-    const assignmentMdPath = resolve7(assignmentDir, "assignment.md");
+    const assignmentDir = resolve8(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile6(assignmentMdPath, "utf-8");
+      const content = await readFile7(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -2270,9 +2412,9 @@ async function listProjects(projectsDir) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve7(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw = await readFile6(registryPath, "utf-8");
+    const raw = await readFile7(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -2280,8 +2422,8 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve7(dirname2(projectsDir), "workspaces.json");
-  await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
+  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
+  await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir) {
   const [projectRecords, registered] = await Promise.all([
@@ -2480,7 +2622,7 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -2504,9 +2646,9 @@ async function getEditableDocumentById(projectsDir, assignmentsDir, documentType
   }
   const fileName = documentType === "assignment" ? "assignment.md" : documentType === "plan" ? "plan.md" : documentType === "scratchpad" ? "scratchpad.md" : documentType === "handoff" ? "handoff.md" : documentType === "decision-record" ? "decision-record.md" : null;
   if (!fileName) return null;
-  const filePath = resolve7(resolved.assignmentDir, fileName);
+  const filePath = resolve8(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const label = resolved.id;
   const title = documentType === "assignment" ? `Edit Assignment: ${label}` : documentType === "plan" ? `Edit Plan: ${label}` : documentType === "scratchpad" ? `Edit Scratchpad: ${label}` : documentType === "handoff" ? `Append Handoff: ${label}` : `Append Decision: ${label}`;
   return {
@@ -2520,12 +2662,12 @@ async function getEditableDocumentById(projectsDir, assignmentsDir, documentType
   };
 }
 async function getProjectDetail(projectsDir, slug) {
-  const projectPath = resolve7(projectsDir, slug);
-  const projectMdPath = resolve7(projectPath, "project.md");
+  const projectPath = resolve8(projectsDir, slug);
+  const projectMdPath = resolve8(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile6(projectMdPath, "utf-8");
+  const projectContent = await readFile7(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
   const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -2555,17 +2697,17 @@ async function getProjectDetail(projectsDir, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve7(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve7(assignmentDir, "assignment.md");
+  const assignmentDir = resolve8(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile6(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile7(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve7(assignmentDir, "plan.md");
+  const planPath = resolve8(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile6(planPath, "utf-8");
+    const planContent = await readFile7(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2574,9 +2716,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve7(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile6(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile7(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2584,9 +2726,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve7(assignmentDir, "handoff.md");
+  const handoffPath = resolve8(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile6(handoffPath, "utf-8");
+    const handoffContent = await readFile7(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2595,9 +2737,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve7(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile6(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile7(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2606,9 +2748,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve7(assignmentDir, "progress.md");
+  const progressPath = resolve8(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile6(progressPath, "utf-8");
+    const progressContent = await readFile7(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -2617,9 +2759,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve7(assignmentDir, "comments.md");
+  const commentsPath = resolve8(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile6(commentsPath, "utf-8");
+    const commentsContent = await readFile7(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -2733,7 +2875,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve7(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve8(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -2766,17 +2908,17 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve7(sourceDir, "assignment.md");
+  const assignmentMd = resolve8(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile6(assignmentMd, "utf-8");
+    const content = await readFile7(assignmentMd, "utf-8");
     const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
     if (todosMatch) bodies.push(todosMatch[1]);
   }
   for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
-    const path = resolve7(sourceDir, filename);
+    const path = resolve8(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile6(path, "utf-8"));
+        bodies.push(await readFile7(path, "utf-8"));
       } catch {
       }
     }
@@ -2834,44 +2976,44 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve7(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile6(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile7(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve7(assignmentDir, "plan.md");
+  const planPath = resolve8(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile6(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile7(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve7(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile6(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile7(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve7(assignmentDir, "handoff.md");
+  const handoffPath = resolve8(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile6(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile7(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve7(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile6(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile7(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve7(assignmentDir, "progress.md");
+  const progressPath = resolve8(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile6(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile7(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve7(assignmentDir, "comments.md");
+  const commentsPath = resolve8(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile6(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile7(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   const detail = {
@@ -2909,16 +3051,20 @@ async function listProjectRecords(projectsDir) {
   if (!await fileExists(projectsDir)) {
     return [];
   }
-  const entries = await readdir4(projectsDir, { withFileTypes: true });
+  if (!migratedProjectsDirs.has(projectsDir)) {
+    migratedProjectsDirs.add(projectsDir);
+    await migrateLegacyProjectFiles(projectsDir);
+  }
+  const entries = await readdir5(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const records = [];
   for (const entry of projectDirs) {
-    const projectPath = resolve7(projectsDir, entry.name);
-    const projectMdPath = resolve7(projectPath, "project.md");
+    const projectPath = resolve8(projectsDir, entry.name);
+    const projectMdPath = resolve8(projectPath, "project.md");
     if (!await fileExists(projectMdPath)) {
       continue;
     }
-    const projectContent = await readFile6(projectMdPath, "utf-8");
+    const projectContent = await readFile7(projectMdPath, "utf-8");
     const project = parseProject(projectContent);
     const assignments = await listAssignmentRecords(projectPath);
     const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -2949,39 +3095,39 @@ async function listProjectRecords(projectsDir) {
   return records;
 }
 async function listAssignmentRecords(projectPath) {
-  const assignmentsDir = resolve7(projectPath, "assignments");
+  const assignmentsDir = resolve8(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
-  const entries = await readdir4(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const assignmentMd = resolve7(assignmentsDir, entry.name, "assignment.md");
+    const assignmentMd = resolve8(assignmentsDir, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       continue;
     }
-    const content = await readFile6(assignmentMd, "utf-8");
+    const content = await readFile7(assignmentMd, "utf-8");
     records.push(parseAssignmentFull(content));
   }
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve7(projectPath, "resources");
+  const resourcesDir = resolve8(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir4(resourcesDir, { withFileTypes: true });
+  const entries = await readdir5(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve7(resourcesDir, entry.name);
-    const content = await readFile6(filePath, "utf-8");
+    const filePath = resolve8(resourcesDir, entry.name);
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -2996,18 +3142,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve7(projectPath, "memories");
+  const memoriesDir = resolve8(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir4(memoriesDir, { withFileTypes: true });
+  const entries = await readdir5(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve7(memoriesDir, entry.name);
-    const content = await readFile6(filePath, "utf-8");
+    const filePath = resolve8(memoriesDir, entry.name);
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -3022,9 +3168,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve7(projectPath, "_status.md");
+  const statusPath = resolve8(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile6(statusPath, "utf-8");
+    const statusContent = await readFile7(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -3124,7 +3270,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve7(projectsDir, projectSlug);
+  const projectPath = resolve8(projectsDir, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -3154,12 +3300,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve7(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve8(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile6(dependencyPath, "utf-8");
+    const content = await readFile7(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -3314,7 +3460,7 @@ function isStale(updated) {
   return Date.now() - timestamp > STALE_ASSIGNMENT_MS;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve7(
+  const commentsPath = resolve8(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -3324,7 +3470,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile6(commentsPath, "utf-8");
+    const content = await readFile7(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -3345,17 +3491,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve7(projectsDir, projectSlug, "project.md");
+      return resolve8(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -3382,12 +3528,12 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return [];
-  const entries = await readdir4(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve7(playbooksDir2, entry.name);
-    const raw = await readFile6(filePath, "utf-8");
+    const filePath = resolve8(playbooksDir2, entry.name);
+    const raw = await readFile7(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -3403,9 +3549,9 @@ async function listPlaybooks(playbooksDir2) {
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
 async function getPlaybookDetail(playbooksDir2, slug) {
-  const filePath = resolve7(playbooksDir2, `${slug}.md`);
+  const filePath = resolve8(playbooksDir2, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile6(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
   return {
     slug: parsed.slug || slug,
@@ -3418,13 +3564,14 @@ async function getPlaybookDetail(playbooksDir2, slug) {
     body: parsed.body
   };
 }
-var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, 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, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
 var init_api = __esm({
   "src/dashboard/api.ts"() {
     "use strict";
     init_lifecycle();
     init_fs();
     init_config2();
+    init_fs_migration();
     init_assignment_resolver();
     init_parser();
     init_help();
@@ -3487,6 +3634,7 @@ var init_api = __esm({
     };
     _cachedConfig = null;
     REFERENCED_BY_LIMIT = 50;
+    migratedProjectsDirs = /* @__PURE__ */ new Set();
     DEFAULT_GRAPH_COLORS = {
       completed: "fill:#4ea84f,stroke:#1f6b29,color:#ffffff",
       in_progress: "fill:#1e6fd9,stroke:#0f3f8f,color:#ffffff",
@@ -3519,8 +3667,8 @@ __export(parser_exports, {
   writeChecklist: () => writeChecklist
 });
 import { randomBytes } from "crypto";
-import { readFile as readFile11 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { resolve as resolve15 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -3680,10 +3828,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve14(todosDir2, `${workspace}.md`);
+  return resolve15(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve14(todosDir2, `${workspace}-log.md`);
+  return resolve15(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -3707,14 +3855,14 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve14(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve15(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
 async function readChecklist(todosDir2, workspace) {
   const path = checklistPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, archiveInterval: "weekly", items: [] };
   }
-  const content = await readFile11(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseChecklist(content);
 }
 async function writeChecklist(todosDir2, checklist) {
@@ -3727,7 +3875,7 @@ async function readLog(todosDir2, workspace) {
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
-  const content = await readFile11(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseLog(content);
 }
 async function appendLogEntry2(todosDir2, workspace, entry) {
@@ -3735,7 +3883,7 @@ async function appendLogEntry2(todosDir2, workspace, entry) {
   const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
-    content = await readFile11(path, "utf-8");
+    content = await readFile12(path, "utf-8");
     content = content.trimEnd() + "\n\n" + serializeLogEntry(entry) + "\n";
   } else {
     const fm = `---
@@ -3774,21 +3922,21 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve16 } from "path";
-import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
+import { resolve as resolve17 } from "path";
+import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/agent-sessions.ts
 init_fs();
-import { readFile as readFile7 } from "fs/promises";
-import { resolve as resolve9 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve10 } from "path";
 
 // src/dashboard/session-db.ts
 init_paths();
 init_fs();
 import Database from "better-sqlite3";
-import { resolve as resolve8 } from "path";
-import { readdir as readdir5 } from "fs/promises";
+import { resolve as resolve9 } from "path";
+import { readdir as readdir6 } from "fs/promises";
 var db = null;
 var SCHEMA_VERSION = "3";
 var SCHEMA_SQL = `
@@ -3806,14 +3954,16 @@ 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_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);
 `;
+var POST_MIGRATION_INDEXES_SQL = `
+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);
+`;
 function initSessionDb(dbPath) {
   if (db) return db;
-  const finalPath = dbPath ?? resolve8(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve9(syntaurRoot(), "syntaur.db");
   db = new Database(finalPath);
   db.pragma("journal_mode = WAL");
   db.exec(SCHEMA_SQL);
@@ -3821,57 +3971,74 @@ function initSessionDb(dbPath) {
     "schema_version",
     SCHEMA_VERSION
   );
-  const currentVersion = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
-  if (currentVersion?.value === "1") {
-    db.exec(`
-      CREATE TABLE sessions_v2 (
-        session_id TEXT PRIMARY KEY,
-        project_slug TEXT,
-        assignment_slug TEXT,
-        agent TEXT NOT NULL,
-        started TEXT NOT NULL,
-        ended TEXT,
-        status TEXT NOT NULL DEFAULT 'active',
-        path TEXT,
-        description TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      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_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';
-    `);
-  }
-  const versionAfterV1 = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
-  if (versionAfterV1?.value === "2") {
-    db.exec(`
-      CREATE TABLE sessions_v3 (
-        session_id TEXT PRIMARY KEY,
-        project_slug TEXT,
-        assignment_slug TEXT,
-        agent TEXT NOT NULL,
-        started TEXT NOT NULL,
-        ended TEXT,
-        status TEXT NOT NULL DEFAULT 'active',
-        path TEXT,
-        description TEXT,
-        transcript_path TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      INSERT INTO sessions_v3 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at FROM sessions;
-      DROP TABLE sessions;
-      ALTER TABLE sessions_v3 RENAME TO sessions;
-      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
-      CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
-      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
-      UPDATE meta SET value = '3' WHERE key = 'schema_version';
-    `);
-  }
+  const database = db;
+  const runMigrations = database.transaction(() => {
+    const vBeforeV2 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV2 === "1") {
+      database.exec(`
+        CREATE TABLE sessions_v2 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        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_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';
+      `);
+    }
+    const vBeforeV3 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV3 === "2") {
+      const v2Columns = database.prepare("PRAGMA table_info(sessions)").all();
+      const v2ColNames = v2Columns.map((c) => c.name);
+      const hasProject = v2ColNames.includes("project_slug");
+      const hasMission = v2ColNames.includes("mission_slug");
+      const projectSlugExpr = hasProject && hasMission ? "COALESCE(project_slug, mission_slug)" : hasProject ? "project_slug" : hasMission ? "mission_slug" : null;
+      if (!projectSlugExpr) {
+        throw new Error(
+          "sessions table has neither project_slug nor mission_slug; cannot migrate from v2 to v3"
+        );
+      }
+      database.exec(`
+        CREATE TABLE sessions_v3 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          transcript_path TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v3
+          SELECT session_id, ${projectSlugExpr}, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v3 RENAME TO sessions;
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '3' WHERE key = 'schema_version';
+      `);
+    }
+  });
+  runMigrations.exclusive();
+  db.exec(POST_MIGRATION_INDEXES_SQL);
   return db;
 }
 function getSessionDb() {
@@ -3893,12 +4060,12 @@ async function migrateFromMarkdown(projectsDir) {
   const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
   if (count.count > 0) return 0;
   if (!await fileExists(projectsDir)) return 0;
-  const entries = await readdir5(projectsDir, { withFileTypes: true });
+  const entries = await readdir6(projectsDir, { withFileTypes: true });
   const allSessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const projectDir = resolve8(projectsDir, entry.name);
-    const indexPath = resolve8(projectDir, "_index-sessions.md");
+    const projectDir = resolve9(projectsDir, entry.name);
+    const indexPath = resolve9(projectDir, "_index-sessions.md");
     if (!await fileExists(indexPath)) continue;
     const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
     allSessions.push(...sessions);
@@ -3918,8 +4085,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile13 } = await import("fs/promises");
-  const raw = await readFile13(filePath, "utf-8");
+  const { readFile: readFile14 } = await import("fs/promises");
+  const raw = await readFile14(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -3975,13 +4142,13 @@ async function appendSession(_projectDir, session) {
     INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
-      project_slug    = COALESCE(excluded.project_slug,    project_slug),
-      assignment_slug = COALESCE(excluded.assignment_slug, assignment_slug),
+      project_slug    = COALESCE(NULLIF(excluded.project_slug, ''),    project_slug),
+      assignment_slug = COALESCE(NULLIF(excluded.assignment_slug, ''), assignment_slug),
       agent           = excluded.agent,
       status          = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
-      path            = COALESCE(excluded.path,            path),
-      description     = COALESCE(excluded.description,     description),
-      transcript_path = COALESCE(excluded.transcript_path, transcript_path),
+      path            = COALESCE(NULLIF(excluded.path, ''),            path),
+      description     = COALESCE(NULLIF(excluded.description, ''),     description),
+      transcript_path = COALESCE(NULLIF(excluded.transcript_path, ''), transcript_path),
       updated_at      = datetime('now')
   `).run(
     session.sessionId,
@@ -4031,13 +4198,13 @@ async function deleteSessions(sessionIds) {
 var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
 async function readAssignmentStatusFromPath(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
-  const raw = await readFile7(assignmentMdPath, "utf-8");
+  const raw = await readFile8(assignmentMdPath, "utf-8");
   const match = raw.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
 async function readAssignmentStatus(projectDir, assignmentSlug) {
   return readAssignmentStatusFromPath(
-    resolve9(projectDir, "assignments", assignmentSlug, "assignment.md")
+    resolve10(projectDir, "assignments", assignmentSlug, "assignment.md")
   );
 }
 async function reconcileActiveSessions(projectsDir, assignmentsDir) {
@@ -4055,13 +4222,13 @@ async function reconcileActiveSessions(projectsDir, assignmentsDir) {
     seen.add(key);
     if (session.project_slug) {
       const status = await readAssignmentStatus(
-        resolve9(projectsDir, session.project_slug),
+        resolve10(projectsDir, session.project_slug),
         aslug
       );
       if (status) assignmentStatuses.set(key, status);
     } else if (assignmentsDir) {
       const status = await readAssignmentStatusFromPath(
-        resolve9(assignmentsDir, aslug, "assignment.md")
+        resolve10(assignmentsDir, aslug, "assignment.md")
       );
       if (status) assignmentStatuses.set(key, status);
     }
@@ -4275,8 +4442,8 @@ init_config2();
 // src/dashboard/api-write.ts
 init_lifecycle();
 import { Router } from "express";
-import { resolve as resolve10 } from "path";
-import { rm, readFile as readFile8 } from "fs/promises";
+import { resolve as resolve11 } from "path";
+import { rm, readFile as readFile9 } from "fs/promises";
 
 // src/utils/slug.ts
 function isValidSlug(slug) {
@@ -4799,7 +4966,7 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile8(filePath, "utf-8");
+  return readFile9(filePath, "utf-8");
 }
 function createWriteRouter(projectsDir, assignmentsDir) {
   const router = Router();
@@ -4929,26 +5096,26 @@ function createWriteRouter(projectsDir, assignmentsDir) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve10(projectsDir, slug);
+      const projectDir = resolve11(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(resolve10(projectDir, "assignments"));
-      await ensureDir(resolve10(projectDir, "resources"));
-      await ensureDir(resolve10(projectDir, "memories"));
-      await writeFileForce(resolve10(projectDir, "project.md"), content);
+      await ensureDir(resolve11(projectDir, "assignments"));
+      await ensureDir(resolve11(projectDir, "resources"));
+      await ensureDir(resolve11(projectDir, "memories"));
+      await writeFileForce(resolve11(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve10(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve10(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve10(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve10(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve10(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve10(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve10(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve11(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve11(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve11(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve11(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve11(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve11(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve11(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -4969,8 +5136,8 @@ function createWriteRouter(projectsDir, assignmentsDir) {
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve10(projectsDir, projectSlug);
-      const projectMdPath = resolve10(projectDir, "project.md");
+      const projectDir = resolve11(projectsDir, projectSlug);
+      const projectMdPath = resolve11(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5000,7 +5167,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve10(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve11(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -5009,12 +5176,12 @@ function createWriteRouter(projectsDir, assignmentsDir) {
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve10(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve11(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve10(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve10(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve10(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve11(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve11(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve11(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -5035,7 +5202,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -5068,7 +5235,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve10(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5111,7 +5278,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve10(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5147,7 +5314,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve10(
+      const planPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5185,7 +5352,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve10(
+      const scratchpadPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5223,7 +5390,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve10(
+      const handoffPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5261,7 +5428,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve10(
+      const decisionPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5299,7 +5466,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve10(
+      const commentsPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5317,7 +5484,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile8(commentsPath, "utf-8");
+        currentContent = await readFile9(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -5358,7 +5525,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve10(
+      const commentsPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5374,7 +5541,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile8(commentsPath, "utf-8");
+      const content = await readFile9(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -5409,7 +5576,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5419,7 +5586,7 @@ ${entry}`;
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile8(projectPath, "utf-8");
+      let content = await readFile9(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -5433,7 +5600,7 @@ ${entry}`;
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5445,7 +5612,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile8(projectPath, "utf-8");
+      let content = await readFile9(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -5460,7 +5627,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve10(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5478,7 +5645,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile8(assignmentPath, "utf-8");
+      let content = await readFile9(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -5503,8 +5670,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve10(projectsDir, projectSlug);
-      const assignmentPath = resolve10(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve11(projectsDir, projectSlug);
+      const assignmentPath = resolve11(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -5530,8 +5697,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve10(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve10(assignmentDir, "assignment.md");
+      const assignmentDir = resolve11(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve11(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -5560,7 +5727,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve10(assignmentsDir, id);
+      const assignmentDir = resolve11(assignmentsDir, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -5580,25 +5747,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve10(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve11(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve10(assignmentDir, "scratchpad.md"),
+        resolve11(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve10(assignmentDir, "handoff.md"),
+        resolve11(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve10(assignmentDir, "decision-record.md"),
+        resolve11(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve10(assignmentDir, "progress.md"),
+        resolve11(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve10(assignmentDir, "comments.md"),
+        resolve11(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
@@ -5726,7 +5893,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve10(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -5768,7 +5935,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve10(resolved.assignmentDir, "plan.md");
+      const planPath = resolve11(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -5802,7 +5969,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve10(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve11(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -5836,7 +6003,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve10(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve11(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -5876,7 +6043,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve10(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve11(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -5916,7 +6083,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve10(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -5928,7 +6095,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile8(assignmentPath, "utf-8");
+      let content = await readFile9(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -5954,7 +6121,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve10(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -6019,7 +6186,7 @@ function slugifyLocal(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve10(assignmentDir, "comments.md");
+  const commentsPath = resolve11(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req.body || {};
   if (!body || typeof body !== "string" || !body.trim()) {
     res.status(400).json({ error: "body is required" });
@@ -6031,7 +6198,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile8(commentsPath, "utf-8");
+    currentContent = await readFile9(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -6061,7 +6228,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve10(assignmentDir, "comments.md");
+  const commentsPath = resolve11(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -6071,7 +6238,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile8(commentsPath, "utf-8");
+  const content = await readFile9(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -6216,7 +6383,7 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir) {
 
 // src/dashboard/api-agent-sessions.ts
 import { Router as Router3 } from "express";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 init_fs();
 function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
   const router = Router3();
@@ -6233,7 +6400,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve11(projectsDir, projectSlug);
+      const projectDir = resolve12(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -6259,7 +6426,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve11(projectsDir, projectSlug);
+        const projectDir = resolve12(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -6327,8 +6494,8 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
 init_api();
 init_parser();
 import { Router as Router4 } from "express";
-import { resolve as resolve13 } from "path";
-import { readFile as readFile10, unlink as unlink2 } from "fs/promises";
+import { resolve as resolve14 } from "path";
+import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
 
@@ -6336,15 +6503,15 @@ init_fs();
 init_fs();
 init_parser();
 init_timestamp();
-import { resolve as resolve12 } from "path";
-import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+import { readdir as readdir7, readFile as readFile10 } from "fs/promises";
 async function rebuildPlaybookManifest(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return;
-  const entries = await readdir6(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir7(playbooksDir2, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const raw = await readFile9(resolve12(playbooksDir2, entry.name), "utf-8");
+    const raw = await readFile10(resolve13(playbooksDir2, entry.name), "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     rows.push({
@@ -6374,7 +6541,7 @@ async function rebuildPlaybookManifest(playbooksDir2) {
     }
   }
   lines.push("");
-  await writeFileForce(resolve12(playbooksDir2, "manifest.md"), lines.join("\n"));
+  await writeFileForce(resolve13(playbooksDir2, "manifest.md"), lines.join("\n"));
 }
 
 // src/dashboard/api-playbooks.ts
@@ -6415,12 +6582,12 @@ function createPlaybooksRouter(playbooksDir2) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve13(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const content = await readFile10(filePath, "utf-8");
+      const content = await readFile11(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${req.params.slug}`,
@@ -6445,7 +6612,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve13(playbooksDir2, `${slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -6464,7 +6631,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve13(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -6482,7 +6649,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve13(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -6497,11 +6664,14 @@ function createPlaybooksRouter(playbooksDir2) {
   return router;
 }
 
+// src/dashboard/server.ts
+init_fs_migration();
+
 // src/dashboard/api-todos.ts
 init_parser2();
 init_fs();
 import { Router as Router5 } from "express";
-import { readdir as readdir7 } from "fs/promises";
+import { readdir as readdir8 } from "fs/promises";
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -6535,7 +6705,7 @@ function createTodosRouter(todosDir2, broadcast) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir7(todosDir2).catch(() => []);
+      const files = await readdir8(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -6640,8 +6810,8 @@ function createTodosRouter(todosDir2, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve17 } = await import("path");
-      const { readFile: readFile13 } = await import("fs/promises");
+      const { resolve: resolve18 } = await import("path");
+      const { readFile: readFile14 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -6657,10 +6827,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve17(todosDir2, "archive"));
+      await ensureDir(resolve18(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile13(archFile, "utf-8");
+        archContent = await readFile14(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -6920,8 +7090,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile12, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
-import { resolve as resolve15, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile13, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve16, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -6961,7 +7131,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve15(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve16(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -6972,7 +7142,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve15(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -6981,7 +7151,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile12(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -7019,7 +7189,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve15(dest, ".."));
+    await ensureDir(resolve16(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -7028,7 +7198,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile12(configPath, "utf-8");
+  const content = await readFile13(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -7067,8 +7237,8 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve15(destPath, ".."));
-        await writeFile3(destPath, sanitized, "utf-8");
+        await ensureDir(resolve16(destPath, ".."));
+        await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -7121,7 +7291,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve15(localPath, ".."));
+    await ensureDir(resolve16(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -7132,7 +7302,7 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   const localExistsBefore = await fileExists(localPath);
   if (backupExistsBefore) {
     if (!localExistsBefore) {
-      await rename2(backupPath, localPath);
+      await rename3(backupPath, localPath);
     } else {
       throw new Error(
         `Cannot restore "${localPath}": a stale crash-recovery backup exists at ${backupPath} while the current path also exists. Inspect both and remove the one you don't need, then retry.`
@@ -7144,15 +7314,15 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
     await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
     const localExists = await fileExists(localPath);
     if (localExists) {
-      await rename2(localPath, backupPath);
+      await rename3(localPath, backupPath);
       localMovedAside = true;
     }
-    await rename2(stagingPath, localPath);
+    await rename3(stagingPath, localPath);
     await rm2(backupPath, { recursive: true, force: true }).catch(() => {
     });
   } catch (err) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename2(backupPath, localPath).catch(() => {
+      await rename3(backupPath, localPath).catch(() => {
       });
     }
     await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
@@ -7222,7 +7392,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve15(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -7556,6 +7726,18 @@ function createDashboardServer(options) {
   migrateFromMarkdown(projectsDir).catch((err) => {
     console.error("Session migration from markdown failed:", err);
   });
+  (async () => {
+    try {
+      const configResult = await migrateLegacyConfig(
+        resolve17(syntaurRoot(), "config.md")
+      );
+      const projectResult = await migrateLegacyProjectFiles(projectsDir);
+      const summary = summarizeMigration(projectResult, configResult);
+      if (summary) console.log(summary);
+    } catch (err) {
+      console.error("Legacy filesystem migration failed:", err);
+    }
+  })();
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
@@ -7775,7 +7957,7 @@ function createDashboardServer(options) {
   if (serveStaticUi && dashboardDistPath) {
     app.use(express.static(dashboardDistPath));
     app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve16(dashboardDistPath, "index.html");
+      const indexPath = resolve17(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -7808,8 +7990,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve16(syntaurRoot(), "dashboard-port");
-          writeFile4(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve17(syntaurRoot(), "dashboard-port");
+          writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -7825,7 +8007,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve16(syntaurRoot(), "dashboard-port");
+      const portFile = resolve17(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();