syntaur 0.4.4 → 0.4.5

package/dist/dashboard/server.js

@@ -622,6 +622,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 +795,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 +1012,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 +1022,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 +1031,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 +1063,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 +1092,10 @@ var init_config2 = __esm({
       },
       backup: null,
       statuses: null,
-      types: null
+      types: null,
+      playbooks: {
+        disabled: []
+      }
     };
     migratedConfigPaths = /* @__PURE__ */ new Set();
   }
@@ -1128,6 +1230,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 +1387,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 +1916,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 +1994,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 +2043,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 +2094,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 +2103,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 +2115,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 +2132,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 +2164,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 +2260,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 +2274,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 +2303,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 +2556,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 +2638,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 +2648,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 +2666,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 +2821,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 +2856,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 +2880,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 +2896,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 +2931,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 +2950,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 +2960,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 +2971,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 +2982,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 +2993,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 +3109,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 +3142,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 +3210,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 +3289,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 +3329,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 +3376,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 +3402,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 +3504,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 +3534,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 +3694,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 +3704,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 +3725,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 +3762,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 +3779,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 +3810,7 @@ var init_api = __esm({
     init_lifecycle();
     init_fs();
     init_config2();
+    init_playbooks();
     init_fs_migration();
     init_assignment_resolver();
     init_parser();
@@ -3928,15 +4168,15 @@ 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 +4203,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 +4300,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);
@@ -4198,13 +4438,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 +4462,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);
     }
@@ -4442,8 +4682,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) {
@@ -4585,12 +4825,25 @@ function renderAssignment(params) {
   const linksYaml = params.links.length === 0 ? "links: []" : `links:
   - ${params.links.join("\n  - ")}`;
   const projectYaml = `project: ${params.project == null ? "null" : params.project}`;
+  const workspaceGroupLine = params.workspaceGroup ? `
+workspaceGroup: ${params.workspaceGroup}` : "";
   const typeYaml = `type: ${params.type ?? "feature"}`;
+  const todosSection = params.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}
 title: ${safeTitle}
-${projectYaml}
+${projectYaml}${workspaceGroupLine}
 ${typeYaml}
 status: pending
 priority: ${params.priority}
@@ -4621,17 +4874,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. -->
 
@@ -4966,7 +5209,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 +5222,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 +5238,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 +5349,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 +5389,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 +5420,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 +5429,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 +5455,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 +5488,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 +5531,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 +5567,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 +5605,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 +5643,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 +5681,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 +5719,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 +5737,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 +5778,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 +5794,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 +5829,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 +5839,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 +5853,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 +5865,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 +5880,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 +5898,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 +5923,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 +5950,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 +5969,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 +6050,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 +6070,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 +6216,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 +6258,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 +6292,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 +6326,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 +6366,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 +6406,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 +6418,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 +6444,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 +6509,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 +6521,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 +6551,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 +6561,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 +6706,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 +6723,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 +6749,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 +6821,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 +6845,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 +6885,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 +6935,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 +6954,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" });
     }
@@ -7836,7 +8143,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);
@@ -7955,16 +8262,25 @@ function createDashboardServer(options) {
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
-    app.use(express.static(dashboardDistPath));
-    app.get("{*path}", async (_req, res) => {
+    app.use("/assets", express.static(resolve17(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 = resolve17(dashboardDistPath, "index.html");
-      if (await fileExists(indexPath)) {
-        res.sendFile(indexPath);
-      } else {
+      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;