syntaur 0.2.0 → 0.3.3

package/dist/dashboard/server.js

@@ -389,6 +389,52 @@ async function executeTransition(projectDir, assignmentSlug, command, options =
     warnings: warnings.length > 0 ? warnings : void 0
   };
 }
+async function executeTransitionByDir(assignmentDir, command, options = {}) {
+  const filePath = resolve2(assignmentDir, "assignment.md");
+  const { content, frontmatter } = await readAssignment(filePath);
+  const targetStatus = getTargetStatus(frontmatter.status, command, options.transitionTable);
+  if (!targetStatus) {
+    return {
+      success: false,
+      message: `Unknown command '${command}' for assignment "${frontmatter.slug || assignmentDir}".`,
+      fromStatus: frontmatter.status
+    };
+  }
+  const warnings = [];
+  if (command === "start" && !options.standalone && frontmatter.dependsOn.length > 0) {
+    const projectDir = resolve2(assignmentDir, "..", "..");
+    const depCheck = await checkDependencies(
+      projectDir,
+      frontmatter.dependsOn,
+      options.terminalStatuses
+    );
+    if (!depCheck.satisfied) {
+      warnings.push(`Starting with unmet dependencies: ${depCheck.unmet.join(", ")}`);
+    }
+  }
+  const updates = {
+    status: targetStatus,
+    updated: nowTimestamp()
+  };
+  if (command === "start" && options.agent && !frontmatter.assignee) {
+    updates.assignee = options.agent;
+  }
+  if (command === "block") {
+    updates.blockedReason = options.reason ?? null;
+  }
+  if (command === "unblock") {
+    updates.blockedReason = null;
+  }
+  const updatedContent = updateAssignmentFile(content, updates);
+  await writeFileForce(filePath, updatedContent);
+  return {
+    success: true,
+    message: `Assignment "${frontmatter.slug || assignmentDir}" transitioned: ${frontmatter.status} -> ${targetStatus}`,
+    fromStatus: frontmatter.status,
+    toStatus: targetStatus,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
 var init_transitions = __esm({
   "src/lifecycle/transitions.ts"() {
     "use strict";
@@ -438,9 +484,144 @@ var init_config = __esm({
   }
 });
 
+// src/utils/fs-migration.ts
+import { readdir, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+async function migrateLegacyProjectFiles(projectsDir) {
+  const result = {
+    renamedProjectFiles: [],
+    legacyExtras: []
+  };
+  if (!await fileExists(projectsDir)) return result;
+  let entries;
+  try {
+    entries = await readdir(projectsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectDir = resolve3(projectsDir, entry.name);
+    const legacy = resolve3(projectDir, "mission.md");
+    const target = resolve3(projectDir, "project.md");
+    try {
+      if (await fileExists(legacy) && !await fileExists(target)) {
+        await rename2(legacy, target);
+        result.renamedProjectFiles.push(`${entry.name}/mission.md`);
+      }
+    } catch {
+      continue;
+    }
+    for (const stale of ["agent.md", "claude.md"]) {
+      try {
+        if (await fileExists(resolve3(projectDir, stale))) {
+          result.legacyExtras.push(`${entry.name}/${stale}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+async function migrateLegacyConfig(configPath) {
+  const result = {
+    renamedField: false,
+    renamedDir: false,
+    resolvedProjectsDir: null
+  };
+  if (!await fileExists(configPath)) return result;
+  let content;
+  try {
+    content = await readFile2(configPath, "utf-8");
+  } catch {
+    return result;
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!fmMatch) return result;
+  const fmBlock = fmMatch[1];
+  const afterFm = content.slice(fmMatch[0].length);
+  const missionLineRe = /^(\s*)defaultMissionDir\s*:\s*(.*)$/m;
+  const missionLineMatch = fmBlock.match(missionLineRe);
+  const hasProjectLine = /^\s*defaultProjectDir\s*:/m.test(fmBlock);
+  let newFmBlock = fmBlock;
+  let missionValue = null;
+  if (missionLineMatch) {
+    missionValue = missionLineMatch[2].trim();
+    if (!hasProjectLine) {
+      newFmBlock = fmBlock.replace(
+        missionLineRe,
+        `$1defaultProjectDir: ${missionValue}`
+      );
+      result.renamedField = true;
+    } else {
+      newFmBlock = fmBlock.replace(missionLineRe, "").replace(/\n{2,}/g, "\n");
+      result.renamedField = true;
+    }
+  }
+  const projectLineRe = /^\s*defaultProjectDir\s*:\s*(.*)$/m;
+  const projectLineMatch = newFmBlock.match(projectLineRe);
+  const projectsDirRaw = projectLineMatch ? projectLineMatch[1].trim().replace(/^['"]|['"]$/g, "") : missionValue;
+  const expand = (p) => p.startsWith("~") ? resolve3(process.env.HOME ?? "/", p.slice(p.startsWith("~/") ? 2 : 1)) : p;
+  let resolvedProjectsDir = projectsDirRaw ? expand(projectsDirRaw) : null;
+  if (resolvedProjectsDir && resolvedProjectsDir.endsWith("/missions")) {
+    const siblingProjectsDir = resolvedProjectsDir.replace(/\/missions$/, "/projects");
+    if (await fileExists(resolvedProjectsDir) && !await fileExists(siblingProjectsDir)) {
+      try {
+        await rename2(resolvedProjectsDir, siblingProjectsDir);
+        const newValue = projectsDirRaw.endsWith("/missions") ? projectsDirRaw.replace(/\/missions$/, "/projects") : siblingProjectsDir;
+        newFmBlock = newFmBlock.replace(
+          projectLineRe,
+          `defaultProjectDir: ${newValue}`
+        );
+        resolvedProjectsDir = siblingProjectsDir;
+        result.renamedDir = true;
+      } catch {
+      }
+    }
+  }
+  result.resolvedProjectsDir = resolvedProjectsDir;
+  if (result.renamedField || result.renamedDir) {
+    const newContent = `---
+${newFmBlock.replace(/\n+$/, "")}
+---
+${afterFm.startsWith("\n") ? afterFm.slice(1) : afterFm}`;
+    try {
+      await writeFile2(configPath, newContent, "utf-8");
+    } catch {
+      result.renamedField = false;
+      result.renamedDir = false;
+    }
+  }
+  return result;
+}
+function summarizeMigration(project, config) {
+  const parts = [];
+  if (project.renamedProjectFiles.length > 0) {
+    const firstThree = project.renamedProjectFiles.map((p) => p.split("/")[0]).slice(0, 3).join(", ");
+    const more = project.renamedProjectFiles.length > 3 ? ` and ${project.renamedProjectFiles.length - 3} more` : "";
+    parts.push(
+      `renamed mission.md \u2192 project.md in ${project.renamedProjectFiles.length} project${project.renamedProjectFiles.length === 1 ? "" : "s"} (${firstThree}${more})`
+    );
+  }
+  if (config?.renamedField) parts.push("updated config defaultMissionDir \u2192 defaultProjectDir");
+  if (config?.renamedDir) parts.push("renamed projects directory on disk");
+  if (project.legacyExtras.length > 0) {
+    parts.push(
+      `${project.legacyExtras.length} legacy agent.md / claude.md file${project.legacyExtras.length === 1 ? "" : "s"} left in place (no longer read)`
+    );
+  }
+  return parts.length ? `[syntaur] legacy migration: ${parts.join("; ")}` : "";
+}
+var init_fs_migration = __esm({
+  "src/utils/fs-migration.ts"() {
+    "use strict";
+    init_fs();
+  }
+});
+
 // src/utils/config.ts
-import { readFile as readFile2 } from "fs/promises";
-import { resolve as resolve3, isAbsolute } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve4, isAbsolute } from "path";
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -627,10 +808,10 @@ function parseOptionalAbsolutePath(value, fieldName) {
     );
     return null;
   }
-  return resolve3(expanded);
+  return resolve4(expanded);
 }
 async function writeStatusConfig(statuses) {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   const statusBlock = serializeStatusConfig(statuses);
   if (!await fileExists(configPath)) {
     const content = `---
@@ -642,7 +823,7 @@ ${statusBlock}
     await writeFileForce(configPath, content);
     return;
   }
-  const existing = await readFile2(configPath, "utf-8");
+  const existing = await readFile3(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -684,9 +865,9 @@ ${statusBlock}
   await writeFileForce(configPath, newContent);
 }
 async function deleteStatusConfig() {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return;
-  const existing = await readFile2(configPath, "utf-8");
+  const existing = await readFile3(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) return;
   const fmBlock = fmMatch[2];
@@ -698,7 +879,7 @@ ${cleanedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateBackupConfig(backup) {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   const current = (await readConfig()).backup;
   const nextBackup = {
     repo: current?.repo ?? null,
@@ -708,7 +889,7 @@ async function updateBackupConfig(backup) {
     ...backup
   };
   const backupBlock = serializeBackupConfig(nextBackup);
-  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -732,11 +913,15 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function readConfig() {
-  const configPath = resolve3(syntaurRoot(), "config.md");
+  const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
     return { ...DEFAULT_CONFIG };
   }
-  const content = await readFile2(configPath, "utf-8");
+  if (!migratedConfigPaths.has(configPath)) {
+    migratedConfigPaths.add(configPath);
+    await migrateLegacyConfig(configPath);
+  }
+  const content = await readFile3(configPath, "utf-8");
   const fm = parseFrontmatter(content);
   if (Object.keys(fm).length === 0) {
     console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
@@ -783,13 +968,14 @@ async function readConfig() {
     types: null
   };
 }
-var DEFAULT_CONFIG;
+var DEFAULT_CONFIG, migratedConfigPaths;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
     init_paths();
     init_fs();
     init_config();
+    init_fs_migration();
     DEFAULT_CONFIG = {
       version: "2.0",
       defaultProjectDir: defaultProjectDir(),
@@ -809,6 +995,7 @@ var init_config2 = __esm({
       statuses: null,
       types: null
     };
+    migratedConfigPaths = /* @__PURE__ */ new Set();
   }
 });
 
@@ -862,9 +1049,10 @@ function parseListField(frontmatter, fieldName) {
 }
 function parseProject(fileContent) {
   const [fm, body] = extractFrontmatter2(fileContent);
+  const slug = getField(fm, "slug") ?? getField(fm, "mission") ?? "";
   return {
     id: getField(fm, "id") ?? "",
-    slug: getField(fm, "slug") ?? "",
+    slug,
     title: getField(fm, "title") ?? "",
     archived: getField(fm, "archived") === "true",
     archivedAt: getField(fm, "archivedAt"),
@@ -996,6 +1184,58 @@ function parseDecisionRecord(fileContent) {
     body
   };
 }
+function parseComments(fileContent) {
+  const [fm, body] = extractFrontmatter2(fileContent);
+  const entries = [];
+  const sections = body.split(/^## /m).slice(1);
+  for (const section of sections) {
+    const newlineIdx = section.indexOf("\n");
+    if (newlineIdx === -1) continue;
+    const id = section.slice(0, newlineIdx).trim();
+    const rest = section.slice(newlineIdx + 1);
+    const headerMatch = rest.match(
+      /^\s*\*\*Recorded:\*\*\s*(.*)\n\*\*Author:\*\*\s*(.*)\n\*\*Type:\*\*\s*(question|note|feedback)(?:\n\*\*Reply to:\*\*\s*(.*))?(?:\n\*\*Resolved:\*\*\s*(true|false))?\n+([\s\S]*)$/
+    );
+    if (!headerMatch) continue;
+    const [, timestamp, author, type, replyTo, resolvedStr, entryBody] = headerMatch;
+    const entry = {
+      id,
+      timestamp: timestamp.trim(),
+      author: author.trim(),
+      type,
+      body: entryBody.trim()
+    };
+    if (replyTo) entry.replyTo = replyTo.trim();
+    if (resolvedStr) entry.resolved = resolvedStr === "true";
+    entries.push(entry);
+  }
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    entryCount: parseInt(getField(fm, "entryCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    entries,
+    body
+  };
+}
+function parseProgress(fileContent) {
+  const [fm, body] = extractFrontmatter2(fileContent);
+  const entries = [];
+  const sections = body.split(/^## /m).slice(1);
+  for (const section of sections) {
+    const newlineIdx = section.indexOf("\n");
+    if (newlineIdx === -1) continue;
+    const timestamp = section.slice(0, newlineIdx).trim();
+    const entryBody = section.slice(newlineIdx + 1).trim();
+    entries.push({ timestamp, body: entryBody });
+  }
+  return {
+    assignment: getField(fm, "assignment") ?? "",
+    entryCount: parseInt(getField(fm, "entryCount") ?? "0", 10),
+    updated: getField(fm, "updated") ?? "",
+    entries,
+    body
+  };
+}
 function parseResource(fileContent) {
   const [fm, body] = extractFrontmatter2(fileContent);
   return {
@@ -1044,6 +1284,74 @@ var init_parser = __esm({
   }
 });
 
+// src/utils/assignment-resolver.ts
+import { resolve as resolve5 } from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
+  let standaloneMatch = null;
+  let projectMatch = null;
+  const standaloneDir = resolve5(assignmentsDir, id);
+  const standalonePath = resolve5(standaloneDir, "assignment.md");
+  if (await fileExists(standalonePath)) {
+    standaloneMatch = {
+      assignmentDir: standaloneDir,
+      projectSlug: null,
+      assignmentSlug: id,
+      id,
+      standalone: true
+    };
+  }
+  if (await fileExists(projectsDir)) {
+    try {
+      const projects = await readdir2(projectsDir, { withFileTypes: true });
+      for (const p of projects) {
+        if (!p.isDirectory()) continue;
+        if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
+        const assignmentsPath = resolve5(projectsDir, p.name, "assignments");
+        if (!await fileExists(assignmentsPath)) continue;
+        const entries = await readdir2(assignmentsPath, { withFileTypes: true });
+        for (const a of entries) {
+          if (!a.isDirectory()) continue;
+          const aPath = resolve5(assignmentsPath, a.name, "assignment.md");
+          if (!await fileExists(aPath)) continue;
+          try {
+            const content = await readFile4(aPath, "utf-8");
+            const [fm] = extractFrontmatter2(content);
+            const fileId = getField(fm, "id");
+            if (fileId === id) {
+              projectMatch = {
+                assignmentDir: resolve5(assignmentsPath, a.name),
+                projectSlug: p.name,
+                assignmentSlug: a.name,
+                id,
+                standalone: false
+              };
+              break;
+            }
+          } catch {
+          }
+        }
+        if (projectMatch) break;
+      }
+    } catch {
+    }
+  }
+  if (standaloneMatch && projectMatch) {
+    console.warn(
+      `Duplicate assignment ID ${id} found in both standalone and project-nested locations; using standalone`
+    );
+    return standaloneMatch;
+  }
+  return standaloneMatch ?? projectMatch ?? null;
+}
+var init_assignment_resolver = __esm({
+  "src/utils/assignment-resolver.ts"() {
+    "use strict";
+    init_fs();
+    init_parser();
+  }
+});
+
 // src/dashboard/help.ts
 async function buildStatusGuide() {
   const config = await getStatusConfig();
@@ -1376,8 +1684,8 @@ var init_help = __esm({
       // --- Session & server tracking (index 17) ---
       {
         command: "syntaur track-session",
-        description: "Register an agent session, optionally linked to a project and assignment.",
-        example: "syntaur track-session --agent claude --project ui-overhaul --assignment implement-overview"
+        description: "Register an agent session. Requires --session-id from the agent runtime (real, not generated). Pass --transcript-path for the rollout/transcript file. --project and --assignment are optional.",
+        example: "syntaur track-session --agent claude --session-id <real-id> --transcript-path <path> --project ui-overhaul --assignment implement-overview"
       },
       // --- Browsing & playbooks (indices 18-20) ---
       {
@@ -1460,8 +1768,8 @@ var init_help = __esm({
 });
 
 // src/dashboard/servers.ts
-import { readdir, readFile as readFile3, unlink } from "fs/promises";
-import { resolve as resolve4 } from "path";
+import { readdir as readdir3, readFile as readFile5, unlink } from "fs/promises";
+import { resolve as resolve6 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1509,18 +1817,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve4(dir, `${name}.md`), content);
+  await writeFileForce(resolve6(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir(dir);
+  const entries = await readdir3(dir);
   return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
 }
 async function readSessionFile(dir, name) {
-  const filePath = resolve4(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve6(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile3(filePath, "utf-8");
+  const raw = await readFile5(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter2(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1560,7 +1868,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve4(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve6(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1569,7 +1877,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve4(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve6(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1581,7 +1889,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve4(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve6(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1598,7 +1906,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve4(dir, `${name}.md`), content);
+  await writeFileForce(resolve6(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1630,8 +1938,8 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve5 } from "path";
-import { realpath, readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { realpath, readdir as readdir4, readFile as readFile6 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -1726,8 +2034,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve5(cwd, commonDir));
-      const resolvedGit = await realpath(resolve5(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve7(cwd, commonDir));
+      const resolvedGit = await realpath(resolve7(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -1735,22 +2043,22 @@ async function getGitInfo(cwd) {
   }
   return { branch: branch || null, worktree: isWorktree };
 }
-async function loadWorkspaceRecords(projectsDir) {
+async function loadWorkspaceRecords(projectsDir, assignmentsDir) {
   const records = [];
   try {
     const projects = await listProjects(projectsDir);
     for (const project of projects) {
-      const assignmentsDir = resolve5(projectsDir, project.slug, "assignments");
+      const projectAssignmentsDir = resolve7(projectsDir, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir2(assignmentsDir);
+        slugs = await readdir4(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve5(assignmentsDir, aslug, "assignment.md");
+        const aFile = resolve7(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile4(aFile, "utf-8");
+          const raw = await readFile6(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -1767,6 +2075,30 @@ async function loadWorkspaceRecords(projectsDir) {
     }
   } catch {
   }
+  if (assignmentsDir) {
+    try {
+      const entries = await readdir4(assignmentsDir);
+      for (const id of entries) {
+        if (id.startsWith(".") || id.startsWith("_")) continue;
+        const aFile = resolve7(assignmentsDir, id, "assignment.md");
+        try {
+          const raw = await readFile6(aFile, "utf-8");
+          const [fm] = extractFrontmatter2(raw);
+          if (!fm) continue;
+          records.push({
+            projectSlug: null,
+            assignmentSlug: id,
+            assignmentTitle: getField(fm, "title") ?? id,
+            worktreePath: getNestedField(fm, "workspace", "worktreePath") ?? null,
+            branch: getNestedField(fm, "workspace", "branch") ?? null
+          });
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+    }
+  }
   return records;
 }
 async function resolveAndNormalize(p) {
@@ -1959,7 +2291,7 @@ async function scanAllSessions(serversDir2, projectsDir, options) {
   const tmuxAvailable = await checkTmuxAvailable();
   const names = await listSessionFiles(serversDir2);
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
   const sessions = [];
   for (const name of names) {
     const data = await readSessionFile(serversDir2, name);
@@ -1974,11 +2306,11 @@ async function scanAllSessions(serversDir2, projectsDir, options) {
   cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
   return result;
 }
-async function scanSingleSession(serversDir2, projectsDir, name) {
+async function scanSingleSession(serversDir2, projectsDir, name, options) {
   const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir, options?.assignmentsDir);
   if (data.kind === "process") {
     return scanProcessSession(data, lsofOutput, workspaceRecords);
   }
@@ -1998,8 +2330,28 @@ var init_scanner = __esm({
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve6, dirname as dirname2 } from "path";
+import { readdir as readdir5, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve8, dirname as dirname2 } from "path";
+async function listStandaloneRecords(assignmentsDir) {
+  if (!assignmentsDir) return [];
+  if (!await fileExists(assignmentsDir)) return [];
+  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const assignmentDir = resolve8(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath)) continue;
+    try {
+      const content = await readFile7(assignmentMdPath, "utf-8");
+      const record = parseAssignmentFull(content);
+      records.push({ assignmentDir, id: entry.name, record });
+    } catch {
+    }
+  }
+  records.sort((left, right) => compareTimestamps(right.record.updated, left.record.updated));
+  return records;
+}
 function toTitleCase(s) {
   return s.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
@@ -2060,9 +2412,9 @@ async function listProjects(projectsDir) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw = await readFile5(registryPath, "utf-8");
+    const raw = await readFile7(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -2070,8 +2422,8 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
-  await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
+  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
+  await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir) {
   const [projectRecords, registered] = await Promise.all([
@@ -2103,15 +2455,16 @@ async function deleteWorkspace(projectsDir, name) {
   const filtered = registered.filter((w) => w !== name);
   await writeWorkspaceRegistry(projectsDir, filtered);
 }
-async function getOverview(projectsDir, serversDir2) {
+async function getOverview(projectsDir, serversDir2, assignmentsDir) {
   const projectRecords = await listProjectRecords(projectsDir);
-  const attention = buildAttentionItems(projectRecords);
-  const recentActivity = buildRecentActivity(projectRecords);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir);
+  const attention = buildAttentionItems(projectRecords, standaloneRecords);
+  const recentActivity = buildRecentActivity(projectRecords, standaloneRecords);
   let serverStats;
   if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir2, projectsDir);
+      const servers = await scanAllSessions2(serversDir2, projectsDir, { assignmentsDir });
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
         const totalPorts = servers.sessions.reduce((sum, s) => sum + s.windows.reduce((ws, w) => ws + w.panes.reduce((ps, p) => ps + p.ports.length, 0), 0), 0);
@@ -2127,7 +2480,7 @@ async function getOverview(projectsDir, serversDir2) {
   }
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    firstRun: projectRecords.length === 0,
+    firstRun: projectRecords.length === 0 && standaloneRecords.length === 0,
     stats: {
       activeProjects: projectRecords.filter((record) => record.summary.status === "active").length,
       inProgressAssignments: projectRecords.reduce(
@@ -2149,7 +2502,7 @@ async function getOverview(projectsDir, serversDir2) {
       staleAssignments: projectRecords.reduce(
         (total, record) => total + record.assignments.filter((assignment) => isStale(assignment.updated)).length,
         0
-      )
+      ) + standaloneRecords.filter((sr) => isStale(sr.record.updated)).length
     },
     attention: attention.slice(0, OVERVIEW_ATTENTION_LIMIT),
     recentProjects: projectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
@@ -2157,13 +2510,14 @@ async function getOverview(projectsDir, serversDir2) {
     serverStats
   };
 }
-async function getAttention(projectsDir, serversDir2) {
+async function getAttention(projectsDir, serversDir2, assignmentsDir) {
   const projectRecords = await listProjectRecords(projectsDir);
-  const items = buildAttentionItems(projectRecords);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir);
+  const items = buildAttentionItems(projectRecords, standaloneRecords);
   if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir2, projectsDir);
+      const servers = await scanAllSessions2(serversDir2, projectsDir, { assignmentsDir });
       for (const session of servers.sessions) {
         if (!session.alive) {
           items.push({
@@ -2207,9 +2561,9 @@ async function getAttention(projectsDir, serversDir2) {
     items: pagedItems
   };
 }
-async function listAssignmentsBoard(projectsDir) {
+async function listAssignmentsBoard(projectsDir, assignmentsDir) {
   const projectRecords = await listProjectRecords(projectsDir);
-  const assignments = await Promise.all(
+  const projectItems = await Promise.all(
     projectRecords.flatMap(
       async (record) => Promise.all(
         record.assignments.map(
@@ -2218,11 +2572,48 @@ async function listAssignmentsBoard(projectsDir) {
       )
     )
   );
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir);
+  const standaloneItems = await Promise.all(
+    standaloneRecords.map(async (sr) => toStandaloneBoardItem(sr))
+  );
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    assignments: assignments.flat().sort((left, right) => compareTimestamps(right.updated, left.updated))
+    assignments: [...projectItems.flat(), ...standaloneItems].sort((left, right) => compareTimestamps(right.updated, left.updated))
+  };
+}
+async function toStandaloneBoardItem(sr) {
+  return {
+    ...toAssignmentSummary(sr.record),
+    projectSlug: null,
+    projectTitle: null,
+    blockedReason: sr.record.blockedReason,
+    projectWorkspace: null,
+    availableTransitions: await getStandaloneAvailableTransitions(sr.record)
   };
 }
+async function getStandaloneAvailableTransitions(assignment) {
+  const config = await getStatusConfig();
+  const transitionDefs = getTransitionDefinitions(config);
+  const actions = [];
+  for (const definition of transitionDefs) {
+    let warning = null;
+    if (definition.command === "start" && !assignment.assignee) {
+      warning = "No assignee set \u2014 consider assigning before starting.";
+    }
+    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
+    actions.push({
+      command: definition.command,
+      label: definition.label,
+      description: definition.description,
+      targetStatus: target ?? definition.command,
+      disabled: false,
+      disabledReason: null,
+      warning,
+      requiresReason: definition.requiresReason
+    });
+  }
+  return actions;
+}
 async function getHelp() {
   return getDashboardHelp();
 }
@@ -2231,7 +2622,7 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile5(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -2242,16 +2633,44 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
     appendOnly: documentType === "handoff" || documentType === "decision-record"
   };
 }
+async function getEditableDocumentById(projectsDir, assignmentsDir, documentType, id) {
+  const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+  if (!resolved) return null;
+  if (!resolved.standalone && resolved.projectSlug) {
+    return getEditableDocument(
+      projectsDir,
+      documentType,
+      resolved.projectSlug,
+      resolved.assignmentSlug
+    );
+  }
+  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 = resolve8(resolved.assignmentDir, fileName);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile7(filePath, "utf-8");
+  const label = resolved.id;
+  const title = documentType === "assignment" ? `Edit Assignment: ${label}` : documentType === "plan" ? `Edit Plan: ${label}` : documentType === "scratchpad" ? `Edit Scratchpad: ${label}` : documentType === "handoff" ? `Append Handoff: ${label}` : `Append Decision: ${label}`;
+  return {
+    documentType,
+    title,
+    content,
+    projectSlug: null,
+    assignmentSlug: void 0,
+    assignmentId: resolved.id,
+    appendOnly: documentType === "handoff" || documentType === "decision-record"
+  };
+}
 async function getProjectDetail(projectsDir, slug) {
-  const projectPath = resolve6(projectsDir, slug);
-  const projectMdPath = resolve6(projectPath, "project.md");
+  const projectPath = resolve8(projectsDir, slug);
+  const projectMdPath = resolve8(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile5(projectMdPath, "utf-8");
+  const projectContent = await readFile7(projectMdPath, "utf-8");
   const project = parseProject(projectContent);
   const assignments = await listAssignmentRecords(projectPath);
-  const rollup = buildProjectRollup(project, assignments);
+  const rollup = await buildProjectRollup(projectPath, project, assignments);
   const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
   const resources = await listResources(projectPath);
   const memories = await listMemories(projectPath);
@@ -2278,17 +2697,17 @@ async function getProjectDetail(projectsDir, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve6(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve6(assignmentDir, "assignment.md");
+  const assignmentDir = resolve8(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile5(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile7(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve6(assignmentDir, "plan.md");
+  const planPath = resolve8(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile5(planPath, "utf-8");
+    const planContent = await readFile7(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2297,9 +2716,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve6(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile5(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile7(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2307,9 +2726,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve6(assignmentDir, "handoff.md");
+  const handoffPath = resolve8(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile5(handoffPath, "utf-8");
+    const handoffContent = await readFile7(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2318,9 +2737,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve6(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile5(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile7(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2328,6 +2747,28 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
       body: parsed.body
     };
   }
+  let progress = null;
+  const progressPath = resolve8(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const progressContent = await readFile7(progressPath, "utf-8");
+    const parsed = parseProgress(progressContent);
+    progress = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
+  let comments = null;
+  const commentsPath = resolve8(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const commentsContent = await readFile7(commentsPath, "utf-8");
+    const parsed = parseComments(commentsContent);
+    comments = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
   const detail = {
     id: assignment.id,
     projectSlug,
@@ -2351,6 +2792,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     scratchpad,
     handoff,
     decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
     availableTransitions: await getAvailableTransitions(
       projectsDir,
       projectSlug,
@@ -2414,85 +2858,276 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     });
   }
   detail.enrichedLinks = enrichedLinks;
+  detail.referencedBy = await computeReferencedBy(
+    { id: assignment.id, projectSlug, slug: detail.slug },
+    projectsDir,
+    void 0
+  );
   return detail;
 }
-async function listProjectRecords(projectsDir) {
-  if (!await fileExists(projectsDir)) {
-    return [];
-  }
-  const entries = await readdir3(projectsDir, { withFileTypes: true });
-  const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
-  const records = [];
-  for (const entry of projectDirs) {
-    const projectPath = resolve6(projectsDir, entry.name);
-    const projectMdPath = resolve6(projectPath, "project.md");
-    if (!await fileExists(projectMdPath)) {
-      continue;
+async function computeReferencedBy(target, projectsDir, assignmentsDir) {
+  const sources = [];
+  const projectRecords = await listProjectRecords(projectsDir);
+  for (const rec of projectRecords) {
+    for (const a of rec.assignments) {
+      sources.push({
+        id: a.id,
+        slug: a.slug,
+        title: a.title,
+        projectSlug: rec.summary.slug,
+        assignmentDir: resolve8(rec.projectPath, "assignments", a.slug)
+      });
     }
-    const projectContent = await readFile5(projectMdPath, "utf-8");
-    const project = parseProject(projectContent);
-    const assignments = await listAssignmentRecords(projectPath);
-    const rollup = buildProjectRollup(project, assignments);
-    const updated = getProjectActivityTimestamp(project.updated, assignments);
-    records.push({
-      projectPath,
-      project,
-      assignments,
-      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
-      summary: {
-        slug: project.slug || entry.name,
-        title: project.title,
-        status: rollup.status,
-        statusOverride: project.statusOverride,
-        archived: project.archived,
-        archivedAt: project.archivedAt,
-        archivedReason: project.archivedReason,
-        created: project.created,
-        updated,
-        tags: project.tags,
-        progress: rollup.progress,
-        needsAttention: rollup.needsAttention,
-        workspace: project.workspace
-      }
+  }
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir);
+  for (const sr of standaloneRecords) {
+    sources.push({
+      id: sr.id,
+      slug: sr.record.slug || sr.id,
+      title: sr.record.title,
+      projectSlug: null,
+      assignmentDir: sr.assignmentDir
     });
   }
-  records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
-  return records;
+  const references = [];
+  for (const source of sources) {
+    if (source.id === target.id) continue;
+    const mentions = await countMentionsInAssignment(source.assignmentDir, target);
+    if (mentions > 0) {
+      references.push({
+        sourceId: source.id,
+        sourceSlug: source.slug,
+        sourceTitle: source.title,
+        sourceProjectSlug: source.projectSlug,
+        mentions
+      });
+    }
+    if (references.length >= REFERENCED_BY_LIMIT) break;
+  }
+  return references.slice(0, REFERENCED_BY_LIMIT);
 }
-async function listAssignmentRecords(projectPath) {
-  const assignmentsDir = resolve6(projectPath, "assignments");
-  if (!await fileExists(assignmentsDir)) {
-    return [];
+async function countMentionsInAssignment(sourceDir, target) {
+  const bodies = [];
+  const assignmentMd = resolve8(sourceDir, "assignment.md");
+  if (await fileExists(assignmentMd)) {
+    const content = await readFile7(assignmentMd, "utf-8");
+    const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
+    if (todosMatch) bodies.push(todosMatch[1]);
   }
-  const entries = await readdir3(assignmentsDir, { withFileTypes: true });
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
+  for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
+    const path = resolve8(sourceDir, filename);
+    if (await fileExists(path)) {
+      try {
+        bodies.push(await readFile7(path, "utf-8"));
+      } catch {
+      }
     }
-    const assignmentMd = resolve6(assignmentsDir, entry.name, "assignment.md");
-    if (!await fileExists(assignmentMd)) {
-      continue;
+  }
+  let total = 0;
+  const patterns = buildLinkPatternsForTarget(target);
+  for (const body of bodies) {
+    for (const pattern of patterns) {
+      const matches = body.match(pattern);
+      if (matches) total += matches.length;
     }
-    const content = await readFile5(assignmentMd, "utf-8");
-    records.push(parseAssignmentFull(content));
+  }
+  return total;
+}
+function buildLinkPatternsForTarget(target) {
+  const patterns = [];
+  patterns.push(new RegExp(`/assignments/${escapeRegExpLocal(target.id)}(?:/|\\b)`, "g"));
+  if (target.projectSlug) {
+    patterns.push(
+      new RegExp(
+        `/projects/${escapeRegExpLocal(target.projectSlug)}/assignments/${escapeRegExpLocal(target.slug)}(?:/|\\b)`,
+        "g"
+      )
+    );
+    patterns.push(
+      new RegExp(`\\.\\./${escapeRegExpLocal(target.slug)}(?:/|\\b)`, "g")
+    );
+  }
+  return patterns;
+}
+function escapeRegExpLocal(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
+  const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+  if (!resolved) return null;
+  if (!resolved.standalone && resolved.projectSlug) {
+    const detail = await getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+    if (!detail) return null;
+    detail.referencedBy = await computeReferencedBy(
+      { id: detail.id, projectSlug: detail.projectSlug, slug: detail.slug },
+      projectsDir,
+      assignmentsDir
+    );
+    return detail;
+  }
+  const standaloneDetail = await buildStandaloneAssignmentDetail(resolved);
+  if (!standaloneDetail) return null;
+  standaloneDetail.referencedBy = await computeReferencedBy(
+    { id: standaloneDetail.id, projectSlug: null, slug: standaloneDetail.slug },
+    projectsDir,
+    assignmentsDir
+  );
+  return standaloneDetail;
+}
+async function buildStandaloneAssignmentDetail(resolved) {
+  const assignmentDir = resolved.assignmentDir;
+  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath)) return null;
+  const assignmentContent = await readFile7(assignmentMdPath, "utf-8");
+  const assignment = parseAssignmentFull(assignmentContent);
+  let plan = null;
+  const planPath = resolve8(assignmentDir, "plan.md");
+  if (await fileExists(planPath)) {
+    const parsed = parsePlan(await readFile7(planPath, "utf-8"));
+    plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
+  }
+  let scratchpad = null;
+  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
+  if (await fileExists(scratchpadPath)) {
+    const parsed = parseScratchpad(await readFile7(scratchpadPath, "utf-8"));
+    scratchpad = { updated: parsed.updated, body: parsed.body };
+  }
+  let handoff = null;
+  const handoffPath = resolve8(assignmentDir, "handoff.md");
+  if (await fileExists(handoffPath)) {
+    const parsed = parseHandoff(await readFile7(handoffPath, "utf-8"));
+    handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
+  }
+  let decisionRecord = null;
+  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
+  if (await fileExists(decisionRecordPath)) {
+    const parsed = parseDecisionRecord(await readFile7(decisionRecordPath, "utf-8"));
+    decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
+  }
+  let progress = null;
+  const progressPath = resolve8(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const parsed = parseProgress(await readFile7(progressPath, "utf-8"));
+    progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  let comments = null;
+  const commentsPath = resolve8(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const parsed = parseComments(await readFile7(commentsPath, "utf-8"));
+    comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  const detail = {
+    id: assignment.id,
+    projectSlug: null,
+    slug: assignment.slug || resolved.id,
+    title: assignment.title,
+    status: assignment.status,
+    priority: assignment.priority,
+    assignee: assignment.assignee,
+    dependsOn: [],
+    // standalone cannot declare dependencies
+    links: [],
+    reverseLinks: [],
+    enrichedLinks: [],
+    blockedReason: assignment.blockedReason,
+    workspace: assignment.workspace,
+    externalIds: assignment.externalIds,
+    tags: assignment.tags,
+    created: assignment.created,
+    updated: assignment.updated,
+    body: assignment.body,
+    plan,
+    scratchpad,
+    handoff,
+    decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
+    availableTransitions: await getStandaloneAvailableTransitions(assignment)
+  };
+  return detail;
+}
+async function listProjectRecords(projectsDir) {
+  if (!await fileExists(projectsDir)) {
+    return [];
+  }
+  if (!migratedProjectsDirs.has(projectsDir)) {
+    migratedProjectsDirs.add(projectsDir);
+    await migrateLegacyProjectFiles(projectsDir);
+  }
+  const entries = await readdir5(projectsDir, { withFileTypes: true });
+  const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+  const records = [];
+  for (const entry of projectDirs) {
+    const projectPath = resolve8(projectsDir, entry.name);
+    const projectMdPath = resolve8(projectPath, "project.md");
+    if (!await fileExists(projectMdPath)) {
+      continue;
+    }
+    const projectContent = await readFile7(projectMdPath, "utf-8");
+    const project = parseProject(projectContent);
+    const assignments = await listAssignmentRecords(projectPath);
+    const rollup = await buildProjectRollup(projectPath, project, assignments);
+    const updated = getProjectActivityTimestamp(project.updated, assignments);
+    records.push({
+      projectPath,
+      project,
+      assignments,
+      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
+      summary: {
+        slug: project.slug || entry.name,
+        title: project.title,
+        status: rollup.status,
+        statusOverride: project.statusOverride,
+        archived: project.archived,
+        archivedAt: project.archivedAt,
+        archivedReason: project.archivedReason,
+        created: project.created,
+        updated,
+        tags: project.tags,
+        progress: rollup.progress,
+        needsAttention: rollup.needsAttention,
+        workspace: project.workspace
+      }
+    });
+  }
+  records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
+  return records;
+}
+async function listAssignmentRecords(projectPath) {
+  const assignmentsDir = resolve8(projectPath, "assignments");
+  if (!await fileExists(assignmentsDir)) {
+    return [];
+  }
+  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const assignmentMd = resolve8(assignmentsDir, entry.name, "assignment.md");
+    if (!await fileExists(assignmentMd)) {
+      continue;
+    }
+    const content = await readFile7(assignmentMd, "utf-8");
+    records.push(parseAssignmentFull(content));
   }
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve6(projectPath, "resources");
+  const resourcesDir = resolve8(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir3(resourcesDir, { withFileTypes: true });
+  const entries = await readdir5(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve6(resourcesDir, entry.name);
-    const content = await readFile5(filePath, "utf-8");
+    const filePath = resolve8(resourcesDir, entry.name);
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -2507,18 +3142,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve6(projectPath, "memories");
+  const memoriesDir = resolve8(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir3(memoriesDir, { withFileTypes: true });
+  const entries = await readdir5(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve6(memoriesDir, entry.name);
-    const content = await readFile5(filePath, "utf-8");
+    const filePath = resolve8(memoriesDir, entry.name);
+    const content = await readFile7(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -2533,9 +3168,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve6(projectPath, "_status.md");
+  const statusPath = resolve8(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile5(statusPath, "utf-8");
+    const statusContent = await readFile7(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -2544,13 +3179,13 @@ async function loadDependencyGraph(projectPath, assignments) {
   }
   return buildDependencyGraph(assignments);
 }
-function buildProjectRollup(project, assignments) {
+async function buildProjectRollup(projectPath, project, assignments) {
   const progress = { total: assignments.length };
   let openQuestions = 0;
   for (const assignment of assignments) {
     const s = assignment.status;
     progress[s] = (progress[s] ?? 0) + 1;
-    openQuestions += countPendingAnswers(assignment.body);
+    openQuestions += await countOpenQuestions(projectPath, assignment.slug);
   }
   const needsAttention = {
     blockedCount: progress["blocked"] ?? 0,
@@ -2635,7 +3270,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve6(projectsDir, projectSlug);
+  const projectPath = resolve8(projectsDir, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -2665,12 +3300,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve6(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve8(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile5(dependencyPath, "utf-8");
+    const content = await readFile7(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -2678,7 +3313,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
   }
   return unmet;
 }
-function buildAttentionItems(projectRecords) {
+function buildAttentionItems(projectRecords, standaloneRecords = []) {
   const items = [];
   for (const record of projectRecords) {
     for (const assignment of record.assignments) {
@@ -2728,9 +3363,36 @@ function buildAttentionItems(projectRecords) {
       }
     }
   }
+  for (const sr of standaloneRecords) {
+    const assignment = sr.record;
+    const stale = isStale(assignment.updated);
+    const base = {
+      projectSlug: null,
+      projectTitle: null,
+      assignmentSlug: assignment.slug || sr.id,
+      assignmentTitle: assignment.title,
+      status: assignment.status,
+      updated: assignment.updated,
+      href: `/assignments/${sr.id}`,
+      blockedReason: assignment.blockedReason,
+      stale
+    };
+    if (assignment.status === "failed") {
+      items.push({ id: `standalone:${sr.id}:failed`, severity: "critical", reason: "Marked failed and needs a recovery decision.", ...base });
+    }
+    if (assignment.status === "blocked") {
+      items.push({ id: `standalone:${sr.id}:blocked`, severity: "high", reason: assignment.blockedReason || "Blocked and waiting for intervention.", ...base });
+    }
+    if (assignment.status === "review") {
+      items.push({ id: `standalone:${sr.id}:review`, severity: "medium", reason: "Ready for review.", ...base });
+    }
+    if (stale) {
+      items.push({ id: `standalone:${sr.id}:stale`, severity: "low", reason: "No source updates have been recorded in the last 7 days.", ...base });
+    }
+  }
   return items.sort(compareAttentionItems);
 }
-function buildRecentActivity(projectRecords) {
+function buildRecentActivity(projectRecords, standaloneRecords = []) {
   const activity = [];
   for (const record of projectRecords) {
     activity.push({
@@ -2758,6 +3420,20 @@ function buildRecentActivity(projectRecords) {
       });
     }
   }
+  for (const sr of standaloneRecords) {
+    const assignment = sr.record;
+    activity.push({
+      id: `standalone-assignment:${sr.id}`,
+      type: "assignment",
+      title: assignment.title,
+      updated: assignment.updated,
+      href: `/assignments/${sr.id}`,
+      projectSlug: null,
+      projectTitle: null,
+      assignmentSlug: assignment.slug || sr.id,
+      summary: `Standalone assignment is ${assignment.status} with ${assignment.priority} priority.`
+    });
+  }
   activity.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return activity;
 }
@@ -2783,9 +3459,25 @@ function isStale(updated) {
   }
   return Date.now() - timestamp > STALE_ASSIGNMENT_MS;
 }
-function countPendingAnswers(body) {
-  const matches = body.match(/^\*\*A:\*\*\s+pending\s*$/gim);
-  return matches ? matches.length : 0;
+async function countOpenQuestions(projectPath, assignmentSlug) {
+  const commentsPath = resolve8(
+    projectPath,
+    "assignments",
+    assignmentSlug,
+    "comments.md"
+  );
+  if (!await fileExists(commentsPath)) {
+    return 0;
+  }
+  try {
+    const content = await readFile7(commentsPath, "utf-8");
+    const parsed = parseComments(content);
+    return parsed.entries.filter(
+      (e) => e.type === "question" && e.resolved !== true
+    ).length;
+  } catch {
+    return 0;
+  }
 }
 function getProjectActivityTimestamp(projectUpdated, assignments) {
   let latest = projectUpdated;
@@ -2799,17 +3491,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve6(projectsDir, projectSlug, "project.md");
+      return resolve8(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -2836,12 +3528,12 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return [];
-  const entries = await readdir3(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve6(playbooksDir2, entry.name);
-    const raw = await readFile5(filePath, "utf-8");
+    const filePath = resolve8(playbooksDir2, entry.name);
+    const raw = await readFile7(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -2857,9 +3549,9 @@ async function listPlaybooks(playbooksDir2) {
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
 async function getPlaybookDetail(playbooksDir2, slug) {
-  const filePath = resolve6(playbooksDir2, `${slug}.md`);
+  const filePath = resolve8(playbooksDir2, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile5(filePath, "utf-8");
+  const raw = await readFile7(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
   return {
     slug: parsed.slug || slug,
@@ -2872,13 +3564,15 @@ async function getPlaybookDetail(playbooksDir2, slug) {
     body: parsed.body
   };
 }
-var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, 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();
     STALE_ASSIGNMENT_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -2939,6 +3633,8 @@ var init_api = __esm({
       failed: "rose"
     };
     _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",
@@ -2971,8 +3667,8 @@ __export(parser_exports, {
   writeChecklist: () => writeChecklist
 });
 import { randomBytes } from "crypto";
-import { readFile as readFile10 } from "fs/promises";
-import { resolve as resolve13 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { resolve as resolve15 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -3132,10 +3828,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve13(todosDir2, `${workspace}.md`);
+  return resolve15(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve13(todosDir2, `${workspace}-log.md`);
+  return resolve15(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -3159,14 +3855,14 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve13(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve15(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
 async function readChecklist(todosDir2, workspace) {
   const path = checklistPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, archiveInterval: "weekly", items: [] };
   }
-  const content = await readFile10(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseChecklist(content);
 }
 async function writeChecklist(todosDir2, checklist) {
@@ -3179,7 +3875,7 @@ async function readLog(todosDir2, workspace) {
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
-  const content = await readFile10(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseLog(content);
 }
 async function appendLogEntry2(todosDir2, workspace, entry) {
@@ -3187,7 +3883,7 @@ async function appendLogEntry2(todosDir2, workspace, entry) {
   const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
-    content = await readFile10(path, "utf-8");
+    content = await readFile12(path, "utf-8");
     content = content.trimEnd() + "\n\n" + serializeLogEntry(entry) + "\n";
   } else {
     const fm = `---
@@ -3223,93 +3919,459 @@ var init_parser2 = __esm({
 // src/dashboard/server.ts
 init_paths();
 init_api();
+init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve15 } from "path";
-import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
+import { resolve as resolve17 } from "path";
+import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
-// src/dashboard/watcher.ts
-import { watch } from "chokidar";
-import { relative, sep } from "path";
-function createWatcher(options) {
-  const { projectsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
-  const pendingEvents = /* @__PURE__ */ new Map();
-  const projectsWatcher = watch(projectsDir, {
-    ignoreInitial: true,
-    persistent: true,
-    depth: 10,
-    ignored: /(^|[\/\\])\../
-  });
-  function handleProjectChange(filePath) {
-    const rel = relative(projectsDir, filePath);
-    const parts = rel.split(sep);
-    if (parts.length === 0) return;
-    const projectSlug = parts[0];
-    let assignmentSlug;
-    if (parts.length >= 3 && parts[1] === "assignments") {
-      assignmentSlug = parts[2];
+// src/dashboard/agent-sessions.ts
+init_fs();
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+
+// src/dashboard/session-db.ts
+init_paths();
+init_fs();
+import Database from "better-sqlite3";
+import { resolve as resolve9 } from "path";
+import { readdir as readdir6 } from "fs/promises";
+var db = null;
+var SCHEMA_VERSION = "3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+  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'))
+);
+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 ?? resolve9(syntaurRoot(), "syntaur.db");
+  db = new Database(finalPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(SCHEMA_SQL);
+  db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+    "schema_version",
+    SCHEMA_VERSION
+  );
+  const database = db;
+  const runMigrations = database.transaction(() => {
+    const vBeforeV2 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV2 === "1") {
+      database.exec(`
+        CREATE TABLE sessions_v2 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v2 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, NULL, created_at, updated_at FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v2 RENAME TO sessions;
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '2' WHERE key = 'schema_version';
+      `);
+    }
+    const vBeforeV3 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV3 === "2") {
+      const v2Columns = database.prepare("PRAGMA table_info(sessions)").all();
+      const v2ColNames = v2Columns.map((c) => c.name);
+      const hasProject = v2ColNames.includes("project_slug");
+      const hasMission = v2ColNames.includes("mission_slug");
+      const projectSlugExpr = hasProject && hasMission ? "COALESCE(project_slug, mission_slug)" : hasProject ? "project_slug" : hasMission ? "mission_slug" : null;
+      if (!projectSlugExpr) {
+        throw new Error(
+          "sessions table has neither project_slug nor mission_slug; cannot migrate from v2 to v3"
+        );
+      }
+      database.exec(`
+        CREATE TABLE sessions_v3 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          transcript_path TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v3
+          SELECT session_id, ${projectSlugExpr}, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v3 RENAME TO sessions;
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '3' WHERE key = 'schema_version';
+      `);
     }
-    const debounceKey = assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
-    const existing = pendingEvents.get(debounceKey);
-    if (existing) clearTimeout(existing);
-    const messageType = assignmentSlug ? "assignment-updated" : "project-updated";
-    pendingEvents.set(
-      debounceKey,
-      setTimeout(() => {
-        pendingEvents.delete(debounceKey);
-        const message = {
-          type: messageType,
-          projectSlug,
-          assignmentSlug,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        onMessage(message);
-      }, debounceMs)
+  });
+  runMigrations.exclusive();
+  db.exec(POST_MIGRATION_INDEXES_SQL);
+  return db;
+}
+function getSessionDb() {
+  if (!db) {
+    throw new Error(
+      "Session database not initialized. Call initSessionDb() first."
     );
   }
-  projectsWatcher.on("change", handleProjectChange);
-  projectsWatcher.on("add", handleProjectChange);
-  projectsWatcher.on("unlink", handleProjectChange);
-  let serversWatcher = null;
-  if (serversDir2) {
-    let handleServerChange2 = function() {
-      const debounceKey = "__servers__";
-      const existing = pendingEvents.get(debounceKey);
-      if (existing) clearTimeout(existing);
-      pendingEvents.set(
-        debounceKey,
-        setTimeout(() => {
-          pendingEvents.delete(debounceKey);
-          const message = {
-            type: "servers-updated",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          onMessage(message);
-        }, debounceMs)
-      );
-    };
-    var handleServerChange = handleServerChange2;
-    serversWatcher = watch(serversDir2, {
-      ignoreInitial: true,
-      persistent: true,
-      depth: 1,
-      ignored: /(^|[\/\\])\../
-    });
-    serversWatcher.on("change", handleServerChange2);
-    serversWatcher.on("add", handleServerChange2);
-    serversWatcher.on("unlink", handleServerChange2);
+  return db;
+}
+function closeSessionDb() {
+  if (db) {
+    db.close();
+    db = null;
   }
-  let playbooksWatcher = null;
-  if (playbooksDir2) {
-    let handlePlaybookChange2 = function() {
-      const debounceKey = "__playbooks__";
-      const existing = pendingEvents.get(debounceKey);
-      if (existing) clearTimeout(existing);
-      pendingEvents.set(
-        debounceKey,
-        setTimeout(() => {
-          pendingEvents.delete(debounceKey);
+}
+async function migrateFromMarkdown(projectsDir) {
+  const database = getSessionDb();
+  const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  if (count.count > 0) return 0;
+  if (!await fileExists(projectsDir)) return 0;
+  const entries = await readdir6(projectsDir, { withFileTypes: true });
+  const allSessions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const projectDir = resolve9(projectsDir, entry.name);
+    const indexPath = resolve9(projectDir, "_index-sessions.md");
+    if (!await fileExists(indexPath)) continue;
+    const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
+    allSessions.push(...sessions);
+  }
+  if (allSessions.length === 0) return 0;
+  const insert = database.prepare(`
+    INSERT OR IGNORE INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertAll = database.transaction((sessions) => {
+    for (const s of sessions) {
+      insert.run(s.sessionId, s.projectSlug, s.assignmentSlug, s.agent, s.started, s.status, s.path);
+    }
+  });
+  insertAll(allSessions);
+  console.log(`Migrated ${allSessions.length} sessions from markdown to SQLite.`);
+  return allSessions.length;
+}
+async function parseMarkdownSessionsIndex(filePath, projectSlug) {
+  const { readFile: readFile14 } = await import("fs/promises");
+  const raw = await readFile14(filePath, "utf-8");
+  const sessions = [];
+  const lines = raw.split("\n");
+  let inTable = false;
+  let headerSeen = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("| Assignment") || trimmed.startsWith("|Assignment")) {
+      inTable = true;
+      headerSeen = false;
+      continue;
+    }
+    if (inTable && !headerSeen && trimmed.match(/^\|[-\s|]+\|$/)) {
+      headerSeen = true;
+      continue;
+    }
+    if (inTable && headerSeen && trimmed.startsWith("|")) {
+      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+      if (cells.length >= 6) {
+        sessions.push({
+          assignmentSlug: cells[0],
+          agent: cells[1],
+          sessionId: cells[2],
+          started: cells[3],
+          status: cells[4] || "active",
+          path: cells[5],
+          projectSlug
+        });
+      }
+    }
+  }
+  return sessions;
+}
+
+// src/dashboard/agent-sessions.ts
+function rowToSession(row) {
+  return {
+    sessionId: row.session_id,
+    projectSlug: row.project_slug ?? null,
+    assignmentSlug: row.assignment_slug ?? null,
+    agent: row.agent,
+    started: row.started,
+    ended: row.ended ?? null,
+    status: row.status,
+    path: row.path ?? "",
+    description: row.description ?? null,
+    transcriptPath: row.transcript_path ?? null
+  };
+}
+async function appendSession(_projectDir, session) {
+  const db2 = getSessionDb();
+  db2.prepare(`
+    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(NULLIF(excluded.project_slug, ''),    project_slug),
+      assignment_slug = COALESCE(NULLIF(excluded.assignment_slug, ''), assignment_slug),
+      agent           = excluded.agent,
+      status          = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
+      path            = COALESCE(NULLIF(excluded.path, ''),            path),
+      description     = COALESCE(NULLIF(excluded.description, ''),     description),
+      transcript_path = COALESCE(NULLIF(excluded.transcript_path, ''), transcript_path),
+      updated_at      = datetime('now')
+  `).run(
+    session.sessionId,
+    session.projectSlug ?? null,
+    session.assignmentSlug ?? null,
+    session.agent,
+    session.started,
+    session.status,
+    session.path,
+    session.description ?? null,
+    session.transcriptPath ?? null
+  );
+}
+async function updateSessionStatus(_projectDir, sessionId, status) {
+  const db2 = getSessionDb();
+  const isTerminal = status === "completed" || status === "stopped";
+  const result = isTerminal ? db2.prepare(
+    "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, sessionId) : db2.prepare(
+    "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, sessionId);
+  return result.changes > 0;
+}
+async function listAllSessions(_projectsDir) {
+  const db2 = getSessionDb();
+  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  return rows.map(rowToSession);
+}
+async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  if (assignmentSlug) {
+    const rows2 = db2.prepare(
+      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+    ).all(projectSlug, assignmentSlug);
+    return rows2.map(rowToSession);
+  }
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  return rows.map(rowToSession);
+}
+async function deleteSessions(sessionIds) {
+  if (sessionIds.length === 0) return 0;
+  const db2 = getSessionDb();
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+  return result.changes;
+}
+var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
+async function readAssignmentStatusFromPath(assignmentMdPath) {
+  if (!await fileExists(assignmentMdPath)) return null;
+  const raw = await readFile8(assignmentMdPath, "utf-8");
+  const match = raw.match(/^status:\s*(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+async function readAssignmentStatus(projectDir, assignmentSlug) {
+  return readAssignmentStatusFromPath(
+    resolve10(projectDir, "assignments", assignmentSlug, "assignment.md")
+  );
+}
+async function reconcileActiveSessions(projectsDir, assignmentsDir) {
+  const db2 = getSessionDb();
+  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  if (activeSessions.length === 0) return 0;
+  const assignmentStatuses = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const session of activeSessions) {
+    const aslug = session.assignment_slug;
+    if (!aslug) continue;
+    const projectKey = session.project_slug ?? "__standalone__";
+    const key = `${projectKey}/${aslug}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (session.project_slug) {
+      const status = await readAssignmentStatus(
+        resolve10(projectsDir, session.project_slug),
+        aslug
+      );
+      if (status) assignmentStatuses.set(key, status);
+    } else if (assignmentsDir) {
+      const status = await readAssignmentStatusFromPath(
+        resolve10(assignmentsDir, aslug, "assignment.md")
+      );
+      if (status) assignmentStatuses.set(key, status);
+    }
+  }
+  let totalUpdated = 0;
+  for (const session of activeSessions) {
+    const projectKey = session.project_slug ?? "__standalone__";
+    const key = `${projectKey}/${session.assignment_slug}`;
+    const assignmentStatus = assignmentStatuses.get(key);
+    if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
+    const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
+    await updateSessionStatus("", session.session_id, newStatus);
+    totalUpdated++;
+  }
+  return totalUpdated;
+}
+async function listSessionsByAssignment(projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  const rows = projectSlug === null ? db2.prepare(
+    "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
+  ).all(assignmentSlug) : db2.prepare(
+    "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+  ).all(projectSlug, assignmentSlug);
+  return rows.map(rowToSession);
+}
+
+// src/dashboard/watcher.ts
+import { watch } from "chokidar";
+import { relative, sep } from "path";
+function createWatcher(options) {
+  const { projectsDir, assignmentsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
+  const pendingEvents = /* @__PURE__ */ new Map();
+  const projectsWatcher = watch(projectsDir, {
+    ignoreInitial: true,
+    persistent: true,
+    depth: 10,
+    ignored: /(^|[\/\\])\../
+  });
+  function handleProjectChange(filePath) {
+    const rel = relative(projectsDir, filePath);
+    const parts = rel.split(sep);
+    if (parts.length === 0) return;
+    const projectSlug = parts[0];
+    let assignmentSlug;
+    if (parts.length >= 3 && parts[1] === "assignments") {
+      assignmentSlug = parts[2];
+    }
+    const debounceKey = assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
+    const existing = pendingEvents.get(debounceKey);
+    if (existing) clearTimeout(existing);
+    const messageType = assignmentSlug ? "assignment-updated" : "project-updated";
+    pendingEvents.set(
+      debounceKey,
+      setTimeout(() => {
+        pendingEvents.delete(debounceKey);
+        const message = {
+          type: messageType,
+          projectSlug,
+          assignmentSlug,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        onMessage(message);
+      }, debounceMs)
+    );
+  }
+  projectsWatcher.on("change", handleProjectChange);
+  projectsWatcher.on("add", handleProjectChange);
+  projectsWatcher.on("unlink", handleProjectChange);
+  let standaloneWatcher = null;
+  if (assignmentsDir) {
+    let handleStandaloneChange2 = function(filePath) {
+      const rel = relative(assignmentsDir, filePath);
+      const parts = rel.split(sep);
+      if (parts.length === 0) return;
+      const assignmentId = parts[0];
+      if (!assignmentId) return;
+      const debounceKey = `__standalone__/${assignmentId}`;
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
+          const message = {
+            type: "assignment-updated",
+            projectSlug: null,
+            assignmentSlug: assignmentId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          onMessage(message);
+        }, debounceMs)
+      );
+    };
+    var handleStandaloneChange = handleStandaloneChange2;
+    standaloneWatcher = watch(assignmentsDir, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 5,
+      ignored: /(^|[\/\\])\../
+    });
+    standaloneWatcher.on("change", handleStandaloneChange2);
+    standaloneWatcher.on("add", handleStandaloneChange2);
+    standaloneWatcher.on("unlink", handleStandaloneChange2);
+  }
+  let serversWatcher = null;
+  if (serversDir2) {
+    let handleServerChange2 = function() {
+      const debounceKey = "__servers__";
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
+          const message = {
+            type: "servers-updated",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          onMessage(message);
+        }, debounceMs)
+      );
+    };
+    var handleServerChange = handleServerChange2;
+    serversWatcher = watch(serversDir2, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 1,
+      ignored: /(^|[\/\\])\../
+    });
+    serversWatcher.on("change", handleServerChange2);
+    serversWatcher.on("add", handleServerChange2);
+    serversWatcher.on("unlink", handleServerChange2);
+  }
+  let playbooksWatcher = null;
+  if (playbooksDir2) {
+    let handlePlaybookChange2 = function() {
+      const debounceKey = "__playbooks__";
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
           const message = {
             type: "playbooks-updated",
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -3365,6 +4427,7 @@ function createWatcher(options) {
       });
       pendingEvents.clear();
       await projectsWatcher.close();
+      if (standaloneWatcher) await standaloneWatcher.close();
       if (serversWatcher) await serversWatcher.close();
       if (playbooksWatcher) await playbooksWatcher.close();
       if (todosWatcher) await todosWatcher.close();
@@ -3379,8 +4442,8 @@ init_config2();
 // src/dashboard/api-write.ts
 init_lifecycle();
 import { Router } from "express";
-import { resolve as resolve7 } from "path";
-import { rm, readFile as readFile6 } from "fs/promises";
+import { resolve as resolve11 } from "path";
+import { rm, readFile as readFile9 } from "fs/promises";
 
 // src/utils/slug.ts
 function isValidSlug(slug) {
@@ -3445,6 +4508,7 @@ function toggleAcceptanceCriterion(content, index, checked) {
 
 // src/dashboard/api-write.ts
 init_api();
+init_assignment_resolver();
 
 // src/templates/index.ts
 init_config();
@@ -3608,12 +4672,60 @@ No handoffs recorded yet.
 `;
 }
 
-// src/templates/decision-record.ts
-function renderDecisionRecord(params) {
+// src/templates/progress.ts
+function renderProgress(params) {
   return `---
-assignment: ${params.assignmentSlug}
+assignment: ${params.assignment}
+entryCount: 0
+generated: "${params.timestamp}"
 updated: "${params.timestamp}"
-decisionCount: 0
+---
+
+# Progress
+
+No progress yet.
+`;
+}
+
+// src/templates/comments.ts
+function renderComments(params) {
+  return `---
+assignment: ${params.assignment}
+entryCount: 0
+generated: "${params.timestamp}"
+updated: "${params.timestamp}"
+---
+
+# Comments
+
+No comments yet.
+`;
+}
+function formatCommentEntry(comment) {
+  const lines = [];
+  lines.push(`## ${comment.id}`);
+  lines.push("");
+  lines.push(`**Recorded:** ${comment.timestamp}`);
+  lines.push(`**Author:** ${comment.author}`);
+  lines.push(`**Type:** ${comment.type}`);
+  if (comment.replyTo) {
+    lines.push(`**Reply to:** ${comment.replyTo}`);
+  }
+  if (comment.type === "question") {
+    lines.push(`**Resolved:** ${comment.resolved ? "true" : "false"}`);
+  }
+  lines.push("");
+  lines.push(comment.body.trim());
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/templates/decision-record.ts
+function renderDecisionRecord(params) {
+  return `---
+assignment: ${params.assignmentSlug}
+updated: "${params.timestamp}"
+decisionCount: 0
 ---
 
 # Decision Record
@@ -3753,6 +4865,8 @@ tags: []
 }
 
 // src/dashboard/api-write.ts
+init_lifecycle();
+init_parser();
 function extractFrontmatter3(content) {
   const trimmed = content.trimStart();
   if (!trimmed.startsWith("---\n") && !trimmed.startsWith("---\r\n")) {
@@ -3852,9 +4966,9 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile6(filePath, "utf-8");
+  return readFile9(filePath, "utf-8");
 }
-function createWriteRouter(projectsDir) {
+function createWriteRouter(projectsDir, assignmentsDir) {
   const router = Router();
   router.get("/api/templates/project", (_req, res) => {
     const content = renderProject({
@@ -3982,26 +5096,26 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve7(projectsDir, slug);
+      const projectDir = resolve11(projectsDir, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve7(projectDir, "assignments"));
-      await ensureDir(resolve7(projectDir, "resources"));
-      await ensureDir(resolve7(projectDir, "memories"));
-      await writeFileForce(resolve7(projectDir, "project.md"), content);
+      await ensureDir(resolve11(projectDir, "assignments"));
+      await ensureDir(resolve11(projectDir, "resources"));
+      await ensureDir(resolve11(projectDir, "memories"));
+      await writeFileForce(resolve11(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve7(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve7(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve7(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve7(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve7(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve7(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve7(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve11(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve11(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve11(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve11(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve11(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve11(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve11(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -4022,8 +5136,8 @@ function createWriteRouter(projectsDir) {
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve7(projectsDir, projectSlug);
-      const projectMdPath = resolve7(projectDir, "project.md");
+      const projectDir = resolve11(projectsDir, projectSlug);
+      const projectMdPath = resolve11(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -4053,7 +5167,7 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve7(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve11(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -4062,12 +5176,12 @@ function createWriteRouter(projectsDir) {
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve7(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve11(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve7(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve7(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve7(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve11(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve11(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve11(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -4088,7 +5202,7 @@ function createWriteRouter(projectsDir) {
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -4121,7 +5235,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4164,7 +5278,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4200,7 +5314,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve7(
+      const planPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4238,7 +5352,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve7(
+      const scratchpadPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4276,7 +5390,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve7(
+      const handoffPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4314,7 +5428,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve7(
+      const decisionPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4348,10 +5462,121 @@ function createWriteRouter(projectsDir) {
       res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
     }
   });
+  router.post("/api/projects/:slug/assignments/:aslug/comments", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const commentsPath = resolve11(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "comments.md"
+      );
+      const { body, author, type, replyTo } = req.body || {};
+      if (!body || typeof body !== "string" || !body.trim()) {
+        res.status(400).json({ error: "body is required" });
+        return;
+      }
+      const commentType = type && ["question", "note", "feedback"].includes(type) ? type : "note";
+      const timestamp = nowTimestamp();
+      const entryAuthor = typeof author === "string" && author.trim() ? author.trim() : "human";
+      let currentContent;
+      let currentCount = 0;
+      if (await fileExists(commentsPath)) {
+        currentContent = await readFile9(commentsPath, "utf-8");
+        const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
+        if (countMatch) currentCount = parseInt(countMatch[1], 10);
+      } else {
+        currentContent = renderComments({
+          assignment: assignmentSlug,
+          timestamp
+        });
+      }
+      const comment = {
+        id: generateId().split("-")[0],
+        timestamp,
+        author: entryAuthor,
+        type: commentType,
+        body,
+        replyTo: typeof replyTo === "string" && replyTo.trim() ? replyTo.trim() : void 0,
+        resolved: commentType === "question" ? false : void 0
+      };
+      const entry = formatCommentEntry(comment);
+      let next = setTopLevelField(currentContent, "entryCount", String(currentCount + 1));
+      next = setTopLevelField(next, "updated", `"${timestamp}"`);
+      if (next.includes("No comments yet.")) {
+        next = next.replace("No comments yet.", entry.trimEnd());
+      } else {
+        next = `${next.trimEnd()}
+
+${entry}`;
+      }
+      await writeFileForce(commentsPath, next);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.status(201).json({ assignment, comment: { id: comment.id } });
+    } catch (error) {
+      console.error("Error appending comment:", error);
+      res.status(500).json({ error: `Failed to append comment: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug/assignments/:aslug/comments/:commentId/resolved", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const commentId = getParam(req.params.commentId);
+      const commentsPath = resolve11(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "comments.md"
+      );
+      if (!await fileExists(commentsPath)) {
+        res.status(404).json({ error: "Comments file not found" });
+        return;
+      }
+      const { resolved } = req.body || {};
+      if (typeof resolved !== "boolean") {
+        res.status(400).json({ error: "resolved (boolean) is required" });
+        return;
+      }
+      const content = await readFile9(commentsPath, "utf-8");
+      const parsed = parseComments(content);
+      const target = parsed.entries.find((e) => e.id === commentId);
+      if (!target) {
+        res.status(404).json({ error: `Comment ${commentId} not found` });
+        return;
+      }
+      if (target.type !== "question") {
+        res.status(400).json({ error: "Only questions can be resolved" });
+        return;
+      }
+      const entryBlockRegex = new RegExp(
+        `(^## ${commentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?)(\\*\\*Resolved:\\*\\*\\s*(?:true|false))`,
+        "m"
+      );
+      const next = content.replace(
+        entryBlockRegex,
+        (_m, preamble) => `${preamble}**Resolved:** ${resolved ? "true" : "false"}`
+      );
+      if (next === content) {
+        res.status(500).json({ error: "Failed to update resolved flag" });
+        return;
+      }
+      const withUpdated = setTopLevelField(next, "updated", `"${nowTimestamp()}"`);
+      await writeFileForce(commentsPath, withUpdated);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment });
+    } catch (error) {
+      console.error("Error toggling comment resolved flag:", error);
+      res.status(500).json({ error: `Failed to toggle resolved: ${error.message}` });
+    }
+  });
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -4361,7 +5586,7 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile6(projectPath, "utf-8");
+      let content = await readFile9(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -4375,7 +5600,7 @@ function createWriteRouter(projectsDir) {
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -4387,7 +5612,7 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile6(projectPath, "utf-8");
+      let content = await readFile9(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -4402,7 +5627,7 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
+      const assignmentPath = resolve11(
         projectsDir,
         projectSlug,
         "assignments",
@@ -4420,7 +5645,7 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile6(assignmentPath, "utf-8");
+      let content = await readFile9(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -4445,8 +5670,8 @@ function createWriteRouter(projectsDir) {
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve7(projectsDir, projectSlug);
-      const assignmentPath = resolve7(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve11(projectsDir, projectSlug);
+      const assignmentPath = resolve11(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -4472,8 +5697,8 @@ function createWriteRouter(projectsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve7(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve7(assignmentDir, "assignment.md");
+      const assignmentDir = resolve11(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve11(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -4485,18 +5710,569 @@ function createWriteRouter(projectsDir) {
       res.status(500).json({ error: `Failed to delete assignment: ${error.message}` });
     }
   });
+  router.post("/api/assignments", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const { title, slug, priority, type } = req.body || {};
+      if (!title || typeof title !== "string" || !title.trim()) {
+        res.status(400).json({ error: "title is required" });
+        return;
+      }
+      const { dependsOn } = req.body || {};
+      if (Array.isArray(dependsOn) && dependsOn.length > 0) {
+        res.status(400).json({ error: "Standalone assignments cannot declare dependsOn." });
+        return;
+      }
+      const id = generateId();
+      const assignmentDir = resolve11(assignmentsDir, id);
+      if (await fileExists(assignmentDir)) {
+        res.status(500).json({ error: "UUID collision \u2014 try again" });
+        return;
+      }
+      const timestamp = nowTimestamp();
+      const resolvedSlug = typeof slug === "string" && slug.trim() ? slug.trim() : slugifyLocal(title);
+      const resolvedPriority = typeof priority === "string" && ["low", "medium", "high", "critical"].includes(priority) ? priority : "medium";
+      await ensureDir(assignmentDir);
+      const assignmentContent = renderAssignment({
+        id,
+        slug: resolvedSlug,
+        title: title.trim(),
+        timestamp,
+        priority: resolvedPriority,
+        dependsOn: [],
+        links: [],
+        project: null,
+        type: typeof type === "string" ? type : void 0
+      });
+      await writeFileForce(resolve11(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(
+        resolve11(assignmentDir, "scratchpad.md"),
+        renderScratchpad({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve11(assignmentDir, "handoff.md"),
+        renderHandoff({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve11(assignmentDir, "decision-record.md"),
+        renderDecisionRecord({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve11(assignmentDir, "progress.md"),
+        renderProgress({ assignment: id, timestamp })
+      );
+      await writeFileForce(
+        resolve11(assignmentDir, "comments.md"),
+        renderComments({ assignment: id, timestamp })
+      );
+      const detail = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.status(201).json({ assignment: detail });
+    } catch (error) {
+      console.error("Error creating standalone assignment:", error);
+      res.status(500).json({ error: `Failed to create standalone assignment: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/comments", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      await appendCommentTo(resolved.assignmentDir, resolved.standalone ? resolved.id : resolved.assignmentSlug, req, res, async () => {
+        return resolved.standalone ? getAssignmentDetailById(projectsDir, assignmentsDir, id) : getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+      });
+    } catch (error) {
+      console.error("Error appending comment (by id):", error);
+      res.status(500).json({ error: `Failed to append comment: ${error.message}` });
+    }
+  });
+  router.patch("/api/assignments/:id/comments/:commentId/resolved", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const commentId = getParam(req.params.commentId);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      await toggleCommentResolvedAt(resolved.assignmentDir, commentId, req, res, async () => {
+        return resolved.standalone ? getAssignmentDetailById(projectsDir, assignmentsDir, id) : getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+      });
+    } catch (error) {
+      console.error("Error toggling comment resolved (by id):", error);
+      res.status(500).json({ error: `Failed to toggle resolved: ${error.message}` });
+    }
+  });
+  router.get("/api/assignments/:id/edit", async (req, res) => {
+    if (!assignmentsDir) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir, assignmentsDir, "assignment", id);
+    if (!doc) {
+      res.status(404).json({ error: "Assignment not found" });
+      return;
+    }
+    res.json(doc);
+  });
+  router.get("/api/assignments/:id/plan/edit", async (req, res) => {
+    if (!assignmentsDir) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir, assignmentsDir, "plan", id);
+    if (!doc) {
+      res.status(404).json({ error: "Plan not found" });
+      return;
+    }
+    res.json(doc);
+  });
+  router.get("/api/assignments/:id/scratchpad/edit", async (req, res) => {
+    if (!assignmentsDir) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir, assignmentsDir, "scratchpad", id);
+    if (!doc) {
+      res.status(404).json({ error: "Scratchpad not found" });
+      return;
+    }
+    res.json(doc);
+  });
+  router.get("/api/assignments/:id/handoff/edit", async (req, res) => {
+    if (!assignmentsDir) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir, assignmentsDir, "handoff", id);
+    if (!doc) {
+      res.status(404).json({ error: "Handoff log not found" });
+      return;
+    }
+    res.json(doc);
+  });
+  router.get("/api/assignments/:id/decision-record/edit", async (req, res) => {
+    if (!assignmentsDir) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir, assignmentsDir, "decision-record", id);
+    if (!doc) {
+      res.status(404).json({ error: "Decision record not found" });
+      return;
+    }
+    res.json(doc);
+  });
+  router.patch("/api/assignments/:id", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      const currentContent = await readCurrentDocument(assignmentPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Assignment not found" });
+        return;
+      }
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const current = parseAssignmentFull(currentContent);
+      const next = parseAssignmentFull(nextContentRaw);
+      if (!next.title) {
+        res.status(400).json({ error: "Assignment content must include a title." });
+        return;
+      }
+      let nextContent = nextContentRaw;
+      if (current.id) nextContent = setTopLevelField(nextContent, "id", current.id);
+      nextContent = setTopLevelField(nextContent, "project", null);
+      if (current.slug) nextContent = setTopLevelField(nextContent, "slug", current.slug);
+      if (next.status !== current.status && current.status === "blocked" && next.status !== "blocked") {
+        nextContent = setTopLevelField(nextContent, "blockedReason", null);
+      }
+      nextContent = setTopLevelField(nextContent, "updated", nowTimestamp());
+      await writeFileForce(assignmentPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating standalone assignment:", error);
+      res.status(500).json({ error: `Failed to update assignment: ${error.message}` });
+    }
+  });
+  router.patch("/api/assignments/:id/plan", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const planPath = resolve11(resolved.assignmentDir, "plan.md");
+      const currentContent = await readCurrentDocument(planPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Plan not found" });
+        return;
+      }
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const parsed = parsePlan(nextContentRaw);
+      if (!parsed.assignment) {
+        res.status(400).json({ error: "Plan content must include the assignment field." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(planPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating standalone plan:", error);
+      res.status(500).json({ error: `Failed to update plan: ${error.message}` });
+    }
+  });
+  router.patch("/api/assignments/:id/scratchpad", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const scratchpadPath = resolve11(resolved.assignmentDir, "scratchpad.md");
+      const currentContent = await readCurrentDocument(scratchpadPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Scratchpad not found" });
+        return;
+      }
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const parsed = parseScratchpad(nextContentRaw);
+      if (!parsed.assignment) {
+        res.status(400).json({ error: "Scratchpad content must include the assignment field." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(scratchpadPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating standalone scratchpad:", error);
+      res.status(500).json({ error: `Failed to update scratchpad: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/handoff/entries", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const handoffPath = resolve11(resolved.assignmentDir, "handoff.md");
+      const currentContent = await readCurrentDocument(handoffPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Handoff log not found" });
+        return;
+      }
+      const { title, body } = req.body || {};
+      if (!body || typeof body !== "string" || !body.trim()) {
+        res.status(400).json({ error: "body is required" });
+        return;
+      }
+      const parsed = parseHandoff(currentContent);
+      const nextContent = appendLogEntry(
+        currentContent,
+        "handoffCount",
+        parsed.handoffCount + 1,
+        title && typeof title === "string" && title.trim() ? title.trim() : `Handoff ${parsed.handoffCount + 1}`,
+        body,
+        "No handoffs recorded yet."
+      );
+      await writeFileForce(handoffPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.status(201).json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error appending standalone handoff entry:", error);
+      res.status(500).json({ error: `Failed to append handoff entry: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/decision-record/entries", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const decisionPath = resolve11(resolved.assignmentDir, "decision-record.md");
+      const currentContent = await readCurrentDocument(decisionPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Decision record not found" });
+        return;
+      }
+      const { title, body } = req.body || {};
+      if (!body || typeof body !== "string" || !body.trim()) {
+        res.status(400).json({ error: "body is required" });
+        return;
+      }
+      const parsed = parseDecisionRecord(currentContent);
+      const nextContent = appendLogEntry(
+        currentContent,
+        "decisionCount",
+        parsed.decisionCount + 1,
+        title && typeof title === "string" && title.trim() ? title.trim() : `Decision ${parsed.decisionCount + 1}`,
+        body,
+        "No decisions recorded yet."
+      );
+      await writeFileForce(decisionPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.status(201).json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error appending standalone decision entry:", error);
+      res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/status-override", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      if (!await fileExists(assignmentPath)) {
+        res.status(404).json({ error: "Assignment not found" });
+        return;
+      }
+      const { status } = req.body || {};
+      const config = await getStatusConfig();
+      const validStatuses = config.statuses.map((s) => s.id);
+      if (typeof status !== "string" || !validStatuses.includes(status)) {
+        res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
+        return;
+      }
+      let content = await readFile9(assignmentPath, "utf-8");
+      content = setTopLevelField(content, "status", status);
+      content = setTopLevelField(content, "updated", nowTimestamp());
+      if (status !== "blocked") {
+        content = setTopLevelField(content, "blockedReason", null);
+      }
+      await writeFileForce(assignmentPath, content);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.json({ assignment });
+    } catch (error) {
+      console.error("Error overriding standalone status:", error);
+      res.status(500).json({ error: `Failed to override status: ${error.message}` });
+    }
+  });
+  router.patch("/api/assignments/:id/acceptance-criteria/:index", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      const currentContent = await readCurrentDocument(assignmentPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Assignment not found" });
+        return;
+      }
+      const { checked } = req.body || {};
+      if (typeof checked !== "boolean") {
+        res.status(400).json({ error: "checked must be a boolean" });
+        return;
+      }
+      const index = Number.parseInt(getParam(req.params.index), 10);
+      const result = toggleAcceptanceCriterion(currentContent, index, checked);
+      if ("error" in result) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const nextContent = setTopLevelField(result.content, "updated", nowTimestamp());
+      await writeFileForce(assignmentPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error toggling standalone acceptance criterion:", error);
+      res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/transitions/:command", async (req, res) => {
+    try {
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const command = getParam(req.params.command);
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const { reason } = req.body || {};
+      const transitionResult = await executeTransitionByDir(
+        resolved.assignmentDir,
+        command,
+        {
+          standalone: resolved.standalone,
+          reason: typeof reason === "string" ? reason : void 0
+        }
+      );
+      if (!transitionResult.success) {
+        res.status(400).json({ error: transitionResult.message, fromStatus: transitionResult.fromStatus });
+        return;
+      }
+      const detail = resolved.standalone ? await getAssignmentDetailById(projectsDir, assignmentsDir, id) : await getAssignmentDetail(projectsDir, resolved.projectSlug, resolved.assignmentSlug);
+      res.json({ assignment: detail, warnings: transitionResult.warnings ?? [] });
+    } catch (error) {
+      console.error("Error transitioning by id:", error);
+      res.status(500).json({ error: `Failed to transition: ${error.message}` });
+    }
+  });
   return router;
 }
+function slugifyLocal(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
+}
+async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const { body, author, type, replyTo } = req.body || {};
+  if (!body || typeof body !== "string" || !body.trim()) {
+    res.status(400).json({ error: "body is required" });
+    return;
+  }
+  const commentType = type && ["question", "note", "feedback"].includes(type) ? type : "note";
+  const timestamp = nowTimestamp();
+  const entryAuthor = typeof author === "string" && author.trim() ? author.trim() : "human";
+  let currentContent;
+  let currentCount = 0;
+  if (await fileExists(commentsPath)) {
+    currentContent = await readFile9(commentsPath, "utf-8");
+    const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
+    if (countMatch) currentCount = parseInt(countMatch[1], 10);
+  } else {
+    currentContent = renderComments({ assignment: assignmentRef, timestamp });
+  }
+  const comment = {
+    id: generateId().split("-")[0],
+    timestamp,
+    author: entryAuthor,
+    type: commentType,
+    body,
+    replyTo: typeof replyTo === "string" && replyTo.trim() ? replyTo.trim() : void 0,
+    resolved: commentType === "question" ? false : void 0
+  };
+  const entry = formatCommentEntry(comment);
+  let next = setTopLevelField(currentContent, "entryCount", String(currentCount + 1));
+  next = setTopLevelField(next, "updated", `"${timestamp}"`);
+  if (next.includes("No comments yet.")) {
+    next = next.replace("No comments yet.", entry.trimEnd());
+  } else {
+    next = `${next.trimEnd()}
+
+${entry}`;
+  }
+  await writeFileForce(commentsPath, next);
+  const assignment = await reloadDetail();
+  res.status(201).json({ assignment, comment: { id: comment.id } });
+}
+async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (!await fileExists(commentsPath)) {
+    res.status(404).json({ error: "Comments file not found" });
+    return;
+  }
+  const { resolved: desired } = req.body || {};
+  if (typeof desired !== "boolean") {
+    res.status(400).json({ error: "resolved (boolean) is required" });
+    return;
+  }
+  const content = await readFile9(commentsPath, "utf-8");
+  const parsed = parseComments(content);
+  const target = parsed.entries.find((e) => e.id === commentId);
+  if (!target) {
+    res.status(404).json({ error: `Comment ${commentId} not found` });
+    return;
+  }
+  if (target.type !== "question") {
+    res.status(400).json({ error: "Only questions can be resolved" });
+    return;
+  }
+  const entryBlockRegex = new RegExp(
+    `(^## ${commentId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?)(\\*\\*Resolved:\\*\\*\\s*(?:true|false))`,
+    "m"
+  );
+  const next = content.replace(entryBlockRegex, (_m, preamble) => `${preamble}**Resolved:** ${desired ? "true" : "false"}`);
+  if (next === content) {
+    res.status(500).json({ error: "Failed to update resolved flag" });
+    return;
+  }
+  const withUpdated = setTopLevelField(next, "updated", `"${nowTimestamp()}"`);
+  await writeFileForce(commentsPath, withUpdated);
+  const assignment = await reloadDetail();
+  res.json({ assignment });
+}
 
 // src/dashboard/api-servers.ts
 init_servers();
 init_scanner();
 import { Router as Router2 } from "express";
-function createServersRouter(serversDir2, projectsDir) {
+function createServersRouter(serversDir2, projectsDir, assignmentsDir) {
   const router = Router2();
   router.get("/", async (_req, res) => {
     try {
-      const result = await scanAllSessions(serversDir2, projectsDir);
+      const result = await scanAllSessions(serversDir2, projectsDir, { assignmentsDir });
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
@@ -4504,7 +6280,7 @@ function createServersRouter(serversDir2, projectsDir) {
   });
   router.get("/:name", async (req, res) => {
     try {
-      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name, { assignmentsDir });
       if (!session) {
         res.status(404).json({ error: "Session not found" });
         return;
@@ -4555,7 +6331,7 @@ function createServersRouter(serversDir2, projectsDir) {
         await updateLastRefreshed(serversDir2, name);
       }
       clearScanCache();
-      const result = await scanAllSessions(serversDir2, projectsDir, { bypassCache: true });
+      const result = await scanAllSessions(serversDir2, projectsDir, { bypassCache: true, assignmentsDir });
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4570,7 +6346,7 @@ function createServersRouter(serversDir2, projectsDir) {
       }
       await updateLastRefreshed(serversDir2, req.params.name);
       clearScanCache();
-      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, projectsDir, req.params.name, { assignmentsDir });
       res.json(session);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4607,266 +6383,13 @@ function createServersRouter(serversDir2, projectsDir) {
 
 // src/dashboard/api-agent-sessions.ts
 import { Router as Router3 } from "express";
-import { resolve as resolve10 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/dashboard/agent-sessions.ts
-init_fs();
-import { readFile as readFile7 } from "fs/promises";
-import { resolve as resolve9 } from "path";
-
-// src/dashboard/session-db.ts
-init_paths();
-init_fs();
-import Database from "better-sqlite3";
-import { resolve as resolve8 } from "path";
-import { readdir as readdir4 } from "fs/promises";
-var db = null;
-var SCHEMA_VERSION = "2";
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS sessions (
-  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'))
-);
-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);
-`;
-function initSessionDb(dbPath) {
-  if (db) return db;
-  const finalPath = dbPath ?? resolve8(syntaurRoot(), "syntaur.db");
-  db = new Database(finalPath);
-  db.pragma("journal_mode = WAL");
-  db.exec(SCHEMA_SQL);
-  db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
-    "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';
-    `);
-  }
-  return db;
-}
-function getSessionDb() {
-  if (!db) {
-    throw new Error(
-      "Session database not initialized. Call initSessionDb() first."
-    );
-  }
-  return db;
-}
-function closeSessionDb() {
-  if (db) {
-    db.close();
-    db = null;
-  }
-}
-async function migrateFromMarkdown(projectsDir) {
-  const database = getSessionDb();
-  const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
-  if (count.count > 0) return 0;
-  if (!await fileExists(projectsDir)) return 0;
-  const entries = await readdir4(projectsDir, { withFileTypes: true });
-  const allSessions = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const projectDir = resolve8(projectsDir, entry.name);
-    const indexPath = resolve8(projectDir, "_index-sessions.md");
-    if (!await fileExists(indexPath)) continue;
-    const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
-    allSessions.push(...sessions);
-  }
-  if (allSessions.length === 0) return 0;
-  const insert = database.prepare(`
-    INSERT OR IGNORE INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-  const insertAll = database.transaction((sessions) => {
-    for (const s of sessions) {
-      insert.run(s.sessionId, s.projectSlug, s.assignmentSlug, s.agent, s.started, s.status, s.path);
-    }
-  });
-  insertAll(allSessions);
-  console.log(`Migrated ${allSessions.length} sessions from markdown to SQLite.`);
-  return allSessions.length;
-}
-async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile12 } = await import("fs/promises");
-  const raw = await readFile12(filePath, "utf-8");
-  const sessions = [];
-  const lines = raw.split("\n");
-  let inTable = false;
-  let headerSeen = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("| Assignment") || trimmed.startsWith("|Assignment")) {
-      inTable = true;
-      headerSeen = false;
-      continue;
-    }
-    if (inTable && !headerSeen && trimmed.match(/^\|[-\s|]+\|$/)) {
-      headerSeen = true;
-      continue;
-    }
-    if (inTable && headerSeen && trimmed.startsWith("|")) {
-      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
-      if (cells.length >= 6) {
-        sessions.push({
-          assignmentSlug: cells[0],
-          agent: cells[1],
-          sessionId: cells[2],
-          started: cells[3],
-          status: cells[4] || "active",
-          path: cells[5],
-          projectSlug
-        });
-      }
-    }
-  }
-  return sessions;
-}
-
-// src/dashboard/agent-sessions.ts
-function rowToSession(row) {
-  return {
-    sessionId: row.session_id,
-    projectSlug: row.project_slug ?? null,
-    assignmentSlug: row.assignment_slug ?? null,
-    agent: row.agent,
-    started: row.started,
-    ended: row.ended ?? null,
-    status: row.status,
-    path: row.path ?? "",
-    description: row.description ?? null
-  };
-}
-async function appendSession(_projectDir, session) {
-  const db2 = getSessionDb();
-  db2.prepare(`
-    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    session.sessionId,
-    session.projectSlug ?? null,
-    session.assignmentSlug ?? null,
-    session.agent,
-    session.started,
-    session.status,
-    session.path,
-    session.description ?? null
-  );
-}
-async function updateSessionStatus(_projectDir, sessionId, status) {
-  const db2 = getSessionDb();
-  const isTerminal = status === "completed" || status === "stopped";
-  const result = isTerminal ? db2.prepare(
-    "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId) : db2.prepare(
-    "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId);
-  return result.changes > 0;
-}
-async function listAllSessions(_projectsDir) {
-  const db2 = getSessionDb();
-  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
-  return rows.map(rowToSession);
-}
-async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
-  const db2 = getSessionDb();
-  if (assignmentSlug) {
-    const rows2 = db2.prepare(
-      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
-    ).all(projectSlug, assignmentSlug);
-    return rows2.map(rowToSession);
-  }
-  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
-  return rows.map(rowToSession);
-}
-async function deleteSessions(sessionIds) {
-  if (sessionIds.length === 0) return 0;
-  const db2 = getSessionDb();
-  const placeholders = sessionIds.map(() => "?").join(", ");
-  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
-  return result.changes;
-}
-var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
-async function readAssignmentStatus(projectDir, assignmentSlug) {
-  const assignmentPath = resolve9(projectDir, "assignments", assignmentSlug, "assignment.md");
-  if (!await fileExists(assignmentPath)) return null;
-  const raw = await readFile7(assignmentPath, "utf-8");
-  const match = raw.match(/^status:\s*(.+)$/m);
-  return match ? match[1].trim() : null;
-}
-async function reconcileActiveSessions(projectsDir) {
-  const db2 = getSessionDb();
-  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND project_slug IS NOT NULL AND assignment_slug IS NOT NULL").all();
-  if (activeSessions.length === 0) return 0;
-  const toCheck = /* @__PURE__ */ new Map();
-  for (const session of activeSessions) {
-    const slugs = toCheck.get(session.project_slug) ?? /* @__PURE__ */ new Set();
-    slugs.add(session.assignment_slug);
-    toCheck.set(session.project_slug, slugs);
-  }
-  const assignmentStatuses = /* @__PURE__ */ new Map();
-  for (const [projectSlug, slugs] of toCheck) {
-    const projectDir = resolve9(projectsDir, projectSlug);
-    for (const slug of slugs) {
-      const status = await readAssignmentStatus(projectDir, slug);
-      if (status) assignmentStatuses.set(`${projectSlug}/${slug}`, status);
-    }
-  }
-  let totalUpdated = 0;
-  for (const session of activeSessions) {
-    const key = `${session.project_slug}/${session.assignment_slug}`;
-    const assignmentStatus = assignmentStatuses.get(key);
-    if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
-    const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
-    await updateSessionStatus("", session.session_id, newStatus);
-    totalUpdated++;
-  }
-  return totalUpdated;
-}
-
-// src/dashboard/api-agent-sessions.ts
+import { resolve as resolve12 } from "path";
 init_fs();
-function createAgentSessionsRouter(projectsDir, broadcast) {
+function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
   const router = Router3();
   router.get("/", async (_req, res) => {
     try {
-      await reconcileActiveSessions(projectsDir);
+      await reconcileActiveSessions(projectsDir, assignmentsDir);
       const sessions = await listAllSessions(projectsDir);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
@@ -4877,12 +6400,12 @@ function createAgentSessionsRouter(projectsDir, broadcast) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve10(projectsDir, projectSlug);
+      const projectDir = resolve12(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      await reconcileActiveSessions(projectsDir);
+      await reconcileActiveSessions(projectsDir, assignmentsDir);
       const sessions = await listProjectSessions(projectsDir, projectSlug, assignment);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
@@ -4891,32 +6414,38 @@ function createAgentSessionsRouter(projectsDir, broadcast) {
   });
   router.post("/", async (req, res) => {
     try {
-      const { projectSlug, assignmentSlug, agent, sessionId, path, description } = req.body;
+      const { projectSlug, assignmentSlug, agent, sessionId, path, description, transcriptPath } = req.body;
       if (!agent) {
         res.status(400).json({ error: "agent is required" });
         return;
       }
+      if (!sessionId) {
+        res.status(400).json({
+          error: "sessionId is required. Pass the real agent-generated session id \u2014 do not synthesize one."
+        });
+        return;
+      }
       if (projectSlug) {
-        const projectDir = resolve10(projectsDir, projectSlug);
+        const projectDir = resolve12(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
       }
-      const id = sessionId || randomUUID2();
       const session = {
         projectSlug: projectSlug || null,
         assignmentSlug: assignmentSlug || null,
         agent,
-        sessionId: id,
+        sessionId,
         started: (/* @__PURE__ */ new Date()).toISOString(),
         status: "active",
         path: path || "",
-        description: description || null
+        description: description || null,
+        transcriptPath: transcriptPath || null
       };
       await appendSession("", session);
       broadcast?.({ type: "agent-sessions-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-      res.status(201).json({ sessionId: id });
+      res.status(201).json({ sessionId });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Registration failed" });
     }
@@ -4965,8 +6494,8 @@ function createAgentSessionsRouter(projectsDir, broadcast) {
 init_api();
 init_parser();
 import { Router as Router4 } from "express";
-import { resolve as resolve12 } from "path";
-import { readFile as readFile9, unlink as unlink2 } from "fs/promises";
+import { resolve as resolve14 } from "path";
+import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
 
@@ -4974,15 +6503,15 @@ init_fs();
 init_fs();
 init_parser();
 init_timestamp();
-import { resolve as resolve11 } from "path";
-import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+import { readdir as readdir7, readFile as readFile10 } from "fs/promises";
 async function rebuildPlaybookManifest(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return;
-  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir7(playbooksDir2, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const raw = await readFile8(resolve11(playbooksDir2, entry.name), "utf-8");
+    const raw = await readFile10(resolve13(playbooksDir2, entry.name), "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     rows.push({
@@ -5012,7 +6541,7 @@ async function rebuildPlaybookManifest(playbooksDir2) {
     }
   }
   lines.push("");
-  await writeFileForce(resolve11(playbooksDir2, "manifest.md"), lines.join("\n"));
+  await writeFileForce(resolve13(playbooksDir2, "manifest.md"), lines.join("\n"));
 }
 
 // src/dashboard/api-playbooks.ts
@@ -5053,12 +6582,12 @@ function createPlaybooksRouter(playbooksDir2) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const content = await readFile9(filePath, "utf-8");
+      const content = await readFile11(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${req.params.slug}`,
@@ -5083,7 +6612,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve12(playbooksDir2, `${slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -5102,7 +6631,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5120,7 +6649,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5135,11 +6664,14 @@ function createPlaybooksRouter(playbooksDir2) {
   return router;
 }
 
+// src/dashboard/server.ts
+init_fs_migration();
+
 // src/dashboard/api-todos.ts
 init_parser2();
 init_fs();
 import { Router as Router5 } from "express";
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir8 } from "fs/promises";
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -5173,7 +6705,7 @@ function createTodosRouter(todosDir2, broadcast) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir6(todosDir2).catch(() => []);
+      const files = await readdir8(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -5278,8 +6810,8 @@ function createTodosRouter(todosDir2, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve16 } = await import("path");
-      const { readFile: readFile12 } = await import("fs/promises");
+      const { resolve: resolve18 } = await import("path");
+      const { readFile: readFile14 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -5295,10 +6827,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve16(todosDir2, "archive"));
+      await ensureDir(resolve18(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile12(archFile, "utf-8");
+        archContent = await readFile14(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -5558,8 +7090,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile11, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
-import { resolve as resolve14, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile13, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve16, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -5599,7 +7131,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve14(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve16(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -5610,7 +7142,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -5619,7 +7151,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile11(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -5657,7 +7189,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve14(dest, ".."));
+    await ensureDir(resolve16(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -5666,7 +7198,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile11(configPath, "utf-8");
+  const content = await readFile13(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -5705,8 +7237,8 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve14(destPath, ".."));
-        await writeFile3(destPath, sanitized, "utf-8");
+        await ensureDir(resolve16(destPath, ".."));
+        await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -5759,7 +7291,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve14(localPath, ".."));
+    await ensureDir(resolve16(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -5770,7 +7302,7 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   const localExistsBefore = await fileExists(localPath);
   if (backupExistsBefore) {
     if (!localExistsBefore) {
-      await rename2(backupPath, localPath);
+      await rename3(backupPath, localPath);
     } else {
       throw new Error(
         `Cannot restore "${localPath}": a stale crash-recovery backup exists at ${backupPath} while the current path also exists. Inspect both and remove the one you don't need, then retry.`
@@ -5782,15 +7314,15 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
     await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
     const localExists = await fileExists(localPath);
     if (localExists) {
-      await rename2(localPath, backupPath);
+      await rename3(localPath, backupPath);
       localMovedAside = true;
     }
-    await rename2(stagingPath, localPath);
+    await rename3(stagingPath, localPath);
     await rm2(backupPath, { recursive: true, force: true }).catch(() => {
     });
   } catch (err) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename2(backupPath, localPath).catch(() => {
+      await rename3(backupPath, localPath).catch(() => {
       });
     }
     await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
@@ -5860,7 +7392,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -6015,7 +7547,7 @@ async function stopAutodiscovery() {
 function runReconcile() {
   if (activeReconcile || !savedOptions) return;
   const opts = savedOptions;
-  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids).catch((err) => {
+  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids, opts.assignmentsDir).catch((err) => {
     console.error("[autodiscovery] reconcile failed:", err);
   }).finally(() => {
     activeReconcile = null;
@@ -6026,10 +7558,10 @@ async function listAllTmuxSessions() {
   if (!output) return [];
   return output.split("\n").filter((line) => line.length > 0);
 }
-async function discoverTmuxSessions(serversDir2, projectsDir, existingNames) {
+async function discoverTmuxSessions(serversDir2, projectsDir, existingNames, assignmentsDir) {
   const tmuxAvailable = await checkTmuxAvailable();
   if (!tmuxAvailable) return false;
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir, assignmentsDir);
   if (workspaceRecords.length === 0) return false;
   const sessions = await listAllTmuxSessions();
   let changed = false;
@@ -6070,8 +7602,8 @@ async function getProcessCwd(pid) {
   }
   return null;
 }
-async function discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids) {
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir);
+async function discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids, assignmentsDir) {
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir, assignmentsDir);
   if (workspaceRecords.length === 0) return false;
   const lsofOutput = await getLsofOutput();
   if (!lsofOutput) return false;
@@ -6136,7 +7668,7 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir2, projectsDir, excludePids) {
+async function reconcile(serversDir2, projectsDir, excludePids, assignmentsDir) {
   const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
@@ -6148,8 +7680,8 @@ async function reconcile(serversDir2, projectsDir, excludePids) {
     existingFiles.delete(name);
   }
   const existingNames = new Set(existingFiles.keys());
-  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir, existingNames);
-  const processChanged = await discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids);
+  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir, existingNames, assignmentsDir);
+  const processChanged = await discoverProcesses(serversDir2, projectsDir, existingFiles, excludePids, assignmentsDir);
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
@@ -6157,7 +7689,7 @@ async function reconcile(serversDir2, projectsDir, excludePids) {
 
 // src/dashboard/server.ts
 function createDashboardServer(options) {
-  const { port, projectsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
+  const { port, projectsDir, assignmentsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
   const app = express();
   const server = createServer(app);
   const wss = new WebSocketServer({ noServer: true });
@@ -6194,10 +7726,22 @@ function createDashboardServer(options) {
   migrateFromMarkdown(projectsDir).catch((err) => {
     console.error("Session migration from markdown failed:", err);
   });
+  (async () => {
+    try {
+      const configResult = await migrateLegacyConfig(
+        resolve17(syntaurRoot(), "config.md")
+      );
+      const projectResult = await migrateLegacyProjectFiles(projectsDir);
+      const summary = summarizeMigration(projectResult, configResult);
+      if (summary) console.log(summary);
+    } catch (err) {
+      console.error("Legacy filesystem migration failed:", err);
+    }
+  })();
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
-      const overview = await getOverview(projectsDir, serversDir2);
+      const overview = await getOverview(projectsDir, serversDir2, assignmentsDir);
       res.json(overview);
     } catch (error) {
       console.error("Error getting overview:", error);
@@ -6206,7 +7750,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/attention", async (_req, res) => {
     try {
-      const attention = await getAttention(projectsDir, serversDir2);
+      const attention = await getAttention(projectsDir, serversDir2, assignmentsDir);
       res.json(attention);
     } catch (error) {
       console.error("Error getting attention queue:", error);
@@ -6326,7 +7870,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/assignments", async (req, res) => {
     try {
-      const result = await listAssignmentsBoard(projectsDir);
+      const result = await listAssignmentsBoard(projectsDir, assignmentsDir);
       const workspaceParam = req.query.workspace;
       if (workspaceParam) {
         if (workspaceParam === "_ungrouped") {
@@ -6354,6 +7898,37 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to get project detail" });
     }
   });
+  app.get("/api/assignments/:id", async (req, res) => {
+    try {
+      const detail = await getAssignmentDetailById(projectsDir, assignmentsDir, req.params.id);
+      if (!detail) {
+        res.status(404).json({ error: `Assignment "${req.params.id}" not found` });
+        return;
+      }
+      res.json(detail);
+    } catch (error) {
+      console.error("Error getting assignment by id:", error);
+      res.status(500).json({ error: "Failed to get assignment" });
+    }
+  });
+  app.get("/api/assignments/:id/sessions", async (req, res) => {
+    try {
+      const resolved = await resolveAssignmentById(projectsDir, assignmentsDir, req.params.id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${req.params.id}" not found` });
+        return;
+      }
+      await reconcileActiveSessions(projectsDir, assignmentsDir);
+      const sessions = await listSessionsByAssignment(
+        resolved.standalone ? null : resolved.projectSlug,
+        resolved.standalone ? resolved.id : resolved.assignmentSlug
+      );
+      res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    } catch (error) {
+      console.error("Error listing sessions by id:", error);
+      res.status(500).json({ error: "Failed to list sessions" });
+    }
+  });
   app.get("/api/projects/:slug/assignments/:aslug", async (req, res) => {
     try {
       const detail = await getAssignmentDetail(
@@ -6373,16 +7948,16 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to get assignment detail" });
     }
   });
-  app.use(createWriteRouter(projectsDir));
-  app.use("/api/servers", createServersRouter(serversDir2, projectsDir));
-  app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast));
+  app.use(createWriteRouter(projectsDir, assignmentsDir));
+  app.use("/api/servers", createServersRouter(serversDir2, projectsDir, assignmentsDir));
+  app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     app.use(express.static(dashboardDistPath));
     app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve15(dashboardDistPath, "index.html");
+      const indexPath = resolve17(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -6397,12 +7972,13 @@ function createDashboardServer(options) {
     async start() {
       watcherHandle = createWatcher({
         projectsDir,
+        assignmentsDir,
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
         onMessage: broadcast
       });
-      startAutodiscovery({ serversDir: serversDir2, projectsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
+      startAutodiscovery({ serversDir: serversDir2, projectsDir, assignmentsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
@@ -6414,8 +7990,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve15(syntaurRoot(), "dashboard-port");
-          writeFile4(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve17(syntaurRoot(), "dashboard-port");
+          writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -6431,7 +8007,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve15(syntaurRoot(), "dashboard-port");
+      const portFile = resolve17(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();