syntaur 0.3.0 → 0.4.0

package/dist/index.js

@@ -168,9 +168,10 @@ function parseListField(frontmatter, fieldName) {
 }
 function parseProject(fileContent) {
   const [fm, body] = extractFrontmatter(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"),
@@ -412,9 +413,144 @@ var init_timestamp = __esm({
   }
 });
 
+// src/utils/fs-migration.ts
+import { readdir as readdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+async function migrateLegacyProjectFiles(projectsDir2) {
+  const result = {
+    renamedProjectFiles: [],
+    legacyExtras: []
+  };
+  if (!await fileExists(projectsDir2)) return result;
+  let entries;
+  try {
+    entries = await readdir3(projectsDir2, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectDir = resolve4(projectsDir2, entry.name);
+    const legacy = resolve4(projectDir, "mission.md");
+    const target = resolve4(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(resolve4(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 readFile3(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("~") ? resolve4(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 readFile3 } from "fs/promises";
-import { resolve as resolve4, isAbsolute } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve5, isAbsolute } from "path";
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -620,10 +756,10 @@ function parseOptionalAbsolutePath(value, fieldName) {
     );
     return null;
   }
-  return resolve4(expanded);
+  return resolve5(expanded);
 }
 async function writeStatusConfig(statuses) {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   const statusBlock = serializeStatusConfig(statuses);
   if (!await fileExists(configPath)) {
     const content = `---
@@ -635,7 +771,7 @@ ${statusBlock}
     await writeFileForce(configPath, content);
     return;
   }
-  const existing = await readFile3(configPath, "utf-8");
+  const existing = await readFile4(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -677,9 +813,9 @@ ${statusBlock}
   await writeFileForce(configPath, newContent);
 }
 async function deleteStatusConfig() {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return;
-  const existing = await readFile3(configPath, "utf-8");
+  const existing = await readFile4(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) return;
   const fmBlock = fmMatch[2];
@@ -691,13 +827,13 @@ ${cleanedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateIntegrationConfig(integrations) {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   const nextIntegrations = {
     ...(await readConfig()).integrations,
     ...integrations
   };
   const integrationBlock = serializeIntegrationConfig(nextIntegrations);
-  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -721,13 +857,13 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateOnboardingConfig(onboarding) {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   const nextOnboarding = {
     ...(await readConfig()).onboarding,
     ...onboarding
   };
   const onboardingBlock = serializeOnboardingConfig(nextOnboarding);
-  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -751,7 +887,7 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateBackupConfig(backup) {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   const current = (await readConfig()).backup;
   const nextBackup = {
     repo: current?.repo ?? null,
@@ -761,7 +897,7 @@ async function updateBackupConfig(backup) {
     ...backup
   };
   const backupBlock = serializeBackupConfig(nextBackup);
-  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -785,11 +921,15 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function readConfig() {
-  const configPath = resolve4(syntaurRoot(), "config.md");
+  const configPath = resolve5(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
-  const content = await readFile3(configPath, "utf-8");
+  if (!migratedConfigPaths.has(configPath)) {
+    migratedConfigPaths.add(configPath);
+    await migrateLegacyConfig(configPath);
+  }
+  const content = await readFile4(configPath, "utf-8");
   const fm = parseFrontmatter(content);
   if (Object.keys(fm).length === 0) {
     console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
@@ -836,13 +976,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(),
@@ -862,6 +1003,7 @@ var init_config2 = __esm({
       statuses: null,
       types: null
     };
+    migratedConfigPaths = /* @__PURE__ */ new Set();
   }
 });
 
@@ -1090,16 +1232,16 @@ var init_frontmatter = __esm({
 });
 
 // src/lifecycle/transitions.ts
-import { resolve as resolve7 } from "path";
-import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+import { readFile as readFile5 } from "fs/promises";
 function resolveAssignmentPath(projectDir, assignmentSlug) {
-  return resolve7(projectDir, "assignments", assignmentSlug, "assignment.md");
+  return resolve8(projectDir, "assignments", assignmentSlug, "assignment.md");
 }
 async function readAssignment(filePath) {
   if (!await fileExists(filePath)) {
     throw new Error(`Assignment file not found: ${filePath}`);
   }
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   const frontmatter = parseAssignmentFrontmatter(content);
   return { content, frontmatter };
 }
@@ -1112,7 +1254,7 @@ async function checkDependencies(projectDir, dependsOn, terminalStatuses3) {
       unmet.push(`${depSlug} (file not found)`);
       continue;
     }
-    const depContent = await readFile4(depPath, "utf-8");
+    const depContent = await readFile5(depPath, "utf-8");
     const depFrontmatter = parseAssignmentFrontmatter(depContent);
     if (!terminals.has(depFrontmatter.status)) {
       unmet.push(`${depSlug} (status: ${depFrontmatter.status})`);
@@ -1177,7 +1319,7 @@ async function executeAssign(projectDir, assignmentSlug, agent) {
   };
 }
 async function executeTransitionByDir(assignmentDir, command, options = {}) {
-  const filePath = resolve7(assignmentDir, "assignment.md");
+  const filePath = resolve8(assignmentDir, "assignment.md");
   const { content, frontmatter } = await readAssignment(filePath);
   const targetStatus = getTargetStatus(frontmatter.status, command, options.transitionTable);
   if (!targetStatus) {
@@ -1189,7 +1331,7 @@ async function executeTransitionByDir(assignmentDir, command, options = {}) {
   }
   const warnings = [];
   if (command === "start" && !options.standalone && frontmatter.dependsOn.length > 0) {
-    const projectDir = resolve7(assignmentDir, "..", "..");
+    const projectDir = resolve8(assignmentDir, "..", "..");
     const depCheck = await checkDependencies(
       projectDir,
       frontmatter.dependsOn,
@@ -1223,7 +1365,7 @@ async function executeTransitionByDir(assignmentDir, command, options = {}) {
   };
 }
 async function executeAssignByDir(assignmentDir, agent) {
-  const filePath = resolve7(assignmentDir, "assignment.md");
+  const filePath = resolve8(assignmentDir, "assignment.md");
   const { content, frontmatter } = await readAssignment(filePath);
   const updates = {
     assignee: agent,
@@ -1259,13 +1401,13 @@ var init_lifecycle = __esm({
 });
 
 // src/utils/assignment-resolver.ts
-import { resolve as resolve8 } from "path";
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
+import { resolve as resolve9 } from "path";
+import { readdir as readdir4, readFile as readFile6 } from "fs/promises";
 async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
   let standaloneMatch = null;
   let projectMatch = null;
-  const standaloneDir = resolve8(assignmentsDir2, id);
-  const standalonePath = resolve8(standaloneDir, "assignment.md");
+  const standaloneDir = resolve9(assignmentsDir2, id);
+  const standalonePath = resolve9(standaloneDir, "assignment.md");
   if (await fileExists(standalonePath)) {
     standaloneMatch = {
       assignmentDir: standaloneDir,
@@ -1277,24 +1419,24 @@ async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
   }
   if (await fileExists(projectsDir2)) {
     try {
-      const projects = await readdir3(projectsDir2, { withFileTypes: true });
+      const projects = await readdir4(projectsDir2, { withFileTypes: true });
       for (const p of projects) {
         if (!p.isDirectory()) continue;
         if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
-        const assignmentsPath = resolve8(projectsDir2, p.name, "assignments");
+        const assignmentsPath = resolve9(projectsDir2, p.name, "assignments");
         if (!await fileExists(assignmentsPath)) continue;
-        const entries = await readdir3(assignmentsPath, { withFileTypes: true });
+        const entries = await readdir4(assignmentsPath, { withFileTypes: true });
         for (const a of entries) {
           if (!a.isDirectory()) continue;
-          const aPath = resolve8(assignmentsPath, a.name, "assignment.md");
+          const aPath = resolve9(assignmentsPath, a.name, "assignment.md");
           if (!await fileExists(aPath)) continue;
           try {
-            const content = await readFile5(aPath, "utf-8");
+            const content = await readFile6(aPath, "utf-8");
             const [fm] = extractFrontmatter(content);
             const fileId = getField(fm, "id");
             if (fileId === id) {
               projectMatch = {
-                assignmentDir: resolve8(assignmentsPath, a.name),
+                assignmentDir: resolve9(assignmentsPath, a.name),
                 projectSlug: p.name,
                 assignmentSlug: a.name,
                 id,
@@ -1658,8 +1800,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) ---
       {
@@ -1742,8 +1884,8 @@ var init_help = __esm({
 });
 
 // src/dashboard/servers.ts
-import { readdir as readdir4, readFile as readFile6, unlink } from "fs/promises";
-import { resolve as resolve9 } from "path";
+import { readdir as readdir5, readFile as readFile7, unlink } from "fs/promises";
+import { resolve as resolve10 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1791,18 +1933,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve9(dir, `${name}.md`), content);
+  await writeFileForce(resolve10(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir4(dir);
+  const entries = await readdir5(dir);
   return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
 }
 async function readSessionFile(dir, name) {
-  const filePath = resolve9(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve10(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile6(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1842,7 +1984,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve9(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve10(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1851,7 +1993,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve9(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve10(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1863,7 +2005,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve9(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve10(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1880,7 +2022,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve9(dir, `${name}.md`), content);
+  await writeFileForce(resolve10(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1912,8 +2054,8 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve10 } from "path";
-import { realpath, readdir as readdir5, readFile as readFile7 } from "fs/promises";
+import { resolve as resolve11 } from "path";
+import { realpath, readdir as readdir6, readFile as readFile8 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -2008,8 +2150,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve10(cwd, commonDir));
-      const resolvedGit = await realpath(resolve10(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve11(cwd, commonDir));
+      const resolvedGit = await realpath(resolve11(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -2022,17 +2164,17 @@ async function loadWorkspaceRecords(projectsDir2, assignmentsDir2) {
   try {
     const projects = await listProjects(projectsDir2);
     for (const project of projects) {
-      const projectAssignmentsDir = resolve10(projectsDir2, project.slug, "assignments");
+      const projectAssignmentsDir = resolve11(projectsDir2, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir5(projectAssignmentsDir);
+        slugs = await readdir6(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve10(projectAssignmentsDir, aslug, "assignment.md");
+        const aFile = resolve11(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile7(aFile, "utf-8");
+          const raw = await readFile8(aFile, "utf-8");
           const [fm] = extractFrontmatter(raw);
           if (!fm) continue;
           records.push({
@@ -2051,12 +2193,12 @@ async function loadWorkspaceRecords(projectsDir2, assignmentsDir2) {
   }
   if (assignmentsDir2) {
     try {
-      const entries = await readdir5(assignmentsDir2);
+      const entries = await readdir6(assignmentsDir2);
       for (const id of entries) {
         if (id.startsWith(".") || id.startsWith("_")) continue;
-        const aFile = resolve10(assignmentsDir2, id, "assignment.md");
+        const aFile = resolve11(assignmentsDir2, id, "assignment.md");
         try {
-          const raw = await readFile7(aFile, "utf-8");
+          const raw = await readFile8(aFile, "utf-8");
           const [fm] = extractFrontmatter(raw);
           if (!fm) continue;
           records.push({
@@ -2304,20 +2446,20 @@ var init_scanner = __esm({
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir6, readFile as readFile8, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve11, dirname as dirname3 } from "path";
+import { readdir as readdir7, readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve12, dirname as dirname3 } from "path";
 async function listStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
-  const entries = await readdir6(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve11(assignmentsDir2, entry.name);
-    const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+    const assignmentDir = resolve12(assignmentsDir2, entry.name);
+    const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile8(assignmentMdPath, "utf-8");
+      const content = await readFile9(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -2386,9 +2528,9 @@ async function listProjects(projectsDir2) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir2) {
-  const registryPath = resolve11(dirname3(projectsDir2), "workspaces.json");
+  const registryPath = resolve12(dirname3(projectsDir2), "workspaces.json");
   try {
-    const raw = await readFile8(registryPath, "utf-8");
+    const raw = await readFile9(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -2396,8 +2538,8 @@ async function readWorkspaceRegistry(projectsDir2) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir2, workspaces) {
-  const registryPath = resolve11(dirname3(projectsDir2), "workspaces.json");
-  await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
+  const registryPath = resolve12(dirname3(projectsDir2), "workspaces.json");
+  await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir2) {
   const [projectRecords, registered] = await Promise.all([
@@ -2596,7 +2738,7 @@ async function getEditableDocument(projectsDir2, documentType, projectSlug, assi
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile9(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -2620,9 +2762,9 @@ async function getEditableDocumentById(projectsDir2, assignmentsDir2, documentTy
   }
   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 = resolve11(resolved.assignmentDir, fileName);
+  const filePath = resolve12(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile9(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 {
@@ -2636,12 +2778,12 @@ async function getEditableDocumentById(projectsDir2, assignmentsDir2, documentTy
   };
 }
 async function getProjectDetail(projectsDir2, slug) {
-  const projectPath = resolve11(projectsDir2, slug);
-  const projectMdPath = resolve11(projectPath, "project.md");
+  const projectPath = resolve12(projectsDir2, slug);
+  const projectMdPath = resolve12(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile8(projectMdPath, "utf-8");
+  const projectContent = await readFile9(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
   const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -2671,17 +2813,17 @@ async function getProjectDetail(projectsDir2, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  const assignmentDir = resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve11(assignmentDir, "plan.md");
+  const planPath = resolve12(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile8(planPath, "utf-8");
+    const planContent = await readFile9(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2690,9 +2832,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve12(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile8(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile9(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2700,9 +2842,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  const handoffPath = resolve12(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile8(handoffPath, "utf-8");
+    const handoffContent = await readFile9(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2711,9 +2853,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve12(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile8(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile9(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2722,9 +2864,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve11(assignmentDir, "progress.md");
+  const progressPath = resolve12(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile8(progressPath, "utf-8");
+    const progressContent = await readFile9(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -2733,9 +2875,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile8(commentsPath, "utf-8");
+    const commentsContent = await readFile9(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -2849,7 +2991,7 @@ async function computeReferencedBy(target, projectsDir2, assignmentsDir2) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve11(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve12(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -2882,17 +3024,17 @@ async function computeReferencedBy(target, projectsDir2, assignmentsDir2) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve11(sourceDir, "assignment.md");
+  const assignmentMd = resolve12(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile8(assignmentMd, "utf-8");
+    const content = await readFile9(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 = resolve11(sourceDir, filename);
+    const path = resolve12(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile8(path, "utf-8"));
+        bodies.push(await readFile9(path, "utf-8"));
       } catch {
       }
     }
@@ -2950,44 +3092,44 @@ async function getAssignmentDetailById(projectsDir2, assignmentsDir2, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve11(assignmentDir, "plan.md");
+  const planPath = resolve12(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile8(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile9(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve12(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile8(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile9(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  const handoffPath = resolve12(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile8(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile9(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve12(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile8(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile9(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve11(assignmentDir, "progress.md");
+  const progressPath = resolve12(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile8(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile9(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile8(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile9(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   const detail = {
@@ -3025,16 +3167,20 @@ async function listProjectRecords(projectsDir2) {
   if (!await fileExists(projectsDir2)) {
     return [];
   }
-  const entries = await readdir6(projectsDir2, { withFileTypes: true });
+  if (!migratedProjectsDirs.has(projectsDir2)) {
+    migratedProjectsDirs.add(projectsDir2);
+    await migrateLegacyProjectFiles(projectsDir2);
+  }
+  const entries = await readdir7(projectsDir2, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const records = [];
   for (const entry of projectDirs) {
-    const projectPath = resolve11(projectsDir2, entry.name);
-    const projectMdPath = resolve11(projectPath, "project.md");
+    const projectPath = resolve12(projectsDir2, entry.name);
+    const projectMdPath = resolve12(projectPath, "project.md");
     if (!await fileExists(projectMdPath)) {
       continue;
     }
-    const projectContent = await readFile8(projectMdPath, "utf-8");
+    const projectContent = await readFile9(projectMdPath, "utf-8");
     const project = parseProject(projectContent);
     const assignments = await listAssignmentRecords(projectPath);
     const rollup = await buildProjectRollup(projectPath, project, assignments);
@@ -3065,39 +3211,39 @@ async function listProjectRecords(projectsDir2) {
   return records;
 }
 async function listAssignmentRecords(projectPath) {
-  const assignmentsDir2 = resolve11(projectPath, "assignments");
+  const assignmentsDir2 = resolve12(projectPath, "assignments");
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
-  const entries = await readdir6(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir7(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const assignmentMd = resolve11(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve12(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       continue;
     }
-    const content = await readFile8(assignmentMd, "utf-8");
+    const content = await readFile9(assignmentMd, "utf-8");
     records.push(parseAssignmentFull(content));
   }
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve11(projectPath, "resources");
+  const resourcesDir = resolve12(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir6(resourcesDir, { withFileTypes: true });
+  const entries = await readdir7(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve11(resourcesDir, entry.name);
-    const content = await readFile8(filePath, "utf-8");
+    const filePath = resolve12(resourcesDir, entry.name);
+    const content = await readFile9(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -3112,18 +3258,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve11(projectPath, "memories");
+  const memoriesDir = resolve12(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir6(memoriesDir, { withFileTypes: true });
+  const entries = await readdir7(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve11(memoriesDir, entry.name);
-    const content = await readFile8(filePath, "utf-8");
+    const filePath = resolve12(memoriesDir, entry.name);
+    const content = await readFile9(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -3138,9 +3284,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve11(projectPath, "_status.md");
+  const statusPath = resolve12(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile8(statusPath, "utf-8");
+    const statusContent = await readFile9(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -3240,7 +3386,7 @@ async function getAvailableTransitions(projectsDir2, projectSlug, assignmentSlug
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve11(projectsDir2, projectSlug);
+  const projectPath = resolve12(projectsDir2, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -3270,12 +3416,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3) {
   const terminals = terminalStatuses3 ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve11(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve12(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile8(dependencyPath, "utf-8");
+    const content = await readFile9(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -3430,7 +3576,7 @@ function isStale(updated) {
   return Date.now() - timestamp > STALE_ASSIGNMENT_MS;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve11(
+  const commentsPath = resolve12(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -3440,7 +3586,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile8(commentsPath, "utf-8");
+    const content = await readFile9(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -3461,17 +3607,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir2, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve11(projectsDir2, projectSlug, "project.md");
+      return resolve12(projectsDir2, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -3498,12 +3644,12 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir3) {
   if (!await fileExists(playbooksDir3)) return [];
-  const entries = await readdir6(playbooksDir3, { withFileTypes: true });
+  const entries = await readdir7(playbooksDir3, { 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 = resolve11(playbooksDir3, entry.name);
-    const raw = await readFile8(filePath, "utf-8");
+    const filePath = resolve12(playbooksDir3, entry.name);
+    const raw = await readFile9(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -3519,9 +3665,9 @@ async function listPlaybooks(playbooksDir3) {
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
 async function getPlaybookDetail(playbooksDir3, slug) {
-  const filePath = resolve11(playbooksDir3, `${slug}.md`);
+  const filePath = resolve12(playbooksDir3, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile8(filePath, "utf-8");
+  const raw = await readFile9(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
   return {
     slug: parsed.slug || slug,
@@ -3534,13 +3680,14 @@ async function getPlaybookDetail(playbooksDir3, 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();
@@ -3603,6 +3750,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",
@@ -3635,8 +3783,8 @@ __export(parser_exports, {
   writeChecklist: () => writeChecklist
 });
 import { randomBytes } from "crypto";
-import { readFile as readFile12 } from "fs/promises";
-import { resolve as resolve17 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { resolve as resolve18 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -3796,10 +3944,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve17(todosDir2, `${workspace}.md`);
+  return resolve18(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve17(todosDir2, `${workspace}-log.md`);
+  return resolve18(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -3823,14 +3971,14 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve17(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve18(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 readFile12(path, "utf-8");
+  const content = await readFile13(path, "utf-8");
   return parseChecklist(content);
 }
 async function writeChecklist(todosDir2, checklist) {
@@ -3843,7 +3991,7 @@ async function readLog(todosDir2, workspace) {
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
-  const content = await readFile12(path, "utf-8");
+  const content = await readFile13(path, "utf-8");
   return parseLog(content);
 }
 async function appendLogEntry2(todosDir2, workspace, entry) {
@@ -3851,7 +3999,7 @@ async function appendLogEntry2(todosDir2, workspace, entry) {
   const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
-    content = await readFile12(path, "utf-8");
+    content = await readFile13(path, "utf-8");
     content = content.trimEnd() + "\n\n" + serializeLogEntry(entry) + "\n";
   } else {
     const fm = `---
@@ -4398,8 +4546,8 @@ __export(launch_exports, {
   launchAgent: () => launchAgent
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile6 } from "fs/promises";
-import { resolve as resolve27 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
+import { resolve as resolve30 } from "path";
 async function launchAgent(options) {
   const { projectsDir: projectsDir2, projectSlug, assignmentSlug, agent } = options;
   const command = AGENT_COMMANDS[agent];
@@ -4409,10 +4557,10 @@ async function launchAgent(options) {
     process.exit(1);
   }
   const workspaceDir = detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null) ?? process.cwd();
-  const projectDir = resolve27(projectsDir2, projectSlug);
-  const assignmentDir = resolve27(projectDir, "assignments", assignmentSlug);
-  const contextDir = resolve27(workspaceDir, ".syntaur");
-  await mkdir2(contextDir, { recursive: true });
+  const projectDir = resolve30(projectsDir2, projectSlug);
+  const assignmentDir = resolve30(projectDir, "assignments", assignmentSlug);
+  const contextDir = resolve30(workspaceDir, ".syntaur");
+  await mkdir4(contextDir, { recursive: true });
   const context = {
     projectSlug,
     assignmentSlug,
@@ -4423,8 +4571,8 @@ async function launchAgent(options) {
     branch: detail.workspace.branch ?? null,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile6(
-    resolve27(contextDir, "context.json"),
+  await writeFile8(
+    resolve30(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   return new Promise((resolvePromise, reject) => {
@@ -4573,7 +4721,7 @@ async function seedDefaultPlaybooks(playbooksDir3) {
 }
 
 // src/commands/create-project.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 
 // src/utils/slug.ts
 function slugify(title) {
@@ -5331,7 +5479,7 @@ async function createProjectCommand(title, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve5(baseDir, slug);
+  const projectDir = resolve6(baseDir, slug);
   if (await fileExists(projectDir)) {
     throw new Error(
       `Project folder already exists: ${projectDir}
@@ -5340,40 +5488,40 @@ Use --slug to specify a different slug.`
   }
   const timestamp = nowTimestamp();
   const id = generateId();
-  await ensureDir(resolve5(projectDir, "assignments"));
-  await ensureDir(resolve5(projectDir, "resources"));
-  await ensureDir(resolve5(projectDir, "memories"));
+  await ensureDir(resolve6(projectDir, "assignments"));
+  await ensureDir(resolve6(projectDir, "resources"));
+  await ensureDir(resolve6(projectDir, "memories"));
   const files = [
     [
-      resolve5(projectDir, "manifest.md"),
+      resolve6(projectDir, "manifest.md"),
       renderManifest({ slug, timestamp })
     ],
     [
-      resolve5(projectDir, "project.md"),
+      resolve6(projectDir, "project.md"),
       renderProject({ id, slug, title, timestamp, workspace: options.workspace })
     ],
     [
-      resolve5(projectDir, "_index-assignments.md"),
+      resolve6(projectDir, "_index-assignments.md"),
       renderIndexAssignments({ slug, title, timestamp })
     ],
     [
-      resolve5(projectDir, "_index-plans.md"),
+      resolve6(projectDir, "_index-plans.md"),
       renderIndexPlans({ slug, title, timestamp })
     ],
     [
-      resolve5(projectDir, "_index-decisions.md"),
+      resolve6(projectDir, "_index-decisions.md"),
       renderIndexDecisions({ slug, title, timestamp })
     ],
     [
-      resolve5(projectDir, "_status.md"),
+      resolve6(projectDir, "_status.md"),
       renderStatus({ slug, title, timestamp })
     ],
     [
-      resolve5(projectDir, "resources", "_index.md"),
+      resolve6(projectDir, "resources", "_index.md"),
       renderResourcesIndex({ slug, title, timestamp })
     ],
     [
-      resolve5(projectDir, "memories", "_index.md"),
+      resolve6(projectDir, "memories", "_index.md"),
       renderMemoriesIndex({ slug, title, timestamp })
     ]
   ];
@@ -5395,7 +5543,7 @@ Use --slug to specify a different slug.`
 }
 
 // src/commands/create-assignment.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
@@ -5461,14 +5609,14 @@ async function createAssignmentCommand(title, options) {
   if (options.oneOff) {
     const standaloneRoot = assignmentsDir();
     folderName = id;
-    assignmentDir = resolve6(standaloneRoot, folderName);
+    assignmentDir = resolve7(standaloneRoot, folderName);
     projectSlug = null;
     await ensureDir(standaloneRoot);
   } else {
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
     projectSlug = options.project;
-    const projectDir = resolve6(baseDir, projectSlug);
-    const projectMdPath = resolve6(projectDir, "project.md");
+    const projectDir = resolve7(baseDir, projectSlug);
+    const projectMdPath = resolve7(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(
         `Project "${projectSlug}" not found at ${projectDir}.
@@ -5476,9 +5624,9 @@ Run 'syntaur create-project' first or use --one-off.`
       );
     }
     if (dependsOn.length > 0) {
-      const depDirBase = resolve6(projectDir, "assignments");
+      const depDirBase = resolve7(projectDir, "assignments");
       for (const dep of dependsOn) {
-        const depDir = resolve6(depDirBase, dep);
+        const depDir = resolve7(depDirBase, dep);
         if (!await fileExists(depDir)) {
           console.warn(
             `Warning: dependency "${dep}" does not exist in project "${projectSlug}" yet.`
@@ -5487,7 +5635,7 @@ Run 'syntaur create-project' first or use --one-off.`
       }
     }
     folderName = assignmentSlug;
-    assignmentDir = resolve6(projectDir, "assignments", folderName);
+    assignmentDir = resolve7(projectDir, "assignments", folderName);
   }
   if (await fileExists(assignmentDir)) {
     throw new Error(
@@ -5499,7 +5647,7 @@ Use --slug to specify a different slug.`
   const companionAssignmentRef = projectSlug === null ? id : assignmentSlug;
   const files = [
     [
-      resolve6(assignmentDir, "assignment.md"),
+      resolve7(assignmentDir, "assignment.md"),
       renderAssignment({
         id,
         slug: assignmentSlug,
@@ -5513,35 +5661,35 @@ Use --slug to specify a different slug.`
       })
     ],
     [
-      resolve6(assignmentDir, "scratchpad.md"),
+      resolve7(assignmentDir, "scratchpad.md"),
       renderScratchpad({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve6(assignmentDir, "handoff.md"),
+      resolve7(assignmentDir, "handoff.md"),
       renderHandoff({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve6(assignmentDir, "decision-record.md"),
+      resolve7(assignmentDir, "decision-record.md"),
       renderDecisionRecord({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve6(assignmentDir, "progress.md"),
+      resolve7(assignmentDir, "progress.md"),
       renderProgress({
         assignment: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve6(assignmentDir, "comments.md"),
+      resolve7(assignmentDir, "comments.md"),
       renderComments({
         assignment: companionAssignmentRef,
         timestamp
@@ -5589,7 +5737,7 @@ Use --slug to specify a different slug.`
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve20, dirname as dirname4 } from "path";
+import { resolve as resolve21, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -5598,21 +5746,21 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve19 } from "path";
-import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
+import { resolve as resolve20 } 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 readFile9 } from "fs/promises";
-import { resolve as resolve13 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { resolve as resolve14 } from "path";
 
 // src/dashboard/session-db.ts
 init_paths();
 init_fs();
 import Database from "better-sqlite3";
-import { resolve as resolve12 } from "path";
-import { readdir as readdir7 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+import { readdir as readdir8 } from "fs/promises";
 var db = null;
 var SCHEMA_VERSION = "3";
 var SCHEMA_SQL = `
@@ -5630,14 +5778,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 ?? resolve12(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve13(syntaurRoot(), "syntaur.db");
   db = new Database(finalPath);
   db.pragma("journal_mode = WAL");
   db.exec(SCHEMA_SQL);
@@ -5645,57 +5795,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((c2) => c2.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() {
@@ -5717,12 +5884,12 @@ async function migrateFromMarkdown(projectsDir2) {
   const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
   if (count.count > 0) return 0;
   if (!await fileExists(projectsDir2)) return 0;
-  const entries = await readdir7(projectsDir2, { withFileTypes: true });
+  const entries = await readdir8(projectsDir2, { withFileTypes: true });
   const allSessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const projectDir = resolve12(projectsDir2, entry.name);
-    const indexPath = resolve12(projectDir, "_index-sessions.md");
+    const projectDir = resolve13(projectsDir2, entry.name);
+    const indexPath = resolve13(projectDir, "_index-sessions.md");
     if (!await fileExists(indexPath)) continue;
     const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
     allSessions.push(...sessions);
@@ -5742,8 +5909,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile25 } = await import("fs/promises");
-  const raw = await readFile25(filePath, "utf-8");
+  const { readFile: readFile28 } = await import("fs/promises");
+  const raw = await readFile28(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -5799,13 +5966,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,
@@ -5855,13 +6022,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 readFile9(assignmentMdPath, "utf-8");
+  const raw = await readFile10(assignmentMdPath, "utf-8");
   const match = raw.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
 async function readAssignmentStatus(projectDir, assignmentSlug) {
   return readAssignmentStatusFromPath(
-    resolve13(projectDir, "assignments", assignmentSlug, "assignment.md")
+    resolve14(projectDir, "assignments", assignmentSlug, "assignment.md")
   );
 }
 async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
@@ -5879,13 +6046,13 @@ async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
     seen.add(key);
     if (session.project_slug) {
       const status = await readAssignmentStatus(
-        resolve13(projectsDir2, session.project_slug),
+        resolve14(projectsDir2, session.project_slug),
         aslug
       );
       if (status) assignmentStatuses.set(key, status);
     } else if (assignmentsDir2) {
       const status = await readAssignmentStatusFromPath(
-        resolve13(assignmentsDir2, aslug, "assignment.md")
+        resolve14(assignmentsDir2, aslug, "assignment.md")
       );
       if (status) assignmentStatuses.set(key, status);
     }
@@ -6099,8 +6266,8 @@ init_config2();
 // src/dashboard/api-write.ts
 init_lifecycle();
 import { Router } from "express";
-import { resolve as resolve14 } from "path";
-import { rm, readFile as readFile10 } from "fs/promises";
+import { resolve as resolve15 } from "path";
+import { rm, readFile as readFile11 } from "fs/promises";
 init_timestamp();
 init_fs();
 init_parser();
@@ -6254,7 +6421,7 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile10(filePath, "utf-8");
+  return readFile11(filePath, "utf-8");
 }
 function createWriteRouter(projectsDir2, assignmentsDir2) {
   const router = Router();
@@ -6384,26 +6551,26 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve14(projectsDir2, slug);
+      const projectDir = resolve15(projectsDir2, 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(resolve14(projectDir, "assignments"));
-      await ensureDir(resolve14(projectDir, "resources"));
-      await ensureDir(resolve14(projectDir, "memories"));
-      await writeFileForce(resolve14(projectDir, "project.md"), content);
+      await ensureDir(resolve15(projectDir, "assignments"));
+      await ensureDir(resolve15(projectDir, "resources"));
+      await ensureDir(resolve15(projectDir, "memories"));
+      await writeFileForce(resolve15(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve14(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve14(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve14(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve14(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve14(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve14(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve14(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve15(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve15(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve15(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve15(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve15(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve15(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve15(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -6424,8 +6591,8 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve14(projectsDir2, projectSlug);
-      const projectMdPath = resolve14(projectDir, "project.md");
+      const projectDir = resolve15(projectsDir2, projectSlug);
+      const projectMdPath = resolve15(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -6455,7 +6622,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve14(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve15(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -6464,12 +6631,12 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve14(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve15(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve14(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve14(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve14(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve15(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve15(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve15(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -6490,7 +6657,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve15(projectsDir2, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -6523,7 +6690,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve14(
+      const assignmentPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6566,7 +6733,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve14(
+      const assignmentPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6602,7 +6769,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve14(
+      const planPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6640,7 +6807,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve14(
+      const scratchpadPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6678,7 +6845,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve14(
+      const handoffPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6716,7 +6883,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve14(
+      const decisionPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6754,7 +6921,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve14(
+      const commentsPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6772,7 +6939,7 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile10(commentsPath, "utf-8");
+        currentContent = await readFile11(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -6813,7 +6980,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve14(
+      const commentsPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6829,7 +6996,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile10(commentsPath, "utf-8");
+      const content = await readFile11(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -6864,7 +7031,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve15(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -6874,7 +7041,7 @@ ${entry}`;
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile10(projectPath, "utf-8");
+      let content = await readFile11(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -6888,7 +7055,7 @@ ${entry}`;
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve15(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -6900,7 +7067,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile10(projectPath, "utf-8");
+      let content = await readFile11(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -6915,7 +7082,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve14(
+      const assignmentPath = resolve15(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -6933,7 +7100,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile10(assignmentPath, "utf-8");
+      let content = await readFile11(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -6958,8 +7125,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve14(projectsDir2, projectSlug);
-      const assignmentPath = resolve14(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve15(projectsDir2, projectSlug);
+      const assignmentPath = resolve15(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -6985,8 +7152,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve14(projectsDir2, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve14(assignmentDir, "assignment.md");
+      const assignmentDir = resolve15(projectsDir2, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve15(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -7015,7 +7182,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve14(assignmentsDir2, id);
+      const assignmentDir = resolve15(assignmentsDir2, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -7035,25 +7202,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve14(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve15(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve14(assignmentDir, "scratchpad.md"),
+        resolve15(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve14(assignmentDir, "handoff.md"),
+        resolve15(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve14(assignmentDir, "decision-record.md"),
+        resolve15(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve14(assignmentDir, "progress.md"),
+        resolve15(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve14(assignmentDir, "comments.md"),
+        resolve15(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
@@ -7181,7 +7348,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -7223,7 +7390,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve14(resolved.assignmentDir, "plan.md");
+      const planPath = resolve15(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -7257,7 +7424,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve14(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve15(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -7291,7 +7458,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve14(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve15(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -7331,7 +7498,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve14(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve15(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -7371,7 +7538,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -7383,7 +7550,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile10(assignmentPath, "utf-8");
+      let content = await readFile11(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -7409,7 +7576,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve15(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -7474,7 +7641,7 @@ function slugifyLocal(input2) {
   return input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve14(assignmentDir, "comments.md");
+  const commentsPath = resolve15(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" });
@@ -7486,7 +7653,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile10(commentsPath, "utf-8");
+    currentContent = await readFile11(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -7516,7 +7683,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve14(assignmentDir, "comments.md");
+  const commentsPath = resolve15(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -7526,7 +7693,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile10(commentsPath, "utf-8");
+  const content = await readFile11(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -7671,7 +7838,7 @@ function createServersRouter(serversDir2, projectsDir2, assignmentsDir2) {
 
 // src/dashboard/api-agent-sessions.ts
 import { Router as Router3 } from "express";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 init_fs();
 function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
   const router = Router3();
@@ -7688,7 +7855,7 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve15(projectsDir2, projectSlug);
+      const projectDir = resolve16(projectsDir2, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -7714,7 +7881,7 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve15(projectsDir2, projectSlug);
+        const projectDir = resolve16(projectsDir2, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -7782,8 +7949,8 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
 init_api();
 init_parser();
 import { Router as Router4 } from "express";
-import { resolve as resolve16 } from "path";
-import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
+import { resolve as resolve17 } from "path";
+import { readFile as readFile12, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
 function createPlaybooksRouter(playbooksDir3) {
@@ -7823,12 +7990,12 @@ function createPlaybooksRouter(playbooksDir3) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const content = await readFile11(filePath, "utf-8");
+      const content = await readFile12(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${req.params.slug}`,
@@ -7853,7 +8020,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       await ensureDir(playbooksDir3);
-      const filePath = resolve16(playbooksDir3, `${slug}.md`);
+      const filePath = resolve17(playbooksDir3, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -7872,7 +8039,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -7890,7 +8057,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -7905,11 +8072,14 @@ function createPlaybooksRouter(playbooksDir3) {
   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 readdir8 } from "fs/promises";
+import { readdir as readdir9 } from "fs/promises";
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -7943,7 +8113,7 @@ function createTodosRouter(todosDir2, broadcast) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir8(todosDir2).catch(() => []);
+      const files = await readdir9(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -8048,8 +8218,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: resolve41 } = await import("path");
-      const { readFile: readFile25 } = await import("fs/promises");
+      const { resolve: resolve44 } = await import("path");
+      const { readFile: readFile28 } = 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);
@@ -8065,10 +8235,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve41(todosDir2, "archive"));
+      await ensureDir(resolve44(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile25(archFile, "utf-8");
+        archContent = await readFile28(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -8328,8 +8498,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 readFile13, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
-import { resolve as resolve18, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile14, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve19, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -8369,7 +8539,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve18(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve19(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -8380,7 +8550,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve18(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve19(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -8389,7 +8559,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile14(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.`
       );
@@ -8427,7 +8597,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve18(dest, ".."));
+    await ensureDir(resolve19(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -8436,7 +8606,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile13(configPath, "utf-8");
+  const content = await readFile14(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -8475,8 +8645,8 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve18(destPath, ".."));
-        await writeFile3(destPath, sanitized, "utf-8");
+        await ensureDir(resolve19(destPath, ".."));
+        await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -8529,7 +8699,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve18(localPath, ".."));
+    await ensureDir(resolve19(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -8540,7 +8710,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.`
@@ -8552,15 +8722,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 (err2) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename2(backupPath, localPath).catch(() => {
+      await rename3(backupPath, localPath).catch(() => {
       });
     }
     await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
@@ -8630,7 +8800,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve18(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve19(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -8964,6 +9134,18 @@ function createDashboardServer(options) {
   migrateFromMarkdown(projectsDir2).catch((err2) => {
     console.error("Session migration from markdown failed:", err2);
   });
+  (async () => {
+    try {
+      const configResult = await migrateLegacyConfig(
+        resolve20(syntaurRoot(), "config.md")
+      );
+      const projectResult = await migrateLegacyProjectFiles(projectsDir2);
+      const summary = summarizeMigration(projectResult, configResult);
+      if (summary) console.log(summary);
+    } catch (err2) {
+      console.error("Legacy filesystem migration failed:", err2);
+    }
+  })();
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
@@ -9183,7 +9365,7 @@ function createDashboardServer(options) {
   if (serveStaticUi && dashboardDistPath) {
     app.use(express.static(dashboardDistPath));
     app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve19(dashboardDistPath, "index.html");
+      const indexPath = resolve20(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -9216,8 +9398,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve19(syntaurRoot(), "dashboard-port");
-          writeFile4(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve20(syntaurRoot(), "dashboard-port");
+          writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -9233,7 +9415,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve19(syntaurRoot(), "dashboard-port");
+      const portFile = resolve20(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();
@@ -9313,8 +9495,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve20(dirname4(thisFile), "..");
-  const dashboardDist = resolve20(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve21(dirname4(thisFile), "..");
+  const dashboardDist = resolve21(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
@@ -9328,8 +9510,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve20(packageRoot, "dashboard");
-    const viteBin = resolve20(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve21(packageRoot, "dashboard");
+    const viteBin = resolve21(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -9401,7 +9583,7 @@ async function dashboardCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 init_lifecycle();
 init_assignment_resolver();
 async function runTransition(assignment, command, options = {}) {
@@ -9414,8 +9596,8 @@ async function runTransition(assignment, command, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve21(baseDir, options.project);
-    const projectMdPath = resolve21(projectDir, "project.md");
+    const projectDir = resolve22(baseDir, options.project);
+    const projectMdPath = resolve22(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -9446,8 +9628,8 @@ async function runAssign(assignment, agent, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve21(baseDir, options.project);
-    const projectMdPath = resolve21(projectDir, "project.md");
+    const projectDir = resolve22(baseDir, options.project);
+    const projectMdPath = resolve22(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -9530,31 +9712,31 @@ init_config2();
 init_fs();
 import {
   cp as cp2,
-  readdir as readdir9,
+  readdir as readdir10,
   symlink,
   lstat,
-  readFile as readFile14,
+  readFile as readFile15,
   readlink,
   rm as rm3,
   unlink as unlink5,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve23 } from "path";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve24 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname5, resolve as resolve22 } from "path";
+import { dirname as dirname5, resolve as resolve23 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
   let currentDir = dirname5(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve22(currentDir, expectedRelativePath);
+    const candidate = resolve23(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve22(currentDir, "..");
+    const parentDir = resolve23(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -9575,25 +9757,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir2();
-  return pluginKind === "claude" ? resolve23(home, ".claude", "plugins", "syntaur") : resolve23(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve24(home, ".claude", "plugins", "syntaur") : resolve24(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve23(homedir2(), ".agents", "plugins", "marketplace.json");
+  return resolve24(homedir2(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve23(homedir2(), ".claude", "plugins", "marketplaces");
+  return resolve24(homedir2(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve23(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve24(homedir2(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve23(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  return resolve24(homedir2(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve23(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve24(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile14(resolve23(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile15(resolve24(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -9601,7 +9783,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile14(pathValue, "utf-8");
+    const raw = await readFile15(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9609,15 +9791,15 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve23(pluginDir, ".claude-plugin", "plugin.json")
+    resolve24(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve23(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve24(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile14(manifestPath, "utf-8");
+  const raw = await readFile15(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -9627,7 +9809,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile14(markerPath, "utf-8");
+    const raw = await readFile15(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9640,7 +9822,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve23(dirname6(targetDir), symlinkTarget);
+    const resolvedTarget = resolve24(dirname6(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -9669,7 +9851,7 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
     installMode,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile5(
+  await writeFile6(
     getInstallMarkerPath(targetDir),
     `${JSON.stringify(metadata, null, 2)}
 `,
@@ -9686,7 +9868,7 @@ async function installLink(paths) {
   await ensureDir(dirname6(paths.targetDir));
   await rm3(paths.targetDir, { recursive: true, force: true });
   await ensureDir(dirname6(paths.targetDir));
-  await symlink(resolve23(paths.sourceDir), paths.targetDir, "dir");
+  await symlink(resolve24(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
@@ -9700,13 +9882,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute2(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve23(expanded);
+  return resolve24(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve23(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve24(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -9741,7 +9923,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   await ensureDir(dirname6(manifestPath));
-  await writeFile5(manifestPath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile6(manifestPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 function buildClaudeMarketplaceSourcePath(pluginTargetDir, marketplaceRootDir) {
@@ -9802,7 +9984,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir9(rootDir, { withFileTypes: true })
+    readdir10(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9810,8 +9992,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve23(rootDir, entry.name);
-    const manifestPath = resolve23(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve24(rootDir, entry.name);
+    const manifestPath = resolve24(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -9838,11 +10020,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve23(expandHome(installLocation));
+    const candidateRoot = resolve24(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve23(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve24(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -9870,7 +10052,7 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve23(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve24(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
@@ -9880,7 +10062,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const rootDir = dirname6(pluginsDir);
-  const manifestPath = resolve23(rootDir, ".claude-plugin", "marketplace.json");
+  const manifestPath = resolve24(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
@@ -9896,7 +10078,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve23(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve24(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -10021,7 +10203,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve23(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve24(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -10073,7 +10255,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile14(marketplacePath, "utf-8");
+  const raw = await readFile15(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -10083,7 +10265,7 @@ async function readMarketplaceFile(marketplacePath) {
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
   await ensureDir(dirname6(marketplacePath));
-  await writeFile5(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile6(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
@@ -10234,13 +10416,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve23(syntaurRoot(), "config.md"));
+  return fileExists(resolve24(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
   await rm3(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve23(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve24(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -10307,6 +10489,165 @@ async function textPrompt(question, defaultValue) {
   }
 }
 
+// src/utils/install-skills.ts
+init_fs();
+import { readFile as readFile16, readdir as readdir11, mkdir as mkdir2, copyFile, rm as rm4 } from "fs/promises";
+import { dirname as dirname7, resolve as resolve25, relative as relative3, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { homedir as homedir3 } from "os";
+var REQUIRED_SKILLS = [
+  "syntaur-protocol",
+  "grab-assignment",
+  "plan-assignment",
+  "complete-assignment",
+  "create-assignment",
+  "create-project"
+];
+function getVendoredSkillsDir() {
+  const here = dirname7(fileURLToPath4(import.meta.url));
+  return resolve25(here, "..", "vendor", "syntaur-skills", "skills");
+}
+function defaultSkillTargetDir(target) {
+  if (target === "claude") return resolve25(homedir3(), ".claude", "skills");
+  return resolve25(homedir3(), ".codex", "skills");
+}
+async function walkFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir11(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(root);
+  return out.sort();
+}
+async function filesEqual(a, b) {
+  try {
+    const [ba, bb] = await Promise.all([readFile16(a), readFile16(b)]);
+    if (ba.length !== bb.length) return false;
+    return ba.equals(bb);
+  } catch {
+    return false;
+  }
+}
+async function copyDir(srcDir, destDir) {
+  await mkdir2(destDir, { recursive: true });
+  const entries = await readdir11(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = join3(srcDir, entry.name);
+    const dest = join3(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(src, dest);
+    } else if (entry.isFile()) {
+      await copyFile(src, dest);
+    }
+  }
+}
+async function skillMatches(srcDir, destDir) {
+  if (!await fileExists(destDir)) return false;
+  const srcFiles = await walkFiles(srcDir);
+  for (const srcFile of srcFiles) {
+    const rel = relative3(srcDir, srcFile);
+    const destFile = join3(destDir, rel);
+    if (!await filesEqual(srcFile, destFile)) return false;
+  }
+  const destFiles = await walkFiles(destDir);
+  if (destFiles.length !== srcFiles.length) return false;
+  return true;
+}
+async function installSkills(options) {
+  const source = options.sourceDir ?? getVendoredSkillsDir();
+  const targetRoot = options.targetDir ?? defaultSkillTargetDir(options.target);
+  const force = options.force ?? false;
+  if (!await fileExists(source)) {
+    throw new Error(
+      `Vendored skills not found at ${source}. Reinstall syntaur: npm install -g syntaur@latest`
+    );
+  }
+  const results = [];
+  await mkdir2(targetRoot, { recursive: true });
+  for (const skill of REQUIRED_SKILLS) {
+    const srcDir = join3(source, skill);
+    const destDir = join3(targetRoot, skill);
+    if (!await fileExists(srcDir)) continue;
+    if (!await fileExists(destDir)) {
+      await copyDir(srcDir, destDir);
+      results.push({
+        skill,
+        status: "installed",
+        targetPath: destDir
+      });
+      continue;
+    }
+    if (await skillMatches(srcDir, destDir)) {
+      results.push({
+        skill,
+        status: "already-current",
+        targetPath: destDir
+      });
+      continue;
+    }
+    if (force) {
+      await rm4(destDir, { recursive: true, force: true });
+      await copyDir(srcDir, destDir);
+      results.push({
+        skill,
+        status: "overwritten",
+        targetPath: destDir
+      });
+    } else {
+      results.push({
+        skill,
+        status: "differs-preserved",
+        targetPath: destDir
+      });
+    }
+  }
+  return results;
+}
+async function uninstallSkills(options) {
+  const targetRoot = options.targetDir ?? defaultSkillTargetDir(options.target);
+  if (!await fileExists(targetRoot)) return [];
+  const removed = [];
+  for (const skill of REQUIRED_SKILLS) {
+    const destDir = join3(targetRoot, skill);
+    if (!await fileExists(destDir)) continue;
+    const skillMd = join3(destDir, "SKILL.md");
+    if (!await fileExists(skillMd)) continue;
+    const content = await readFile16(skillMd, "utf-8").catch(() => "");
+    const match = content.match(/^name:\s*(\S+)\s*$/m);
+    if (!match || match[1] !== skill) continue;
+    await rm4(destDir, { recursive: true, force: true });
+    removed.push(destDir);
+  }
+  return removed;
+}
+function formatInstallReport(results, target) {
+  const lines = [];
+  lines.push(`Skill install (${target}):`);
+  for (const r of results) {
+    const marker = r.status === "installed" ? "+" : r.status === "overwritten" ? "!" : r.status === "differs-preserved" ? "?" : "=";
+    lines.push(`  ${marker} ${r.skill} (${r.status})`);
+  }
+  const diffs = results.filter((r) => r.status === "differs-preserved");
+  if (diffs.length > 0) {
+    lines.push("");
+    lines.push(
+      `  Note: ${diffs.length} skill(s) already exist with different content and were preserved.`
+    );
+    lines.push(
+      "  Run with --force-skills to overwrite with the vendored version."
+    );
+  }
+  return lines.join("\n");
+}
+
 // src/commands/install-plugin.ts
 async function promptForInstallPath(question, recommendedPath) {
   while (true) {
@@ -10389,10 +10730,261 @@ async function installPluginCommand(options) {
   if (currentMarketplace) {
     console.log(`  marketplace: ${currentMarketplace.manifestPath}`);
   }
+  if (!options.skipSkills) {
+    try {
+      const skillResults = await installSkills({
+        target: "claude",
+        force: options.forceSkills
+      });
+      console.log("");
+      console.log(formatInstallReport(skillResults, "claude"));
+    } catch (error) {
+      console.warn(
+        `Warning: skill install failed \u2014 ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   console.log("\nThe plugin is now available in Claude Code.");
-  console.log("  Skills: /grab-assignment, /plan-assignment, /complete-assignment");
-  console.log("  Background: syntaur-protocol (auto-invoked)");
-  console.log("  Hook: write boundary enforcement (PreToolUse)");
+  console.log("  Slash commands: /grab-assignment, /plan-assignment, /complete-assignment, /create-assignment, /create-project");
+  console.log("  Background: syntaur-protocol skill (auto-invoked)");
+  console.log("  Hook: write boundary enforcement (PreToolUse) + SessionStart/End");
+}
+
+// src/commands/install-statusline.ts
+init_paths();
+init_fs();
+import { readFile as readFile17, writeFile as writeFile7, copyFile as copyFile2, rm as rm5, stat as stat3, symlink as symlink2, unlink as unlink6, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve26, dirname as dirname8 } from "path";
+import { homedir as homedir4 } from "os";
+import { fileURLToPath as fileURLToPath5 } from "url";
+function getPackageStatuslineSource() {
+  const here = dirname8(fileURLToPath5(import.meta.url));
+  return resolve26(here, "..", "statusline", "statusline.sh");
+}
+async function readSettingsJson(settingsPath) {
+  if (!await fileExists(settingsPath)) return {};
+  const raw = await readFile17(settingsPath, "utf-8");
+  if (raw.trim() === "") return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    throw new Error(
+      `Unable to parse ${settingsPath}: ${error.message}. Fix the JSON and re-run.`
+    );
+  }
+}
+async function writeSettingsJson(settingsPath, data) {
+  await ensureDir(dirname8(settingsPath));
+  await writeFile7(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function resolveMode(mode, existingCommand, ourCommand) {
+  if (mode !== "ask") return mode;
+  if (!existingCommand || existingCommand === ourCommand) return "replace";
+  if (!isInteractiveTerminal()) {
+    return "wrap";
+  }
+  console.log(
+    `A Claude Code statusLine is already configured:
+  ${existingCommand}
+`
+  );
+  const wantWrap = await confirmPrompt(
+    "Compose (wrap) your existing statusline with syntaur segments? [Y to wrap / n to replace]",
+    true
+  );
+  if (wantWrap) return "wrap";
+  const confirmReplace = await confirmPrompt(
+    "Replace your existing statusline with syntaur only?",
+    false
+  );
+  return confirmReplace ? "replace" : "skip";
+}
+function extractExistingCommand(settings) {
+  const sl = settings.statusLine;
+  if (!sl || typeof sl !== "object") return void 0;
+  const obj = sl;
+  return {
+    type: typeof obj.type === "string" ? obj.type : void 0,
+    command: typeof obj.command === "string" ? obj.command : void 0
+  };
+}
+async function backupSettings(settingsSnapshot, backupPath) {
+  await ensureDir(dirname8(backupPath));
+  await writeFile7(
+    backupPath,
+    JSON.stringify(
+      {
+        version: 1,
+        takenAt: (/* @__PURE__ */ new Date()).toISOString(),
+        settingsPath: settingsSnapshot.settingsPath,
+        previousStatusLine: settingsSnapshot.existingStatusLine ?? null
+      },
+      null,
+      2
+    ) + "\n",
+    "utf-8"
+  );
+}
+async function installScript(sourceScript, destScript, link) {
+  await ensureDir(dirname8(destScript));
+  try {
+    const s = await lstat2(destScript);
+    if (s.isSymbolicLink() || s.isFile()) {
+      await unlink6(destScript);
+    }
+  } catch {
+  }
+  if (link) {
+    await symlink2(sourceScript, destScript);
+  } else {
+    await copyFile2(sourceScript, destScript);
+  }
+}
+async function installStatuslineCommand(options = {}) {
+  const mode = options.mode ?? "ask";
+  const settingsPath = options.settingsPath ?? resolve26(homedir4(), ".claude", "settings.json");
+  const installRoot = options.installRoot ?? syntaurRoot();
+  const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
+  const destScript = resolve26(installRoot, "statusline.sh");
+  const confPath = resolve26(installRoot, "statusline.conf");
+  const backupPath = resolve26(installRoot, "statusline.backup.json");
+  if (!await fileExists(sourceScript)) {
+    throw new Error(
+      `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
+    );
+  }
+  await installScript(sourceScript, destScript, Boolean(options.link));
+  const settings = await readSettingsJson(settingsPath);
+  const existingStatusLine = extractExistingCommand(settings);
+  const existingCommand = existingStatusLine?.command;
+  const ourCommand = `bash ${destScript}`;
+  const resolvedMode = await resolveMode(mode, existingCommand, ourCommand);
+  if (resolvedMode === "skip") {
+    console.log("Installed statusline script only:");
+    console.log(`  script: ${destScript}`);
+    console.log(`  source: ${sourceScript}`);
+    console.log(
+      "  (settings.json left unchanged \u2014 run with --mode=replace or --mode=wrap to wire it up)"
+    );
+    return;
+  }
+  await backupSettings(
+    {
+      settingsPath,
+      existingStatusLine,
+      existingCommand
+    },
+    backupPath
+  );
+  let wrapTarget = "";
+  if (resolvedMode === "wrap" && existingCommand && existingCommand !== ourCommand) {
+    const parsed = parseWrapCommand(existingCommand);
+    if (parsed) {
+      wrapTarget = parsed;
+    } else {
+      const wrapperPath = resolve26(installRoot, "statusline-wrapped.sh");
+      const wrapperBody = `#!/usr/bin/env bash
+# Auto-generated by syntaur install-statusline.
+# Executes the previously configured statusLine command.
+exec ${existingCommand}
+`;
+      await writeFile7(wrapperPath, wrapperBody, "utf-8");
+      await chmodExec(wrapperPath);
+      wrapTarget = wrapperPath;
+    }
+  }
+  await ensureDir(dirname8(confPath));
+  await writeFile7(
+    confPath,
+    wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
+# stdout becomes the leading segment of the statusline. Remove this
+# line or comment it out to disable wrapping.
+${wrapTarget}
+` : `# syntaur statusline config. Add a single path on a non-comment line to
+# wrap another statusline script with syntaur segments appended.
+`,
+    "utf-8"
+  );
+  settings.statusLine = {
+    type: "command",
+    command: ourCommand
+  };
+  await writeSettingsJson(settingsPath, settings);
+  console.log("Installed syntaur statusline:");
+  console.log(`  script:       ${destScript}`);
+  console.log(`  source:       ${sourceScript}`);
+  console.log(`  mode:         ${resolvedMode}`);
+  console.log(`  settings.json:${settingsPath}`);
+  console.log(`  backup:       ${backupPath}`);
+  if (wrapTarget) {
+    console.log(`  wrap target:  ${wrapTarget}`);
+    console.log(`  (edit ${confPath} to change or disable wrapping)`);
+  }
+}
+function parseWrapCommand(command) {
+  const trimmed = command.trim();
+  const bashMatch = trimmed.match(/^bash\s+(\S+)$/);
+  if (bashMatch) return bashMatch[1];
+  if (/^\S+\.(sh|bash)$/.test(trimmed)) return trimmed;
+  return null;
+}
+async function chmodExec(path) {
+  const fs = await import("fs/promises");
+  try {
+    const s = await stat3(path);
+    await fs.chmod(path, s.mode | 73);
+  } catch {
+  }
+}
+async function uninstallStatuslineCommand(options = {}) {
+  const settingsPath = options.settingsPath ?? resolve26(homedir4(), ".claude", "settings.json");
+  const installRoot = options.installRoot ?? syntaurRoot();
+  const destScript = resolve26(installRoot, "statusline.sh");
+  const confPath = resolve26(installRoot, "statusline.conf");
+  const backupPath = resolve26(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve26(installRoot, "statusline-wrapped.sh");
+  const settings = await readSettingsJson(settingsPath);
+  const existing = extractExistingCommand(settings);
+  const ourCommand = `bash ${destScript}`;
+  let restored = null;
+  if (await fileExists(backupPath)) {
+    try {
+      const raw = await readFile17(backupPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const prev = parsed?.previousStatusLine;
+      if (prev && typeof prev === "object" && typeof prev.command === "string") {
+        restored = { command: prev.command };
+      }
+    } catch {
+    }
+  }
+  if (existing?.command === ourCommand) {
+    if (restored) {
+      settings.statusLine = {
+        type: "command",
+        command: restored.command
+      };
+    } else {
+      delete settings.statusLine;
+    }
+    await writeSettingsJson(settingsPath, settings);
+  }
+  if (!options.keepScript) {
+    for (const path of [destScript, confPath, backupPath, wrapperPath]) {
+      try {
+        await rm5(path, { force: true });
+      } catch {
+      }
+    }
+  }
+  console.log("Uninstalled syntaur statusline.");
+  if (restored) {
+    console.log(`  Restored previous command: ${restored.command}`);
+  } else {
+    console.log("  Removed statusLine entry from settings.json.");
+  }
+  console.log(`  settings.json: ${settingsPath}`);
 }
 
 // src/commands/install-codex-plugin.ts
@@ -10474,14 +11066,61 @@ async function installCodexPluginCommand(options) {
   console.log(`  source: ${result.sourceDir}`);
   console.log(`  mode: ${result.mode}`);
   console.log(`  marketplace: ${marketplace.marketplacePath}`);
+  if (!options.skipSkills) {
+    try {
+      const skillResults = await installSkills({
+        target: "codex",
+        force: options.forceSkills
+      });
+      console.log("");
+      console.log(formatInstallReport(skillResults, "codex"));
+    } catch (error) {
+      console.warn(
+        `Warning: skill install failed \u2014 ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   console.log("\nThe plugin is now available to Codex.");
   console.log(
-    "  Skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment, track-session"
+    "  Protocol skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment"
   );
-  console.log("  Command: /track-session");
+  console.log("  Codex-specific: track-session skill (rollout path aware)");
   console.log("  Hooks: write boundary enforcement, session cleanup");
 }
 
+// src/commands/uninstall-skills.ts
+async function uninstallSkillsCommand(options) {
+  const runClaude = Boolean(options.claude || options.all);
+  const runCodex = Boolean(options.codex || options.all);
+  if (!runClaude && !runCodex) {
+    throw new Error(
+      "Specify --claude, --codex, or --all (use one or more)."
+    );
+  }
+  let totalRemoved = 0;
+  if (runClaude) {
+    const removed = await uninstallSkills({ target: "claude" });
+    totalRemoved += removed.length;
+    console.log(
+      `Removed ${removed.length} Syntaur protocol skill(s) from ~/.claude/skills:`
+    );
+    for (const p of removed) console.log(`  - ${p}`);
+  }
+  if (runCodex) {
+    const removed = await uninstallSkills({ target: "codex" });
+    totalRemoved += removed.length;
+    console.log(
+      `Removed ${removed.length} Syntaur protocol skill(s) from ~/.codex/skills:`
+    );
+    for (const p of removed) console.log(`  - ${p}`);
+  }
+  if (totalRemoved === 0) {
+    console.log(
+      "No Syntaur protocol skills found to remove. (User-authored skills with matching directory names are preserved.)"
+    );
+  }
+}
+
 // src/commands/setup.ts
 import { execSync } from "child_process";
 init_config2();
@@ -10586,7 +11225,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve27 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -10666,7 +11305,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve24(configuredProjectDir) !== resolve24(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve27(configuredProjectDir) !== resolve27(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -10681,7 +11320,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve25 } from "path";
+import { resolve as resolve28 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -10707,19 +11346,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve25(baseDir, options.project);
-  const assignmentDir = resolve25(
+  const projectDir = resolve28(baseDir, options.project);
+  const assignmentDir = resolve28(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve25(projectDir, "project.md");
+  const projectMdPath = resolve28(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath = resolve25(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve28(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -10747,15 +11386,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve25(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve25(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve28(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve28(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve25(cwd, "AGENTS.md");
+    const agentsPath = resolve28(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve25(cwd, "opencode.json");
+      const configPath = resolve28(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -10780,16 +11419,20 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve26 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import { resolve as resolve29 } from "path";
 async function trackSessionCommand(options) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
   }
+  if (!options.sessionId) {
+    throw new Error(
+      "--session-id <id> is required. Pass the real agent-generated session id \u2014 do not synthesize one."
+    );
+  }
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve26(baseDir, options.project);
+    const projectDir = resolve29(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -10797,7 +11440,7 @@ async function trackSessionCommand(options) {
     }
   }
   initSessionDb();
-  const sessionId = options.sessionId || randomUUID2();
+  const { sessionId } = options;
   await appendSession("", {
     projectSlug: options.project || null,
     assignmentSlug: options.assignment || null,
@@ -10806,10 +11449,13 @@ async function trackSessionCommand(options) {
     started: (/* @__PURE__ */ new Date()).toISOString(),
     status: "active",
     path: options.path || process.cwd(),
-    description: options.description || null
+    description: options.description || null,
+    transcriptPath: options.transcriptPath ?? null
   });
   if (options.project && options.assignment) {
-    console.log(`Registered agent session ${sessionId} for ${options.assignment} in ${options.project}.`);
+    console.log(
+      `Registered agent session ${sessionId} for ${options.assignment} in ${options.project}.`
+    );
   } else {
     console.log(`Registered standalone agent session ${sessionId}.`);
   }
@@ -10841,7 +11487,7 @@ async function browseCommand(options) {
 }
 
 // src/commands/create-playbook.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve31 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
@@ -10857,7 +11503,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve28(dir, `${slug}.md`);
+  const filePath = resolve31(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -10878,15 +11524,15 @@ Use --slug to specify a different slug.`
 init_paths();
 init_fs();
 init_parser();
-import { readdir as readdir10, readFile as readFile15 } from "fs/promises";
-import { resolve as resolve29 } from "path";
+import { readdir as readdir12, readFile as readFile18 } from "fs/promises";
+import { resolve as resolve32 } from "path";
 async function listPlaybooksCommand() {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
     console.log('No playbooks directory found. Run "syntaur init" first.');
     return;
   }
-  const entries = await readdir10(dir, { withFileTypes: true });
+  const entries = await readdir12(dir, { withFileTypes: true });
   const mdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md");
   if (mdFiles.length === 0) {
     console.log('No playbooks found. Create one with "syntaur create-playbook <name>".');
@@ -10897,8 +11543,8 @@ async function listPlaybooksCommand() {
   console.log(`${"Slug".padEnd(30)} ${"Name".padEnd(30)} Description`);
   console.log(`${"\u2500".repeat(30)} ${"\u2500".repeat(30)} ${"\u2500".repeat(40)}`);
   for (const entry of mdFiles) {
-    const filePath = resolve29(dir, entry.name);
-    const raw = await readFile15(filePath, "utf-8");
+    const filePath = resolve32(dir, entry.name);
+    const raw = await readFile18(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const name = parsed.name || slug;
@@ -10912,8 +11558,8 @@ init_paths();
 init_parser2();
 init_fs();
 import { Command } from "commander";
-import { readFile as readFile16 } from "fs/promises";
-import { resolve as resolve30 } from "path";
+import { readFile as readFile19 } from "fs/promises";
+import { resolve as resolve33 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function resolveWorkspace(options) {
   if (options.global) return "_global";
@@ -11194,10 +11840,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve30(todosPath, "archive"));
+    await ensureDir(resolve33(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile16(archFile, "utf-8");
+      archContent = await readFile19(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -11385,20 +12031,20 @@ backupCommand.command("config").description("Show or update backup configuration
 import { Command as Command3 } from "commander";
 
 // src/utils/doctor/index.ts
-import { fileURLToPath as fileURLToPath5 } from "url";
-import { readFile as readFile20 } from "fs/promises";
-import { dirname as dirname8, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { readFile as readFile23 } from "fs/promises";
+import { dirname as dirname10, join as join5 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
 init_paths();
 init_fs();
 import Database2 from "better-sqlite3";
-import { resolve as resolve31 } from "path";
+import { resolve as resolve34 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve31(root, "syntaur.db");
+  const dbPath = resolve34(root, "syntaur.db");
   let db2 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -11432,10 +12078,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve32, isAbsolute as isAbsolute3 } from "path";
-import { readFile as readFile17, stat as stat2 } from "fs/promises";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname7, join as join3 } from "path";
+import { resolve as resolve35, isAbsolute as isAbsolute3 } from "path";
+import { readFile as readFile20, stat as stat4 } from "fs/promises";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { dirname as dirname9, join as join4 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -11443,7 +12089,7 @@ var syntaurRootExists = {
   title: "~/.syntaur/ directory exists",
   async run(ctx) {
     try {
-      const s = await stat2(ctx.syntaurRoot);
+      const s = await stat4(ctx.syntaurRoot);
       if (!s.isDirectory()) {
         return err(this, `${ctx.syntaurRoot} exists but is not a directory`, [
           ctx.syntaurRoot
@@ -11473,7 +12119,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve32(ctx.syntaurRoot, "config.md");
+    const configPath = resolve35(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -11490,7 +12136,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile17(configPath, "utf-8");
+    const content = await readFile20(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -11765,15 +12411,15 @@ async function readLocalVersion() {
 }
 async function readLocalPkg() {
   try {
-    const here = fileURLToPath4(import.meta.url);
-    let dir = dirname7(here);
+    const here = fileURLToPath6(import.meta.url);
+    let dir = dirname9(here);
     for (let i = 0; i < 6; i++) {
-      const candidate = join3(dir, "package.json");
+      const candidate = join4(dir, "package.json");
       try {
-        const text = await readFile17(candidate, "utf-8");
+        const text = await readFile20(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname7(dir);
+        dir = dirname9(dir);
       }
     }
     return null;
@@ -11822,8 +12468,8 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve33 } from "path";
-import { readdir as readdir11, stat as stat3 } from "fs/promises";
+import { resolve as resolve36 } from "path";
+import { readdir as readdir13, stat as stat5 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -11842,7 +12488,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve33(ctx.syntaurRoot, "projects");
+    const p = resolve36(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -11867,7 +12513,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve33(ctx.syntaurRoot, "playbooks");
+    const p = resolve36(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -11892,7 +12538,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve33(ctx.syntaurRoot, "todos");
+    const p = resolve36(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -11903,7 +12549,7 @@ var todosDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat3(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -11923,7 +12569,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve33(ctx.syntaurRoot, "servers");
+    const p = resolve36(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -11934,7 +12580,7 @@ var serversDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat3(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -11954,7 +12600,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir11(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir13(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -11968,7 +12614,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve33(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve36(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -11997,8 +12643,8 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve34 } from "path";
-import { readdir as readdir12, stat as stat4 } from "fs/promises";
+import { resolve as resolve37 } from "path";
+import { readdir as readdir14, stat as stat6 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -12022,15 +12668,15 @@ var PROJECT_MARKERS = ["project.md", "manifest.md", "assignments"];
 async function listProjects2(ctx) {
   const dir = ctx.config.defaultProjectDir;
   if (!await fileExists(dir)) return [];
-  const entries = await readdir12(dir, { withFileTypes: true });
+  const entries = await readdir14(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve34(dir, e.name);
+    const projectDir = resolve37(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve34(projectDir, marker))) {
+      if (await fileExists(resolve37(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -12049,7 +12695,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve34(projectDir, rel);
+        const p = resolve37(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -12059,7 +12705,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve34(projectDir, m)),
+        affected: missing.map((m) => resolve37(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -12082,9 +12728,9 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve34(projectDir, "manifest.md");
+      const manifestPath = resolve37(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
-      const manifestMtime = (await stat4(manifestPath)).mtimeMs;
+      const manifestMtime = (await stat6(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
       if (newestAssignment === 0) continue;
       if (newestAssignment > manifestMtime) {
@@ -12116,7 +12762,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir12(projectDir, { withFileTypes: true });
+      const entries = await readdir14(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -12131,7 +12777,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve34(projectDir, o)),
+        affected: orphans.map((o) => resolve37(projectDir, o)),
         autoFixable: false
       });
     }
@@ -12141,20 +12787,20 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve34(projectDir, "assignments");
+  const assignmentsRoot = resolve37(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
   try {
-    entries = await readdir12(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir14(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve34(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve37(assignmentsRoot, e.name, "assignment.md");
     try {
-      const s = await stat4(assignmentMd);
+      const s = await stat6(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
     } catch {
     }
@@ -12176,28 +12822,28 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve35 } from "path";
-import { readdir as readdir13, readFile as readFile18 } from "fs/promises";
+import { resolve as resolve38 } from "path";
+import { readdir as readdir15, readFile as readFile21 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 async function listAssignments(ctx) {
   const result = { withAssignmentMd: [], orphanFolders: [] };
   const projectsDir2 = ctx.config.defaultProjectDir;
   if (await fileExists(projectsDir2)) {
-    const projects = await readdir13(projectsDir2, { withFileTypes: true });
+    const projects = await readdir15(projectsDir2, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve35(projectsDir2, m.name, "assignments");
+      const assignmentsDir2 = resolve38(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir15(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve35(assignmentsDir2, a.name);
-        const assignmentMd = resolve35(assignmentDir, "assignment.md");
+        const assignmentDir = resolve38(assignmentsDir2, a.name);
+        const assignmentMd = resolve38(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve35(projectsDir2, m.name),
+          projectDir: resolve38(projectsDir2, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -12213,12 +12859,12 @@ async function listAssignments(ctx) {
   }
   const standaloneRoot = assignmentsDir();
   if (await fileExists(standaloneRoot)) {
-    const entries = await readdir13(standaloneRoot, { withFileTypes: true });
+    const entries = await readdir15(standaloneRoot, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve35(standaloneRoot, a.name);
-      const assignmentMd = resolve35(assignmentDir, "assignment.md");
+      const assignmentDir = resolve38(standaloneRoot, a.name);
+      const assignmentMd = resolve38(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneRoot,
         projectSlug: null,
@@ -12296,7 +12942,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve35(a.assignmentDir, "assignment.md");
+      const path = resolve38(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -12329,7 +12975,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve35(a.assignmentDir, "assignment.md");
+      const path = resolve38(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -12376,12 +13022,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve35(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve38(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve35(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve38(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -12391,7 +13037,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve35(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve38(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -12414,7 +13060,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve35(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve38(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -12426,7 +13072,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve35(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve38(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -12459,7 +13105,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve35(a.assignmentDir, "assignment.md");
+      const path = resolve38(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -12493,7 +13139,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve35(a.assignmentDir, "assignment.md");
+      const path = resolve38(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -12548,7 +13194,7 @@ var assignmentChecks = [
 ];
 async function parseSafe(path) {
   try {
-    const content = await readFile18(path, "utf-8");
+    const content = await readFile21(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -12567,7 +13213,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve36 } from "path";
+import { resolve as resolve39 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -12581,7 +13227,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve36(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve39(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -12599,7 +13245,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve36(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve39(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -12611,7 +13257,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve36(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve39(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -12637,7 +13283,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve36(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve39(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -12656,7 +13302,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve36(
+        const assignmentPath = resolve39(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -12708,7 +13354,7 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { readdir as readdir14 } from "fs/promises";
+import { readdir as readdir16 } from "fs/promises";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
   id: "integrations.claude-plugin-linked",
@@ -12770,7 +13416,7 @@ var backupConfigured = {
     if (ctx.config.backup?.repo) return pass6(this);
     const projectsDir2 = ctx.config.defaultProjectDir;
     if (!await fileExists(projectsDir2)) return skipped2(this, "no projects dir");
-    const entries = await readdir14(projectsDir2, { withFileTypes: true });
+    const entries = await readdir16(projectsDir2, { withFileTypes: true });
     const hasProjects = entries.some((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
     if (!hasProjects) return skipped2(this, "no projects yet");
     return {
@@ -12813,8 +13459,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve37 } from "path";
-import { readFile as readFile19 } from "fs/promises";
+import { resolve as resolve40 } from "path";
+import { readFile as readFile22 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 function hasAnyAssignmentField(ctx) {
@@ -12826,12 +13472,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve37(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve40(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile19(path, "utf-8");
+    const raw = await readFile22(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -12906,7 +13552,7 @@ var contextAssignmentResolves = {
     if (!exists) return skipped3(this, "no context to resolve");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve37(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve40(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -12935,10 +13581,10 @@ var contextTerminal = {
     if (!exists) return skipped3(this, "no context to check");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve37(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve40(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile19(assignmentMd, "utf-8");
+      const content = await readFile22(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -13081,15 +13727,15 @@ async function finalize(checks) {
 }
 async function readVersion() {
   try {
-    const here = fileURLToPath5(import.meta.url);
-    let dir = dirname8(here);
+    const here = fileURLToPath7(import.meta.url);
+    let dir = dirname10(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile20(join4(dir, "package.json"), "utf-8");
+        const raw = await readFile23(join5(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname8(dir);
+        dir = dirname10(dir);
       }
     }
     return null;
@@ -13222,8 +13868,8 @@ var doctorCommand = new Command3("doctor").description("Diagnose Syntaur state a
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve38 } from "path";
-import { readFile as readFile21 } from "fs/promises";
+import { resolve as resolve41 } from "path";
+import { readFile as readFile24 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function shortId() {
@@ -13255,7 +13901,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve38(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve41(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -13265,13 +13911,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve38(assignmentDir, "comments.md");
+  const commentsPath = resolve41(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile21(commentsPath, "utf-8");
+    currentContent = await readFile24(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -13308,8 +13954,8 @@ ${entry}`;
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve39 } from "path";
-import { readFile as readFile22 } from "fs/promises";
+import { resolve as resolve42 } from "path";
+import { readFile as readFile25 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function setTopLevelField3(content, key, value) {
@@ -13334,7 +13980,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve39(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve42(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -13344,12 +13990,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath = resolve39(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve42(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile22(assignmentMdPath, "utf-8");
+  let content = await readFile25(assignmentMdPath, "utf-8");
   const todoLine = `- [ ] ${text.trim()} (from: ${source})`;
   const todosHeading = /^## Todos\s*$/m;
   if (todosHeading.test(content)) {
@@ -13377,10 +14023,10 @@ ${todoLine}
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir15 } from "fs/promises";
+import { readdir as readdir17 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir15(projectsDir2, { withFileTypes: true });
+    const entries = await readdir17(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;
@@ -13416,21 +14062,21 @@ async function getDefaultCommandName() {
 // src/utils/npx-prompt.ts
 init_paths();
 init_fs();
-import { fileURLToPath as fileURLToPath7 } from "url";
-import { readFile as readFile24 } from "fs/promises";
-import { dirname as dirname10, join as join6, resolve as resolve40 } from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
+import { readFile as readFile27 } from "fs/promises";
+import { dirname as dirname12, join as join7, resolve as resolve43 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
-import { fileURLToPath as fileURLToPath6 } from "url";
-import { readFile as readFile23 } from "fs/promises";
-import { dirname as dirname9, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+import { readFile as readFile26 } from "fs/promises";
+import { dirname as dirname11, join as join6 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
-    const scriptPath = fileURLToPath6(scriptUrl);
-    const pkgRoot = dirname9(dirname9(scriptPath));
-    const raw = await readFile23(join5(pkgRoot, "package.json"), "utf-8");
+    const scriptPath = fileURLToPath8(scriptUrl);
+    const pkgRoot = dirname11(dirname11(scriptPath));
+    const raw = await readFile26(join6(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -13439,13 +14085,13 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve40(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve43(syntaurRoot(), "npx-install.json");
 var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
   let scriptPath;
   try {
-    scriptPath = fileURLToPath7(scriptUrl);
+    scriptPath = fileURLToPath9(scriptUrl);
   } catch {
     return false;
   }
@@ -13460,7 +14106,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile24(STATE_FILE, "utf-8");
+    const raw = await readFile27(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -13471,10 +14117,10 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname10(process.execPath);
+  const nodeDir = dirname12(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
-  const nearNode = join6(nodeDir, npmName);
+  const nearNode = join7(nodeDir, npmName);
   if (await fileExists(nearNode)) {
     return { cmd: nearNode, shell: false };
   }
@@ -13517,9 +14163,9 @@ async function readGlobalVersion() {
   });
   if (!rootPath) return null;
   try {
-    const manifestPath = join6(rootPath, "syntaur", "package.json");
+    const manifestPath = join7(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile24(manifestPath, "utf-8");
+    const raw = await readFile27(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -13814,7 +14460,7 @@ program.command("setup").description("Initialize Syntaur and optionally install
     process.exit(1);
   }
 });
-program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-plugin").description("Install the Syntaur Claude Code plugin").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--link", "Use a symlink instead of copying files (repo-local dev only)").option("--force-skills", "Overwrite user-edited skills in ~/.claude/skills").option("--skip-skills", "Do not install protocol skills into ~/.claude/skills").action(async (options) => {
   try {
     await installPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {
@@ -13825,7 +14471,45 @@ program.command("install-plugin").description("Install the Syntaur Claude Code p
     process.exit(1);
   }
 });
-program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--marketplace-path <path>", "Write the marketplace entry to a specific file").option("--link", "Use a symlink instead of copying files (repo-local dev only)").action(async (options) => {
+program.command("install-statusline").description(
+  "Install the syntaur statusLine for Claude Code. Augments ~/.claude/settings.json; wraps any existing script by default."
+).option("--mode <mode>", "replace | wrap | skip | ask (default: ask, wrap in non-TTY)", "ask").option("--link", "Symlink the installed script to the package source (dev mode)").action(async (options) => {
+  try {
+    const rawMode = (options.mode ?? "ask").toLowerCase();
+    const valid = ["replace", "wrap", "skip", "ask"];
+    if (!valid.includes(rawMode)) {
+      throw new Error(
+        `Invalid --mode "${rawMode}". Must be one of: ${valid.join(", ")}.`
+      );
+    }
+    await installStatuslineCommand({
+      mode: rawMode,
+      link: options.link
+    });
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("uninstall-statusline").description(
+  "Remove the syntaur statusLine. Restores the previously configured command from backup if present."
+).option("--keep-script", "Leave ~/.syntaur/statusline.sh on disk (only edit settings.json)").action(async (options) => {
+  try {
+    await uninstallStatuslineCommand({ keepScript: options.keepScript });
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("uninstall-skills").description("Remove Syntaur protocol skills from ~/.claude/skills and/or ~/.codex/skills").option("--claude", "Remove from ~/.claude/skills").option("--codex", "Remove from ~/.codex/skills").option("--all", "Remove from both").action(async (options) => {
+  try {
+    await uninstallSkillsCommand(options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("install-codex-plugin").description("Install the Syntaur Codex plugin and marketplace entry").option("--force", "Overwrite an existing Syntaur-managed install").option("--target-dir <path>", "Install the plugin at a specific directory").option("--marketplace-path <path>", "Write the marketplace entry to a specific file").option("--link", "Use a symlink instead of copying files (repo-local dev only)").option("--force-skills", "Overwrite user-edited skills in ~/.codex/skills").option("--skip-skills", "Do not install protocol skills into ~/.codex/skills").action(async (options) => {
   try {
     await installCodexPluginCommand({ ...options, promptForTarget: true });
   } catch (error) {
@@ -13858,7 +14542,13 @@ program.command("setup-adapter").description("Generate adapter instruction files
     process.exit(1);
   }
 });
-program.command("track-session").description("Register an agent session (optionally linked to a project/assignment)").option("--project <slug>", "Target project slug").option("--assignment <slug>", "Assignment slug").option("--agent <name>", "Agent name, e.g. claude, codex, cursor (required)").option("--session-id <id>", "Session ID (auto-generated if omitted)").option("--path <path>", "Full path to session on disk (defaults to cwd)").option("--dir <path>", "Override default project directory").option("--description <text>", "Description of what this session is for").action(async (options) => {
+program.command("track-session").description("Register an agent session (optionally linked to a project/assignment)").option("--project <slug>", "Target project slug").option("--assignment <slug>", "Assignment slug").option("--agent <name>", "Agent name, e.g. claude, codex, cursor (required)").requiredOption(
+  "--session-id <id>",
+  "Session id from the agent runtime (real, not generated). Claude: read from ~/.claude/sessions/<pid>.json or the SessionStart hook payload. Codex: `payload.id` from the first line of the matching ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl."
+).option(
+  "--transcript-path <path>",
+  "Absolute path to the agent rollout/transcript file (e.g. the Codex rollout jsonl or Claude transcript jsonl)."
+).option("--path <path>", "Full path to session on disk (defaults to cwd)").option("--dir <path>", "Override default project directory").option("--description <text>", "Description of what this session is for").action(async (options) => {
   try {
     await trackSessionCommand(options);
   } catch (error) {