syntaur 0.4.4 → 0.5.0

package/dist/dashboard/server.js

@@ -36,6 +36,9 @@ function playbooksDir() {
 function todosDir() {
   return resolve(syntaurRoot(), "todos");
 }
+function projectTodosDir(projectsDir, projectSlug) {
+  return resolve(projectsDir, projectSlug, "todos");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -457,10 +460,10 @@ var init_lifecycle = __esm({
 });
 
 // src/templates/config.ts
-function renderConfig(params) {
+function renderConfig(params2) {
   return `---
 version: "1.0"
-defaultProjectDir: ${params.defaultProjectDir}
+defaultProjectDir: ${params2.defaultProjectDir}
 onboarding:
   completed: false
 agentDefaults:
@@ -622,6 +625,27 @@ var init_fs_migration = __esm({
 // src/utils/config.ts
 import { readFile as readFile3 } from "fs/promises";
 import { resolve as resolve4, isAbsolute } from "path";
+function cloneDefaultConfig() {
+  return {
+    ...DEFAULT_CONFIG,
+    onboarding: { ...DEFAULT_CONFIG.onboarding },
+    agentDefaults: { ...DEFAULT_CONFIG.agentDefaults },
+    integrations: { ...DEFAULT_CONFIG.integrations },
+    backup: DEFAULT_CONFIG.backup ? { ...DEFAULT_CONFIG.backup } : null,
+    statuses: DEFAULT_CONFIG.statuses ? {
+      statuses: DEFAULT_CONFIG.statuses.statuses.map((s) => ({ ...s })),
+      order: [...DEFAULT_CONFIG.statuses.order],
+      transitions: DEFAULT_CONFIG.statuses.transitions.map((t) => ({ ...t }))
+    } : null,
+    types: DEFAULT_CONFIG.types ? {
+      definitions: DEFAULT_CONFIG.types.definitions.map((d) => ({ ...d })),
+      default: DEFAULT_CONFIG.types.default
+    } : null,
+    playbooks: {
+      disabled: [...DEFAULT_CONFIG.playbooks.disabled]
+    }
+  };
+}
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -774,6 +798,82 @@ function serializeBackupConfig(backup) {
   lines.push(`  lastRestore: ${backup.lastRestore ?? "null"}`);
   return lines.join("\n");
 }
+function serializePlaybooksConfig(playbooks) {
+  if (!playbooks.disabled || playbooks.disabled.length === 0) {
+    return null;
+  }
+  const lines = ["playbooks:", "  disabled:"];
+  for (const slug of playbooks.disabled) {
+    lines.push(`    - ${slug}`);
+  }
+  return lines.join("\n");
+}
+function parsePlaybooksConfig(fmBlock) {
+  const blockStart = fmBlock.match(/^playbooks:\s*$/m);
+  if (!blockStart) {
+    return { disabled: [] };
+  }
+  const startIdx = fmBlock.indexOf(blockStart[0]) + blockStart[0].length;
+  const remaining = fmBlock.slice(startIdx).split("\n");
+  const disabled = [];
+  let currentSection = null;
+  for (const line of remaining) {
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    if (indent === 0 && trimmed.length > 0) break;
+    if (trimmed === "") continue;
+    if (indent === 2 && trimmed.startsWith("disabled:")) {
+      currentSection = "disabled";
+      const afterColon = trimmed.slice("disabled:".length).trim();
+      if (afterColon === "[]" || afterColon === "") {
+        continue;
+      }
+      continue;
+    }
+    if (currentSection === "disabled" && indent >= 4 && trimmed.startsWith("- ")) {
+      const raw = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
+      if (raw.length === 0) continue;
+      if (/\s/.test(raw)) {
+        console.warn(`Warning: config.md playbooks.disabled entry "${raw}" contains whitespace, ignoring`);
+        continue;
+      }
+      disabled.push(raw);
+      continue;
+    }
+  }
+  return { disabled };
+}
+async function updatePlaybooksConfig(playbooks) {
+  const configPath = resolve4(syntaurRoot(), "config.md");
+  const current = (await readConfig()).playbooks;
+  const nextPlaybooks = {
+    disabled: Array.from(new Set(playbooks.disabled ?? current.disabled))
+  };
+  const playbooksBlock = serializePlaybooksConfig(nextPlaybooks);
+  const existing = await fileExists(configPath) ? await readFile3(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const bodyBlock = playbooksBlock ? `${playbooksBlock}
+` : "";
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${bodyBlock}---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "playbooks");
+  const newFm = playbooksBlock ? `${cleanedFm}
+${playbooksBlock}`.replace(/^\n+/, "") : cleanedFm;
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 function stripTopLevelBlock(fmBlock, key) {
   const blockStart = fmBlock.match(new RegExp(`^${key}:\\s*$`, "m"));
   if (!blockStart) {
@@ -915,7 +1015,7 @@ ${normalizedFm}
 async function readConfig() {
   const configPath = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
-    return { ...DEFAULT_CONFIG };
+    return cloneDefaultConfig();
   }
   if (!migratedConfigPaths.has(configPath)) {
     migratedConfigPaths.add(configPath);
@@ -925,7 +1025,7 @@ async function readConfig() {
   const fm = parseFrontmatter(content);
   if (Object.keys(fm).length === 0) {
     console.warn("Warning: ~/.syntaur/config.md has malformed frontmatter, using defaults");
-    return { ...DEFAULT_CONFIG };
+    return cloneDefaultConfig();
   }
   let projectDir = fm["defaultProjectDir"] ? expandHome(String(fm["defaultProjectDir"])) : DEFAULT_CONFIG.defaultProjectDir;
   if (!isAbsolute(projectDir)) {
@@ -934,6 +1034,7 @@ async function readConfig() {
     );
     projectDir = DEFAULT_CONFIG.defaultProjectDir;
   }
+  const fmBlock = content.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "";
   return {
     version: fm["version"] || DEFAULT_CONFIG.version,
     defaultProjectDir: projectDir,
@@ -965,7 +1066,8 @@ async function readConfig() {
       lastRestore: fm["backup.lastRestore"] && fm["backup.lastRestore"] !== "null" ? fm["backup.lastRestore"] : null
     } : null,
     statuses: parseStatusConfig(content),
-    types: null
+    types: null,
+    playbooks: parsePlaybooksConfig(fmBlock)
   };
 }
 var DEFAULT_CONFIG, migratedConfigPaths;
@@ -993,7 +1095,10 @@ var init_config2 = __esm({
       },
       backup: null,
       statuses: null,
-      types: null
+      types: null,
+      playbooks: {
+        disabled: []
+      }
     };
     migratedConfigPaths = /* @__PURE__ */ new Set();
   }
@@ -1128,6 +1233,7 @@ function parseAssignmentFull(fileContent) {
     slug: getField(fm, "slug") ?? "",
     title: getField(fm, "title") ?? "",
     project: getField(fm, "project"),
+    workspaceGroup: getField(fm, "workspaceGroup"),
     type: getField(fm, "type"),
     status: getField(fm, "status") ?? "pending",
     priority: getField(fm, "priority") ?? "medium",
@@ -1284,47 +1390,160 @@ var init_parser = __esm({
   }
 });
 
-// src/utils/assignment-resolver.ts
+// src/utils/playbooks.ts
 import { resolve as resolve5 } from "path";
 import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+function isVisiblePlaybookFile(name, isFile) {
+  return isFile && name.endsWith(".md") && !name.startsWith("_") && name !== "manifest.md";
+}
+async function resolvePlaybookSlug(playbooksDir2, slug) {
+  if (!await fileExists(playbooksDir2)) return null;
+  const entries = await readdir2(playbooksDir2, { withFileTypes: true });
+  let filenameStemFallback = null;
+  for (const entry of entries) {
+    if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
+    const filePath = resolve5(playbooksDir2, entry.name);
+    const raw = await readFile4(filePath, "utf-8");
+    const parsed = parsePlaybook(raw);
+    const canonical = parsed.slug || entry.name.replace(/\.md$/, "");
+    if (canonical === slug) {
+      return { filename: entry.name, slug: canonical, parsed };
+    }
+    if (!parsed.slug && entry.name.replace(/\.md$/, "") === slug) {
+      filenameStemFallback = { filename: entry.name, slug: canonical, parsed };
+    }
+  }
+  return filenameStemFallback;
+}
+async function setPlaybookEnabled(playbooksDir2, slug, enabled) {
+  const resolved = await resolvePlaybookSlug(playbooksDir2, slug);
+  if (!resolved) {
+    throw new Error(`Playbook "${slug}" not found in ${playbooksDir2}`);
+  }
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
+  const wasDisabled = disabledSet.has(resolved.slug);
+  const shouldBeDisabled = !enabled;
+  if (wasDisabled === shouldBeDisabled) {
+    return { slug: resolved.slug, enabled, changed: false };
+  }
+  if (shouldBeDisabled) {
+    disabledSet.add(resolved.slug);
+  } else {
+    disabledSet.delete(resolved.slug);
+  }
+  await updatePlaybooksConfig({ disabled: Array.from(disabledSet).sort() });
+  await rebuildPlaybookManifest(playbooksDir2);
+  return { slug: resolved.slug, enabled, changed: true };
+}
+async function removeFromDisabledList(slug) {
+  const config = await readConfig();
+  if (!config.playbooks.disabled.includes(slug)) return;
+  await updatePlaybooksConfig({
+    disabled: config.playbooks.disabled.filter((s) => s !== slug)
+  });
+}
+async function rebuildPlaybookManifest(playbooksDir2) {
+  if (!await fileExists(playbooksDir2)) return;
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
+  const entries = await readdir2(playbooksDir2, { withFileTypes: true });
+  const rows = [];
+  for (const entry of entries) {
+    if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
+    const raw = await readFile4(resolve5(playbooksDir2, entry.name), "utf-8");
+    const parsed = parsePlaybook(raw);
+    const slug = parsed.slug || entry.name.replace(/\.md$/, "");
+    if (disabledSet.has(slug)) continue;
+    rows.push({
+      name: parsed.name || slug,
+      slug,
+      description: parsed.description,
+      whenToUse: parsed.whenToUse
+    });
+  }
+  rows.sort((a, b) => a.name.localeCompare(b.name));
+  const timestamp = nowTimestamp();
+  const lines = [
+    "---",
+    `generated: "${timestamp}"`,
+    `total: ${rows.length}`,
+    "---",
+    "",
+    "# Playbooks",
+    "",
+    "Behavioral rules for AI agents. Read and follow all playbooks before starting work.",
+    ""
+  ];
+  for (const row of rows) {
+    lines.push(`- **[${row.name}](${row.slug}.md)** \u2014 ${row.description}`);
+    if (row.whenToUse) {
+      lines.push(`  _When to use: ${row.whenToUse}_`);
+    }
+  }
+  lines.push("");
+  await writeFileForce(resolve5(playbooksDir2, "manifest.md"), lines.join("\n"));
+}
+var init_playbooks = __esm({
+  "src/utils/playbooks.ts"() {
+    "use strict";
+    init_fs();
+    init_parser();
+    init_timestamp();
+    init_config2();
+  }
+});
+
+// src/utils/assignment-resolver.ts
+import { resolve as resolve6 } from "path";
+import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
 async function resolveAssignmentById(projectsDir, assignmentsDir, id) {
   let standaloneMatch = null;
   let projectMatch = null;
-  const standaloneDir = resolve5(assignmentsDir, id);
-  const standalonePath = resolve5(standaloneDir, "assignment.md");
+  const standaloneDir = resolve6(assignmentsDir, id);
+  const standalonePath = resolve6(standaloneDir, "assignment.md");
   if (await fileExists(standalonePath)) {
+    let workspaceGroup = null;
+    try {
+      const content = await readFile5(standalonePath, "utf-8");
+      const [fm] = extractFrontmatter2(content);
+      workspaceGroup = getField(fm, "workspaceGroup");
+    } catch {
+    }
     standaloneMatch = {
       assignmentDir: standaloneDir,
       projectSlug: null,
       assignmentSlug: id,
       id,
-      standalone: true
+      standalone: true,
+      workspaceGroup
     };
   }
   if (await fileExists(projectsDir)) {
     try {
-      const projects = await readdir2(projectsDir, { withFileTypes: true });
+      const projects = await readdir3(projectsDir, { withFileTypes: true });
       for (const p of projects) {
         if (!p.isDirectory()) continue;
         if (p.name.startsWith(".") || p.name.startsWith("_")) continue;
-        const assignmentsPath = resolve5(projectsDir, p.name, "assignments");
+        const assignmentsPath = resolve6(projectsDir, p.name, "assignments");
         if (!await fileExists(assignmentsPath)) continue;
-        const entries = await readdir2(assignmentsPath, { withFileTypes: true });
+        const entries = await readdir3(assignmentsPath, { withFileTypes: true });
         for (const a of entries) {
           if (!a.isDirectory()) continue;
-          const aPath = resolve5(assignmentsPath, a.name, "assignment.md");
+          const aPath = resolve6(assignmentsPath, a.name, "assignment.md");
           if (!await fileExists(aPath)) continue;
           try {
-            const content = await readFile4(aPath, "utf-8");
+            const content = await readFile5(aPath, "utf-8");
             const [fm] = extractFrontmatter2(content);
             const fileId = getField(fm, "id");
             if (fileId === id) {
               projectMatch = {
-                assignmentDir: resolve5(assignmentsPath, a.name),
+                assignmentDir: resolve6(assignmentsPath, a.name),
                 projectSlug: p.name,
                 assignmentSlug: a.name,
                 id,
-                standalone: false
+                standalone: false,
+                workspaceGroup: null
               };
               break;
             }
@@ -1700,8 +1919,18 @@ var init_help = __esm({
       },
       {
         command: "syntaur list-playbooks",
-        description: "List all playbooks in the Syntaur home directory.",
-        example: "syntaur list-playbooks"
+        description: "List playbooks in the Syntaur home directory. Disabled playbooks are excluded by default; pass --all to include them with a (disabled) tag.",
+        example: "syntaur list-playbooks --all"
+      },
+      {
+        command: "syntaur enable-playbook",
+        description: "Re-enable a previously-disabled playbook so agents load it again. Updates config.md and rebuilds manifest.md.",
+        example: "syntaur enable-playbook commit-discipline"
+      },
+      {
+        command: "syntaur disable-playbook",
+        description: "Disable a playbook so agents no longer list or load it. Playbook file is untouched; state is tracked in config.md.",
+        example: "syntaur disable-playbook commit-discipline"
       }
     ];
     WORKFLOW = [
@@ -1768,8 +1997,8 @@ var init_help = __esm({
 });
 
 // src/dashboard/servers.ts
-import { readdir as readdir3, readFile as readFile5, unlink } from "fs/promises";
-import { resolve as resolve6 } from "path";
+import { readdir as readdir4, readFile as readFile6, unlink } from "fs/promises";
+import { resolve as resolve7 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -1817,18 +2046,18 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve6(dir, `${name}.md`), content);
+  await writeFileForce(resolve7(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 = resolve6(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve7(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] = extractFrontmatter2(raw);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
@@ -1868,7 +2097,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve6(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve7(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink(filePath);
   }
@@ -1877,7 +2106,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve6(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve7(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -1889,7 +2118,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve6(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve7(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -1906,7 +2135,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve6(dir, `${name}.md`), content);
+  await writeFileForce(resolve7(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -1938,8 +2167,8 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve7 } from "path";
-import { realpath, readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { resolve as resolve8 } from "path";
+import { realpath, readdir as readdir5, readFile as readFile7 } from "fs/promises";
 function clearScanCache() {
   cache = null;
 }
@@ -2034,8 +2263,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve7(cwd, commonDir));
-      const resolvedGit = await realpath(resolve7(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve8(cwd, commonDir));
+      const resolvedGit = await realpath(resolve8(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -2048,17 +2277,17 @@ async function loadWorkspaceRecords(projectsDir, assignmentsDir) {
   try {
     const projects = await listProjects(projectsDir);
     for (const project of projects) {
-      const projectAssignmentsDir = resolve7(projectsDir, project.slug, "assignments");
+      const projectAssignmentsDir = resolve8(projectsDir, project.slug, "assignments");
       let slugs;
       try {
-        slugs = await readdir4(projectAssignmentsDir);
+        slugs = await readdir5(projectAssignmentsDir);
       } catch {
         continue;
       }
       for (const aslug of slugs) {
-        const aFile = resolve7(projectAssignmentsDir, aslug, "assignment.md");
+        const aFile = resolve8(projectAssignmentsDir, aslug, "assignment.md");
         try {
-          const raw = await readFile6(aFile, "utf-8");
+          const raw = await readFile7(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -2077,12 +2306,12 @@ async function loadWorkspaceRecords(projectsDir, assignmentsDir) {
   }
   if (assignmentsDir) {
     try {
-      const entries = await readdir4(assignmentsDir);
+      const entries = await readdir5(assignmentsDir);
       for (const id of entries) {
         if (id.startsWith(".") || id.startsWith("_")) continue;
-        const aFile = resolve7(assignmentsDir, id, "assignment.md");
+        const aFile = resolve8(assignmentsDir, id, "assignment.md");
         try {
-          const raw = await readFile6(aFile, "utf-8");
+          const raw = await readFile7(aFile, "utf-8");
           const [fm] = extractFrontmatter2(raw);
           if (!fm) continue;
           records.push({
@@ -2330,20 +2559,20 @@ var init_scanner = __esm({
 });
 
 // src/dashboard/api.ts
-import { readdir as readdir5, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve8, dirname as dirname2 } from "path";
+import { readdir as readdir6, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve9, dirname as dirname2 } from "path";
 async function listStandaloneRecords(assignmentsDir) {
   if (!assignmentsDir) return [];
   if (!await fileExists(assignmentsDir)) return [];
-  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve8(assignmentsDir, entry.name);
-    const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
+    const assignmentDir = resolve9(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve9(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
-      const content = await readFile7(assignmentMdPath, "utf-8");
+      const content = await readFile8(assignmentMdPath, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -2412,9 +2641,9 @@ async function listProjects(projectsDir) {
   return projectRecords.map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve9(dirname2(projectsDir), "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 {
@@ -2422,13 +2651,14 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve8(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve9(dirname2(projectsDir), "workspaces.json");
   await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
-async function listWorkspaces(projectsDir) {
-  const [projectRecords, registered] = await Promise.all([
+async function listWorkspaces(projectsDir, assignmentsDir) {
+  const [projectRecords, registered, standaloneRecords] = await Promise.all([
     listProjectRecords(projectsDir),
-    readWorkspaceRegistry(projectsDir)
+    readWorkspaceRegistry(projectsDir),
+    listStandaloneRecords(assignmentsDir)
   ]);
   const workspaceSet = new Set(registered);
   let hasUngrouped = false;
@@ -2439,6 +2669,13 @@ async function listWorkspaces(projectsDir) {
       hasUngrouped = true;
     }
   }
+  for (const sr of standaloneRecords) {
+    if (sr.record.workspaceGroup) {
+      workspaceSet.add(sr.record.workspaceGroup);
+    } else {
+      hasUngrouped = true;
+    }
+  }
   const workspaces = Array.from(workspaceSet).sort();
   return { workspaces, hasUngrouped };
 }
@@ -2587,7 +2824,7 @@ async function toStandaloneBoardItem(sr) {
     projectSlug: null,
     projectTitle: null,
     blockedReason: sr.record.blockedReason,
-    projectWorkspace: null,
+    projectWorkspace: sr.record.workspaceGroup ?? null,
     availableTransitions: await getStandaloneAvailableTransitions(sr.record)
   };
 }
@@ -2622,7 +2859,7 @@ async function getEditableDocument(projectsDir, documentType, projectSlug, assig
   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,
@@ -2646,9 +2883,9 @@ async function getEditableDocumentById(projectsDir, assignmentsDir, documentType
   }
   const fileName = documentType === "assignment" ? "assignment.md" : documentType === "plan" ? "plan.md" : documentType === "scratchpad" ? "scratchpad.md" : documentType === "handoff" ? "handoff.md" : documentType === "decision-record" ? "decision-record.md" : null;
   if (!fileName) return null;
-  const filePath = resolve8(resolved.assignmentDir, fileName);
+  const filePath = resolve9(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
-  const content = await readFile7(filePath, "utf-8");
+  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 {
@@ -2662,12 +2899,12 @@ async function getEditableDocumentById(projectsDir, assignmentsDir, documentType
   };
 }
 async function getProjectDetail(projectsDir, slug) {
-  const projectPath = resolve8(projectsDir, slug);
-  const projectMdPath = resolve8(projectPath, "project.md");
+  const projectPath = resolve9(projectsDir, slug);
+  const projectMdPath = resolve9(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 = await buildProjectRollup(projectPath, project, assignments);
@@ -2697,17 +2934,17 @@ async function getProjectDetail(projectsDir, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve8(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
+  const assignmentDir = resolve9(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve9(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 = resolve8(assignmentDir, "plan.md");
+  const planPath = resolve9(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,
@@ -2716,9 +2953,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve9(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,
@@ -2726,9 +2963,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve8(assignmentDir, "handoff.md");
+  const handoffPath = resolve9(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,
@@ -2737,9 +2974,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve9(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,
@@ -2748,9 +2985,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve8(assignmentDir, "progress.md");
+  const progressPath = resolve9(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const progressContent = await readFile7(progressPath, "utf-8");
+    const progressContent = await readFile8(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
     progress = {
       updated: parsed.updated,
@@ -2759,9 +2996,9 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve8(assignmentDir, "comments.md");
+  const commentsPath = resolve9(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const commentsContent = await readFile7(commentsPath, "utf-8");
+    const commentsContent = await readFile8(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
     comments = {
       updated: parsed.updated,
@@ -2875,7 +3112,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve8(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve9(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -2908,17 +3145,17 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve8(sourceDir, "assignment.md");
+  const assignmentMd = resolve9(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
-    const content = await readFile7(assignmentMd, "utf-8");
+    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 = resolve8(sourceDir, filename);
+    const path = resolve9(sourceDir, filename);
     if (await fileExists(path)) {
       try {
-        bodies.push(await readFile7(path, "utf-8"));
+        bodies.push(await readFile8(path, "utf-8"));
       } catch {
       }
     }
@@ -2976,44 +3213,44 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve8(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve9(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 = resolve8(assignmentDir, "plan.md");
+  const planPath = resolve9(assignmentDir, "plan.md");
   if (await fileExists(planPath)) {
-    const parsed = parsePlan(await readFile7(planPath, "utf-8"));
+    const parsed = parsePlan(await readFile8(planPath, "utf-8"));
     plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
   }
   let scratchpad = null;
-  const scratchpadPath = resolve8(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve9(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
-    const parsed = parseScratchpad(await readFile7(scratchpadPath, "utf-8"));
+    const parsed = parseScratchpad(await readFile8(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve8(assignmentDir, "handoff.md");
+  const handoffPath = resolve9(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
-    const parsed = parseHandoff(await readFile7(handoffPath, "utf-8"));
+    const parsed = parseHandoff(await readFile8(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve8(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve9(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
-    const parsed = parseDecisionRecord(await readFile7(decisionRecordPath, "utf-8"));
+    const parsed = parseDecisionRecord(await readFile8(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve8(assignmentDir, "progress.md");
+  const progressPath = resolve9(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
-    const parsed = parseProgress(await readFile7(progressPath, "utf-8"));
+    const parsed = parseProgress(await readFile8(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve8(assignmentDir, "comments.md");
+  const commentsPath = resolve9(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
-    const parsed = parseComments(await readFile7(commentsPath, "utf-8"));
+    const parsed = parseComments(await readFile8(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   const detail = {
@@ -3055,16 +3292,16 @@ async function listProjectRecords(projectsDir) {
     migratedProjectsDirs.add(projectsDir);
     await migrateLegacyProjectFiles(projectsDir);
   }
-  const entries = await readdir5(projectsDir, { withFileTypes: true });
+  const entries = await readdir6(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const records = [];
   for (const entry of projectDirs) {
-    const projectPath = resolve8(projectsDir, entry.name);
-    const projectMdPath = resolve8(projectPath, "project.md");
+    const projectPath = resolve9(projectsDir, entry.name);
+    const projectMdPath = resolve9(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 = await buildProjectRollup(projectPath, project, assignments);
@@ -3095,39 +3332,39 @@ async function listProjectRecords(projectsDir) {
   return records;
 }
 async function listAssignmentRecords(projectPath) {
-  const assignmentsDir = resolve8(projectPath, "assignments");
+  const assignmentsDir = resolve9(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
-  const entries = await readdir5(assignmentsDir, { withFileTypes: true });
+  const entries = await readdir6(assignmentsDir, { withFileTypes: true });
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const assignmentMd = resolve8(assignmentsDir, entry.name, "assignment.md");
+    const assignmentMd = resolve9(assignmentsDir, 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 = resolve8(projectPath, "resources");
+  const resourcesDir = resolve9(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 = resolve8(resourcesDir, entry.name);
-    const content = await readFile7(filePath, "utf-8");
+    const filePath = resolve9(resourcesDir, entry.name);
+    const content = await readFile8(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
       name: parsed.name,
@@ -3142,18 +3379,18 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve8(projectPath, "memories");
+  const memoriesDir = resolve9(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 = resolve8(memoriesDir, entry.name);
-    const content = await readFile7(filePath, "utf-8");
+    const filePath = resolve9(memoriesDir, entry.name);
+    const content = await readFile8(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
       name: parsed.name,
@@ -3168,9 +3405,9 @@ async function listMemories(projectPath) {
   return results;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve8(projectPath, "_status.md");
+  const statusPath = resolve9(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) {
@@ -3270,7 +3507,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve8(projectsDir, projectSlug);
+  const projectPath = resolve9(projectsDir, projectSlug);
   for (const definition of transitionDefs) {
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
@@ -3300,12 +3537,12 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
-    const dependencyPath = resolve8(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve9(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})`);
@@ -3460,7 +3697,7 @@ function isStale(updated) {
   return Date.now() - timestamp > STALE_ASSIGNMENT_MS;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve8(
+  const commentsPath = resolve9(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -3470,7 +3707,7 @@ async function countOpenQuestions(projectPath, assignmentSlug) {
     return 0;
   }
   try {
-    const content = await readFile7(commentsPath, "utf-8");
+    const content = await readFile8(commentsPath, "utf-8");
     const parsed = parseComments(content);
     return parsed.entries.filter(
       (e) => e.type === "question" && e.resolved !== true
@@ -3491,17 +3728,17 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve8(projectsDir, projectSlug, "project.md");
+      return resolve9(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve8(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     default:
       return null;
   }
@@ -3528,12 +3765,14 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir2) {
   if (!await fileExists(playbooksDir2)) return [];
-  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
+  const entries = await readdir6(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve8(playbooksDir2, entry.name);
-    const raw = await readFile7(filePath, "utf-8");
+    const filePath = resolve9(playbooksDir2, entry.name);
+    const raw = await readFile8(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
@@ -3543,25 +3782,28 @@ async function listPlaybooks(playbooksDir2) {
       whenToUse: parsed.whenToUse,
       tags: parsed.tags,
       created: parsed.created,
-      updated: parsed.updated
+      updated: parsed.updated,
+      enabled: !disabledSet.has(slug)
     });
   }
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
 async function getPlaybookDetail(playbooksDir2, slug) {
-  const filePath = resolve8(playbooksDir2, `${slug}.md`);
-  if (!await fileExists(filePath)) return null;
-  const raw = await readFile7(filePath, "utf-8");
-  const parsed = parsePlaybook(raw);
+  const resolved = await resolvePlaybookSlug(playbooksDir2, slug);
+  if (!resolved) return null;
+  const config = await readConfig();
+  const enabled = !config.playbooks.disabled.includes(resolved.slug);
+  const parsed = resolved.parsed;
   return {
-    slug: parsed.slug || slug,
-    name: parsed.name || slug,
+    slug: resolved.slug,
+    name: parsed.name || resolved.slug,
     description: parsed.description,
     whenToUse: parsed.whenToUse,
     tags: parsed.tags,
     created: parsed.created,
     updated: parsed.updated,
-    body: parsed.body
+    body: parsed.body,
+    enabled
   };
 }
 var STALE_ASSIGNMENT_MS, ATTENTION_PAGE_LIMIT, OVERVIEW_ATTENTION_LIMIT, RECENT_PROJECTS_LIMIT, RECENT_ACTIVITY_LIMIT, DEFAULT_TRANSITION_DEFINITIONS, DEFAULT_STATUS_COLORS, _cachedConfig, REFERENCED_BY_LIMIT, migratedProjectsDirs, DEFAULT_GRAPH_COLORS;
@@ -3571,6 +3813,7 @@ var init_api = __esm({
     init_lifecycle();
     init_fs();
     init_config2();
+    init_playbooks();
     init_fs_migration();
     init_assignment_resolver();
     init_parser();
@@ -3922,21 +4165,21 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/agent-sessions.ts
 init_fs();
-import { readFile as readFile8 } from "fs/promises";
-import { resolve as resolve10 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { resolve as resolve11 } from "path";
 
 // src/dashboard/session-db.ts
 init_paths();
 init_fs();
 import Database from "better-sqlite3";
-import { resolve as resolve9 } from "path";
-import { readdir as readdir6 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { readdir as readdir7 } from "fs/promises";
 var db = null;
 var SCHEMA_VERSION = "3";
 var SCHEMA_SQL = `
@@ -3963,7 +4206,7 @@ CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, ass
 `;
 function initSessionDb(dbPath) {
   if (db) return db;
-  const finalPath = dbPath ?? resolve9(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve10(syntaurRoot(), "syntaur.db");
   db = new Database(finalPath);
   db.pragma("journal_mode = WAL");
   db.exec(SCHEMA_SQL);
@@ -4060,12 +4303,12 @@ async function migrateFromMarkdown(projectsDir) {
   const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
   if (count.count > 0) return 0;
   if (!await fileExists(projectsDir)) return 0;
-  const entries = await readdir6(projectsDir, { withFileTypes: true });
+  const entries = await readdir7(projectsDir, { withFileTypes: true });
   const allSessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const projectDir = resolve9(projectsDir, entry.name);
-    const indexPath = resolve9(projectDir, "_index-sessions.md");
+    const projectDir = resolve10(projectsDir, entry.name);
+    const indexPath = resolve10(projectDir, "_index-sessions.md");
     if (!await fileExists(indexPath)) continue;
     const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
     allSessions.push(...sessions);
@@ -4085,8 +4328,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile14 } = await import("fs/promises");
-  const raw = await readFile14(filePath, "utf-8");
+  const { readFile: readFile15 } = await import("fs/promises");
+  const raw = await readFile15(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4198,13 +4441,13 @@ async function deleteSessions(sessionIds) {
 var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
 async function readAssignmentStatusFromPath(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
-  const raw = await readFile8(assignmentMdPath, "utf-8");
+  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(
-    resolve10(projectDir, "assignments", assignmentSlug, "assignment.md")
+    resolve11(projectDir, "assignments", assignmentSlug, "assignment.md")
   );
 }
 async function reconcileActiveSessions(projectsDir, assignmentsDir) {
@@ -4222,13 +4465,13 @@ async function reconcileActiveSessions(projectsDir, assignmentsDir) {
     seen.add(key);
     if (session.project_slug) {
       const status = await readAssignmentStatus(
-        resolve10(projectsDir, session.project_slug),
+        resolve11(projectsDir, session.project_slug),
         aslug
       );
       if (status) assignmentStatuses.set(key, status);
     } else if (assignmentsDir) {
       const status = await readAssignmentStatusFromPath(
-        resolve10(assignmentsDir, aslug, "assignment.md")
+        resolve11(assignmentsDir, aslug, "assignment.md")
       );
       if (status) assignmentStatuses.set(key, status);
     }
@@ -4273,18 +4516,25 @@ function createWatcher(options) {
     if (parts.length === 0) return;
     const projectSlug = parts[0];
     let assignmentSlug;
+    let isProjectTodos = false;
     if (parts.length >= 3 && parts[1] === "assignments") {
       assignmentSlug = parts[2];
+    } else if (parts.length >= 2 && parts[1] === "todos") {
+      isProjectTodos = true;
     }
-    const debounceKey = assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
+    const debounceKey = isProjectTodos ? `todos:${projectSlug}` : assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
     const existing = pendingEvents.get(debounceKey);
     if (existing) clearTimeout(existing);
-    const messageType = assignmentSlug ? "assignment-updated" : "project-updated";
+    const messageType = isProjectTodos ? "todos-updated" : assignmentSlug ? "assignment-updated" : "project-updated";
     pendingEvents.set(
       debounceKey,
       setTimeout(() => {
         pendingEvents.delete(debounceKey);
-        const message = {
+        const message = isProjectTodos ? {
+          type: "todos-updated",
+          projectSlug,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        } : {
           type: messageType,
           projectSlug,
           assignmentSlug,
@@ -4442,8 +4692,8 @@ init_config2();
 // src/dashboard/api-write.ts
 init_lifecycle();
 import { Router } from "express";
-import { resolve as resolve11 } from "path";
-import { rm, readFile as readFile9 } from "fs/promises";
+import { resolve as resolve12 } from "path";
+import { rm, readFile as readFile10 } from "fs/promises";
 
 // src/utils/slug.ts
 function isValidSlug(slug) {
@@ -4514,14 +4764,14 @@ init_assignment_resolver();
 init_config();
 
 // src/templates/manifest.ts
-function renderManifest(params) {
+function renderManifest(params2) {
   return `---
 version: "2.0"
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
-# Project: ${params.slug}
+# Project: ${params2.slug}
 
 ## Overview
 - [Project Overview](./project.md)
@@ -4548,24 +4798,24 @@ function escapeYamlString(value) {
 }
 
 // src/templates/project.ts
-function renderProject(params) {
-  const safeTitle = escapeYamlString(params.title);
-  const workspaceLine = params.workspace ? `
-workspace: ${params.workspace}` : "";
+function renderProject(params2) {
+  const safeTitle = escapeYamlString(params2.title);
+  const workspaceLine = params2.workspace ? `
+workspace: ${params2.workspace}` : "";
   return `---
-id: ${params.id}
-slug: ${params.slug}
+id: ${params2.id}
+slug: ${params2.slug}
 title: ${safeTitle}
 archived: false
 archivedAt: null
 archivedReason: null
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 externalIds: []
 tags: []${workspaceLine}
 ---
 
-# ${params.title}
+# ${params2.title}
 
 ## Overview
 
@@ -4578,24 +4828,37 @@ tags: []${workspaceLine}
 }
 
 // src/templates/assignment.ts
-function renderAssignment(params) {
-  const safeTitle = escapeYamlString(params.title);
-  const dependsOnYaml = params.dependsOn.length === 0 ? "dependsOn: []" : `dependsOn:
-  - ${params.dependsOn.join("\n  - ")}`;
-  const linksYaml = params.links.length === 0 ? "links: []" : `links:
-  - ${params.links.join("\n  - ")}`;
-  const projectYaml = `project: ${params.project == null ? "null" : params.project}`;
-  const typeYaml = `type: ${params.type ?? "feature"}`;
+function renderAssignment(params2) {
+  const safeTitle = escapeYamlString(params2.title);
+  const dependsOnYaml = params2.dependsOn.length === 0 ? "dependsOn: []" : `dependsOn:
+  - ${params2.dependsOn.join("\n  - ")}`;
+  const linksYaml = params2.links.length === 0 ? "links: []" : `links:
+  - ${params2.links.join("\n  - ")}`;
+  const projectYaml = `project: ${params2.project == null ? "null" : params2.project}`;
+  const workspaceGroupLine = params2.workspaceGroup ? `
+workspaceGroup: ${params2.workspaceGroup}` : "";
+  const typeYaml = `type: ${params2.type ?? "feature"}`;
+  const todosSection = params2.includeTodos ? `## Todos
+
+<!--
+Checklist of work items for this assignment. Items may be simple tasks
+or a markdown link to a plan file (e.g., "- [ ] Execute [plan](./plan.md)").
+When a plan is superseded by a new one, mark the old todo as:
+  - [x] ~~Execute [old plan](./plan.md)~~ (superseded by plan-v2)
+Never delete superseded todos \u2014 preserve the history.
+-->
+
+` : "";
   return `---
-id: ${params.id}
-slug: ${params.slug}
+id: ${params2.id}
+slug: ${params2.slug}
 title: ${safeTitle}
-${projectYaml}
+${projectYaml}${workspaceGroupLine}
 ${typeYaml}
 status: pending
-priority: ${params.priority}
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
+priority: ${params2.priority}
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 assignee: null
 externalIds: []
 ${dependsOnYaml}
@@ -4609,7 +4872,7 @@ workspace:
 tags: []
 ---
 
-# ${params.title}
+# ${params2.title}
 
 ## Objective
 
@@ -4621,17 +4884,7 @@ tags: []
 - [ ] <!-- criterion 2 -->
 - [ ] <!-- criterion 3 -->
 
-## Todos
-
-<!--
-Checklist of work items for this assignment. Items may be simple tasks
-or a markdown link to a plan file (e.g., "- [ ] Execute [plan](./plan.md)").
-When a plan is superseded by a new one, mark the old todo as:
-  - [x] ~~Execute [old plan](./plan.md)~~ (superseded by plan-v2)
-Never delete superseded todos \u2014 preserve the history.
--->
-
-## Context
+${todosSection}## Context
 
 <!-- Links to relevant docs, code, or other assignments. -->
 
@@ -4646,10 +4899,10 @@ Never delete superseded todos \u2014 preserve the history.
 }
 
 // src/templates/scratchpad.ts
-function renderScratchpad(params) {
+function renderScratchpad(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 ---
 
 # Scratchpad
@@ -4659,10 +4912,10 @@ No working notes yet.
 }
 
 // src/templates/handoff.ts
-function renderHandoff(params) {
+function renderHandoff(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 handoffCount: 0
 ---
 
@@ -4673,12 +4926,12 @@ No handoffs recorded yet.
 }
 
 // src/templates/progress.ts
-function renderProgress(params) {
+function renderProgress(params2) {
   return `---
-assignment: ${params.assignment}
+assignment: ${params2.assignment}
 entryCount: 0
-generated: "${params.timestamp}"
-updated: "${params.timestamp}"
+generated: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 ---
 
 # Progress
@@ -4688,12 +4941,12 @@ No progress yet.
 }
 
 // src/templates/comments.ts
-function renderComments(params) {
+function renderComments(params2) {
   return `---
-assignment: ${params.assignment}
+assignment: ${params2.assignment}
 entryCount: 0
-generated: "${params.timestamp}"
-updated: "${params.timestamp}"
+generated: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 ---
 
 # Comments
@@ -4721,10 +4974,10 @@ function formatCommentEntry(comment) {
 }
 
 // src/templates/decision-record.ts
-function renderDecisionRecord(params) {
+function renderDecisionRecord(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 decisionCount: 0
 ---
 
@@ -4735,10 +4988,10 @@ No decisions recorded yet.
 }
 
 // src/templates/index-stubs.ts
-function renderIndexAssignments(params) {
+function renderIndexAssignments(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 by_status:
   pending: 0
@@ -4755,10 +5008,10 @@ by_status:
 |------|-------|--------|----------|----------|--------------|---------|
 `;
 }
-function renderIndexPlans(params) {
+function renderIndexPlans(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
 # Plans
@@ -4767,10 +5020,10 @@ generated: "${params.timestamp}"
 |------------|-------------|---------|
 `;
 }
-function renderIndexDecisions(params) {
+function renderIndexDecisions(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
 # Decision Records
@@ -4779,10 +5032,10 @@ generated: "${params.timestamp}"
 |------------|-------|-----------------|---------------|---------|
 `;
 }
-function renderStatus(params) {
+function renderStatus(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 status: pending
 progress:
   total: 0
@@ -4798,7 +5051,7 @@ needsAttention:
   openQuestions: 0
 ---
 
-# Project Status: ${params.title}
+# Project Status: ${params2.title}
 
 **Status:** pending
 **Progress:** 0/0 assignments complete
@@ -4818,10 +5071,10 @@ No dependencies yet.
 - **0 unanswered** questions
 `;
 }
-function renderResourcesIndex(params) {
+function renderResourcesIndex(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 ---
 
@@ -4831,10 +5084,10 @@ total: 0
 |------|----------|--------|---------------------|---------|
 `;
 }
-function renderMemoriesIndex(params) {
+function renderMemoriesIndex(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 ---
 
@@ -4846,19 +5099,19 @@ total: 0
 }
 
 // src/templates/playbook.ts
-function renderPlaybook(params) {
-  const whenToUse = params.whenToUse ? escapeYamlString(params.whenToUse) : "null";
+function renderPlaybook(params2) {
+  const whenToUse = params2.whenToUse ? escapeYamlString(params2.whenToUse) : "null";
   return `---
-name: ${escapeYamlString(params.name)}
-slug: ${params.slug}
-description: ${escapeYamlString(params.description)}
+name: ${escapeYamlString(params2.name)}
+slug: ${params2.slug}
+description: ${escapeYamlString(params2.description)}
 when_to_use: ${whenToUse}
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 tags: []
 ---
 
-# ${params.name}
+# ${params2.name}
 
 <!-- Write imperative rules and workflows here. Keep it under 50 lines. -->
 `;
@@ -4966,7 +5219,7 @@ async function readCurrentDocument(filePath) {
   if (!await fileExists(filePath)) {
     return null;
   }
-  return readFile9(filePath, "utf-8");
+  return readFile10(filePath, "utf-8");
 }
 function createWriteRouter(projectsDir, assignmentsDir) {
   const router = Router();
@@ -4979,7 +5232,15 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     });
     res.json({ content });
   });
-  router.get("/api/templates/assignment", (_req, res) => {
+  router.get("/api/templates/assignment", (req, res) => {
+    const standalone = req.query.standalone === "1";
+    const workspaceParam = typeof req.query.workspace === "string" ? req.query.workspace : "";
+    if (workspaceParam && !isValidSlug(workspaceParam)) {
+      res.status(400).json({
+        error: `Invalid workspace slug "${workspaceParam}". Slugs must be lowercase, hyphen-separated, with no special characters.`
+      });
+      return;
+    }
     const content = renderAssignment({
       id: generateId(),
       slug: "my-new-assignment",
@@ -4987,7 +5248,9 @@ function createWriteRouter(projectsDir, assignmentsDir) {
       timestamp: nowTimestamp(),
       priority: "medium",
       dependsOn: [],
-      links: []
+      links: [],
+      project: standalone ? null : void 0,
+      workspaceGroup: standalone && workspaceParam ? workspaceParam : null
     });
     res.json({ content });
   });
@@ -5096,26 +5359,26 @@ function createWriteRouter(projectsDir, assignmentsDir) {
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve11(projectsDir, slug);
+      const projectDir = resolve12(projectsDir, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve11(projectDir, "assignments"));
-      await ensureDir(resolve11(projectDir, "resources"));
-      await ensureDir(resolve11(projectDir, "memories"));
-      await writeFileForce(resolve11(projectDir, "project.md"), content);
+      await ensureDir(resolve12(projectDir, "assignments"));
+      await ensureDir(resolve12(projectDir, "resources"));
+      await ensureDir(resolve12(projectDir, "memories"));
+      await writeFileForce(resolve12(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 })]
+          [resolve12(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve12(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve12(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve12(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve12(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve12(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve12(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -5136,8 +5399,8 @@ function createWriteRouter(projectsDir, assignmentsDir) {
   router.post("/api/projects/:slug/assignments", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectDir = resolve11(projectsDir, projectSlug);
-      const projectMdPath = resolve11(projectDir, "project.md");
+      const projectDir = resolve12(projectsDir, projectSlug);
+      const projectMdPath = resolve12(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5167,7 +5430,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve11(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve12(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -5176,12 +5439,12 @@ function createWriteRouter(projectsDir, assignmentsDir) {
       }
       const timestamp = fields.created || nowTimestamp();
       await ensureDir(assignmentDir);
-      await writeFileForce(resolve11(assignmentDir, "assignment.md"), content);
+      await writeFileForce(resolve12(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 })]
+          [resolve12(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve12(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve12(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -5202,7 +5465,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
   router.patch("/api/projects/:slug", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve12(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -5235,7 +5498,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5278,7 +5541,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5314,7 +5577,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const planPath = resolve11(
+      const planPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5352,7 +5615,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const scratchpadPath = resolve11(
+      const scratchpadPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5390,7 +5653,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const handoffPath = resolve11(
+      const handoffPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5428,7 +5691,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const decisionPath = resolve11(
+      const decisionPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5466,7 +5729,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const commentsPath = resolve11(
+      const commentsPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5484,7 +5747,7 @@ function createWriteRouter(projectsDir, assignmentsDir) {
       let currentContent;
       let currentCount = 0;
       if (await fileExists(commentsPath)) {
-        currentContent = await readFile9(commentsPath, "utf-8");
+        currentContent = await readFile10(commentsPath, "utf-8");
         const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
         if (countMatch) currentCount = parseInt(countMatch[1], 10);
       } else {
@@ -5525,7 +5788,7 @@ ${entry}`;
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
       const commentId = getParam(req.params.commentId);
-      const commentsPath = resolve11(
+      const commentsPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5541,7 +5804,7 @@ ${entry}`;
         res.status(400).json({ error: "resolved (boolean) is required" });
         return;
       }
-      const content = await readFile9(commentsPath, "utf-8");
+      const content = await readFile10(commentsPath, "utf-8");
       const parsed = parseComments(content);
       const target = parsed.entries.find((e) => e.id === commentId);
       if (!target) {
@@ -5576,7 +5839,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve12(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5586,7 +5849,7 @@ ${entry}`;
         res.status(400).json({ error: "workspace must be a non-empty string or null (for ungrouped)." });
         return;
       }
-      let content = await readFile9(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);
@@ -5600,7 +5863,7 @@ ${entry}`;
   router.post("/api/projects/:slug/status-override", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
-      const projectPath = resolve11(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve12(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -5612,7 +5875,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
       }
-      let content = await readFile9(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);
@@ -5627,7 +5890,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentPath = resolve11(
+      const assignmentPath = resolve12(
         projectsDir,
         projectSlug,
         "assignments",
@@ -5645,7 +5908,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile9(assignmentPath, "utf-8");
+      let content = await readFile10(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -5670,8 +5933,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req.params.command}"` });
         return;
       }
-      const projectDir = resolve11(projectsDir, projectSlug);
-      const assignmentPath = resolve11(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve12(projectsDir, projectSlug);
+      const assignmentPath = resolve12(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -5697,8 +5960,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req.params.slug);
       const assignmentSlug = getParam(req.params.aslug);
-      const assignmentDir = resolve11(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve11(assignmentDir, "assignment.md");
+      const assignmentDir = resolve12(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve12(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -5716,6 +5979,76 @@ ${entry}`;
         res.status(501).json({ error: "Standalone assignments not configured on this server" });
         return;
       }
+      const rawContent = typeof req.body?.content === "string" ? req.body.content : "";
+      if (rawContent.trim()) {
+        const fields = extractFrontmatter3(rawContent);
+        if (!fields) {
+          res.status(400).json({ error: "Invalid frontmatter: missing --- delimiters" });
+          return;
+        }
+        const validation = validateRequired(fields, ["slug", "title"]);
+        if (!validation.valid) {
+          res.status(400).json({ error: `Missing required fields: ${validation.missing.join(", ")}` });
+          return;
+        }
+        const submittedSlug = fields.slug;
+        if (!isValidSlug(submittedSlug)) {
+          res.status(400).json({ error: `Invalid slug "${submittedSlug}". Must be lowercase and hyphen-separated.` });
+          return;
+        }
+        const validPriorities = ["low", "medium", "high", "critical"];
+        const submittedPriority = fields.priority || "medium";
+        if (!validPriorities.includes(submittedPriority)) {
+          res.status(400).json({ error: `Invalid priority "${submittedPriority}". Must be low, medium, high, or critical.` });
+          return;
+        }
+        if (fields.project && fields.project !== "null") {
+          res.status(400).json({
+            error: 'Standalone assignments cannot have a project; remove "project" or set it to null.'
+          });
+          return;
+        }
+        const submittedWorkspaceGroup = fields.workspaceGroup && fields.workspaceGroup !== "null" ? fields.workspaceGroup : "";
+        if (submittedWorkspaceGroup && !isValidSlug(submittedWorkspaceGroup)) {
+          res.status(400).json({
+            error: `Invalid workspace slug "${submittedWorkspaceGroup}". Slugs must be lowercase, hyphen-separated, with no special characters.`
+          });
+          return;
+        }
+        const id2 = generateId();
+        const assignmentDir2 = resolve12(assignmentsDir, id2);
+        if (await fileExists(assignmentDir2)) {
+          res.status(500).json({ error: "UUID collision \u2014 try again" });
+          return;
+        }
+        const timestamp2 = fields.created || nowTimestamp();
+        await ensureDir(assignmentDir2);
+        const normalizedContent = setTopLevelField(rawContent, "id", id2);
+        await writeFileForce(resolve12(assignmentDir2, "assignment.md"), normalizedContent);
+        await writeFileForce(
+          resolve12(assignmentDir2, "scratchpad.md"),
+          renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve12(assignmentDir2, "handoff.md"),
+          renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve12(assignmentDir2, "decision-record.md"),
+          renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve12(assignmentDir2, "progress.md"),
+          renderProgress({ assignment: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve12(assignmentDir2, "comments.md"),
+          renderComments({ assignment: id2, timestamp: timestamp2 })
+        );
+        const detail2 = await getAssignmentDetailById(projectsDir, assignmentsDir, id2);
+        res.status(201).json({ assignment: detail2 });
+        return;
+      }
       const { title, slug, priority, type } = req.body || {};
       if (!title || typeof title !== "string" || !title.trim()) {
         res.status(400).json({ error: "title is required" });
@@ -5727,7 +6060,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve11(assignmentsDir, id);
+      const assignmentDir = resolve12(assignmentsDir, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -5747,25 +6080,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve11(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve12(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve11(assignmentDir, "scratchpad.md"),
+        resolve12(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve11(assignmentDir, "handoff.md"),
+        resolve12(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve11(assignmentDir, "decision-record.md"),
+        resolve12(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve11(assignmentDir, "progress.md"),
+        resolve12(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve11(assignmentDir, "comments.md"),
+        resolve12(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       const detail = await getAssignmentDetailById(projectsDir, assignmentsDir, id);
@@ -5893,7 +6226,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve12(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -5935,7 +6268,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve11(resolved.assignmentDir, "plan.md");
+      const planPath = resolve12(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -5969,7 +6302,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve11(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve12(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -6003,7 +6336,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve11(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve12(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -6043,7 +6376,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve11(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve12(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -6083,7 +6416,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve12(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -6095,7 +6428,7 @@ ${entry}`;
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}.` });
         return;
       }
-      let content = await readFile9(assignmentPath, "utf-8");
+      let content = await readFile10(assignmentPath, "utf-8");
       content = setTopLevelField(content, "status", status);
       content = setTopLevelField(content, "updated", nowTimestamp());
       if (status !== "blocked") {
@@ -6121,7 +6454,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve11(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve12(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -6186,7 +6519,7 @@ function slugifyLocal(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "untitled";
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(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" });
@@ -6198,7 +6531,7 @@ async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDet
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile9(commentsPath, "utf-8");
+    currentContent = await readFile10(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -6228,7 +6561,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloadDetail) {
-  const commentsPath = resolve11(assignmentDir, "comments.md");
+  const commentsPath = resolve12(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -6238,7 +6571,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req, res, reloa
     res.status(400).json({ error: "resolved (boolean) is required" });
     return;
   }
-  const content = await readFile9(commentsPath, "utf-8");
+  const content = await readFile10(commentsPath, "utf-8");
   const parsed = parseComments(content);
   const target = parsed.entries.find((e) => e.id === commentId);
   if (!target) {
@@ -6383,7 +6716,7 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir) {
 
 // src/dashboard/api-agent-sessions.ts
 import { Router as Router3 } from "express";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 init_fs();
 function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
   const router = Router3();
@@ -6400,7 +6733,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
     try {
       const { projectSlug } = req.params;
       const assignment = req.query.assignment;
-      const projectDir = resolve12(projectsDir, projectSlug);
+      const projectDir = resolve13(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -6426,7 +6759,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir) {
         return;
       }
       if (projectSlug) {
-        const projectDir = resolve12(projectsDir, projectSlug);
+        const projectDir = resolve13(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -6498,53 +6831,7 @@ import { resolve as resolve14 } from "path";
 import { readFile as readFile11, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
-
-// src/utils/playbooks.ts
-init_fs();
-init_parser();
-init_timestamp();
-import { resolve as resolve13 } from "path";
-import { readdir as readdir7, readFile as readFile10 } from "fs/promises";
-async function rebuildPlaybookManifest(playbooksDir2) {
-  if (!await fileExists(playbooksDir2)) return;
-  const entries = await readdir7(playbooksDir2, { withFileTypes: true });
-  const rows = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const raw = await readFile10(resolve13(playbooksDir2, entry.name), "utf-8");
-    const parsed = parsePlaybook(raw);
-    const slug = parsed.slug || entry.name.replace(/\.md$/, "");
-    rows.push({
-      name: parsed.name || slug,
-      slug,
-      description: parsed.description,
-      whenToUse: parsed.whenToUse
-    });
-  }
-  rows.sort((a, b) => a.name.localeCompare(b.name));
-  const timestamp = nowTimestamp();
-  const lines = [
-    "---",
-    `generated: "${timestamp}"`,
-    `total: ${rows.length}`,
-    "---",
-    "",
-    "# Playbooks",
-    "",
-    "Behavioral rules for AI agents. Read and follow all playbooks before starting work.",
-    ""
-  ];
-  for (const row of rows) {
-    lines.push(`- **[${row.name}](${row.slug}.md)** \u2014 ${row.description}`);
-    if (row.whenToUse) {
-      lines.push(`  _When to use: ${row.whenToUse}_`);
-    }
-  }
-  lines.push("");
-  await writeFileForce(resolve13(playbooksDir2, "manifest.md"), lines.join("\n"));
-}
-
-// src/dashboard/api-playbooks.ts
+init_playbooks();
 function createPlaybooksRouter(playbooksDir2) {
   const router = Router4();
   router.get("/", async (_req, res) => {
@@ -6568,6 +6855,32 @@ function createPlaybooksRouter(playbooksDir2) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get template" });
     }
   });
+  router.post("/:slug/enable", async (req, res) => {
+    try {
+      const result = await setPlaybookEnabled(playbooksDir2, req.params.slug, true);
+      res.json({ slug: result.slug, enabled: result.enabled, changed: result.changed });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Failed to enable playbook";
+      if (msg.startsWith("Playbook ")) {
+        res.status(404).json({ error: msg });
+        return;
+      }
+      res.status(500).json({ error: msg });
+    }
+  });
+  router.post("/:slug/disable", async (req, res) => {
+    try {
+      const result = await setPlaybookEnabled(playbooksDir2, req.params.slug, false);
+      res.json({ slug: result.slug, enabled: result.enabled, changed: result.changed });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Failed to disable playbook";
+      if (msg.startsWith("Playbook ")) {
+        res.status(404).json({ error: msg });
+        return;
+      }
+      res.status(500).json({ error: msg });
+    }
+  });
   router.get("/:slug", async (req, res) => {
     try {
       const detail = await getPlaybookDetail(playbooksDir2, req.params.slug);
@@ -6582,17 +6895,18 @@ function createPlaybooksRouter(playbooksDir2) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir2, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve14(playbooksDir2, resolved.filename);
       const content = await readFile11(filePath, "utf-8");
       res.json({
         documentType: "playbook",
-        title: `Edit Playbook: ${req.params.slug}`,
+        title: `Edit Playbook: ${resolved.slug}`,
         content,
-        slug: req.params.slug
+        slug: resolved.slug
       });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get playbook for editing" });
@@ -6631,14 +6945,15 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir2, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve14(playbooksDir2, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir2);
-      res.json({ slug: req.params.slug, path: filePath });
+      res.json({ slug: resolved.slug, path: filePath });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to update playbook" });
     }
@@ -6649,14 +6964,16 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve14(playbooksDir2, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir2, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve14(playbooksDir2, resolved.filename);
       await unlink2(filePath);
+      await removeFromDisabledList(resolved.slug);
       await rebuildPlaybookManifest(playbooksDir2);
-      res.json({ deleted: req.params.slug });
+      res.json({ deleted: resolved.slug });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to delete playbook" });
     }
@@ -6680,14 +6997,17 @@ function getWorkspaceParam(value) {
   return value ?? "";
 }
 var writeLocks = /* @__PURE__ */ new Map();
-function withLock(workspace, fn) {
-  const prev = writeLocks.get(workspace) ?? Promise.resolve();
+function withLock(lockKey, fn) {
+  const prev = writeLocks.get(lockKey) ?? Promise.resolve();
   const next = prev.then(fn);
-  writeLocks.set(workspace, next.then(() => {
+  writeLocks.set(lockKey, next.then(() => {
   }, () => {
   }));
   return next;
 }
+function wsLock(workspace, fn) {
+  return withLock(`ws:${workspace}`, fn);
+}
 function createTodosRouter(todosDir2, broadcast) {
   const router = Router5();
   function broadcastUpdate() {
@@ -6746,7 +7066,7 @@ function createTodosRouter(todosDir2, broadcast) {
         res.status(400).json({ error: "description is required" });
         return;
       }
-      const item = await withLock(workspace, async () => {
+      const item = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const existingIds = new Set(checklist.items.map((i) => i.id));
         const id = generateUniqueId(existingIds);
@@ -6775,7 +7095,7 @@ function createTodosRouter(todosDir2, broadcast) {
         res.status(400).json({ error: "ids must be an array of strings" });
         return;
       }
-      const items = await withLock(workspace, async () => {
+      const items = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
         const reordered = [];
@@ -6810,8 +7130,8 @@ function createTodosRouter(todosDir2, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve18 } = await import("path");
-      const { readFile: readFile14 } = await import("fs/promises");
+      const { resolve: resolve19 } = await import("path");
+      const { readFile: readFile15 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -6827,10 +7147,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve18(todosDir2, "archive"));
+      await ensureDir(resolve19(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile14(archFile, "utf-8");
+        archContent = await readFile15(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -6899,7 +7219,7 @@ workspace: ${workspace}
   router.patch("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -6921,7 +7241,7 @@ workspace: ${workspace}
   router.delete("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const deleted = await withLock(workspace, async () => {
+      const deleted = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const idx = checklist.items.findIndex((i) => i.id === req.params.id);
         if (idx === -1) return false;
@@ -6942,7 +7262,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/start", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return { error: "not_found" };
@@ -6969,7 +7289,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/complete", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7003,7 +7323,7 @@ workspace: ${workspace}
     try {
       const reason = req.body.reason || null;
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7036,7 +7356,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/reopen", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7058,7 +7378,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/unblock", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7080,18 +7400,615 @@ workspace: ${workspace}
   return router;
 }
 
-// src/dashboard/api-backup.ts
-init_config2();
-import { Router as Router6 } from "express";
-
-// src/utils/github-backup.ts
-init_paths();
+// src/dashboard/api-project-todos.ts
+init_parser2();
 init_fs();
-init_config2();
+init_paths();
+import { Router as Router6 } from "express";
+import { mkdir as mkdir2, readFile as readFile13 } from "fs/promises";
+import { resolve as resolve16 } from "path";
+var writeLocks2 = /* @__PURE__ */ new Map();
+function projLock(slug, fn) {
+  const key = `proj:${slug}`;
+  const prev = writeLocks2.get(key) ?? Promise.resolve();
+  const next = prev.then(fn);
+  writeLocks2.set(key, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+function getProjectIdParam(value) {
+  if (Array.isArray(value)) return value[0] ?? "";
+  return value ?? "";
+}
+function params(req) {
+  return req.params;
+}
+async function projectExists(projectsDir, slug) {
+  return fileExists(resolve16(projectsDir, slug, "project.md"));
+}
+async function ensureProjectTodosDir(projectsDir, slug) {
+  const todosDir2 = projectTodosDir(projectsDir, slug);
+  try {
+    await mkdir2(todosDir2, { recursive: false });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err;
+  }
+  try {
+    await mkdir2(resolve16(todosDir2, "archive"), { recursive: false });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err;
+  }
+}
+function notFound(res, slug) {
+  res.status(404).json({ error: `Project "${slug}" not found` });
+}
+function createProjectTodosRouter(projectsDir, broadcast) {
+  const router = Router6({ mergeParams: true });
+  function broadcastUpdate(projectSlug) {
+    broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  function validateProjectId(req, res, next) {
+    const slug = getProjectIdParam(params(req).projectId);
+    if (!slug || !isValidSlug(slug)) {
+      res.status(400).json({ error: `Invalid project slug: "${slug}"` });
+      return;
+    }
+    next();
+  }
+  router.use(validateProjectId);
+  router.get("/", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      res.json({
+        workspace: checklist.workspace,
+        archiveInterval: checklist.archiveInterval,
+        items: checklist.items,
+        counts: computeCounts(checklist.items)
+      });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todos" });
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const { description, tags } = req.body;
+      if (!description || typeof description !== "string") {
+        res.status(400).json({ error: "description is required" });
+        return;
+      }
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const item = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return null;
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const existingIds = new Set(checklist.items.map((i) => i.id));
+        const id = generateUniqueId(existingIds);
+        const newItem = {
+          id,
+          description,
+          status: "open",
+          tags: Array.isArray(tags) ? tags : [],
+          session: null
+        };
+        checklist.workspace = slug;
+        checklist.items.push(newItem);
+        await writeChecklist(todosDir2, checklist);
+        return newItem;
+      });
+      if (!item) {
+        notFound(res, slug);
+        return;
+      }
+      broadcastUpdate(slug);
+      res.status(201).json(item);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to add todo" });
+    }
+  });
+  router.post("/reorder", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const { ids } = req.body;
+      if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string")) {
+        res.status(400).json({ error: "ids must be an array of strings" });
+        return;
+      }
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const items = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return null;
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
+        const reordered = [];
+        for (const id of ids) {
+          const item = itemMap.get(id);
+          if (item) {
+            reordered.push(item);
+            itemMap.delete(id);
+          }
+        }
+        for (const item of itemMap.values()) reordered.push(item);
+        checklist.workspace = slug;
+        checklist.items = reordered;
+        await writeChecklist(todosDir2, checklist);
+        return reordered;
+      });
+      if (!items) {
+        notFound(res, slug);
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json({ items });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to reorder todos" });
+    }
+  });
+  router.get("/log", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const log = await readLog(todosDir2, slug);
+      res.json(log);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
+    }
+  });
+  router.post("/archive", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      await ensureProjectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      const log = await readLog(todosDir2, slug);
+      const completedIds = new Set(
+        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+      );
+      if (completedIds.size === 0) {
+        res.json({ archived: 0, message: "No completed items to archive" });
+        return;
+      }
+      const toArchive = log.entries.filter(
+        (e) => e.itemIds.every((id) => completedIds.has(id))
+      );
+      const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
+      let archContent = "";
+      if (await fileExists(archFile)) {
+        archContent = await readFile13(archFile, "utf-8");
+        archContent = archContent.trimEnd() + "\n\n";
+      } else {
+        archContent = `---
+workspace: ${slug}
+---
+
+# Archive
+
+`;
+      }
+      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+      for (const item of completedItems) {
+        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+`;
+      }
+      archContent += "\n";
+      for (const entry of toArchive) {
+        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+`;
+        if (entry.items) archContent += `**Items:** ${entry.items}
+`;
+        if (entry.session) archContent += `**Session:** ${entry.session}
+`;
+        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+`;
+        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+`;
+        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+`;
+        archContent += "\n";
+      }
+      await writeFileForce(archFile, archContent);
+      checklist.workspace = slug;
+      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+      await writeChecklist(todosDir2, checklist);
+      broadcastUpdate(slug);
+      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to archive" });
+    }
+  });
+  router.get("/log/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const log = await readLog(todosDir2, slug);
+      const entries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
+      res.json({ workspace: log.workspace, entries });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+      if (!item) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      const log = await readLog(todosDir2, slug);
+      const logEntries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
+      res.json({ ...item, log: logEntries });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
+    }
+  });
+  router.patch("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        if (req.body.description !== void 0) item.description = req.body.description;
+        if (Array.isArray(req.body.tags)) item.tags = req.body.tags;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to update todo" });
+    }
+  });
+  router.delete("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const deleted = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const idx = checklist.items.findIndex((i) => i.id === (params(req).id ?? ""));
+        if (idx === -1) return false;
+        checklist.items.splice(idx, 1);
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return true;
+      });
+      if (deleted === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!deleted) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json({ deleted: params(req).id ?? "" });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to delete todo" });
+    }
+  });
+  router.post("/:id/start", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return { error: "gone" };
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return { error: "not_found" };
+        if (item.status === "in_progress") return { error: "conflict", session: item.session };
+        item.status = "in_progress";
+        item.session = req.body.session || null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { item: { ...item } };
+      });
+      if ("error" in result) {
+        if (result.error === "gone") {
+          notFound(res, slug);
+          return;
+        }
+        if (result.error === "not_found") {
+          res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+          return;
+        }
+        res.status(409).json({ error: `Todo is already in progress (session: ${result.session})` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result.item);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to start todo" });
+    }
+  });
+  router.post("/:id/complete", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "completed";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        const entry = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          itemIds: [item.id],
+          items: item.description,
+          session: req.body.session || null,
+          branch: req.body.branch || null,
+          summary: req.body.summary || "Completed.",
+          blockers: null,
+          status: null
+        };
+        await appendLogEntry2(todosDir2, slug, entry);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to complete todo" });
+    }
+  });
+  router.post("/:id/block", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const reason = req.body.reason || null;
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "blocked";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        const entry = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          itemIds: [item.id],
+          items: item.description,
+          session: req.body.session || null,
+          branch: null,
+          summary: reason || "Blocked.",
+          blockers: reason,
+          status: "blocked"
+        };
+        await appendLogEntry2(todosDir2, slug, entry);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to block todo" });
+    }
+  });
+  router.post("/:id/reopen", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "open";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to reopen todo" });
+    }
+  });
+  router.post("/:id/unblock", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "open";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to unblock todo" });
+    }
+  });
+  return router;
+}
+
+// src/dashboard/api-backup.ts
+init_config2();
+import { Router as Router7 } from "express";
+
+// src/utils/github-backup.ts
+init_paths();
+init_fs();
+init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile13, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
-import { resolve as resolve16, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile14, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve17, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -7131,7 +8048,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve16(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve17(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -7142,7 +8059,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -7151,7 +8068,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile14(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -7189,7 +8106,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve16(dest, ".."));
+    await ensureDir(resolve17(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -7198,7 +8115,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile13(configPath, "utf-8");
+  const content = await readFile14(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -7237,7 +8154,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve16(destPath, ".."));
+        await ensureDir(resolve17(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -7291,7 +8208,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve16(localPath, ".."));
+    await ensureDir(resolve17(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -7392,7 +8309,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -7405,7 +8322,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router6();
+  const router = Router7();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -7729,7 +8646,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve17(syntaurRoot(), "config.md")
+        resolve18(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -7836,7 +8753,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/workspaces", async (_req, res) => {
     try {
-      const result = await listWorkspaces(projectsDir);
+      const result = await listWorkspaces(projectsDir, assignmentsDir);
       res.json(result);
     } catch (error) {
       console.error("Error listing workspaces:", error);
@@ -7953,18 +8870,28 @@ function createDashboardServer(options) {
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
+  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir, broadcast));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
-    app.use(express.static(dashboardDistPath));
-    app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve17(dashboardDistPath, "index.html");
-      if (await fileExists(indexPath)) {
-        res.sendFile(indexPath);
-      } else {
+    app.use("/assets", express.static(resolve18(dashboardDistPath, "assets")));
+    app.get("{*path}", async (req, res) => {
+      if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
+        res.status(404).json({ error: "Not Found" });
+        return;
+      }
+      const indexPath = resolve18(dashboardDistPath, "index.html");
+      if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
         );
+        return;
       }
+      res.sendFile(indexPath, (err) => {
+        if (err) {
+          console.error("Error sending dashboard index.html:", err);
+          if (!res.headersSent) res.status(500).send("Dashboard load error");
+        }
+      });
     });
   }
   let watcherHandle = null;
@@ -7990,7 +8917,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve17(syntaurRoot(), "dashboard-port");
+          const portFile = resolve18(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -8007,7 +8934,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve17(syntaurRoot(), "dashboard-port");
+      const portFile = resolve18(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();