syntaur 0.2.0 → 0.3.0

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";
@@ -996,6 +1042,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 +1142,74 @@ var init_parser = __esm({
   }
 });
 
+// src/utils/assignment-resolver.ts
+import { resolve as resolve4 } from "path";
+import { readdir, readFile as readFile3 } from "fs/promises";
+async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
+  let standaloneMatch = null;
+  let projectMatch = null;
+  const standaloneDir = resolve4(assignmentsDir, id);
+  const standalonePath = resolve4(standaloneDir, "assignment.md");
+  if (await fileExists(standalonePath)) {
+    standaloneMatch = {
+      assignmentDir: standaloneDir,
+      projectSlug: null,
+      assignmentSlug: id,
+      id,
+      standalone: true
+    };
+  }
+  if (await fileExists(projectsDir)) {
+    try {
+      const projects = await readdir(projectsDir, { withFileTypes: true });
+      for (const p of projects) {
+        if (!p.isDirectory()) continue;
+        if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
+        const assignmentsPath = resolve4(projectsDir, p.name, "assignments");
+        if (!await fileExists(assignmentsPath)) continue;
+        const entries = await readdir(assignmentsPath, { withFileTypes: true });
+        for (const a of entries) {
+          if (!a.isDirectory()) continue;
+          const aPath = resolve4(assignmentsPath, a.name, "assignment.md");
+          if (!await fileExists(aPath)) continue;
+          try {
+            const content = await readFile3(aPath, "utf-8");
+            const [fm] = extractFrontmatter2(content);
+            const fileId = getField(fm, "id");
+            if (fileId === id) {
+              projectMatch = {
+                assignmentDir: resolve4(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();
@@ -1460,8 +1626,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 readdir2, readFile as readFile4, unlink } from "fs/promises";
+import { resolve as resolve5 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1509,18 +1675,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve4(dir, `${name}.md`), content);
+  await writeFileForce(resolve5(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir(dir);
+  const entries = await readdir2(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 = resolve5(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile3(filePath, "utf-8");
+  const raw = await readFile4(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter2(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1560,7 +1726,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve4(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve5(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1569,7 +1735,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(resolve5(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1581,7 +1747,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(resolve5(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1598,7 +1764,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve4(dir, `${name}.md`), content);
+  await writeFileForce(resolve5(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1630,8 +1796,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 resolve6 } from "path";
+import { realpath, readdir as readdir3, readFile as readFile5 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -1726,8 +1892,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(resolve6(cwd, commonDir));
+      const resolvedGit = await realpath(resolve6(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -1735,22 +1901,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 = resolve6(projectsDir, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir2(assignmentsDir);
+        slugs = await readdir3(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve5(assignmentsDir, aslug, "assignment.md");
+        const aFile = resolve6(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile4(aFile, "utf-8");
+          const raw = await readFile5(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -1767,6 +1933,30 @@ async function loadWorkspaceRecords(projectsDir) {
     }
   } catch {
   }
+  if (assignmentsDir) {
+    try {
+      const entries = await readdir3(assignmentsDir);
+      for (const id of entries) {
+        if (id.startsWith(".") || id.startsWith("_")) continue;
+        const aFile = resolve6(assignmentsDir, id, "assignment.md");
+        try {
+          const raw = await readFile5(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 +2149,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 +2164,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 +2188,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 readdir4, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve7, dirname as dirname2 } from "path";
+async function listStandaloneRecords(assignmentsDir) {
+  if (!assignmentsDir) return [];
+  if (!await fileExists(assignmentsDir)) return [];
+  const entries = await readdir4(assignmentsDir, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const assignmentDir = resolve7(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve7(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath)) continue;
+    try {
+      const content = await readFile6(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 +2270,9 @@ async function listProjects(projectsDir) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve7(dirname2(projectsDir), "workspaces.json");
   try {
-    const raw = await readFile5(registryPath, "utf-8");
+    const raw = await readFile6(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -2070,7 +2280,7 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve6(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve7(dirname2(projectsDir), "workspaces.json");
   await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir) {
@@ -2103,15 +2313,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 +2338,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 +2360,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 +2368,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 +2419,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 +2430,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 +2480,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 readFile6(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -2242,16 +2491,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 = resolve7(resolved.assignmentDir, fileName);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile6(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 = resolve7(projectsDir, slug);
+  const projectMdPath = resolve7(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile5(projectMdPath, "utf-8");
+  const projectContent = await readFile6(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 +2555,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 = resolve7(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve7(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile5(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile6(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve6(assignmentDir, "plan.md");
+  const planPath = resolve7(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile5(planPath, "utf-8");
+    const planContent = await readFile6(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2297,9 +2574,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve6(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve7(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile5(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile6(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2307,9 +2584,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve6(assignmentDir, "handoff.md");
+  const handoffPath = resolve7(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile5(handoffPath, "utf-8");
+    const handoffContent = await readFile6(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2318,9 +2595,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve6(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve7(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile5(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile6(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2328,6 +2605,28 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
       body: parsed.body
     };
   }
+  let progress = null;
+  const progressPath = resolve7(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const progressContent = await readFile6(progressPath, "utf-8");
+    const parsed = parseProgress(progressContent);
+    progress = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
+  let comments = null;
+  const commentsPath = resolve7(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const commentsContent = await readFile6(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 +2650,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     scratchpad,
     handoff,
     decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
     availableTransitions: await getAvailableTransitions(
       projectsDir,
       projectSlug,
@@ -2414,25 +2716,212 @@ 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 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: resolve7(rec.projectPath, "assignments", a.slug)
+      });
+    }
+  }
+  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
+    });
+  }
+  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 countMentionsInAssignment(sourceDir, target) {
+  const bodies = [];
+  const assignmentMd = resolve7(sourceDir, "assignment.md");
+  if (await fileExists(assignmentMd)) {
+    const content = await readFile6(assignmentMd, "utf-8");
+    const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
+    if (todosMatch) bodies.push(todosMatch[1]);
+  }
+  for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
+    const path = resolve7(sourceDir, filename);
+    if (await fileExists(path)) {
+      try {
+        bodies.push(await readFile6(path, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  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;
+    }
+  }
+  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 = resolve7(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath)) return null;
+  const assignmentContent = await readFile6(assignmentMdPath, "utf-8");
+  const assignment = parseAssignmentFull(assignmentContent);
+  let plan = null;
+  const planPath = resolve7(assignmentDir, "plan.md");
+  if (await fileExists(planPath)) {
+    const parsed = parsePlan(await readFile6(planPath, "utf-8"));
+    plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
+  }
+  let scratchpad = null;
+  const scratchpadPath = resolve7(assignmentDir, "scratchpad.md");
+  if (await fileExists(scratchpadPath)) {
+    const parsed = parseScratchpad(await readFile6(scratchpadPath, "utf-8"));
+    scratchpad = { updated: parsed.updated, body: parsed.body };
+  }
+  let handoff = null;
+  const handoffPath = resolve7(assignmentDir, "handoff.md");
+  if (await fileExists(handoffPath)) {
+    const parsed = parseHandoff(await readFile6(handoffPath, "utf-8"));
+    handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
+  }
+  let decisionRecord = null;
+  const decisionRecordPath = resolve7(assignmentDir, "decision-record.md");
+  if (await fileExists(decisionRecordPath)) {
+    const parsed = parseDecisionRecord(await readFile6(decisionRecordPath, "utf-8"));
+    decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
+  }
+  let progress = null;
+  const progressPath = resolve7(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const parsed = parseProgress(await readFile6(progressPath, "utf-8"));
+    progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  let comments = null;
+  const commentsPath = resolve7(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const parsed = parseComments(await readFile6(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 [];
   }
-  const entries = await readdir3(projectsDir, { withFileTypes: true });
+  const entries = await readdir4(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");
+    const projectPath = resolve7(projectsDir, entry.name);
+    const projectMdPath = resolve7(projectPath, "project.md");
     if (!await fileExists(projectMdPath)) {
       continue;
     }
-    const projectContent = await readFile5(projectMdPath, "utf-8");
+    const projectContent = await readFile6(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 updated = getProjectActivityTimestamp(project.updated, assignments);
     records.push({
       projectPath,
@@ -2460,39 +2949,39 @@ async function listProjectRecords(projectsDir) {
   return records;
 }
 async function listAssignmentRecords(projectPath) {
-  const assignmentsDir = resolve6(projectPath, "assignments");
+  const assignmentsDir = resolve7(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
-  const entries = await readdir3(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir4(assignmentsDir, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const assignmentMd = resolve6(assignmentsDir, entry.name, "assignment.md");
+    const assignmentMd = resolve7(assignmentsDir, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       continue;
     }
-    const content = await readFile5(assignmentMd, "utf-8");
+    const content = await readFile6(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 = resolve7(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir3(resourcesDir, { withFileTypes: true });
+  const entries = await readdir4(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 = resolve7(resourcesDir, entry.name);
+    const content = await readFile6(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -2507,18 +2996,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve6(projectPath, "memories");
+  const memoriesDir = resolve7(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir3(memoriesDir, { withFileTypes: true });
+  const entries = await readdir4(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 = resolve7(memoriesDir, entry.name);
+    const content = await readFile6(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -2533,9 +3022,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve6(projectPath, "_status.md");
+  const statusPath = resolve7(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile5(statusPath, "utf-8");
+    const statusContent = await readFile6(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -2544,13 +3033,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 +3124,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve6(projectsDir, projectSlug);
+  const projectPath = resolve7(projectsDir, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -2665,12 +3154,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 = resolve7(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile5(dependencyPath, "utf-8");
+    const content = await readFile6(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -2678,7 +3167,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 +3217,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 +3274,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 +3313,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 = resolve7(
+    projectPath,
+    "assignments",
+    assignmentSlug,
+    "comments.md"
+  );
+  if (!await fileExists(commentsPath)) {
+    return 0;
+  }
+  try {
+    const content = await readFile6(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 +3345,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve6(projectsDir, projectSlug, "project.md");
+      return resolve7(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve6(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve7(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -2836,12 +3382,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 readdir4(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 = resolve7(playbooksDir2, entry.name);
+    const raw = await readFile6(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -2857,9 +3403,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 = resolve7(playbooksDir2, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile5(filePath, "utf-8");
+  const raw = await readFile6(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
   return {
     slug: parsed.slug || slug,
@@ -2872,13 +3418,14 @@ async function getPlaybookDetail(playbooksDir2, slug) {
     body: parsed.body
   };
 }
-var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, 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, DEFAULT_GRAPH_COLORS;
 var init_api = __esm({
   "src/dashboard/api.ts"() {
     "use strict";
     init_lifecycle();
     init_fs();
     init_config2();
+    init_assignment_resolver();
     init_parser();
     init_help();
     STALE_ASSIGNMENT_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -2939,6 +3486,7 @@ var init_api = __esm({
       failed: "rose"
     };
     _cachedConfig = null;
+    REFERENCED_BY_LIMIT = 50;
     DEFAULT_GRAPH_COLORS = {
       completed: "fill:#4ea84f,stroke:#1f6b29,color:#ffffff",
       in_progress: "fill:#1e6fd9,stroke:#0f3f8f,color:#ffffff",
@@ -2971,8 +3519,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 readFile11 } from "fs/promises";
+import { resolve as resolve14 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -3132,10 +3680,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve13(todosDir2, `${workspace}.md`);
+  return resolve14(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve13(todosDir2, `${workspace}-log.md`);
+  return resolve14(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -3159,14 +3707,14 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve13(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve14(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 readFile11(path, "utf-8");
   return parseChecklist(content);
 }
 async function writeChecklist(todosDir2, checklist) {
@@ -3179,7 +3727,7 @@ async function readLog(todosDir2, workspace) {
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
-  const content = await readFile10(path, "utf-8");
+  const content = await readFile11(path, "utf-8");
   return parseLog(content);
 }
 async function appendLogEntry2(todosDir2, workspace, entry) {
@@ -3187,7 +3735,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 readFile11(path, "utf-8");
     content = content.trimEnd() + "\n\n" + serializeLogEntry(entry) + "\n";
   } else {
     const fm = `---
@@ -3223,409 +3771,806 @@ 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 { resolve as resolve16 } from "path";
 import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
-// src/dashboard/watcher.ts
-import { watch } from "chokidar";
-import { relative, sep } from "path";
-function createWatcher(options) {
-  const { 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];
-    }
-    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 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()
-          };
-          onMessage(message);
-        }, debounceMs)
+// 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 readdir5 } 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_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'))
       );
-    };
-    var handlePlaybookChange = handlePlaybookChange2;
-    playbooksWatcher = watch(playbooksDir2, {
-      ignoreInitial: true,
-      persistent: true,
-      depth: 1,
-      ignored: /(^|[\/\\])\../
-    });
-    playbooksWatcher.on("change", handlePlaybookChange2);
-    playbooksWatcher.on("add", handlePlaybookChange2);
-    playbooksWatcher.on("unlink", handlePlaybookChange2);
+      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';
+    `);
   }
-  let todosWatcher = null;
-  if (todosDir2) {
-    let handleTodoChange2 = function() {
-      const debounceKey = "__todos__";
-      const existing = pendingEvents.get(debounceKey);
-      if (existing) clearTimeout(existing);
-      pendingEvents.set(
-        debounceKey,
-        setTimeout(() => {
-          pendingEvents.delete(debounceKey);
-          const message = {
-            type: "todos-updated",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          onMessage(message);
-        }, debounceMs)
+  const versionAfterV1 = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  if (versionAfterV1?.value === "2") {
+    db.exec(`
+      CREATE TABLE sessions_v3 (
+        session_id TEXT PRIMARY KEY,
+        project_slug TEXT,
+        assignment_slug TEXT,
+        agent TEXT NOT NULL,
+        started TEXT NOT NULL,
+        ended TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        path TEXT,
+        description TEXT,
+        transcript_path TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
-    };
-    var handleTodoChange = handleTodoChange2;
-    todosWatcher = watch(todosDir2, {
-      ignoreInitial: true,
-      persistent: true,
-      depth: 1,
-      ignored: /(^|[\/\\])\../
-    });
-    todosWatcher.on("change", handleTodoChange2);
-    todosWatcher.on("add", handleTodoChange2);
-    todosWatcher.on("unlink", handleTodoChange2);
+      INSERT INTO sessions_v3 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at FROM sessions;
+      DROP TABLE sessions;
+      ALTER TABLE sessions_v3 RENAME TO sessions;
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+      CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      UPDATE meta SET value = '3' WHERE key = 'schema_version';
+    `);
   }
-  return {
-    close: async () => {
-      pendingEvents.forEach((timeout) => {
-        clearTimeout(timeout);
-      });
-      pendingEvents.clear();
-      await projectsWatcher.close();
-      if (serversWatcher) await serversWatcher.close();
-      if (playbooksWatcher) await playbooksWatcher.close();
-      if (todosWatcher) await todosWatcher.close();
-    }
-  };
-}
-
-// src/dashboard/server.ts
-init_fs();
-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";
-
-// src/utils/slug.ts
-function isValidSlug(slug) {
-  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug);
-}
-
-// src/utils/uuid.ts
-import { randomUUID } from "crypto";
-function generateId() {
-  return randomUUID();
+  return db;
 }
-
-// src/dashboard/api-write.ts
-init_timestamp();
-init_fs();
-init_parser();
-
-// src/dashboard/acceptance-criteria.ts
-function splitFrontmatter(content) {
-  const match = content.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n?)([\s\S]*)$/);
-  if (!match) {
-    return { prefix: "", body: content };
+function getSessionDb() {
+  if (!db) {
+    throw new Error(
+      "Session database not initialized. Call initSessionDb() first."
+    );
   }
-  return {
-    prefix: match[1],
-    body: match[2]
-  };
+  return db;
 }
-function toggleAcceptanceCriterion(content, index, checked) {
-  if (!Number.isInteger(index) || index < 0) {
-    return { error: "acceptance criteria index must be a non-negative integer" };
-  }
-  const { prefix, body } = splitFrontmatter(content);
-  const lines = body.split("\n");
-  const sectionStart = lines.findIndex((line) => /^##\s+Acceptance Criteria\s*$/i.test(line.trim()));
-  if (sectionStart === -1) {
-    return { error: "Acceptance Criteria section not found." };
+function closeSessionDb() {
+  if (db) {
+    db.close();
+    db = null;
   }
-  let sectionEnd = lines.length;
-  for (let lineIndex = sectionStart + 1; lineIndex < lines.length; lineIndex += 1) {
-    if (/^#{1,2}\s+\S/.test(lines[lineIndex].trim())) {
-      sectionEnd = lineIndex;
-      break;
-    }
+}
+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 readdir5(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);
   }
-  const checklistLines = lines.map((line, lineIndex) => ({ line, lineIndex })).filter(
-    ({ lineIndex, line }) => lineIndex > sectionStart && lineIndex < sectionEnd && /^\s*[-*]\s+\[( |x|X)\]\s+.*$/.test(line)
-  );
-  const target = checklistLines[index];
-  if (!target) {
-    return { error: `Acceptance criteria item ${index} not found.` };
+  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: readFile13 } = await import("fs/promises");
+  const raw = await readFile13(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
+        });
+      }
+    }
   }
-  const nextLine = target.line.replace(
-    /^(\s*[-*]\s+\[)( |x|X)(\]\s+.*)$/,
-    `$1${checked ? "x" : " "}$3`
-  );
-  lines[target.lineIndex] = nextLine;
+  return sessions;
+}
+
+// src/dashboard/agent-sessions.ts
+function rowToSession(row) {
   return {
-    content: `${prefix}${lines.join("\n")}`
+    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
   };
 }
-
-// src/dashboard/api-write.ts
-init_api();
-
-// src/templates/index.ts
-init_config();
-
-// src/templates/manifest.ts
-function renderManifest(params) {
-  return `---
-version: "2.0"
-project: ${params.slug}
-generated: "${params.timestamp}"
----
-
-# Project: ${params.slug}
-
-## Overview
-- [Project Overview](./project.md)
-
-## Indexes
-- [Assignments](./_index-assignments.md)
-- [Plans](./_index-plans.md)
-- [Decision Records](./_index-decisions.md)
-- [Status](./_status.md)
-- [Resources](./resources/_index.md)
-- [Memories](./memories/_index.md)
-`;
+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(excluded.project_slug,    project_slug),
+      assignment_slug = COALESCE(excluded.assignment_slug, assignment_slug),
+      agent           = excluded.agent,
+      status          = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
+      path            = COALESCE(excluded.path,            path),
+      description     = COALESCE(excluded.description,     description),
+      transcript_path = COALESCE(excluded.transcript_path, transcript_path),
+      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
+  );
 }
-
-// src/utils/yaml.ts
-function escapeYamlString(value) {
-  if (value.includes("\n") || value.includes("\r")) {
-    throw new Error(
-      `YAML string values must be single-line. Got: "${value.slice(0, 50)}..."`
-    );
+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 escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-  return `"${escaped}"`;
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  return rows.map(rowToSession);
 }
-
-// src/templates/project.ts
-function renderProject(params) {
-  const safeTitle = escapeYamlString(params.title);
-  const workspaceLine = params.workspace ? `
-workspace: ${params.workspace}` : "";
-  return `---
-id: ${params.id}
-slug: ${params.slug}
-title: ${safeTitle}
-archived: false
-archivedAt: null
-archivedReason: null
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
-externalIds: []
-tags: []${workspaceLine}
----
-
-# ${params.title}
-
-## Overview
-
-<!-- Describe the project goal, context, and success criteria here. -->
-
-## Notes
-
-<!-- Optional human notes, updates, or context. -->
-`;
+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 readFile7(assignmentMdPath, "utf-8");
+  const match = raw.match(/^status:\s*(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+async function readAssignmentStatus(projectDir, assignmentSlug) {
+  return readAssignmentStatusFromPath(
+    resolve9(projectDir, "assignments", assignmentSlug, "assignment.md")
+  );
+}
+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(
+        resolve9(projectsDir, session.project_slug),
+        aslug
+      );
+      if (status) assignmentStatuses.set(key, status);
+    } else if (assignmentsDir) {
+      const status = await readAssignmentStatusFromPath(
+        resolve9(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/templates/assignment.ts
-function renderAssignment(params) {
-  const safeTitle = escapeYamlString(params.title);
-  const dependsOnYaml = params.dependsOn.length === 0 ? "dependsOn: []" : `dependsOn:
-  - ${params.dependsOn.join("\n  - ")}`;
-  const linksYaml = params.links.length === 0 ? "links: []" : `links:
-  - ${params.links.join("\n  - ")}`;
-  const projectYaml = `project: ${params.project == null ? "null" : params.project}`;
-  const typeYaml = `type: ${params.type ?? "feature"}`;
-  return `---
-id: ${params.id}
-slug: ${params.slug}
-title: ${safeTitle}
-${projectYaml}
-${typeYaml}
-status: pending
-priority: ${params.priority}
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
-assignee: null
-externalIds: []
-${dependsOnYaml}
-${linksYaml}
-blockedReason: null
-workspace:
-  repository: null
-  worktreePath: null
-  branch: null
-  parentBranch: null
-tags: []
----
-
-# ${params.title}
-
-## Objective
-
-<!-- Clear description of what needs to be done and why. -->
-
-## Acceptance Criteria
-
-- [ ] <!-- criterion 1 -->
-- [ ] <!-- criterion 2 -->
-- [ ] <!-- criterion 3 -->
-
-## Todos
-
-<!--
-Checklist of work items for this assignment. Items may be simple tasks
-or a markdown link to a plan file (e.g., "- [ ] Execute [plan](./plan.md)").
-When a plan is superseded by a new one, mark the old todo as:
-  - [x] ~~Execute [old plan](./plan.md)~~ (superseded by plan-v2)
-Never delete superseded todos \u2014 preserve the history.
--->
-
-## Context
-
-<!-- Links to relevant docs, code, or other assignments. -->
-
-## Links
-
-- [Progress](./progress.md)
-- [Comments](./comments.md)
-- [Scratchpad](./scratchpad.md)
-- [Handoff](./handoff.md)
-- [Decision Record](./decision-record.md)
-`;
+// 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()
+          };
+          onMessage(message);
+        }, debounceMs)
+      );
+    };
+    var handlePlaybookChange = handlePlaybookChange2;
+    playbooksWatcher = watch(playbooksDir2, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 1,
+      ignored: /(^|[\/\\])\../
+    });
+    playbooksWatcher.on("change", handlePlaybookChange2);
+    playbooksWatcher.on("add", handlePlaybookChange2);
+    playbooksWatcher.on("unlink", handlePlaybookChange2);
+  }
+  let todosWatcher = null;
+  if (todosDir2) {
+    let handleTodoChange2 = function() {
+      const debounceKey = "__todos__";
+      const existing = pendingEvents.get(debounceKey);
+      if (existing) clearTimeout(existing);
+      pendingEvents.set(
+        debounceKey,
+        setTimeout(() => {
+          pendingEvents.delete(debounceKey);
+          const message = {
+            type: "todos-updated",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          onMessage(message);
+        }, debounceMs)
+      );
+    };
+    var handleTodoChange = handleTodoChange2;
+    todosWatcher = watch(todosDir2, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 1,
+      ignored: /(^|[\/\\])\../
+    });
+    todosWatcher.on("change", handleTodoChange2);
+    todosWatcher.on("add", handleTodoChange2);
+    todosWatcher.on("unlink", handleTodoChange2);
+  }
+  return {
+    close: async () => {
+      pendingEvents.forEach((timeout) => {
+        clearTimeout(timeout);
+      });
+      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();
+    }
+  };
 }
 
-// src/templates/scratchpad.ts
-function renderScratchpad(params) {
-  return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
----
+// src/dashboard/server.ts
+init_fs();
+init_config2();
 
-# Scratchpad
+// src/dashboard/api-write.ts
+init_lifecycle();
+import { Router } from "express";
+import { resolve as resolve10 } from "path";
+import { rm, readFile as readFile8 } from "fs/promises";
 
-No working notes yet.
-`;
+// src/utils/slug.ts
+function isValidSlug(slug) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug);
 }
 
-// src/templates/handoff.ts
-function renderHandoff(params) {
-  return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
-handoffCount: 0
----
-
-# Handoff Log
-
-No handoffs recorded yet.
-`;
+// src/utils/uuid.ts
+import { randomUUID } from "crypto";
+function generateId() {
+  return randomUUID();
 }
 
-// src/templates/decision-record.ts
-function renderDecisionRecord(params) {
-  return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
-decisionCount: 0
----
-
-# Decision Record
+// src/dashboard/api-write.ts
+init_timestamp();
+init_fs();
+init_parser();
 
-No decisions recorded yet.
-`;
+// src/dashboard/acceptance-criteria.ts
+function splitFrontmatter(content) {
+  const match = content.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n?)([\s\S]*)$/);
+  if (!match) {
+    return { prefix: "", body: content };
+  }
+  return {
+    prefix: match[1],
+    body: match[2]
+  };
 }
-
-// src/templates/index-stubs.ts
-function renderIndexAssignments(params) {
-  return `---
-project: ${params.slug}
+function toggleAcceptanceCriterion(content, index, checked) {
+  if (!Number.isInteger(index) || index < 0) {
+    return { error: "acceptance criteria index must be a non-negative integer" };
+  }
+  const { prefix, body } = splitFrontmatter(content);
+  const lines = body.split("\n");
+  const sectionStart = lines.findIndex((line) => /^##\s+Acceptance Criteria\s*$/i.test(line.trim()));
+  if (sectionStart === -1) {
+    return { error: "Acceptance Criteria section not found." };
+  }
+  let sectionEnd = lines.length;
+  for (let lineIndex = sectionStart + 1; lineIndex < lines.length; lineIndex += 1) {
+    if (/^#{1,2}\s+\S/.test(lines[lineIndex].trim())) {
+      sectionEnd = lineIndex;
+      break;
+    }
+  }
+  const checklistLines = lines.map((line, lineIndex) => ({ line, lineIndex })).filter(
+    ({ lineIndex, line }) => lineIndex > sectionStart && lineIndex < sectionEnd && /^\s*[-*]\s+\[( |x|X)\]\s+.*$/.test(line)
+  );
+  const target = checklistLines[index];
+  if (!target) {
+    return { error: `Acceptance criteria item ${index} not found.` };
+  }
+  const nextLine = target.line.replace(
+    /^(\s*[-*]\s+\[)( |x|X)(\]\s+.*)$/,
+    `$1${checked ? "x" : " "}$3`
+  );
+  lines[target.lineIndex] = nextLine;
+  return {
+    content: `${prefix}${lines.join("\n")}`
+  };
+}
+
+// src/dashboard/api-write.ts
+init_api();
+init_assignment_resolver();
+
+// src/templates/index.ts
+init_config();
+
+// src/templates/manifest.ts
+function renderManifest(params) {
+  return `---
+version: "2.0"
+project: ${params.slug}
+generated: "${params.timestamp}"
+---
+
+# Project: ${params.slug}
+
+## Overview
+- [Project Overview](./project.md)
+
+## Indexes
+- [Assignments](./_index-assignments.md)
+- [Plans](./_index-plans.md)
+- [Decision Records](./_index-decisions.md)
+- [Status](./_status.md)
+- [Resources](./resources/_index.md)
+- [Memories](./memories/_index.md)
+`;
+}
+
+// src/utils/yaml.ts
+function escapeYamlString(value) {
+  if (value.includes("\n") || value.includes("\r")) {
+    throw new Error(
+      `YAML string values must be single-line. Got: "${value.slice(0, 50)}..."`
+    );
+  }
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+// src/templates/project.ts
+function renderProject(params) {
+  const safeTitle = escapeYamlString(params.title);
+  const workspaceLine = params.workspace ? `
+workspace: ${params.workspace}` : "";
+  return `---
+id: ${params.id}
+slug: ${params.slug}
+title: ${safeTitle}
+archived: false
+archivedAt: null
+archivedReason: null
+created: "${params.timestamp}"
+updated: "${params.timestamp}"
+externalIds: []
+tags: []${workspaceLine}
+---
+
+# ${params.title}
+
+## Overview
+
+<!-- Describe the project goal, context, and success criteria here. -->
+
+## Notes
+
+<!-- Optional human notes, updates, or context. -->
+`;
+}
+
+// src/templates/assignment.ts
+function renderAssignment(params) {
+  const safeTitle = escapeYamlString(params.title);
+  const dependsOnYaml = params.dependsOn.length === 0 ? "dependsOn: []" : `dependsOn:
+  - ${params.dependsOn.join("\n  - ")}`;
+  const linksYaml = params.links.length === 0 ? "links: []" : `links:
+  - ${params.links.join("\n  - ")}`;
+  const projectYaml = `project: ${params.project == null ? "null" : params.project}`;
+  const typeYaml = `type: ${params.type ?? "feature"}`;
+  return `---
+id: ${params.id}
+slug: ${params.slug}
+title: ${safeTitle}
+${projectYaml}
+${typeYaml}
+status: pending
+priority: ${params.priority}
+created: "${params.timestamp}"
+updated: "${params.timestamp}"
+assignee: null
+externalIds: []
+${dependsOnYaml}
+${linksYaml}
+blockedReason: null
+workspace:
+  repository: null
+  worktreePath: null
+  branch: null
+  parentBranch: null
+tags: []
+---
+
+# ${params.title}
+
+## Objective
+
+<!-- Clear description of what needs to be done and why. -->
+
+## Acceptance Criteria
+
+- [ ] <!-- criterion 1 -->
+- [ ] <!-- criterion 2 -->
+- [ ] <!-- criterion 3 -->
+
+## Todos
+
+<!--
+Checklist of work items for this assignment. Items may be simple tasks
+or a markdown link to a plan file (e.g., "- [ ] Execute [plan](./plan.md)").
+When a plan is superseded by a new one, mark the old todo as:
+  - [x] ~~Execute [old plan](./plan.md)~~ (superseded by plan-v2)
+Never delete superseded todos \u2014 preserve the history.
+-->
+
+## Context
+
+<!-- Links to relevant docs, code, or other assignments. -->
+
+## Links
+
+- [Progress](./progress.md)
+- [Comments](./comments.md)
+- [Scratchpad](./scratchpad.md)
+- [Handoff](./handoff.md)
+- [Decision Record](./decision-record.md)
+`;
+}
+
+// src/templates/scratchpad.ts
+function renderScratchpad(params) {
+  return `---
+assignment: ${params.assignmentSlug}
+updated: "${params.timestamp}"
+---
+
+# Scratchpad
+
+No working notes yet.
+`;
+}
+
+// src/templates/handoff.ts
+function renderHandoff(params) {
+  return `---
+assignment: ${params.assignmentSlug}
+updated: "${params.timestamp}"
+handoffCount: 0
+---
+
+# Handoff Log
+
+No handoffs recorded yet.
+`;
+}
+
+// src/templates/progress.ts
+function renderProgress(params) {
+  return `---
+assignment: ${params.assignment}
+entryCount: 0
+generated: "${params.timestamp}"
+updated: "${params.timestamp}"
+---
+
+# 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
+
+No decisions recorded yet.
+`;
+}
+
+// src/templates/index-stubs.ts
+function renderIndexAssignments(params) {
+  return `---
+project: ${params.slug}
 generated: "${params.timestamp}"
 total: 0
 by_status:
@@ -3753,6 +4698,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 +4799,9 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile6(filePath, "utf-8");
+  return readFile8(filePath, "utf-8");
 }
-function createWriteRouter(projectsDir) {
+function createWriteRouter(projectsDir, assignmentsDir) {
   const router = Router();
   router.get("/api/templates/project", (_req, res) => {
     const content = renderProject({
@@ -3877,412 +4824,1019 @@ function createWriteRouter(projectsDir) {
     });
     res.json({ content });
   });
-  router.get("/api/projects/:slug/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const document = await getEditableDocument(projectsDir, "project", slug);
-    if (!document) {
-      res.status(404).json({ error: `Project "${slug}" not found` });
-      return;
+  router.get("/api/projects/:slug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const document = await getEditableDocument(projectsDir, "project", slug);
+    if (!document) {
+      res.status(404).json({ error: `Project "${slug}" not found` });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/assignments/:aslug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const document = await getEditableDocument(
+      projectsDir,
+      "assignment",
+      slug,
+      assignmentSlug
+    );
+    if (!document) {
+      res.status(404).json({ error: "Assignment not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/assignments/:aslug/plan/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const document = await getEditableDocument(
+      projectsDir,
+      "plan",
+      slug,
+      assignmentSlug
+    );
+    if (!document) {
+      res.status(404).json({ error: "Plan not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/assignments/:aslug/scratchpad/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const document = await getEditableDocument(
+      projectsDir,
+      "scratchpad",
+      slug,
+      assignmentSlug
+    );
+    if (!document) {
+      res.status(404).json({ error: "Scratchpad not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/assignments/:aslug/handoff/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const document = await getEditableDocument(
+      projectsDir,
+      "handoff",
+      slug,
+      assignmentSlug
+    );
+    if (!document) {
+      res.status(404).json({ error: "Handoff log not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/assignments/:aslug/decision-record/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const document = await getEditableDocument(
+      projectsDir,
+      "decision-record",
+      slug,
+      assignmentSlug
+    );
+    if (!document) {
+      res.status(404).json({ error: "Decision record not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.post("/api/projects", async (req, res) => {
+    try {
+      const content = requireContent(req, res);
+      if (!content) {
+        return;
+      }
+      const fields = extractFrontmatter3(content);
+      if (!fields) {
+        res.status(400).json({ error: "Invalid frontmatter: missing --- delimiters" });
+        return;
+      }
+      const validation = validateRequired(fields, ["slug", "title"]);
+      if (!validation.valid) {
+        res.status(400).json({ error: `Missing required fields: ${validation.missing.join(", ")}` });
+        return;
+      }
+      const slug = fields.slug;
+      if (!isValidSlug(slug)) {
+        res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
+        return;
+      }
+      const projectDir = resolve10(projectsDir, slug);
+      if (await fileExists(projectDir)) {
+        res.status(409).json({ error: `Project "${slug}" already exists` });
+        return;
+      }
+      const title = fields.title;
+      const timestamp = fields.created || nowTimestamp();
+      await ensureDir(resolve10(projectDir, "assignments"));
+      await ensureDir(resolve10(projectDir, "resources"));
+      await ensureDir(resolve10(projectDir, "memories"));
+      await writeFileForce(resolve10(projectDir, "project.md"), content);
+      try {
+        const companions = [
+          [resolve10(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve10(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve10(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve10(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve10(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve10(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve10(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+        ];
+        for (const [filePath, fileContent] of companions) {
+          await writeFileForce(filePath, fileContent);
+        }
+      } catch (companionError) {
+        try {
+          await rm(projectDir, { recursive: true, force: true });
+        } catch {
+        }
+        throw companionError;
+      }
+      res.status(201).json({ slug });
+    } catch (error) {
+      console.error("Error creating project:", error);
+      res.status(500).json({ error: `Failed to create project: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/assignments", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectDir = resolve10(projectsDir, projectSlug);
+      const projectMdPath = resolve10(projectDir, "project.md");
+      if (!await fileExists(projectMdPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const content = requireContent(req, res);
+      if (!content) {
+        return;
+      }
+      const fields = extractFrontmatter3(content);
+      if (!fields) {
+        res.status(400).json({ error: "Invalid frontmatter: missing --- delimiters" });
+        return;
+      }
+      const validation = validateRequired(fields, ["slug", "title"]);
+      if (!validation.valid) {
+        res.status(400).json({ error: `Missing required fields: ${validation.missing.join(", ")}` });
+        return;
+      }
+      const assignmentSlug = fields.slug;
+      if (!isValidSlug(assignmentSlug)) {
+        res.status(400).json({ error: `Invalid slug "${assignmentSlug}". Must be lowercase and hyphen-separated.` });
+        return;
+      }
+      const validPriorities = ["low", "medium", "high", "critical"];
+      const priority = fields.priority || "medium";
+      if (!validPriorities.includes(priority)) {
+        res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
+        return;
+      }
+      const assignmentDir = resolve10(projectDir, "assignments", assignmentSlug);
+      if (await fileExists(assignmentDir)) {
+        res.status(409).json({
+          error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
+        });
+        return;
+      }
+      const timestamp = fields.created || nowTimestamp();
+      await ensureDir(assignmentDir);
+      await writeFileForce(resolve10(assignmentDir, "assignment.md"), content);
+      try {
+        const companions = [
+          [resolve10(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve10(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve10(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+        ];
+        for (const [filePath, fileContent] of companions) {
+          await writeFileForce(filePath, fileContent);
+        }
+      } catch (companionError) {
+        try {
+          await rm(assignmentDir, { recursive: true, force: true });
+        } catch {
+        }
+        throw companionError;
+      }
+      res.status(201).json({ slug: assignmentSlug, projectSlug });
+    } catch (error) {
+      console.error("Error creating assignment:", error);
+      res.status(500).json({ error: `Failed to create assignment: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      const currentContent = await readCurrentDocument(projectPath);
+      if (!currentContent) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) {
+        return;
+      }
+      const current = parseProject(currentContent);
+      const next = parseProject(nextContentRaw);
+      if (!next.slug || !next.title) {
+        res.status(400).json({ error: "Project content must include slug and title." });
+        return;
+      }
+      if (next.slug !== current.slug) {
+        res.status(400).json({ error: "Project slug cannot be changed once created." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(projectPath, nextContent);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project, content: nextContent });
+    } catch (error) {
+      console.error("Error updating project:", error);
+      res.status(500).json({ error: `Failed to update project: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug/assignments/:aslug", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const assignmentPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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.slug || !next.title) {
+        res.status(400).json({ error: "Assignment content must include slug and title." });
+        return;
+      }
+      if (next.slug !== current.slug) {
+        res.status(400).json({ error: "Assignment slug cannot be changed once created." });
+        return;
+      }
+      let nextContent = nextContentRaw;
+      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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating assignment:", error);
+      res.status(500).json({ error: `Failed to update assignment: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug/assignments/:aslug/acceptance-criteria/:index", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const assignmentPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error toggling acceptance criterion:", error);
+      res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug/assignments/:aslug/plan", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const planPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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 next = parsePlan(nextContentRaw);
+      if (!next.assignment) {
+        res.status(400).json({ error: "Plan content must include the assignment field." });
+        return;
+      }
+      if (next.assignment !== assignmentSlug) {
+        res.status(400).json({ error: "Plan assignment field must match the route assignment slug." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(planPath, nextContent);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating plan:", error);
+      res.status(500).json({ error: `Failed to update plan: ${error.message}` });
     }
-    res.json(document);
   });
-  router.get("/api/projects/:slug/assignments/:aslug/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const assignmentSlug = getParam(req.params.aslug);
-    const document = await getEditableDocument(
-      projectsDir,
-      "assignment",
-      slug,
-      assignmentSlug
-    );
-    if (!document) {
-      res.status(404).json({ error: "Assignment not found" });
-      return;
+  router.patch("/api/projects/:slug/assignments/:aslug/scratchpad", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const scratchpadPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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 next = parseScratchpad(nextContentRaw);
+      if (!next.assignment) {
+        res.status(400).json({ error: "Scratchpad content must include the assignment field." });
+        return;
+      }
+      if (next.assignment !== assignmentSlug) {
+        res.status(400).json({ error: "Scratchpad assignment field must match the route assignment slug." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(scratchpadPath, nextContent);
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error updating scratchpad:", error);
+      res.status(500).json({ error: `Failed to update scratchpad: ${error.message}` });
     }
-    res.json(document);
   });
-  router.get("/api/projects/:slug/assignments/:aslug/plan/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const assignmentSlug = getParam(req.params.aslug);
-    const document = await getEditableDocument(
-      projectsDir,
-      "plan",
-      slug,
-      assignmentSlug
-    );
-    if (!document) {
-      res.status(404).json({ error: "Plan not found" });
-      return;
+  router.post("/api/projects/:slug/assignments/:aslug/handoff/entries", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const handoffPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.status(201).json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error appending handoff entry:", error);
+      res.status(500).json({ error: `Failed to append handoff entry: ${error.message}` });
     }
-    res.json(document);
   });
-  router.get("/api/projects/:slug/assignments/:aslug/scratchpad/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const assignmentSlug = getParam(req.params.aslug);
-    const document = await getEditableDocument(
-      projectsDir,
-      "scratchpad",
-      slug,
-      assignmentSlug
-    );
-    if (!document) {
-      res.status(404).json({ error: "Scratchpad not found" });
-      return;
+  router.post("/api/projects/:slug/assignments/:aslug/decision-record/entries", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const decisionPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.status(201).json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error appending decision entry:", error);
+      res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
     }
-    res.json(document);
   });
-  router.get("/api/projects/:slug/assignments/:aslug/handoff/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const assignmentSlug = getParam(req.params.aslug);
-    const document = await getEditableDocument(
-      projectsDir,
-      "handoff",
-      slug,
-      assignmentSlug
-    );
-    if (!document) {
-      res.status(404).json({ error: "Handoff log not found" });
-      return;
+  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 = resolve10(
+        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 readFile8(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}` });
     }
-    res.json(document);
   });
-  router.get("/api/projects/:slug/assignments/:aslug/decision-record/edit", async (req, res) => {
-    const slug = getParam(req.params.slug);
-    const assignmentSlug = getParam(req.params.aslug);
-    const document = await getEditableDocument(
-      projectsDir,
-      "decision-record",
-      slug,
-      assignmentSlug
-    );
-    if (!document) {
-      res.status(404).json({ error: "Decision record not found" });
-      return;
+  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 = resolve10(
+        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 readFile8(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}` });
     }
-    res.json(document);
   });
-  router.post("/api/projects", async (req, res) => {
+  router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
-      const content = requireContent(req, res);
-      if (!content) {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      const fields = extractFrontmatter3(content);
-      if (!fields) {
-        res.status(400).json({ error: "Invalid frontmatter: missing --- delimiters" });
+      const { workspace } = req.body || {};
+      if (workspace !== null && (typeof workspace !== "string" || !workspace.trim())) {
+        res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      const validation = validateRequired(fields, ["slug", "title"]);
-      if (!validation.valid) {
-        res.status(400).json({ error: `Missing required fields: ${validation.missing.join(", ")}` });
+      let content = await readFile8(projectPath, "utf-8");
+      content = setTopLevelField(content, "workspace", workspace ?? null);
+      content = setTopLevelField(content, "updated", nowTimestamp());
+      await writeFileForce(projectPath, content);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error moving project workspace:", error);
+      res.status(500).json({ error: `Failed to move workspace: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/status-override", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve10(projectsDir, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      const slug = fields.slug;
-      if (!isValidSlug(slug)) {
-        res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
+      const { status } = req.body || {};
+      const config = await getStatusConfig();
+      const validStatuses = ["active", "archived", ...config.statuses.map((s) => s.id)];
+      if (status !== null && (typeof status !== "string" || !validStatuses.includes(status))) {
+        res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      const projectDir = resolve7(projectsDir, slug);
-      if (await fileExists(projectDir)) {
-        res.status(409).json({ error: `Project "${slug}" already exists` });
+      let content = await readFile8(projectPath, "utf-8");
+      content = setTopLevelField(content, "statusOverride", status ?? null);
+      content = setTopLevelField(content, "updated", nowTimestamp());
+      await writeFileForce(projectPath, content);
+      const project = await getProjectDetail(projectsDir, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error setting project status override:", error);
+      res.status(500).json({ error: `Failed to set status override: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/assignments/:aslug/status-override", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const assignmentPath = resolve10(
+        projectsDir,
+        projectSlug,
+        "assignments",
+        assignmentSlug,
+        "assignment.md"
+      );
+      if (!await fileExists(assignmentPath)) {
+        res.status(404).json({ error: "Assignment not found" });
         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);
-      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 })]
-        ];
-        for (const [filePath, fileContent] of companions) {
-          await writeFileForce(filePath, fileContent);
-        }
-      } catch (companionError) {
-        try {
-          await rm(projectDir, { recursive: true, force: true });
-        } catch {
-        }
-        throw companionError;
+      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;
       }
-      res.status(201).json({ slug });
+      let content = await readFile8(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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment });
     } catch (error) {
-      console.error("Error creating project:", error);
-      res.status(500).json({ error: `Failed to create project: ${error.message}` });
+      console.error("Error overriding assignment status:", error);
+      res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
   });
-  router.post("/api/projects/:slug/assignments", async (req, res) => {
+  router.post("/api/projects/:slug/assignments/:aslug/transitions/:command", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve7(projectsDir, projectSlug);
-      const projectMdPath = resolve7(projectDir, "project.md");
-      if (!await fileExists(projectMdPath)) {
-        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+      const assignmentSlug = getParam(req.params.aslug);
+      const command = req.params.command;
+      const config = await getStatusConfig();
+      const validCommands = [...new Set(config.transitions.map((t) => t.command))];
+      if (!validCommands.includes(command)) {
+        res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const content = requireContent(req, res);
-      if (!content) {
+      const projectDir = resolve10(projectsDir, projectSlug);
+      const assignmentPath = resolve10(projectDir, "assignments", assignmentSlug, "assignment.md");
+      if (!await fileExists(assignmentPath)) {
+        res.status(404).json({ error: "Assignment not found" });
         return;
       }
-      const fields = extractFrontmatter3(content);
-      if (!fields) {
-        res.status(400).json({ error: "Invalid frontmatter: missing --- delimiters" });
+      const { reason } = req.body || {};
+      const result = await executeTransition(projectDir, assignmentSlug, command, {
+        reason: typeof reason === "string" ? reason : void 0,
+        transitionTable: config.custom ? config.transitionTable : void 0,
+        terminalStatuses: config.custom ? config.terminalStatuses : void 0
+      });
+      if (!result.success) {
+        res.status(400).json({ error: result.message });
         return;
       }
-      const validation = validateRequired(fields, ["slug", "title"]);
-      if (!validation.valid) {
-        res.status(400).json({ error: `Missing required fields: ${validation.missing.join(", ")}` });
+      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      res.json({ assignment, transition: result });
+    } catch (error) {
+      console.error("Error running assignment transition:", error);
+      res.status(500).json({ error: `Failed to transition assignment: ${error.message}` });
+    }
+  });
+  router.delete("/api/projects/:slug/assignments/:aslug", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const assignmentDir = resolve10(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve10(assignmentDir, "assignment.md");
+      if (!await fileExists(assignmentPath)) {
+        res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
       }
-      const assignmentSlug = fields.slug;
-      if (!isValidSlug(assignmentSlug)) {
-        res.status(400).json({ error: `Invalid slug "${assignmentSlug}". Must be lowercase and hyphen-separated.` });
+      await rm(assignmentDir, { recursive: true, force: true });
+      res.json({ deleted: assignmentSlug, projectSlug });
+    } catch (error) {
+      console.error("Error deleting assignment:", error);
+      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 validPriorities = ["low", "medium", "high", "critical"];
-      const priority = fields.priority || "medium";
-      if (!validPriorities.includes(priority)) {
-        res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
+      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 assignmentDir = resolve7(projectDir, "assignments", assignmentSlug);
+      const id = generateId();
+      const assignmentDir = resolve10(assignmentsDir, id);
       if (await fileExists(assignmentDir)) {
-        res.status(409).json({
-          error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
-        });
+        res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
       }
-      const timestamp = fields.created || nowTimestamp();
+      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);
-      await writeFileForce(resolve7(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 })]
-        ];
-        for (const [filePath, fileContent] of companions) {
-          await writeFileForce(filePath, fileContent);
-        }
-      } catch (companionError) {
-        try {
-          await rm(assignmentDir, { recursive: true, force: true });
-        } catch {
-        }
-        throw companionError;
-      }
-      res.status(201).json({ slug: assignmentSlug, projectSlug });
+      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(resolve10(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(
+        resolve10(assignmentDir, "scratchpad.md"),
+        renderScratchpad({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve10(assignmentDir, "handoff.md"),
+        renderHandoff({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve10(assignmentDir, "decision-record.md"),
+        renderDecisionRecord({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve10(assignmentDir, "progress.md"),
+        renderProgress({ assignment: id, timestamp })
+      );
+      await writeFileForce(
+        resolve10(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 assignment:", error);
-      res.status(500).json({ error: `Failed to create assignment: ${error.message}` });
+      console.error("Error creating standalone assignment:", error);
+      res.status(500).json({ error: `Failed to create standalone assignment: ${error.message}` });
     }
   });
-  router.patch("/api/projects/:slug", async (req, res) => {
+  router.post("/api/assignments/:id/comments", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
-      const currentContent = await readCurrentDocument(projectPath);
-      if (!currentContent) {
-        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      const nextContentRaw = requireContent(req, res);
-      if (!nextContentRaw) {
+      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 current = parseProject(currentContent);
-      const next = parseProject(nextContentRaw);
-      if (!next.slug || !next.title) {
-        res.status(400).json({ error: "Project content must include slug and title." });
+      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;
       }
-      if (next.slug !== current.slug) {
-        res.status(400).json({ error: "Project slug cannot be changed once created." });
+      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;
       }
-      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
-      await writeFileForce(projectPath, nextContent);
-      const project = await getProjectDetail(projectsDir, projectSlug);
-      res.json({ project, content: nextContent });
+      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 updating project:", error);
-      res.status(500).json({ error: `Failed to update project: ${error.message}` });
+      console.error("Error toggling comment resolved (by id):", error);
+      res.status(500).json({ error: `Failed to toggle resolved: ${error.message}` });
     }
   });
-  router.patch("/api/projects/:slug/assignments/:aslug", async (req, res) => {
-    try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "assignment.md"
-      );
+  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 = resolve10(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;
-      }
+      if (!nextContentRaw) return;
       const current = parseAssignmentFull(currentContent);
       const next = parseAssignmentFull(nextContentRaw);
-      if (!next.slug || !next.title) {
-        res.status(400).json({ error: "Assignment content must include slug and title." });
-        return;
-      }
-      if (next.slug !== current.slug) {
-        res.status(400).json({ error: "Assignment slug cannot be changed once created." });
+      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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.json({ assignment, content: nextContent });
     } catch (error) {
-      console.error("Error updating assignment:", error);
+      console.error("Error updating standalone assignment:", error);
       res.status(500).json({ error: `Failed to update assignment: ${error.message}` });
     }
   });
-  router.patch("/api/projects/:slug/assignments/:aslug/acceptance-criteria/:index", async (req, res) => {
+  router.patch("/api/assignments/:id/plan", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "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" });
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         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 });
+      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 nextContent = setTopLevelField(result.content, "updated", nowTimestamp());
-      await writeFileForce(assignmentPath, nextContent);
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
-      res.json({ assignment, content: nextContent });
-    } catch (error) {
-      console.error("Error toggling acceptance criterion:", error);
-      res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
-    }
-  });
-  router.patch("/api/projects/:slug/assignments/:aslug/plan", async (req, res) => {
-    try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "plan.md"
-      );
+      const planPath = resolve10(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 next = parsePlan(nextContentRaw);
-      if (!next.assignment) {
+      if (!nextContentRaw) return;
+      const parsed = parsePlan(nextContentRaw);
+      if (!parsed.assignment) {
         res.status(400).json({ error: "Plan content must include the assignment field." });
         return;
       }
-      if (next.assignment !== assignmentSlug) {
-        res.status(400).json({ error: "Plan assignment field must match the route assignment slug." });
-        return;
-      }
       const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
       await writeFileForce(planPath, nextContent);
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.json({ assignment, content: nextContent });
     } catch (error) {
-      console.error("Error updating plan:", error);
+      console.error("Error updating standalone plan:", error);
       res.status(500).json({ error: `Failed to update plan: ${error.message}` });
     }
   });
-  router.patch("/api/projects/:slug/assignments/:aslug/scratchpad", async (req, res) => {
+  router.patch("/api/assignments/:id/scratchpad", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "scratchpad.md"
-      );
+      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 = resolve10(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 next = parseScratchpad(nextContentRaw);
-      if (!next.assignment) {
+      if (!nextContentRaw) return;
+      const parsed = parseScratchpad(nextContentRaw);
+      if (!parsed.assignment) {
         res.status(400).json({ error: "Scratchpad content must include the assignment field." });
         return;
       }
-      if (next.assignment !== assignmentSlug) {
-        res.status(400).json({ error: "Scratchpad assignment field must match the route assignment slug." });
-        return;
-      }
       const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
       await writeFileForce(scratchpadPath, nextContent);
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.json({ assignment, content: nextContent });
     } catch (error) {
-      console.error("Error updating scratchpad:", error);
+      console.error("Error updating standalone scratchpad:", error);
       res.status(500).json({ error: `Failed to update scratchpad: ${error.message}` });
     }
   });
-  router.post("/api/projects/:slug/assignments/:aslug/handoff/entries", async (req, res) => {
+  router.post("/api/assignments/:id/handoff/entries", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "handoff.md"
-      );
+      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 = resolve10(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -4303,24 +5857,26 @@ function createWriteRouter(projectsDir) {
         "No handoffs recorded yet."
       );
       await writeFileForce(handoffPath, nextContent);
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.status(201).json({ assignment, content: nextContent });
     } catch (error) {
-      console.error("Error appending handoff entry:", error);
+      console.error("Error appending standalone handoff entry:", error);
       res.status(500).json({ error: `Failed to append handoff entry: ${error.message}` });
     }
   });
-  router.post("/api/projects/:slug/assignments/:aslug/decision-record/entries", async (req, res) => {
+  router.post("/api/assignments/:id/decision-record/entries", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "decision-record.md"
-      );
+      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 = resolve10(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -4341,74 +5897,26 @@ function createWriteRouter(projectsDir) {
         "No decisions recorded yet."
       );
       await writeFileForce(decisionPath, nextContent);
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.status(201).json({ assignment, content: nextContent });
     } catch (error) {
-      console.error("Error appending decision entry:", error);
+      console.error("Error appending standalone decision entry:", error);
       res.status(500).json({ error: `Failed to append decision entry: ${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");
-      if (!await fileExists(projectPath)) {
-        res.status(404).json({ error: `Project "${projectSlug}" not found` });
-        return;
-      }
-      const { workspace } = req.body || {};
-      if (workspace !== null && (typeof workspace !== "string" || !workspace.trim())) {
-        res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
-        return;
-      }
-      let content = await readFile6(projectPath, "utf-8");
-      content = setTopLevelField(content, "workspace", workspace ?? null);
-      content = setTopLevelField(content, "updated", nowTimestamp());
-      await writeFileForce(projectPath, content);
-      const project = await getProjectDetail(projectsDir, projectSlug);
-      res.json({ project });
-    } catch (error) {
-      console.error("Error moving project workspace:", error);
-      res.status(500).json({ error: `Failed to move workspace: ${error.message}` });
-    }
-  });
-  router.post("/api/projects/:slug/status-override", async (req, res) => {
+  router.post("/api/assignments/:id/status-override", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve7(projectsDir, projectSlug, "project.md");
-      if (!await fileExists(projectPath)) {
-        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      const { status } = req.body || {};
-      const config = await getStatusConfig();
-      const validStatuses = ["active", "archived", ...config.statuses.map((s) => s.id)];
-      if (status !== null && (typeof status !== "string" || !validStatuses.includes(status))) {
-        res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
+      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;
       }
-      let content = await readFile6(projectPath, "utf-8");
-      content = setTopLevelField(content, "statusOverride", status ?? null);
-      content = setTopLevelField(content, "updated", nowTimestamp());
-      await writeFileForce(projectPath, content);
-      const project = await getProjectDetail(projectsDir, projectSlug);
-      res.json({ project });
-    } catch (error) {
-      console.error("Error setting project status override:", error);
-      res.status(500).json({ error: `Failed to set status override: ${error.message}` });
-    }
-  });
-  router.post("/api/projects/:slug/assignments/:aslug/status-override", async (req, res) => {
-    try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve7(
-        projectsDir,
-        projectSlug,
-        "assignments",
-        assignmentSlug,
-        "assignment.md"
-      );
+      const assignmentPath = resolve10(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -4420,83 +5928,184 @@ 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 readFile8(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 getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
+      const assignment = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
       res.json({ assignment });
     } catch (error) {
-      console.error("Error overriding assignment status:", error);
+      console.error("Error overriding standalone status:", error);
       res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
   });
-  router.post("/api/projects/:slug/assignments/:aslug/transitions/:command", async (req, res) => {
+  router.patch("/api/assignments/:id/acceptance-criteria/:index", async (req, res) => {
     try {
-      const projectSlug = getParam(req.params.slug);
-      const assignmentSlug = getParam(req.params.aslug);
-      const command = req.params.command;
-      const config = await getStatusConfig();
-      const validCommands = [...new Set(config.transitions.map((t) => t.command))];
-      if (!validCommands.includes(command)) {
-        res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      const projectDir = resolve7(projectsDir, projectSlug);
-      const assignmentPath = resolve7(projectDir, "assignments", assignmentSlug, "assignment.md");
-      if (!await fileExists(assignmentPath)) {
+      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 = resolve10(resolved.assignmentDir, "assignment.md");
+      const currentContent = await readCurrentDocument(assignmentPath);
+      if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
         return;
       }
-      const { reason } = req.body || {};
-      const result = await executeTransition(projectDir, assignmentSlug, command, {
-        reason: typeof reason === "string" ? reason : void 0,
-        transitionTable: config.custom ? config.transitionTable : void 0,
-        terminalStatuses: config.custom ? config.terminalStatuses : void 0
-      });
-      if (!result.success) {
-        res.status(400).json({ error: result.message });
+      const { checked } = req.body || {};
+      if (typeof checked !== "boolean") {
+        res.status(400).json({ error: "checked must be a boolean" });
         return;
       }
-      const assignment = await getAssignmentDetail(projectsDir, projectSlug, assignmentSlug);
-      res.json({ assignment, transition: result });
+      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 running assignment transition:", error);
-      res.status(500).json({ error: `Failed to transition assignment: ${error.message}` });
+      console.error("Error toggling standalone acceptance criterion:", error);
+      res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
     }
   });
-  router.delete("/api/projects/:slug/assignments/:aslug", async (req, res) => {
+  router.post("/api/assignments/:id/transitions/:command", async (req, res) => {
     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");
-      if (!await fileExists(assignmentPath)) {
-        res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
+      if (!assignmentsDir) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      await rm(assignmentDir, { recursive: true, force: true });
-      res.json({ deleted: assignmentSlug, projectSlug });
+      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 deleting assignment:", error);
-      res.status(500).json({ error: `Failed to delete assignment: ${error.message}` });
+      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 = resolve10(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 readFile8(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 = resolve10(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 readFile8(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 +6113,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 +6164,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 +6179,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 +6216,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 resolve11 } 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 +6233,12 @@ function createAgentSessionsRouter(projectsDir, broadcast) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve10(projectsDir, projectSlug);
+      const projectDir = resolve11(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 +6247,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 = resolve11(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 +6327,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 resolve13 } from "path";
+import { readFile as readFile10, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
 
@@ -4974,15 +6336,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 resolve12 } from "path";
+import { readdir as readdir6, readFile as readFile9 } from "fs/promises";
 async function rebuildPlaybookManifest(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return;
-  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
+  const entries = await readdir6(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 readFile9(resolve12(playbooksDir2, entry.name), "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     rows.push({
@@ -5012,7 +6374,7 @@ async function rebuildPlaybookManifest(playbooksDir2) {
     }
   }
   lines.push("");
-  await writeFileForce(resolve11(playbooksDir2, "manifest.md"), lines.join("\n"));
+  await writeFileForce(resolve12(playbooksDir2, "manifest.md"), lines.join("\n"));
 }
 
 // src/dashboard/api-playbooks.ts
@@ -5053,12 +6415,12 @@ function createPlaybooksRouter(playbooksDir2) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve13(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 readFile10(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${req.params.slug}`,
@@ -5083,7 +6445,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve12(playbooksDir2, `${slug}.md`);
+      const filePath = resolve13(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -5102,7 +6464,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
+      const filePath = resolve13(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5120,7 +6482,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 = resolve13(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5139,7 +6501,7 @@ function createPlaybooksRouter(playbooksDir2) {
 init_parser2();
 init_fs();
 import { Router as Router5 } from "express";
-import { readdir as readdir6 } from "fs/promises";
+import { readdir as readdir7 } from "fs/promises";
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -5173,7 +6535,7 @@ function createTodosRouter(todosDir2, broadcast) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir6(todosDir2).catch(() => []);
+      const files = await readdir7(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -5278,8 +6640,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: resolve17 } = await import("path");
+      const { readFile: readFile13 } = 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 +6657,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(resolve17(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile12(archFile, "utf-8");
+        archContent = await readFile13(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -5558,8 +6920,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 readFile12, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
+import { resolve as resolve15, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -5599,7 +6961,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: resolve15(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -5610,7 +6972,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve15(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -5619,7 +6981,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile11(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile12(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 +7019,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve14(dest, ".."));
+    await ensureDir(resolve15(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -5666,7 +7028,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile11(configPath, "utf-8");
+  const content = await readFile12(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -5705,7 +7067,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve14(destPath, ".."));
+        await ensureDir(resolve15(destPath, ".."));
         await writeFile3(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -5759,7 +7121,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve14(localPath, ".."));
+    await ensureDir(resolve15(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -5860,7 +7222,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve15(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -6015,7 +7377,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 +7388,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 +7432,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 +7498,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 +7510,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 +7519,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 });
@@ -6197,7 +7559,7 @@ function createDashboardServer(options) {
   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 +7568,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 +7688,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 +7716,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 +7766,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 = resolve16(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -6397,12 +7790,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,7 +7808,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve15(syntaurRoot(), "dashboard-port");
+          const portFile = resolve16(syntaurRoot(), "dashboard-port");
           writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -6431,7 +7825,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve15(syntaurRoot(), "dashboard-port");
+      const portFile = resolve16(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();