syntaur 0.2.0 → 0.3.0

package/dist/index.js

@@ -302,6 +302,58 @@ function parseDecisionRecord(fileContent) {
     body
   };
 }
+function parseComments(fileContent) {
+  const [fm, body] = extractFrontmatter(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] = extractFrontmatter(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] = extractFrontmatter(fileContent);
   return {
@@ -1206,6 +1258,74 @@ var init_lifecycle = __esm({
   }
 });
 
+// src/utils/assignment-resolver.ts
+import { resolve as resolve8 } from "path";
+import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
+async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
+  let standaloneMatch = null;
+  let projectMatch = null;
+  const standaloneDir = resolve8(assignmentsDir2, id);
+  const standalonePath = resolve8(standaloneDir, "assignment.md");
+  if (await fileExists(standalonePath)) {
+    standaloneMatch = {
+      assignmentDir: standaloneDir,
+      projectSlug: null,
+      assignmentSlug: id,
+      id,
+      standalone: true
+    };
+  }
+  if (await fileExists(projectsDir2)) {
+    try {
+      const projects = await readdir3(projectsDir2, { withFileTypes: true });
+      for (const p of projects) {
+        if (!p.isDirectory()) continue;
+        if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
+        const assignmentsPath = resolve8(projectsDir2, p.name, "assignments");
+        if (!await fileExists(assignmentsPath)) continue;
+        const entries = await readdir3(assignmentsPath, { withFileTypes: true });
+        for (const a of entries) {
+          if (!a.isDirectory()) continue;
+          const aPath = resolve8(assignmentsPath, a.name, "assignment.md");
+          if (!await fileExists(aPath)) continue;
+          try {
+            const content = await readFile5(aPath, "utf-8");
+            const [fm] = extractFrontmatter(content);
+            const fileId = getField(fm, "id");
+            if (fileId === id) {
+              projectMatch = {
+                assignmentDir: resolve8(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();
@@ -1622,8 +1742,8 @@ var init_help = __esm({
 });
 
 // src/dashboard/servers.ts
-import { readdir as readdir3, readFile as readFile5, unlink } from "fs/promises";
-import { resolve as resolve8 } from "path";
+import { readdir as readdir4, readFile as readFile6, unlink } from "fs/promises";
+import { resolve as resolve9 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1671,18 +1791,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve8(dir, `${name}.md`), content);
+  await writeFileForce(resolve9(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir3(dir);
+  const entries = await readdir4(dir);
   return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
 }
 async function readSessionFile(dir, name) {
-  const filePath = resolve8(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve9(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile5(filePath, "utf-8");
+  const raw = await readFile6(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1722,7 +1842,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve8(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve9(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1731,7 +1851,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve8(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve9(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1743,7 +1863,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve8(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve9(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1760,7 +1880,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve8(dir, `${name}.md`), content);
+  await writeFileForce(resolve9(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1792,8 +1912,8 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve9 } from "path";
-import { realpath, readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { realpath, readdir as readdir5, readFile as readFile7 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -1888,8 +2008,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve9(cwd, commonDir));
-      const resolvedGit = await realpath(resolve9(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve10(cwd, commonDir));
+      const resolvedGit = await realpath(resolve10(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -1897,22 +2017,22 @@ async function getGitInfo(cwd) {
   }
   return { branch: branch || null, worktree: isWorktree };
 }
-async function loadWorkspaceRecords(projectsDir2) {
+async function loadWorkspaceRecords(projectsDir2, assignmentsDir2) {
   const records = [];
   try {
     const projects = await listProjects(projectsDir2);
     for (const project of projects) {
-      const assignmentsDir2 = resolve9(projectsDir2, project.slug, "assignments");
+      const projectAssignmentsDir = resolve10(projectsDir2, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir4(assignmentsDir2);
+        slugs = await readdir5(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve9(assignmentsDir2, aslug, "assignment.md");
+        const aFile = resolve10(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile6(aFile, "utf-8");
+          const raw = await readFile7(aFile, "utf-8");
           const [fm] = extractFrontmatter(raw);
           if (!fm) continue;
           records.push({
@@ -1929,6 +2049,30 @@ async function loadWorkspaceRecords(projectsDir2) {
     }
   } catch {
   }
+  if (assignmentsDir2) {
+    try {
+      const entries = await readdir5(assignmentsDir2);
+      for (const id of entries) {
+        if (id.startsWith(".") || id.startsWith("_")) continue;
+        const aFile = resolve10(assignmentsDir2, id, "assignment.md");
+        try {
+          const raw = await readFile7(aFile, "utf-8");
+          const [fm] = extractFrontmatter(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) {
@@ -2121,7 +2265,7 @@ async function scanAllSessions(serversDir2, projectsDir2, options) {
   const tmuxAvailable = await checkTmuxAvailable();
   const names = await listSessionFiles(serversDir2);
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir2);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir2, options?.assignmentsDir);
   const sessions = [];
   for (const name of names) {
     const data = await readSessionFile(serversDir2, name);
@@ -2136,11 +2280,11 @@ async function scanAllSessions(serversDir2, projectsDir2, options) {
   cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
   return result;
 }
-async function scanSingleSession(serversDir2, projectsDir2, name) {
+async function scanSingleSession(serversDir2, projectsDir2, name, options) {
   const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
   const lsofOutput = await getLsofOutput();
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir2);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir2, options?.assignmentsDir);
   if (data.kind === "process") {
     return scanProcessSession(data, lsofOutput, workspaceRecords);
   }
@@ -2160,8 +2304,28 @@ var init_scanner = __esm({
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir5, readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve10, dirname as dirname3 } from "path";
+import { readdir as readdir6, readFile as readFile8, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve11, dirname as dirname3 } from "path";
+async function listStandaloneRecords(assignmentsDir2) {
+  if (!assignmentsDir2) return [];
+  if (!await fileExists(assignmentsDir2)) return [];
+  const entries = await readdir6(assignmentsDir2, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+    const assignmentDir = resolve11(assignmentsDir2, entry.name);
+    const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath)) continue;
+    try {
+      const content = await readFile8(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, (c2) => c2.toUpperCase());
 }
@@ -2222,9 +2386,9 @@ async function listProjects(projectsDir2) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir2) {
-  const registryPath = resolve10(dirname3(projectsDir2), "workspaces.json");
+  const registryPath = resolve11(dirname3(projectsDir2), "workspaces.json");
   try {
-    const raw = await readFile7(registryPath, "utf-8");
+    const raw = await readFile8(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
@@ -2232,7 +2396,7 @@ async function readWorkspaceRegistry(projectsDir2) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir2, workspaces) {
-  const registryPath = resolve10(dirname3(projectsDir2), "workspaces.json");
+  const registryPath = resolve11(dirname3(projectsDir2), "workspaces.json");
   await writeFile2(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir2) {
@@ -2265,15 +2429,16 @@ async function deleteWorkspace(projectsDir2, name) {
   const filtered = registered.filter((w) => w !== name);
   await writeWorkspaceRegistry(projectsDir2, filtered);
 }
-async function getOverview(projectsDir2, serversDir2) {
+async function getOverview(projectsDir2, serversDir2, assignmentsDir2) {
   const projectRecords = await listProjectRecords(projectsDir2);
-  const attention = buildAttentionItems(projectRecords);
-  const recentActivity = buildRecentActivity(projectRecords);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  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, projectsDir2);
+      const servers = await scanAllSessions2(serversDir2, projectsDir2, { assignmentsDir: assignmentsDir2 });
       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);
@@ -2289,7 +2454,7 @@ async function getOverview(projectsDir2, 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(
@@ -2311,7 +2476,7 @@ async function getOverview(projectsDir2, 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),
@@ -2319,13 +2484,14 @@ async function getOverview(projectsDir2, serversDir2) {
     serverStats
   };
 }
-async function getAttention(projectsDir2, serversDir2) {
+async function getAttention(projectsDir2, serversDir2, assignmentsDir2) {
   const projectRecords = await listProjectRecords(projectsDir2);
-  const items = buildAttentionItems(projectRecords);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const items = buildAttentionItems(projectRecords, standaloneRecords);
   if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir2, projectsDir2);
+      const servers = await scanAllSessions2(serversDir2, projectsDir2, { assignmentsDir: assignmentsDir2 });
       for (const session of servers.sessions) {
         if (!session.alive) {
           items.push({
@@ -2369,9 +2535,9 @@ async function getAttention(projectsDir2, serversDir2) {
     items: pagedItems
   };
 }
-async function listAssignmentsBoard(projectsDir2) {
+async function listAssignmentsBoard(projectsDir2, assignmentsDir2) {
   const projectRecords = await listProjectRecords(projectsDir2);
-  const assignments = await Promise.all(
+  const projectItems = await Promise.all(
     projectRecords.flatMap(
       async (record) => Promise.all(
         record.assignments.map(
@@ -2380,11 +2546,48 @@ async function listAssignmentsBoard(projectsDir2) {
       )
     )
   );
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  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();
 }
@@ -2393,7 +2596,7 @@ async function getEditableDocument(projectsDir2, documentType, projectSlug, assi
   if (!filePath || !await fileExists(filePath)) {
     return null;
   }
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   const title = getEditableDocumentTitle(documentType, projectSlug, assignmentSlug);
   return {
     documentType,
@@ -2404,16 +2607,44 @@ async function getEditableDocument(projectsDir2, documentType, projectSlug, assi
     appendOnly: documentType === "handoff" || documentType === "decision-record"
   };
 }
+async function getEditableDocumentById(projectsDir2, assignmentsDir2, documentType, id) {
+  const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+  if (!resolved) return null;
+  if (!resolved.standalone && resolved.projectSlug) {
+    return getEditableDocument(
+      projectsDir2,
+      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 = resolve11(resolved.assignmentDir, fileName);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile8(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(projectsDir2, slug) {
-  const projectPath = resolve10(projectsDir2, slug);
-  const projectMdPath = resolve10(projectPath, "project.md");
+  const projectPath = resolve11(projectsDir2, slug);
+  const projectMdPath = resolve11(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
-  const projectContent = await readFile7(projectMdPath, "utf-8");
+  const projectContent = await readFile8(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);
@@ -2440,17 +2671,17 @@ async function getProjectDetail(projectsDir2, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve10(assignmentDir, "assignment.md");
+  const assignmentDir = resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
-  const assignmentContent = await readFile7(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
-  const planPath = resolve10(assignmentDir, "plan.md");
+  const planPath = resolve11(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const planContent = await readFile7(planPath, "utf-8");
+    const planContent = await readFile8(planPath, "utf-8");
     const parsed = parsePlan(planContent);
     plan = {
       status: parsed.status,
@@ -2459,9 +2690,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve10(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const scratchpadContent = await readFile7(scratchpadPath, "utf-8");
+    const scratchpadContent = await readFile8(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
     scratchpad = {
       updated: parsed.updated,
@@ -2469,9 +2700,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve10(assignmentDir, "handoff.md");
+  const handoffPath = resolve11(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const handoffContent = await readFile7(handoffPath, "utf-8");
+    const handoffContent = await readFile8(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
     handoff = {
       updated: parsed.updated,
@@ -2480,9 +2711,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve10(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const decisionRecordContent = await readFile7(decisionRecordPath, "utf-8");
+    const decisionRecordContent = await readFile8(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
     decisionRecord = {
       updated: parsed.updated,
@@ -2490,6 +2721,28 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
       body: parsed.body
     };
   }
+  let progress = null;
+  const progressPath = resolve11(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const progressContent = await readFile8(progressPath, "utf-8");
+    const parsed = parseProgress(progressContent);
+    progress = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
+  let comments = null;
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const commentsContent = await readFile8(commentsPath, "utf-8");
+    const parsed = parseComments(commentsContent);
+    comments = {
+      updated: parsed.updated,
+      entryCount: parsed.entryCount,
+      entries: parsed.entries
+    };
+  }
   const detail = {
     id: assignment.id,
     projectSlug,
@@ -2513,6 +2766,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     scratchpad,
     handoff,
     decisionRecord,
+    progress,
+    comments,
+    referencedBy: [],
     availableTransitions: await getAvailableTransitions(
       projectsDir2,
       projectSlug,
@@ -2576,25 +2832,212 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     });
   }
   detail.enrichedLinks = enrichedLinks;
+  detail.referencedBy = await computeReferencedBy(
+    { id: assignment.id, projectSlug, slug: detail.slug },
+    projectsDir2,
+    void 0
+  );
+  return detail;
+}
+async function computeReferencedBy(target, projectsDir2, assignmentsDir2) {
+  const sources = [];
+  const projectRecords = await listProjectRecords(projectsDir2);
+  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: resolve11(rec.projectPath, "assignments", a.slug)
+      });
+    }
+  }
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  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 = resolve11(sourceDir, "assignment.md");
+  if (await fileExists(assignmentMd)) {
+    const content = await readFile8(assignmentMd, "utf-8");
+    const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
+    if (todosMatch) bodies.push(todosMatch[1]);
+  }
+  for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
+    const path = resolve11(sourceDir, filename);
+    if (await fileExists(path)) {
+      try {
+        bodies.push(await readFile8(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(projectsDir2, assignmentsDir2, id) {
+  const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+  if (!resolved) return null;
+  if (!resolved.standalone && resolved.projectSlug) {
+    const detail = await getAssignmentDetail(projectsDir2, resolved.projectSlug, resolved.assignmentSlug);
+    if (!detail) return null;
+    detail.referencedBy = await computeReferencedBy(
+      { id: detail.id, projectSlug: detail.projectSlug, slug: detail.slug },
+      projectsDir2,
+      assignmentsDir2
+    );
+    return detail;
+  }
+  const standaloneDetail = await buildStandaloneAssignmentDetail(resolved);
+  if (!standaloneDetail) return null;
+  standaloneDetail.referencedBy = await computeReferencedBy(
+    { id: standaloneDetail.id, projectSlug: null, slug: standaloneDetail.slug },
+    projectsDir2,
+    assignmentsDir2
+  );
+  return standaloneDetail;
+}
+async function buildStandaloneAssignmentDetail(resolved) {
+  const assignmentDir = resolved.assignmentDir;
+  const assignmentMdPath = resolve11(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath)) return null;
+  const assignmentContent = await readFile8(assignmentMdPath, "utf-8");
+  const assignment = parseAssignmentFull(assignmentContent);
+  let plan = null;
+  const planPath = resolve11(assignmentDir, "plan.md");
+  if (await fileExists(planPath)) {
+    const parsed = parsePlan(await readFile8(planPath, "utf-8"));
+    plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
+  }
+  let scratchpad = null;
+  const scratchpadPath = resolve11(assignmentDir, "scratchpad.md");
+  if (await fileExists(scratchpadPath)) {
+    const parsed = parseScratchpad(await readFile8(scratchpadPath, "utf-8"));
+    scratchpad = { updated: parsed.updated, body: parsed.body };
+  }
+  let handoff = null;
+  const handoffPath = resolve11(assignmentDir, "handoff.md");
+  if (await fileExists(handoffPath)) {
+    const parsed = parseHandoff(await readFile8(handoffPath, "utf-8"));
+    handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
+  }
+  let decisionRecord = null;
+  const decisionRecordPath = resolve11(assignmentDir, "decision-record.md");
+  if (await fileExists(decisionRecordPath)) {
+    const parsed = parseDecisionRecord(await readFile8(decisionRecordPath, "utf-8"));
+    decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
+  }
+  let progress = null;
+  const progressPath = resolve11(assignmentDir, "progress.md");
+  if (await fileExists(progressPath)) {
+    const parsed = parseProgress(await readFile8(progressPath, "utf-8"));
+    progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
+  }
+  let comments = null;
+  const commentsPath = resolve11(assignmentDir, "comments.md");
+  if (await fileExists(commentsPath)) {
+    const parsed = parseComments(await readFile8(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(projectsDir2) {
   if (!await fileExists(projectsDir2)) {
     return [];
   }
-  const entries = await readdir5(projectsDir2, { withFileTypes: true });
+  const entries = await readdir6(projectsDir2, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const records = [];
   for (const entry of projectDirs) {
-    const projectPath = resolve10(projectsDir2, entry.name);
-    const projectMdPath = resolve10(projectPath, "project.md");
+    const projectPath = resolve11(projectsDir2, entry.name);
+    const projectMdPath = resolve11(projectPath, "project.md");
     if (!await fileExists(projectMdPath)) {
       continue;
     }
-    const projectContent = await readFile7(projectMdPath, "utf-8");
+    const projectContent = await readFile8(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,
@@ -2622,39 +3065,39 @@ async function listProjectRecords(projectsDir2) {
   return records;
 }
 async function listAssignmentRecords(projectPath) {
-  const assignmentsDir2 = resolve10(projectPath, "assignments");
+  const assignmentsDir2 = resolve11(projectPath, "assignments");
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
-  const entries = await readdir5(assignmentsDir2, { withFileTypes: true });
+  const entries = await readdir6(assignmentsDir2, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const assignmentMd = resolve10(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve11(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       continue;
     }
-    const content = await readFile7(assignmentMd, "utf-8");
+    const content = await readFile8(assignmentMd, "utf-8");
     records.push(parseAssignmentFull(content));
   }
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve10(projectPath, "resources");
+  const resourcesDir = resolve11(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
-  const entries = await readdir5(resourcesDir, { withFileTypes: true });
+  const entries = await readdir6(resourcesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve10(resourcesDir, entry.name);
-    const content = await readFile7(filePath, "utf-8");
+    const filePath = resolve11(resourcesDir, entry.name);
+    const content = await readFile8(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -2669,18 +3112,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve10(projectPath, "memories");
+  const memoriesDir = resolve11(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
-  const entries = await readdir5(memoriesDir, { withFileTypes: true });
+  const entries = await readdir6(memoriesDir, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve10(memoriesDir, entry.name);
-    const content = await readFile7(filePath, "utf-8");
+    const filePath = resolve11(memoriesDir, entry.name);
+    const content = await readFile8(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -2695,9 +3138,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve10(projectPath, "_status.md");
+  const statusPath = resolve11(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
-    const statusContent = await readFile7(statusPath, "utf-8");
+    const statusContent = await readFile8(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
     const derivedGraph = extractMermaidGraph(parsed.body);
     if (derivedGraph) {
@@ -2706,13 +3149,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,
@@ -2797,7 +3240,7 @@ async function getAvailableTransitions(projectsDir2, projectSlug, assignmentSlug
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve10(projectsDir2, projectSlug);
+  const projectPath = resolve11(projectsDir2, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -2827,12 +3270,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3) {
   const terminals = terminalStatuses3 ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve10(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve11(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
     }
-    const content = await readFile7(dependencyPath, "utf-8");
+    const content = await readFile8(dependencyPath, "utf-8");
     const parsed = parseAssignmentFull(content);
     if (!terminals.has(parsed.status)) {
       unmet.push(`${dependency} (${parsed.status})`);
@@ -2840,7 +3283,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses3) {
   }
   return unmet;
 }
-function buildAttentionItems(projectRecords) {
+function buildAttentionItems(projectRecords, standaloneRecords = []) {
   const items = [];
   for (const record of projectRecords) {
     for (const assignment of record.assignments) {
@@ -2890,9 +3333,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({
@@ -2920,6 +3390,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;
 }
@@ -2945,9 +3429,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 = resolve11(
+    projectPath,
+    "assignments",
+    assignmentSlug,
+    "comments.md"
+  );
+  if (!await fileExists(commentsPath)) {
+    return 0;
+  }
+  try {
+    const content = await readFile8(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;
@@ -2961,17 +3461,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir2, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve10(projectsDir2, projectSlug, "project.md");
+      return resolve11(projectsDir2, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve10(projectsDir2, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -2998,12 +3498,12 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir3) {
   if (!await fileExists(playbooksDir3)) return [];
-  const entries = await readdir5(playbooksDir3, { withFileTypes: true });
+  const entries = await readdir6(playbooksDir3, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve10(playbooksDir3, entry.name);
-    const raw = await readFile7(filePath, "utf-8");
+    const filePath = resolve11(playbooksDir3, entry.name);
+    const raw = await readFile8(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -3019,9 +3519,9 @@ async function listPlaybooks(playbooksDir3) {
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
 async function getPlaybookDetail(playbooksDir3, slug) {
-  const filePath = resolve10(playbooksDir3, `${slug}.md`);
+  const filePath = resolve11(playbooksDir3, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile7(filePath, "utf-8");
+  const raw = await readFile8(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
   return {
     slug: parsed.slug || slug,
@@ -3034,13 +3534,14 @@ async function getPlaybookDetail(playbooksDir3, slug) {
     body: parsed.body
   };
 }
-var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, 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;
@@ -3101,6 +3602,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",
@@ -3133,8 +3635,8 @@ __export(parser_exports, {
   writeChecklist: () => writeChecklist
 });
 import { randomBytes } from "crypto";
-import { readFile as readFile11 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { resolve as resolve17 } from "path";
 function generateShortId() {
   return randomBytes(2).toString("hex");
 }
@@ -3294,10 +3796,10 @@ function serializeLogEntry(entry) {
   return lines.join("\n");
 }
 function checklistPath(todosDir2, workspace) {
-  return resolve16(todosDir2, `${workspace}.md`);
+  return resolve17(todosDir2, `${workspace}.md`);
 }
 function logPath(todosDir2, workspace) {
-  return resolve16(todosDir2, `${workspace}-log.md`);
+  return resolve17(todosDir2, `${workspace}-log.md`);
 }
 function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
@@ -3321,14 +3823,14 @@ function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new D
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve16(todosDir2, "archive", `${workspace}-${suffix}.md`);
+  return resolve17(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
 async function readChecklist(todosDir2, workspace) {
   const path = checklistPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, archiveInterval: "weekly", items: [] };
   }
-  const content = await readFile11(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseChecklist(content);
 }
 async function writeChecklist(todosDir2, checklist) {
@@ -3341,7 +3843,7 @@ async function readLog(todosDir2, workspace) {
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
-  const content = await readFile11(path, "utf-8");
+  const content = await readFile12(path, "utf-8");
   return parseLog(content);
 }
 async function appendLogEntry2(todosDir2, workspace, entry) {
@@ -3349,7 +3851,7 @@ async function appendLogEntry2(todosDir2, workspace, entry) {
   const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
-    content = await readFile11(path, "utf-8");
+    content = await readFile12(path, "utf-8");
     content = content.trimEnd() + "\n\n" + serializeLogEntry(entry) + "\n";
   } else {
     const fm = `---
@@ -4474,12 +4976,12 @@ You are working within the Syntaur protocol for multi-agent project coordination
       _index-plans.md        # Derived (read-only)
       _index-decisions.md    # Derived (read-only)
       _status.md             # Derived (read-only)
-      claude.md              # Human-authored: Claude-specific instructions (read-only)
-      agent.md               # Human-authored: universal agent instructions (read-only)
       assignments/
         <assignment-slug>/
           assignment.md      # Agent-writable: source of truth for state (includes ## Todos)
           plan*.md           # Agent-writable: versioned implementation plans (optional, one per ## Todos entry)
+          progress.md        # Agent-writable, append-only: timestamped progress log
+          comments.md        # CLI-mediated: threaded questions/notes/feedback (via \`syntaur comment\`)
           scratchpad.md      # Agent-writable: working notes
           handoff.md         # Agent-writable: append-only handoff log
           decision-record.md # Agent-writable: append-only decision log
@@ -4489,14 +4991,24 @@ You are working within the Syntaur protocol for multi-agent project coordination
       memories/
         _index.md            # Derived (read-only)
         <memory-slug>.md     # Shared-writable
+  assignments/
+    <assignment-id>/         # Standalone assignments \u2014 folder = UUID, \`project: null\`, slug display-only
+      assignment.md
+      plan*.md
+      progress.md
+      comments.md
+      scratchpad.md
+      handoff.md
+      decision-record.md
 \`\`\`
 
 ## Write Boundary Rules (CRITICAL)
 
 ### Files you may WRITE:
 1. **Your assignment folder** -- only the assignment you are currently working on:
-   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`scratchpad.md\`, \`handoff.md\`, \`decision-record.md\`
-   - Path: \`~/.syntaur/projects/<project>/assignments/<your-assignment>/\`
+   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`progress.md\`, \`scratchpad.md\`, \`handoff.md\`, \`decision-record.md\`
+   - Path (project-nested): \`~/.syntaur/projects/<project>/assignments/<your-assignment>/\`
+   - Path (standalone): \`~/.syntaur/assignments/<your-assignment-uuid>/\`
 2. **Shared resources and memories** at the project level:
    - \`~/.syntaur/projects/<project>/resources/<slug>.md\`
    - \`~/.syntaur/projects/<project>/memories/<slug>.md\`
@@ -4504,11 +5016,15 @@ You are working within the Syntaur protocol for multi-agent project coordination
 
 > **Note:** The \`setup-adapter\` command does not parse assignment frontmatter for workspace paths. Workspace boundaries are resolved by the agent at runtime by reading \`assignment.md\` frontmatter. If no \`workspace\` field is set, treat the current working directory as your workspace.
 
+### Files written only via CLI (never edit directly):
+- \`comments.md\` (any assignment) -- use \`syntaur comment <slug-or-uuid> "body" [--type question|note|feedback] [--reply-to <id>]\`
+- Another assignment's \`## Todos\` section -- use \`syntaur request <source> <target> "text"\` to request cross-assignment work
+
 ### Files you must NEVER write:
-1. \`project.md\`, \`agent.md\`, \`claude.md\` -- human-authored, read-only
+1. \`project.md\` -- human-authored, read-only
 2. \`manifest.md\` -- derived, rebuilt by tooling
 3. Any file prefixed with \`_\` -- derived
-4. Other agents' assignment folders
+4. Other agents' assignment folders (except via the CLI-mediated channels above)
 5. Any files outside your workspace boundary
 
 ## Assignment Lifecycle
@@ -4539,7 +5055,7 @@ You are working within the Syntaur protocol for multi-agent project coordination
 
 ## Lifecycle Commands
 
-Use the \`syntaur\` CLI for state transitions:
+Use the \`syntaur\` CLI for state transitions and coordination:
 - \`syntaur assign <slug> --agent <name> --project <project>\` -- set assignee
 - \`syntaur start <slug> --project <project>\` -- pending -> in_progress
 - \`syntaur review <slug> --project <project>\` -- in_progress -> review
@@ -4547,6 +5063,9 @@ Use the \`syntaur\` CLI for state transitions:
 - \`syntaur block <slug> --project <project> --reason <text>\` -- block an assignment
 - \`syntaur unblock <slug> --project <project>\` -- unblock
 - \`syntaur fail <slug> --project <project>\` -- mark as failed
+- \`syntaur create-assignment "Title" [--type <type>] [--project <slug> | --one-off]\` -- create project-nested or standalone assignment
+- \`syntaur comment <slug-or-uuid> "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (questions support resolve toggle via dashboard)
+- \`syntaur request <source> <target> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: <source>)\`
 
 ## Playbooks
 
@@ -4560,11 +5079,13 @@ Follow the rules in each playbook. They take precedence over default conventions
 
 ## Conventions
 
-- Assignment frontmatter is the single source of truth for state
-- Slugs are lowercase, hyphen-separated
-- Always read \`agent.md\` at the project level before starting work
-- Add unanswered questions to the Q&A section of assignment.md
-- Commit frequently with messages referencing the assignment slug
+- Assignment frontmatter is the single source of truth for state. \`project\` is the containing project slug (\`null\` for standalone); \`type\` is a classification validated against \`config.md\` \`types.definitions\` when present.
+- Slugs are lowercase, hyphen-separated. Standalone assignment folders are named by UUID; \`slug\` is display-only in that case.
+- Always read \`project.md\` at the project level (when project-nested) before starting work.
+- Append timestamped entries to \`progress.md\` (never to \`assignment.md\`).
+- Record questions, notes, and feedback via \`syntaur comment\`. Never edit \`comments.md\` directly.
+- To route work to another assignment, use \`syntaur request\`.
+- Commit frequently with messages referencing the assignment slug.
 `;
 }
 function renderCursorAssignment(params) {
@@ -4584,21 +5105,25 @@ alwaysApply: true
 ## Reading Order
 
 Before starting work, read these files in order:
-1. \`${params.projectDir}/agent.md\` -- universal agent instructions and boundaries
-2. \`${params.projectDir}/project.md\` -- project overview and goals
-3. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status
-4. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
-5. \`${params.assignmentDir}/handoff.md\` -- previous session handoff notes
+1. \`${params.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+2. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+3. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+4. \`${params.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+5. \`${params.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
+6. \`${params.assignmentDir}/handoff.md\` -- previous session handoff notes
 
 ## Your Writable Files
 
-You may ONLY write to files inside your assignment folder:
+You may write directly to these files inside your assignment folder:
 - \`${params.assignmentDir}/assignment.md\`
 - \`${params.assignmentDir}/plan*.md\` (0 or more versioned plan files, e.g., \`plan.md\`, \`plan-v2.md\`)
+- \`${params.assignmentDir}/progress.md\` (append timestamped entries, newest first)
 - \`${params.assignmentDir}/scratchpad.md\`
 - \`${params.assignmentDir}/handoff.md\`
 - \`${params.assignmentDir}/decision-record.md\`
 
+Do NOT edit \`${params.assignmentDir}/comments.md\` directly \u2014 use \`syntaur comment\`. Do NOT edit other assignments' files \u2014 use \`syntaur request\` for cross-assignment todos.
+
 And source code files in your workspace. Read the \`workspace\` field from your assignment's frontmatter to determine the exact boundary. If not set, the current working directory is your workspace.
 `;
 }
@@ -4623,10 +5148,10 @@ If the global Syntaur Codex plugin is installed, prefer these workflows instead
 - \`syntaur-operator\` agent -- use for broad Syntaur protocol work or when a task spans multiple lifecycle steps
 - \`syntaur-protocol\` -- background protocol and write-boundary rules
 - \`create-project\` -- scaffold a project
-- \`create-assignment\` -- create a new assignment
+- \`create-assignment\` -- create a new assignment (use \`--type <bug|feature|chore|...>\` to classify; use \`--one-off\` to create a standalone assignment at \`~/.syntaur/assignments/<uuid>/\` with no parent project)
 - \`grab-assignment\` -- claim work, create \`.syntaur/context.json\`, and register a session
 - \`plan-assignment\` -- write a versioned plan file (\`plan.md\`, \`plan-v2.md\`, ...) and link it from the \`## Todos\` section of \`assignment.md\`
-- \`complete-assignment\` -- append the handoff, close the session, and transition state
+- \`complete-assignment\` -- append the handoff, append a final entry to \`progress.md\`, close the session, and transition state
 - \`track-session\` -- manage tracked tmux sessions for the dashboard
 
 If the plugin is unavailable, follow the same workflow manually with the \`syntaur\` CLI and keep the protocol files current yourself.
@@ -4634,12 +5159,12 @@ If the plugin is unavailable, follow the same workflow manually with the \`synta
 ## Reading Order
 
 Before starting work, read these files in order:
-1. \`${params.projectDir}/manifest.md\` -- root navigation entry point
-2. \`${params.projectDir}/agent.md\` -- universal agent instructions and boundaries
-3. \`${params.projectDir}/project.md\` -- project overview and goals
-4. \`${params.projectDir}/claude.md\` if it exists -- extra project context that may still be relevant
-5. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status
-6. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+1. \`${params.projectDir}/manifest.md\` -- root navigation entry point (project-nested assignments only)
+2. \`${params.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+3. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter now includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+4. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+5. \`${params.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+6. \`${params.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
 7. \`${params.assignmentDir}/handoff.md\` -- previous session handoff notes
 
 ## Context File
@@ -4661,12 +5186,12 @@ Before starting work, read these files in order:
       _index-plans.md        # Derived (read-only)
       _index-decisions.md    # Derived (read-only)
       _status.md             # Derived (read-only)
-      claude.md              # Human-authored: Claude-specific instructions (read-only)
-      agent.md               # Human-authored: universal agent instructions (read-only)
       assignments/
         <assignment-slug>/
           assignment.md      # Agent-writable: source of truth for state (includes ## Todos)
           plan*.md           # Agent-writable: versioned implementation plans (optional, one per ## Todos entry)
+          progress.md        # Agent-writable, append-only: timestamped progress log
+          comments.md        # CLI-mediated: threaded questions/notes/feedback (via \`syntaur comment\`)
           scratchpad.md      # Agent-writable: working notes
           handoff.md         # Agent-writable: append-only handoff log
           decision-record.md # Agent-writable: append-only decision log
@@ -4676,13 +5201,22 @@ Before starting work, read these files in order:
       memories/
         _index.md            # Derived (read-only)
         <memory-slug>.md     # Shared-writable
+  assignments/
+    <assignment-id>/         # Standalone assignments \u2014 folder = UUID, \`project: null\`, slug display-only
+      assignment.md
+      plan*.md
+      progress.md
+      comments.md
+      scratchpad.md
+      handoff.md
+      decision-record.md
 \`\`\`
 
 ## Write Boundary Rules (CRITICAL)
 
 ### Files you may WRITE:
 1. **Your assignment folder** -- only the assignment you are currently working on:
-   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`scratchpad.md\`, \`handoff.md\`, \`decision-record.md\`
+   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`progress.md\`, \`scratchpad.md\`, \`handoff.md\`, \`decision-record.md\`
    - Path: \`${params.assignmentDir}/\`
 2. **Shared resources and memories** at the project level:
    - \`${params.projectDir}/resources/<slug>.md\`
@@ -4691,11 +5225,15 @@ Before starting work, read these files in order:
 
 > **Note:** Workspace boundaries are resolved by the agent at runtime by reading \`assignment.md\` frontmatter. If no \`workspace\` field is set, treat the current working directory as your workspace.
 
+### Files written only via CLI (never edit directly):
+- \`comments.md\` (any assignment) -- use \`syntaur comment <slug-or-uuid> "body" [--type question|note|feedback] [--reply-to <id>]\`
+- Another assignment's \`## Todos\` section -- use \`syntaur request <source> <target> "text"\` to request cross-assignment work
+
 ### Files you must NEVER write:
-1. \`project.md\`, \`agent.md\`, \`claude.md\` -- human-authored, read-only
+1. \`project.md\` -- human-authored, read-only
 2. \`manifest.md\` -- derived, rebuilt by tooling
 3. Any file prefixed with \`_\` -- derived
-4. Other agents' assignment folders
+4. Other agents' assignment folders (except via the CLI-mediated channels above)
 5. Any files outside your workspace boundary
 
 ## Assignment Lifecycle
@@ -4726,7 +5264,7 @@ Before starting work, read these files in order:
 
 ## Lifecycle Commands
 
-Use the \`syntaur\` CLI for state transitions:
+Use the \`syntaur\` CLI for state transitions and coordination:
 - \`syntaur assign ${params.assignmentSlug} --agent <name> --project ${params.projectSlug}\` -- set assignee
 - \`syntaur start ${params.assignmentSlug} --project ${params.projectSlug}\` -- pending -> in_progress
 - \`syntaur review ${params.assignmentSlug} --project ${params.projectSlug}\` -- in_progress -> review
@@ -4734,6 +5272,8 @@ Use the \`syntaur\` CLI for state transitions:
 - \`syntaur block ${params.assignmentSlug} --project ${params.projectSlug} --reason <text>\` -- block
 - \`syntaur unblock ${params.assignmentSlug} --project ${params.projectSlug}\` -- unblock
 - \`syntaur fail ${params.assignmentSlug} --project ${params.projectSlug}\` -- mark as failed
+- \`syntaur comment ${params.assignmentSlug} "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (use for all Q&A; questions support resolve toggle)
+- \`syntaur request ${params.assignmentSlug} <target-slug-or-uuid> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: ${params.assignmentSlug})\`
 
 ## Troubleshooting
 
@@ -4751,14 +5291,15 @@ Read each linked playbook and follow the rules in its body section. The \`when_t
 
 ## Conventions
 
-- Assignment frontmatter is the single source of truth for state
-- Slugs are lowercase, hyphen-separated
-- Always read \`agent.md\` at the project level before starting work
-- Keep \`assignment.md\` progress, acceptance criteria, and \`## Todos\` updated as work lands
-- Keep active plan file(s) current after planning changes and \`handoff.md\` current before leaving the task
-- When requirements shift, supersede the prior plan todo (\`- [x] ~~...~~ (superseded by plan-v<N>)\`) and write a new plan file instead of rewriting the old one
-- Add unanswered questions to the Q&A section of assignment.md
-- Commit frequently with messages referencing the assignment slug
+- Assignment frontmatter is the single source of truth for state. \`project\` is the containing project slug (\`null\` for standalone); \`type\` is a classification validated against \`config.md\` \`types.definitions\` when present.
+- Slugs are lowercase, hyphen-separated. For standalone assignments, \`slug\` is display-only; the folder is named by the UUID.
+- Always read \`project.md\` at the project level (when project-nested) before starting work.
+- Keep \`assignment.md\` acceptance criteria and \`## Todos\` updated as work lands; append timestamped entries to \`progress.md\` (never to \`assignment.md\`).
+- Keep active plan file(s) current after planning changes and \`handoff.md\` current before leaving the task.
+- When requirements shift, supersede the prior plan todo (\`- [x] ~~...~~ (superseded by plan-v<N>)\`) and write a new plan file instead of rewriting the old one.
+- Record questions, notes, and feedback via \`syntaur comment\`. Never edit \`comments.md\` directly. Resolve questions via the dashboard UI (toggle on the question entry).
+- To route work to another assignment, use \`syntaur request\`.
+- Commit frequently with messages referencing the assignment slug.
 `;
 }
 
@@ -4766,8 +5307,12 @@ Read each linked playbook and follow the rules in its body section. The \`when_t
 function renderOpenCodeConfig(params) {
   const config = {
     instructions: [
-      `Read AGENTS.md in this directory for Syntaur protocol instructions.`,
-      `Also read ${params.projectDir}/agent.md for universal agent conventions.`
+      `Read AGENTS.md in this directory for Syntaur protocol (v2.0) instructions.`,
+      `Read ${params.projectDir}/project.md for project overview (project-nested assignments only).`,
+      `Append timestamped progress entries to the assignment's progress.md (not to assignment.md).`,
+      `Use 'syntaur comment <slug-or-uuid> "body" --type question|note|feedback' to append to comments.md \u2014 never edit it directly.`,
+      `Use 'syntaur request <source> <target> "text"' to append a todo to another assignment's ## Todos.`,
+      `Assignment folders are project-nested at ~/.syntaur/projects/<slug>/assignments/<aslug>/ or standalone at ~/.syntaur/assignments/<uuid>/ (project: null, slug display-only).`
     ]
   };
   return JSON.stringify(config, null, 2) + "\n";
@@ -5044,23 +5589,334 @@ Use --slug to specify a different slug.`
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve19, dirname as dirname4 } from "path";
+import { resolve as resolve20, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
 init_paths();
 init_api();
+init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } 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";
+// src/dashboard/agent-sessions.ts
+init_fs();
+import { readFile as readFile9 } from "fs/promises";
+import { resolve as resolve13 } from "path";
+
+// src/dashboard/session-db.ts
+init_paths();
+init_fs();
+import Database from "better-sqlite3";
+import { resolve as resolve12 } from "path";
+import { readdir as readdir7 } from "fs/promises";
+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 ?? resolve12(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';
+    `);
+  }
+  const versionAfterV1 = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+  if (versionAfterV1?.value === "2") {
+    db.exec(`
+      CREATE TABLE sessions_v3 (
+        session_id TEXT PRIMARY KEY,
+        project_slug TEXT,
+        assignment_slug TEXT,
+        agent TEXT NOT NULL,
+        started TEXT NOT NULL,
+        ended TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        path TEXT,
+        description TEXT,
+        transcript_path TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      INSERT INTO sessions_v3 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at FROM sessions;
+      DROP TABLE sessions;
+      ALTER TABLE sessions_v3 RENAME TO sessions;
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
+      CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      UPDATE meta SET value = '3' WHERE key = 'schema_version';
+    `);
+  }
+  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(projectsDir2) {
+  const database = getSessionDb();
+  const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  if (count.count > 0) return 0;
+  if (!await fileExists(projectsDir2)) return 0;
+  const entries = await readdir7(projectsDir2, { withFileTypes: true });
+  const allSessions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const projectDir = resolve12(projectsDir2, entry.name);
+    const indexPath = resolve12(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: readFile25 } = await import("fs/promises");
+  const raw = await readFile25(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((c2) => c2.trim());
+      if (cells.length >= 6) {
+        sessions.push({
+          assignmentSlug: cells[0],
+          agent: cells[1],
+          sessionId: cells[2],
+          started: cells[3],
+          status: cells[4] || "active",
+          path: cells[5],
+          projectSlug
+        });
+      }
+    }
+  }
+  return sessions;
+}
+
+// src/dashboard/agent-sessions.ts
+function rowToSession(row) {
+  return {
+    sessionId: row.session_id,
+    projectSlug: row.project_slug ?? null,
+    assignmentSlug: row.assignment_slug ?? null,
+    agent: row.agent,
+    started: row.started,
+    ended: row.ended ?? null,
+    status: row.status,
+    path: row.path ?? "",
+    description: row.description ?? null,
+    transcriptPath: row.transcript_path ?? null
+  };
+}
+async function appendSession(_projectDir, session) {
+  const db2 = getSessionDb();
+  db2.prepare(`
+    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(session_id) DO UPDATE SET
+      project_slug    = COALESCE(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
+  );
+}
+async function updateSessionStatus(_projectDir, sessionId, status) {
+  const db2 = getSessionDb();
+  const isTerminal = status === "completed" || status === "stopped";
+  const result = isTerminal ? db2.prepare(
+    "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, sessionId) : db2.prepare(
+    "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, sessionId);
+  return result.changes > 0;
+}
+async function listAllSessions(_projectsDir) {
+  const db2 = getSessionDb();
+  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  return rows.map(rowToSession);
+}
+async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  if (assignmentSlug) {
+    const rows2 = db2.prepare(
+      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+    ).all(projectSlug, assignmentSlug);
+    return rows2.map(rowToSession);
+  }
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  return rows.map(rowToSession);
+}
+async function deleteSessions(sessionIds) {
+  if (sessionIds.length === 0) return 0;
+  const db2 = getSessionDb();
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+  return result.changes;
+}
+var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
+async function readAssignmentStatusFromPath(assignmentMdPath) {
+  if (!await fileExists(assignmentMdPath)) return null;
+  const raw = await readFile9(assignmentMdPath, "utf-8");
+  const match = raw.match(/^status:\s*(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+async function readAssignmentStatus(projectDir, assignmentSlug) {
+  return readAssignmentStatusFromPath(
+    resolve13(projectDir, "assignments", assignmentSlug, "assignment.md")
+  );
+}
+async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
+  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(
+        resolve13(projectsDir2, session.project_slug),
+        aslug
+      );
+      if (status) assignmentStatuses.set(key, status);
+    } else if (assignmentsDir2) {
+      const status = await readAssignmentStatusFromPath(
+        resolve13(assignmentsDir2, aslug, "assignment.md")
+      );
+      if (status) assignmentStatuses.set(key, status);
+    }
+  }
+  let totalUpdated = 0;
+  for (const session of activeSessions) {
+    const projectKey = session.project_slug ?? "__standalone__";
+    const key = `${projectKey}/${session.assignment_slug}`;
+    const assignmentStatus = assignmentStatuses.get(key);
+    if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
+    const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
+    await updateSessionStatus("", session.session_id, newStatus);
+    totalUpdated++;
+  }
+  return totalUpdated;
+}
+async function listSessionsByAssignment(projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  const rows = projectSlug === null ? db2.prepare(
+    "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
+  ).all(assignmentSlug) : db2.prepare(
+    "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+  ).all(projectSlug, assignmentSlug);
+  return rows.map(rowToSession);
+}
+
+// src/dashboard/watcher.ts
+import { watch } from "chokidar";
+import { relative, sep } from "path";
 function createWatcher(options) {
-  const { projectsDir: projectsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
+  const { projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
   const projectsWatcher = watch(projectsDir2, {
     ignoreInitial: true,
@@ -5098,6 +5954,42 @@ function createWatcher(options) {
   projectsWatcher.on("change", handleProjectChange);
   projectsWatcher.on("add", handleProjectChange);
   projectsWatcher.on("unlink", handleProjectChange);
+  let standaloneWatcher = null;
+  if (assignmentsDir2) {
+    let handleStandaloneChange2 = function(filePath) {
+      const rel = relative(assignmentsDir2, 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(assignmentsDir2, {
+      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() {
@@ -5192,6 +6084,7 @@ function createWatcher(options) {
       });
       pendingEvents.clear();
       await projectsWatcher.close();
+      if (standaloneWatcher) await standaloneWatcher.close();
       if (serversWatcher) await serversWatcher.close();
       if (playbooksWatcher) await playbooksWatcher.close();
       if (todosWatcher) await todosWatcher.close();
@@ -5206,8 +6099,8 @@ init_config2();
 // src/dashboard/api-write.ts
 init_lifecycle();
 import { Router } from "express";
-import { resolve as resolve11 } from "path";
-import { rm, readFile as readFile8 } from "fs/promises";
+import { resolve as resolve14 } from "path";
+import { rm, readFile as readFile10 } from "fs/promises";
 init_timestamp();
 init_fs();
 init_parser();
@@ -5259,6 +6152,9 @@ function toggleAcceptanceCriterion(content, index, checked) {
 
 // src/dashboard/api-write.ts
 init_api();
+init_assignment_resolver();
+init_lifecycle();
+init_parser();
 function extractFrontmatter3(content) {
   const trimmed = content.trimStart();
   if (!trimmed.startsWith("---\n") && !trimmed.startsWith("---\r\n")) {
@@ -5358,9 +6254,9 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile8(filePath, "utf-8");
+  return readFile10(filePath, "utf-8");
 }
-function createWriteRouter(projectsDir2) {
+function createWriteRouter(projectsDir2, assignmentsDir2) {
   const router = Router();
   router.get("/api/templates/project", (_req, res) => {
     const content = renderProject({
@@ -5488,26 +6384,26 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve11(projectsDir2, slug);
+      const projectDir = resolve14(projectsDir2, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve11(projectDir, "assignments"));
-      await ensureDir(resolve11(projectDir, "resources"));
-      await ensureDir(resolve11(projectDir, "memories"));
-      await writeFileForce(resolve11(projectDir, "project.md"), content);
+      await ensureDir(resolve14(projectDir, "assignments"));
+      await ensureDir(resolve14(projectDir, "resources"));
+      await ensureDir(resolve14(projectDir, "memories"));
+      await writeFileForce(resolve14(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve11(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve11(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve11(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve11(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve11(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve11(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve11(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve14(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve14(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve14(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve14(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve14(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve14(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve14(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -5528,8 +6424,8 @@ function createWriteRouter(projectsDir2) {
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve11(projectsDir2, projectSlug);
-      const projectMdPath = resolve11(projectDir, "project.md");
+      const projectDir = resolve14(projectsDir2, projectSlug);
+      const projectMdPath = resolve14(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5559,7 +6455,7 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve11(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve14(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -5568,12 +6464,12 @@ function createWriteRouter(projectsDir2) {
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve11(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve14(assignmentDir, "assignment.md"), content);
       try {
         const companions = [
-          [resolve11(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve11(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve11(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve14(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve14(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve14(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -5594,7 +6490,7 @@ function createWriteRouter(projectsDir2) {
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -5627,7 +6523,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5670,7 +6566,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5706,7 +6602,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve11(
+      const planPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5744,7 +6640,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve11(
+      const scratchpadPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5782,7 +6678,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve11(
+      const handoffPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5820,7 +6716,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve11(
+      const decisionPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5854,10 +6750,121 @@ function createWriteRouter(projectsDir2) {
       res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
     }
   });
+  router.post("/api/projects/:slug/assignments/:aslug/comments", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const commentsPath = resolve14(
+        projectsDir2,
+        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 readFile10(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(projectsDir2, projectSlug, assignmentSlug);
+      res.status(201).json({ assignment, comment: { id: comment.id } });
+    } catch (error) {
+      console.error("Error appending comment:", error);
+      res.status(500).json({ error: `Failed to append comment: ${error.message}` });
+    }
+  });
+  router.patch("/api/projects/:slug/assignments/:aslug/comments/:commentId/resolved", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const assignmentSlug = getParam(req.params.aslug);
+      const commentId = getParam(req.params.commentId);
+      const commentsPath = resolve14(
+        projectsDir2,
+        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 readFile10(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(projectsDir2, projectSlug, assignmentSlug);
+      res.json({ assignment });
+    } catch (error) {
+      console.error("Error toggling comment resolved flag:", error);
+      res.status(500).json({ error: `Failed to toggle resolved: ${error.message}` });
+    }
+  });
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5867,7 +6874,7 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile8(projectPath, "utf-8");
+      let content = await readFile10(projectPath, "utf-8");
       content = setTopLevelField(content, "workspace", workspace ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -5881,7 +6888,7 @@ function createWriteRouter(projectsDir2) {
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir2, projectSlug, "project.md");
+      const projectPath = resolve14(projectsDir2, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5893,7 +6900,7 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile8(projectPath, "utf-8");
+      let content = await readFile10(projectPath, "utf-8");
       content = setTopLevelField(content, "statusOverride", status ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
       await writeFileForce(projectPath, content);
@@ -5908,7 +6915,7 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve14(
         projectsDir2,
         projectSlug,
         "assignments",
@@ -5926,7 +6933,7 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile8(assignmentPath, "utf-8");
+      let content = await readFile10(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -5951,8 +6958,8 @@ function createWriteRouter(projectsDir2) {
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve11(projectsDir2, projectSlug);
-      const assignmentPath = resolve11(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve14(projectsDir2, projectSlug);
+      const assignmentPath = resolve14(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -5978,8 +6985,8 @@ function createWriteRouter(projectsDir2) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve11(projectsDir2, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve11(assignmentDir, "assignment.md");
+      const assignmentDir = resolve14(projectsDir2, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve14(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -5991,388 +6998,686 @@ function createWriteRouter(projectsDir2) {
       res.status(500).json({ error: `Failed to delete assignment: ${error.message}` });
     }
   });
-  return router;
-}
-
-// src/dashboard/api-servers.ts
-init_servers();
-init_scanner();
-import { Router as Router2 } from "express";
-function createServersRouter(serversDir2, projectsDir2) {
-  const router = Router2();
-  router.get("/", async (_req, res) => {
+  router.post("/api/assignments", async (req, res) => {
     try {
-      const result = await scanAllSessions(serversDir2, projectsDir2);
-      res.json(result);
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const { title, slug, priority, type } = req.body || {};
+      if (!title || typeof title !== "string" || !title.trim()) {
+        res.status(400).json({ error: "title is required" });
+        return;
+      }
+      const { dependsOn } = req.body || {};
+      if (Array.isArray(dependsOn) && dependsOn.length > 0) {
+        res.status(400).json({ error: "Standalone assignments cannot declare dependsOn." });
+        return;
+      }
+      const id = generateId();
+      const assignmentDir = resolve14(assignmentsDir2, id);
+      if (await fileExists(assignmentDir)) {
+        res.status(500).json({ error: "UUID collision \u2014 try again" });
+        return;
+      }
+      const timestamp = nowTimestamp();
+      const resolvedSlug = typeof slug === "string" && slug.trim() ? slug.trim() : slugifyLocal(title);
+      const resolvedPriority = typeof priority === "string" && ["low", "medium", "high", "critical"].includes(priority) ? priority : "medium";
+      await ensureDir(assignmentDir);
+      const assignmentContent = renderAssignment({
+        id,
+        slug: resolvedSlug,
+        title: title.trim(),
+        timestamp,
+        priority: resolvedPriority,
+        dependsOn: [],
+        links: [],
+        project: null,
+        type: typeof type === "string" ? type : void 0
+      });
+      await writeFileForce(resolve14(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(
+        resolve14(assignmentDir, "scratchpad.md"),
+        renderScratchpad({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve14(assignmentDir, "handoff.md"),
+        renderHandoff({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve14(assignmentDir, "decision-record.md"),
+        renderDecisionRecord({ assignmentSlug: id, timestamp })
+      );
+      await writeFileForce(
+        resolve14(assignmentDir, "progress.md"),
+        renderProgress({ assignment: id, timestamp })
+      );
+      await writeFileForce(
+        resolve14(assignmentDir, "comments.md"),
+        renderComments({ assignment: id, timestamp })
+      );
+      const detail = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.status(201).json({ assignment: detail });
     } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
+      console.error("Error creating standalone assignment:", error);
+      res.status(500).json({ error: `Failed to create standalone assignment: ${error.message}` });
     }
   });
-  router.get("/:name", async (req, res) => {
+  router.post("/api/assignments/:id/comments", async (req, res) => {
     try {
-      const session = await scanSingleSession(serversDir2, projectsDir2, req.params.name);
-      if (!session) {
-        res.status(404).json({ error: "Session not found" });
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      await appendCommentTo(resolved.assignmentDir, resolved.standalone ? resolved.id : resolved.assignmentSlug, req, res, async () => {
+        return resolved.standalone ? getAssignmentDetailById(projectsDir2, assignmentsDir2, id) : getAssignmentDetail(projectsDir2, 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 (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const commentId = getParam(req.params.commentId);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      await toggleCommentResolvedAt(resolved.assignmentDir, commentId, req, res, async () => {
+        return resolved.standalone ? getAssignmentDetailById(projectsDir2, assignmentsDir2, id) : getAssignmentDetail(projectsDir2, resolved.projectSlug, resolved.assignmentSlug);
+      });
+    } catch (error) {
+      console.error("Error toggling comment resolved (by id):", error);
+      res.status(500).json({ error: `Failed to toggle resolved: ${error.message}` });
+    }
+  });
+  router.get("/api/assignments/:id/edit", async (req, res) => {
+    if (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir2, assignmentsDir2, "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 (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir2, assignmentsDir2, "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 (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir2, assignmentsDir2, "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 (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir2, assignmentsDir2, "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 (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const doc = await getEditableDocumentById(projectsDir2, assignmentsDir2, "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 (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      const currentContent = await readCurrentDocument(assignmentPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Assignment not found" });
         return;
       }
-      res.json(session);
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const current = parseAssignmentFull(currentContent);
+      const next = parseAssignmentFull(nextContentRaw);
+      if (!next.title) {
+        res.status(400).json({ error: "Assignment content must include a title." });
+        return;
+      }
+      let nextContent = nextContentRaw;
+      if (current.id) nextContent = setTopLevelField(nextContent, "id", current.id);
+      nextContent = setTopLevelField(nextContent, "project", null);
+      if (current.slug) nextContent = setTopLevelField(nextContent, "slug", current.slug);
+      if (next.status !== current.status && current.status === "blocked" && next.status !== "blocked") {
+        nextContent = setTopLevelField(nextContent, "blockedReason", null);
+      }
+      nextContent = setTopLevelField(nextContent, "updated", nowTimestamp());
+      await writeFileForce(assignmentPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment, content: nextContent });
     } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
+      console.error("Error updating standalone assignment:", error);
+      res.status(500).json({ error: `Failed to update assignment: ${error.message}` });
     }
   });
-  router.post("/", async (req, res) => {
+  router.patch("/api/assignments/:id/plan", async (req, res) => {
     try {
-      const { name } = req.body;
-      if (!name || typeof name !== "string") {
-        res.status(400).json({ error: "name is required" });
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      const sanitized = sanitizeSessionName(name);
-      const existing = await readSessionFile(serversDir2, sanitized);
-      if (existing) {
-        res.status(409).json({ error: `Session "${sanitized}" already registered` });
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      await registerSession(serversDir2, name);
-      clearScanCache();
-      res.status(201).json({ name: sanitized });
-    } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Registration failed" });
-    }
-  });
-  router.delete("/:name", async (req, res) => {
-    try {
-      const data = await readSessionFile(serversDir2, req.params.name);
-      if (!data) {
-        res.status(404).json({ error: "Session not found" });
+      const planPath = resolve14(resolved.assignmentDir, "plan.md");
+      const currentContent = await readCurrentDocument(planPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Plan not found" });
         return;
       }
-      await removeSession(serversDir2, req.params.name);
-      clearScanCache();
-      res.json({ removed: req.params.name });
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const parsed = parsePlan(nextContentRaw);
+      if (!parsed.assignment) {
+        res.status(400).json({ error: "Plan content must include the assignment field." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(planPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment, content: nextContent });
     } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Removal failed" });
+      console.error("Error updating standalone plan:", error);
+      res.status(500).json({ error: `Failed to update plan: ${error.message}` });
     }
   });
-  router.post("/refresh", async (_req, res) => {
+  router.patch("/api/assignments/:id/scratchpad", async (req, res) => {
     try {
-      const names = await listSessionFiles(serversDir2);
-      for (const name of names) {
-        await updateLastRefreshed(serversDir2, name);
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
       }
-      clearScanCache();
-      const result = await scanAllSessions(serversDir2, projectsDir2, { bypassCache: true });
-      res.json(result);
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const scratchpadPath = resolve14(resolved.assignmentDir, "scratchpad.md");
+      const currentContent = await readCurrentDocument(scratchpadPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Scratchpad not found" });
+        return;
+      }
+      const nextContentRaw = requireContent(req, res);
+      if (!nextContentRaw) return;
+      const parsed = parseScratchpad(nextContentRaw);
+      if (!parsed.assignment) {
+        res.status(400).json({ error: "Scratchpad content must include the assignment field." });
+        return;
+      }
+      const nextContent = setTopLevelField(nextContentRaw, "updated", nowTimestamp());
+      await writeFileForce(scratchpadPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment, content: nextContent });
     } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
+      console.error("Error updating standalone scratchpad:", error);
+      res.status(500).json({ error: `Failed to update scratchpad: ${error.message}` });
     }
   });
-  router.post("/:name/refresh", async (req, res) => {
+  router.post("/api/assignments/:id/handoff/entries", async (req, res) => {
     try {
-      const data = await readSessionFile(serversDir2, req.params.name);
-      if (!data) {
-        res.status(404).json({ error: "Session not found" });
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      await updateLastRefreshed(serversDir2, req.params.name);
-      clearScanCache();
-      const session = await scanSingleSession(serversDir2, projectsDir2, req.params.name);
-      res.json(session);
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const handoffPath = resolve14(resolved.assignmentDir, "handoff.md");
+      const currentContent = await readCurrentDocument(handoffPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Handoff log not found" });
+        return;
+      }
+      const { title, body } = req.body || {};
+      if (!body || typeof body !== "string" || !body.trim()) {
+        res.status(400).json({ error: "body is required" });
+        return;
+      }
+      const parsed = parseHandoff(currentContent);
+      const nextContent = appendLogEntry(
+        currentContent,
+        "handoffCount",
+        parsed.handoffCount + 1,
+        title && typeof title === "string" && title.trim() ? title.trim() : `Handoff ${parsed.handoffCount + 1}`,
+        body,
+        "No handoffs recorded yet."
+      );
+      await writeFileForce(handoffPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.status(201).json({ assignment, content: nextContent });
     } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
+      console.error("Error appending standalone handoff entry:", error);
+      res.status(500).json({ error: `Failed to append handoff entry: ${error.message}` });
     }
   });
-  router.patch("/:name/panes/:windowIndex/:paneIndex/assignment", async (req, res) => {
+  router.post("/api/assignments/:id/decision-record/entries", async (req, res) => {
     try {
-      const { name, windowIndex, paneIndex } = req.params;
-      const data = await readSessionFile(serversDir2, name);
-      if (!data) {
-        res.status(404).json({ error: "Session not found" });
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
-      const body = req.body;
-      if (body === null || body && body.project && body.assignment) {
-        await setOverride(
-          serversDir2,
-          name,
-          parseInt(windowIndex, 10),
-          parseInt(paneIndex, 10),
-          body
-        );
-        clearScanCache();
-        res.json({ updated: true });
-      } else {
-        res.status(400).json({ error: "Body must be { project, assignment } or null" });
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
       }
-    } catch (error) {
-      res.status(500).json({ error: error instanceof Error ? error.message : "Update failed" });
-    }
-  });
-  return router;
-}
-
-// src/dashboard/api-agent-sessions.ts
-import { Router as Router3 } from "express";
-import { resolve as resolve14 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/dashboard/agent-sessions.ts
-init_fs();
-import { readFile as readFile9 } from "fs/promises";
-import { resolve as resolve13 } from "path";
-
-// src/dashboard/session-db.ts
-init_paths();
-init_fs();
-import Database from "better-sqlite3";
-import { resolve as resolve12 } from "path";
-import { readdir as readdir6 } 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 ?? resolve12(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(projectsDir2) {
-  const database = getSessionDb();
-  const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
-  if (count.count > 0) return 0;
-  if (!await fileExists(projectsDir2)) return 0;
-  const entries = await readdir6(projectsDir2, { withFileTypes: true });
-  const allSessions = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const projectDir = resolve12(projectsDir2, entry.name);
-    const indexPath = resolve12(projectDir, "_index-sessions.md");
-    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);
+      const decisionPath = resolve14(resolved.assignmentDir, "decision-record.md");
+      const currentContent = await readCurrentDocument(decisionPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Decision record not found" });
+        return;
+      }
+      const { title, body } = req.body || {};
+      if (!body || typeof body !== "string" || !body.trim()) {
+        res.status(400).json({ error: "body is required" });
+        return;
+      }
+      const parsed = parseDecisionRecord(currentContent);
+      const nextContent = appendLogEntry(
+        currentContent,
+        "decisionCount",
+        parsed.decisionCount + 1,
+        title && typeof title === "string" && title.trim() ? title.trim() : `Decision ${parsed.decisionCount + 1}`,
+        body,
+        "No decisions recorded yet."
+      );
+      await writeFileForce(decisionPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.status(201).json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error appending standalone decision entry:", error);
+      res.status(500).json({ error: `Failed to append decision entry: ${error.message}` });
     }
   });
-  insertAll(allSessions);
-  console.log(`Migrated ${allSessions.length} sessions from markdown to SQLite.`);
-  return allSessions.length;
-}
-async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile25 } = await import("fs/promises");
-  const raw = await readFile25(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;
+  router.post("/api/assignments/:id/status-override", async (req, res) => {
+    try {
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      if (!await fileExists(assignmentPath)) {
+        res.status(404).json({ error: "Assignment not found" });
+        return;
+      }
+      const { status } = req.body || {};
+      const config = await getStatusConfig();
+      const validStatuses = config.statuses.map((s) => s.id);
+      if (typeof status !== "string" || !validStatuses.includes(status)) {
+        res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
+        return;
+      }
+      let content = await readFile10(assignmentPath, "utf-8");
+      content = setTopLevelField(content, "status", status);
+      content = setTopLevelField(content, "updated", nowTimestamp());
+      if (status !== "blocked") {
+        content = setTopLevelField(content, "blockedReason", null);
+      }
+      await writeFileForce(assignmentPath, content);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment });
+    } catch (error) {
+      console.error("Error overriding standalone status:", error);
+      res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
-    if (inTable && !headerSeen && trimmed.match(/^\|[-\s|]+\|$/)) {
-      headerSeen = true;
-      continue;
+  });
+  router.patch("/api/assignments/:id/acceptance-criteria/:index", async (req, res) => {
+    try {
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${id}" not found` });
+        return;
+      }
+      const assignmentPath = resolve14(resolved.assignmentDir, "assignment.md");
+      const currentContent = await readCurrentDocument(assignmentPath);
+      if (!currentContent) {
+        res.status(404).json({ error: "Assignment not found" });
+        return;
+      }
+      const { checked } = req.body || {};
+      if (typeof checked !== "boolean") {
+        res.status(400).json({ error: "checked must be a boolean" });
+        return;
+      }
+      const index = Number.parseInt(getParam(req.params.index), 10);
+      const result = toggleAcceptanceCriterion(currentContent, index, checked);
+      if ("error" in result) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const nextContent = setTopLevelField(result.content, "updated", nowTimestamp());
+      await writeFileForce(assignmentPath, nextContent);
+      const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+      res.json({ assignment, content: nextContent });
+    } catch (error) {
+      console.error("Error toggling standalone acceptance criterion:", error);
+      res.status(500).json({ error: `Failed to toggle acceptance criterion: ${error.message}` });
     }
-    if (inTable && headerSeen && trimmed.startsWith("|")) {
-      const cells = trimmed.split("|").slice(1, -1).map((c2) => c2.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
-        });
+  });
+  router.post("/api/assignments/:id/transitions/:command", async (req, res) => {
+    try {
+      if (!assignmentsDir2) {
+        res.status(501).json({ error: "Standalone assignments not configured on this server" });
+        return;
+      }
+      const id = getParam(req.params.id);
+      const command = getParam(req.params.command);
+      const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, 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(projectsDir2, assignmentsDir2, id) : await getAssignmentDetail(projectsDir2, resolved.projectSlug, resolved.assignmentSlug);
+      res.json({ assignment: detail, warnings: transitionResult.warnings ?? [] });
+    } catch (error) {
+      console.error("Error transitioning by id:", error);
+      res.status(500).json({ error: `Failed to transition: ${error.message}` });
     }
-  }
-  return sessions;
+  });
+  return router;
 }
-
-// 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
+function slugifyLocal(input2) {
+  return input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
+}
+async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
+  const commentsPath = resolve14(assignmentDir, "comments.md");
+  const { 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 readFile10(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 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 toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
+  const commentsPath = resolve14(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 readFile10(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"
   );
-}
-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 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 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 = resolve13(projectDir, "assignments", assignmentSlug, "assignment.md");
-  if (!await fileExists(assignmentPath)) return null;
-  const raw = await readFile9(assignmentPath, "utf-8");
-  const match = raw.match(/^status:\s*(.+)$/m);
-  return match ? match[1].trim() : null;
+  const withUpdated = setTopLevelField(next, "updated", `"${nowTimestamp()}"`);
+  await writeFileForce(commentsPath, withUpdated);
+  const assignment = await reloadDetail();
+  res.json({ assignment });
 }
-async function reconcileActiveSessions(projectsDir2) {
-  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 = resolve13(projectsDir2, projectSlug);
-    for (const slug of slugs) {
-      const status = await readAssignmentStatus(projectDir, slug);
-      if (status) assignmentStatuses.set(`${projectSlug}/${slug}`, status);
+
+// src/dashboard/api-servers.ts
+init_servers();
+init_scanner();
+import { Router as Router2 } from "express";
+function createServersRouter(serversDir2, projectsDir2, assignmentsDir2) {
+  const router = Router2();
+  router.get("/", async (_req, res) => {
+    try {
+      const result = await scanAllSessions(serversDir2, projectsDir2, { assignmentsDir: assignmentsDir2 });
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
+    }
+  });
+  router.get("/:name", async (req, res) => {
+    try {
+      const session = await scanSingleSession(serversDir2, projectsDir2, req.params.name, { assignmentsDir: assignmentsDir2 });
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      res.json(session);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const { name } = req.body;
+      if (!name || typeof name !== "string") {
+        res.status(400).json({ error: "name is required" });
+        return;
+      }
+      const sanitized = sanitizeSessionName(name);
+      const existing = await readSessionFile(serversDir2, sanitized);
+      if (existing) {
+        res.status(409).json({ error: `Session "${sanitized}" already registered` });
+        return;
+      }
+      await registerSession(serversDir2, name);
+      clearScanCache();
+      res.status(201).json({ name: sanitized });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Registration failed" });
+    }
+  });
+  router.delete("/:name", async (req, res) => {
+    try {
+      const data = await readSessionFile(serversDir2, req.params.name);
+      if (!data) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      await removeSession(serversDir2, req.params.name);
+      clearScanCache();
+      res.json({ removed: req.params.name });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Removal failed" });
     }
-  }
-  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;
+  });
+  router.post("/refresh", async (_req, res) => {
+    try {
+      const names = await listSessionFiles(serversDir2);
+      for (const name of names) {
+        await updateLastRefreshed(serversDir2, name);
+      }
+      clearScanCache();
+      const result = await scanAllSessions(serversDir2, projectsDir2, { bypassCache: true, assignmentsDir: assignmentsDir2 });
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
+    }
+  });
+  router.post("/:name/refresh", async (req, res) => {
+    try {
+      const data = await readSessionFile(serversDir2, req.params.name);
+      if (!data) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      await updateLastRefreshed(serversDir2, req.params.name);
+      clearScanCache();
+      const session = await scanSingleSession(serversDir2, projectsDir2, req.params.name, { assignmentsDir: assignmentsDir2 });
+      res.json(session);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
+    }
+  });
+  router.patch("/:name/panes/:windowIndex/:paneIndex/assignment", async (req, res) => {
+    try {
+      const { name, windowIndex, paneIndex } = req.params;
+      const data = await readSessionFile(serversDir2, name);
+      if (!data) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      const body = req.body;
+      if (body === null || body && body.project && body.assignment) {
+        await setOverride(
+          serversDir2,
+          name,
+          parseInt(windowIndex, 10),
+          parseInt(paneIndex, 10),
+          body
+        );
+        clearScanCache();
+        res.json({ updated: true });
+      } else {
+        res.status(400).json({ error: "Body must be { project, assignment } or null" });
+      }
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Update failed" });
+    }
+  });
+  return router;
 }
 
 // src/dashboard/api-agent-sessions.ts
+import { Router as Router3 } from "express";
+import { resolve as resolve15 } from "path";
 init_fs();
-function createAgentSessionsRouter(projectsDir2, broadcast) {
+function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
   const router = Router3();
   router.get("/", async (_req, res) => {
     try {
-      await reconcileActiveSessions(projectsDir2);
+      await reconcileActiveSessions(projectsDir2, assignmentsDir2);
       const sessions = await listAllSessions(projectsDir2);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
@@ -6383,12 +7688,12 @@ function createAgentSessionsRouter(projectsDir2, broadcast) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve14(projectsDir2, projectSlug);
+      const projectDir = resolve15(projectsDir2, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
       }
-      await reconcileActiveSessions(projectsDir2);
+      await reconcileActiveSessions(projectsDir2, assignmentsDir2);
       const sessions = await listProjectSessions(projectsDir2, projectSlug, assignment);
       res.json({ sessions, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
@@ -6397,32 +7702,38 @@ function createAgentSessionsRouter(projectsDir2, 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 = resolve14(projectsDir2, projectSlug);
+        const projectDir = resolve15(projectsDir2, 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" });
     }
@@ -6471,8 +7782,8 @@ function createAgentSessionsRouter(projectsDir2, broadcast) {
 init_api();
 init_parser();
 import { Router as Router4 } from "express";
-import { resolve as resolve15 } from "path";
-import { readFile as readFile10, unlink as unlink2 } from "fs/promises";
+import { resolve as resolve16 } from "path";
+import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
 function createPlaybooksRouter(playbooksDir3) {
@@ -6512,12 +7823,12 @@ function createPlaybooksRouter(playbooksDir3) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve15(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const content = await readFile10(filePath, "utf-8");
+      const content = await readFile11(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${req.params.slug}`,
@@ -6542,7 +7853,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       await ensureDir(playbooksDir3);
-      const filePath = resolve15(playbooksDir3, `${slug}.md`);
+      const filePath = resolve16(playbooksDir3, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -6561,7 +7872,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve15(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -6579,7 +7890,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve15(playbooksDir3, `${req.params.slug}.md`);
+      const filePath = resolve16(playbooksDir3, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -6598,7 +7909,7 @@ function createPlaybooksRouter(playbooksDir3) {
 init_parser2();
 init_fs();
 import { Router as Router5 } from "express";
-import { readdir as readdir7 } from "fs/promises";
+import { readdir as readdir8 } from "fs/promises";
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -6632,7 +7943,7 @@ function createTodosRouter(todosDir2, broadcast) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir7(todosDir2).catch(() => []);
+      const files = await readdir8(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -7017,8 +8328,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile12, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
-import { resolve as resolve17, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile13, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
+import { resolve as resolve18, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -7058,7 +8369,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve17(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve18(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -7069,7 +8380,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve18(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -7078,7 +8389,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile12(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -7116,7 +8427,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve17(dest, ".."));
+    await ensureDir(resolve18(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -7125,7 +8436,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile12(configPath, "utf-8");
+  const content = await readFile13(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -7164,7 +8475,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve17(destPath, ".."));
+        await ensureDir(resolve18(destPath, ".."));
         await writeFile3(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -7218,7 +8529,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve17(localPath, ".."));
+    await ensureDir(resolve18(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -7319,7 +8630,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve18(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -7474,7 +8785,7 @@ async function stopAutodiscovery() {
 function runReconcile() {
   if (activeReconcile || !savedOptions) return;
   const opts = savedOptions;
-  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids).catch((err2) => {
+  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids, opts.assignmentsDir).catch((err2) => {
     console.error("[autodiscovery] reconcile failed:", err2);
   }).finally(() => {
     activeReconcile = null;
@@ -7485,10 +8796,10 @@ async function listAllTmuxSessions() {
   if (!output2) return [];
   return output2.split("\n").filter((line) => line.length > 0);
 }
-async function discoverTmuxSessions(serversDir2, projectsDir2, existingNames) {
+async function discoverTmuxSessions(serversDir2, projectsDir2, existingNames, assignmentsDir2) {
   const tmuxAvailable = await checkTmuxAvailable();
   if (!tmuxAvailable) return false;
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir2);
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir2, assignmentsDir2);
   if (workspaceRecords.length === 0) return false;
   const sessions = await listAllTmuxSessions();
   let changed = false;
@@ -7529,8 +8840,8 @@ async function getProcessCwd(pid) {
   }
   return null;
 }
-async function discoverProcesses(serversDir2, projectsDir2, existingFiles, excludePids) {
-  const workspaceRecords = await loadWorkspaceRecords(projectsDir2);
+async function discoverProcesses(serversDir2, projectsDir2, existingFiles, excludePids, assignmentsDir2) {
+  const workspaceRecords = await loadWorkspaceRecords(projectsDir2, assignmentsDir2);
   if (workspaceRecords.length === 0) return false;
   const lsofOutput = await getLsofOutput();
   if (!lsofOutput) return false;
@@ -7595,7 +8906,7 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir2, projectsDir2, excludePids) {
+async function reconcile(serversDir2, projectsDir2, excludePids, assignmentsDir2) {
   const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
@@ -7607,8 +8918,8 @@ async function reconcile(serversDir2, projectsDir2, excludePids) {
     existingFiles.delete(name);
   }
   const existingNames = new Set(existingFiles.keys());
-  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir2, existingNames);
-  const processChanged = await discoverProcesses(serversDir2, projectsDir2, existingFiles, excludePids);
+  const tmuxChanged = await discoverTmuxSessions(serversDir2, projectsDir2, existingNames, assignmentsDir2);
+  const processChanged = await discoverProcesses(serversDir2, projectsDir2, existingFiles, excludePids, assignmentsDir2);
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
@@ -7616,7 +8927,7 @@ async function reconcile(serversDir2, projectsDir2, excludePids) {
 
 // src/dashboard/server.ts
 function createDashboardServer(options) {
-  const { port, projectsDir: projectsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
+  const { port, projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, serversDir: serversDir2, playbooksDir: playbooksDir3, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
   const app = express();
   const server = createServer(app);
   const wss = new WebSocketServer({ noServer: true });
@@ -7656,7 +8967,7 @@ function createDashboardServer(options) {
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
-      const overview = await getOverview(projectsDir2, serversDir2);
+      const overview = await getOverview(projectsDir2, serversDir2, assignmentsDir2);
       res.json(overview);
     } catch (error) {
       console.error("Error getting overview:", error);
@@ -7665,7 +8976,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/attention", async (_req, res) => {
     try {
-      const attention = await getAttention(projectsDir2, serversDir2);
+      const attention = await getAttention(projectsDir2, serversDir2, assignmentsDir2);
       res.json(attention);
     } catch (error) {
       console.error("Error getting attention queue:", error);
@@ -7785,7 +9096,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/assignments", async (req, res) => {
     try {
-      const result = await listAssignmentsBoard(projectsDir2);
+      const result = await listAssignmentsBoard(projectsDir2, assignmentsDir2);
       const workspaceParam = req.query.workspace;
       if (workspaceParam) {
         if (workspaceParam === "_ungrouped") {
@@ -7813,6 +9124,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(projectsDir2, assignmentsDir2, 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(projectsDir2, assignmentsDir2, req.params.id);
+      if (!resolved) {
+        res.status(404).json({ error: `Assignment "${req.params.id}" not found` });
+        return;
+      }
+      await reconcileActiveSessions(projectsDir2, assignmentsDir2);
+      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(
@@ -7832,16 +9174,16 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to get assignment detail" });
     }
   });
-  app.use(createWriteRouter(projectsDir2));
-  app.use("/api/servers", createServersRouter(serversDir2, projectsDir2));
-  app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast));
+  app.use(createWriteRouter(projectsDir2, assignmentsDir2));
+  app.use("/api/servers", createServersRouter(serversDir2, projectsDir2, assignmentsDir2));
+  app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
   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 = resolve18(dashboardDistPath, "index.html");
+      const indexPath = resolve19(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -7856,12 +9198,13 @@ function createDashboardServer(options) {
     async start() {
       watcherHandle = createWatcher({
         projectsDir: projectsDir2,
+        assignmentsDir: assignmentsDir2,
         serversDir: serversDir2,
         playbooksDir: playbooksDir3,
         todosDir: todosDir2,
         onMessage: broadcast
       });
-      startAutodiscovery({ serversDir: serversDir2, projectsDir: projectsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
+      startAutodiscovery({ serversDir: serversDir2, projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err2) => {
           if (err2.code === "EADDRINUSE") {
@@ -7873,7 +9216,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve18(syntaurRoot(), "dashboard-port");
+          const portFile = resolve19(syntaurRoot(), "dashboard-port");
           writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -7890,7 +9233,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve18(syntaurRoot(), "dashboard-port");
+      const portFile = resolve19(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();
@@ -7970,11 +9313,12 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve19(dirname4(thisFile), "..");
-  const dashboardDist = resolve19(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve20(dirname4(thisFile), "..");
+  const dashboardDist = resolve20(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
+    assignmentsDir: assignmentsDir(),
     serversDir: serversDir(),
     playbooksDir: playbooksDir(),
     todosDir: todosDir(),
@@ -7984,8 +9328,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve19(packageRoot, "dashboard");
-    const viteBin = resolve19(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve20(packageRoot, "dashboard");
+    const viteBin = resolve20(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -8059,71 +9403,7 @@ init_fs();
 init_config2();
 import { resolve as resolve21 } from "path";
 init_lifecycle();
-
-// src/utils/assignment-resolver.ts
-init_fs();
-init_parser();
-import { resolve as resolve20 } from "path";
-import { readdir as readdir8, readFile as readFile13 } from "fs/promises";
-async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
-  let standaloneMatch = null;
-  let projectMatch = null;
-  const standaloneDir = resolve20(assignmentsDir2, id);
-  const standalonePath = resolve20(standaloneDir, "assignment.md");
-  if (await fileExists(standalonePath)) {
-    standaloneMatch = {
-      assignmentDir: standaloneDir,
-      projectSlug: null,
-      assignmentSlug: id,
-      id,
-      standalone: true
-    };
-  }
-  if (await fileExists(projectsDir2)) {
-    try {
-      const projects = await readdir8(projectsDir2, { withFileTypes: true });
-      for (const p of projects) {
-        if (!p.isDirectory()) continue;
-        if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
-        const assignmentsPath = resolve20(projectsDir2, p.name, "assignments");
-        if (!await fileExists(assignmentsPath)) continue;
-        const entries = await readdir8(assignmentsPath, { withFileTypes: true });
-        for (const a of entries) {
-          if (!a.isDirectory()) continue;
-          const aPath = resolve20(assignmentsPath, a.name, "assignment.md");
-          if (!await fileExists(aPath)) continue;
-          try {
-            const content = await readFile13(aPath, "utf-8");
-            const [fm] = extractFrontmatter(content);
-            const fileId = getField(fm, "id");
-            if (fileId === id) {
-              projectMatch = {
-                assignmentDir: resolve20(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;
-}
-
-// src/commands/_lifecycle-helper.ts
+init_assignment_resolver();
 async function runTransition(assignment, command, options = {}) {
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
@@ -9501,7 +10781,7 @@ init_paths();
 init_fs();
 init_config2();
 import { resolve as resolve26 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 async function trackSessionCommand(options) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -9517,7 +10797,7 @@ async function trackSessionCommand(options) {
     }
   }
   initSessionDb();
-  const sessionId = options.sessionId || randomUUID3();
+  const sessionId = options.sessionId || randomUUID2();
   await appendSession("", {
     projectSlug: options.project || null,
     assignmentSlug: options.assignment || null,
@@ -10895,6 +12175,7 @@ function pass3(check) {
 init_fs();
 init_parser();
 init_types();
+init_paths();
 import { resolve as resolve35 } from "path";
 import { readdir as readdir13, readFile as readFile18 } from "fs/promises";
 var CATEGORY4 = "assignment";
@@ -10902,24 +12183,48 @@ var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]
 async function listAssignments(ctx) {
   const result = { withAssignmentMd: [], orphanFolders: [] };
   const projectsDir2 = ctx.config.defaultProjectDir;
-  if (!await fileExists(projectsDir2)) return result;
-  const projects = await readdir13(projectsDir2, { withFileTypes: true });
-  for (const m of projects) {
-    if (!m.isDirectory()) continue;
-    if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-    const assignmentsDir2 = resolve35(projectsDir2, m.name, "assignments");
-    if (!await fileExists(assignmentsDir2)) continue;
-    const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
+  if (await fileExists(projectsDir2)) {
+    const projects = await readdir13(projectsDir2, { withFileTypes: true });
+    for (const m of projects) {
+      if (!m.isDirectory()) continue;
+      if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
+      const assignmentsDir2 = resolve35(projectsDir2, m.name, "assignments");
+      if (!await fileExists(assignmentsDir2)) continue;
+      const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
+      for (const a of entries) {
+        if (!a.isDirectory()) continue;
+        if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
+        const assignmentDir = resolve35(assignmentsDir2, a.name);
+        const assignmentMd = resolve35(assignmentDir, "assignment.md");
+        const entry = {
+          projectDir: resolve35(projectsDir2, m.name),
+          projectSlug: m.name,
+          assignmentDir,
+          assignmentSlug: a.name,
+          standalone: false
+        };
+        if (await fileExists(assignmentMd)) {
+          result.withAssignmentMd.push(entry);
+        } else {
+          result.orphanFolders.push(entry);
+        }
+      }
+    }
+  }
+  const standaloneRoot = assignmentsDir();
+  if (await fileExists(standaloneRoot)) {
+    const entries = await readdir13(standaloneRoot, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve35(assignmentsDir2, a.name);
+      const assignmentDir = resolve35(standaloneRoot, a.name);
       const assignmentMd = resolve35(assignmentDir, "assignment.md");
       const entry = {
-        projectDir: resolve35(projectsDir2, m.name),
-        projectSlug: m.name,
+        projectDir: standaloneRoot,
+        projectSlug: null,
         assignmentDir,
-        assignmentSlug: a.name
+        assignmentSlug: a.name,
+        standalone: true
       };
       if (await fileExists(assignmentMd)) {
         result.withAssignmentMd.push(entry);
@@ -11099,12 +12404,147 @@ var requiredFilesByStatus = {
     return results;
   }
 };
+var companionFilesScaffolded = {
+  id: "assignment.companion-files",
+  category: CATEGORY4,
+  title: "progress.md and comments.md scaffolded (v2.0)",
+  async run(ctx) {
+    const { withAssignmentMd } = await listAssignments(ctx);
+    const results = [];
+    for (const a of withAssignmentMd) {
+      const missing = [];
+      for (const filename of ["progress.md", "comments.md"]) {
+        if (!await fileExists(resolve35(a.assignmentDir, filename))) {
+          missing.push(filename);
+        }
+      }
+      if (missing.length === 0) continue;
+      const label = a.standalone ? `standalone/${a.assignmentSlug}` : `${a.projectSlug}/${a.assignmentSlug}`;
+      results.push({
+        id: this.id,
+        category: this.category,
+        title: this.title,
+        status: "warn",
+        detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
+        affected: missing.map((m) => resolve35(a.assignmentDir, m)),
+        remediation: {
+          kind: "manual",
+          suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
+          command: null
+        },
+        autoFixable: false
+      });
+    }
+    if (results.length === 0) return pass4(this);
+    return results;
+  }
+};
+var typeDefinition = {
+  id: "assignment.type-definition",
+  category: CATEGORY4,
+  title: "Assignment `type` is in config.types.definitions",
+  async run(ctx) {
+    const typesConfig = ctx.config.types;
+    if (!typesConfig) {
+      return {
+        id: this.id,
+        category: this.category,
+        title: this.title,
+        status: "skipped",
+        detail: "config.types is not set; applying defaults \u2014 skipping strict validation",
+        autoFixable: false
+      };
+    }
+    const allowed = new Set(typesConfig.definitions.map((d) => d.id));
+    const { withAssignmentMd } = await listAssignments(ctx);
+    const results = [];
+    for (const a of withAssignmentMd) {
+      const path = resolve35(a.assignmentDir, "assignment.md");
+      const parsed = await parseSafe(path);
+      if (!parsed) continue;
+      if (!parsed.type) continue;
+      if (!allowed.has(parsed.type)) {
+        const label = a.standalone ? `standalone/${a.assignmentSlug}` : `${a.projectSlug}/${a.assignmentSlug}`;
+        results.push({
+          id: this.id,
+          category: this.category,
+          title: this.title,
+          status: "warn",
+          detail: `${label}: type "${parsed.type}" is not in config.types.definitions (${[...allowed].join(", ")})`,
+          affected: [path],
+          remediation: {
+            kind: "manual",
+            suggestion: `Either add "${parsed.type}" to config.types.definitions or change the assignment's type to one of the configured values`,
+            command: null
+          },
+          autoFixable: false
+        });
+      }
+    }
+    if (results.length === 0) return pass4(this);
+    return results;
+  }
+};
+var projectFrontmatterMatchesContainer = {
+  id: "assignment.project-matches-container",
+  category: CATEGORY4,
+  title: "`project` frontmatter matches containing project slug (or null for standalone)",
+  async run(ctx) {
+    const { withAssignmentMd } = await listAssignments(ctx);
+    const results = [];
+    for (const a of withAssignmentMd) {
+      const path = resolve35(a.assignmentDir, "assignment.md");
+      const parsed = await parseSafe(path);
+      if (!parsed) continue;
+      if (a.standalone) {
+        if (parsed.project !== null) {
+          results.push({
+            id: this.id,
+            category: this.category,
+            title: this.title,
+            status: "error",
+            detail: `standalone/${a.assignmentSlug}: frontmatter declares project "${parsed.project}" but the folder is under ~/.syntaur/assignments/ (project must be null)`,
+            affected: [path],
+            remediation: {
+              kind: "manual",
+              suggestion: "Set `project: null` in the frontmatter, or move the folder into a project.",
+              command: null
+            },
+            autoFixable: false
+          });
+        }
+      } else {
+        if (parsed.project !== a.projectSlug) {
+          results.push({
+            id: this.id,
+            category: this.category,
+            title: this.title,
+            status: "error",
+            detail: `${a.projectSlug}/${a.assignmentSlug}: frontmatter declares project "${parsed.project ?? "null"}" but the folder is inside project "${a.projectSlug}"`,
+            affected: [path],
+            remediation: {
+              kind: "manual",
+              suggestion: `Set \`project: ${a.projectSlug}\` in the frontmatter.`,
+              command: null
+            },
+            autoFixable: false
+          });
+        }
+      }
+    }
+    if (results.length === 0) return pass4(this);
+    return results;
+  }
+};
 var assignmentChecks = [
   requiredFiles2,
   orphanedFolder,
   invalidStatus,
   workspaceMissing,
-  requiredFilesByStatus
+  requiredFilesByStatus,
+  companionFilesScaffolded,
+  typeDefinition,
+  projectFrontmatterMatchesContainer
 ];
 async function parseSafe(path) {
   try {
@@ -11785,6 +13225,7 @@ init_config2();
 import { resolve as resolve38 } from "path";
 import { readFile as readFile21 } from "fs/promises";
 init_timestamp();
+init_assignment_resolver();
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -11870,6 +13311,7 @@ init_config2();
 import { resolve as resolve39 } from "path";
 import { readFile as readFile22 } from "fs/promises";
 init_timestamp();
+init_assignment_resolver();
 function setTopLevelField3(content, key, value) {
   const fieldRegex = new RegExp(`^(${key}:)\\s*.*$`, "m");
   if (fieldRegex.test(content)) {
@@ -11912,7 +13354,7 @@ async function requestCommand(target, text, options = {}) {
   const todosHeading = /^## Todos\s*$/m;
   if (todosHeading.test(content)) {
     content = content.replace(
-      /(^## Todos[\s\S]*?)(\n##\s|\n*$)/,
+      /(^## Todos[\s\S]*?)(\n## |\n*$)/m,
       (_m, section, nextHeading) => {
         return `${section.trimEnd()}
 ${todoLine}