syntaur 0.4.4 → 0.5.0

package/dist/index.js

@@ -39,6 +39,9 @@ function playbooksDir() {
 function todosDir() {
   return resolve(syntaurRoot(), "todos");
 }
+function projectTodosDir(projectsDir2, projectSlug) {
+  return resolve(projectsDir2, projectSlug, "todos");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -91,10 +94,10 @@ var init_fs = __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:
@@ -247,6 +250,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",
@@ -414,8 +418,8 @@ var init_timestamp = __esm({
 });
 
 // src/utils/fs-migration.ts
-import { readdir as readdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve4 } from "path";
+import { readdir, readFile, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
 async function migrateLegacyProjectFiles(projectsDir2) {
   const result = {
     renamedProjectFiles: [],
@@ -424,15 +428,15 @@ async function migrateLegacyProjectFiles(projectsDir2) {
   if (!await fileExists(projectsDir2)) return result;
   let entries;
   try {
-    entries = await readdir3(projectsDir2, { withFileTypes: true });
+    entries = await readdir(projectsDir2, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const projectDir = resolve4(projectsDir2, entry.name);
-    const legacy = resolve4(projectDir, "mission.md");
-    const target = resolve4(projectDir, "project.md");
+    const projectDir = resolve2(projectsDir2, entry.name);
+    const legacy = resolve2(projectDir, "mission.md");
+    const target = resolve2(projectDir, "project.md");
     try {
       if (await fileExists(legacy) && !await fileExists(target)) {
         await rename2(legacy, target);
@@ -443,7 +447,7 @@ async function migrateLegacyProjectFiles(projectsDir2) {
     }
     for (const stale of ["agent.md", "claude.md"]) {
       try {
-        if (await fileExists(resolve4(projectDir, stale))) {
+        if (await fileExists(resolve2(projectDir, stale))) {
           result.legacyExtras.push(`${entry.name}/${stale}`);
         }
       } catch {
@@ -461,7 +465,7 @@ async function migrateLegacyConfig(configPath) {
   if (!await fileExists(configPath)) return result;
   let content;
   try {
-    content = await readFile3(configPath, "utf-8");
+    content = await readFile(configPath, "utf-8");
   } catch {
     return result;
   }
@@ -490,7 +494,7 @@ async function migrateLegacyConfig(configPath) {
   const projectLineRe = /^\s*defaultProjectDir\s*:\s*(.*)$/m;
   const projectLineMatch = newFmBlock.match(projectLineRe);
   const projectsDirRaw = projectLineMatch ? projectLineMatch[1].trim().replace(/^['"]|['"]$/g, "") : missionValue;
-  const expand = (p) => p.startsWith("~") ? resolve4(process.env.HOME ?? "/", p.slice(p.startsWith("~/") ? 2 : 1)) : p;
+  const expand = (p) => p.startsWith("~") ? resolve2(process.env.HOME ?? "/", p.slice(p.startsWith("~/") ? 2 : 1)) : p;
   let resolvedProjectsDir = projectsDirRaw ? expand(projectsDirRaw) : null;
   if (resolvedProjectsDir && resolvedProjectsDir.endsWith("/missions")) {
     const siblingProjectsDir = resolvedProjectsDir.replace(/\/missions$/, "/projects");
@@ -549,8 +553,29 @@ var init_fs_migration = __esm({
 });
 
 // src/utils/config.ts
-import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve5, isAbsolute } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve3, 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 {};
@@ -722,6 +747,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 = resolve3(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 readFile2(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) {
@@ -756,10 +857,10 @@ function parseOptionalAbsolutePath(value, fieldName) {
     );
     return null;
   }
-  return resolve5(expanded);
+  return resolve3(expanded);
 }
 async function writeStatusConfig(statuses) {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   const statusBlock = serializeStatusConfig(statuses);
   if (!await fileExists(configPath)) {
     const content = `---
@@ -771,7 +872,7 @@ ${statusBlock}
     await writeFileForce(configPath, content);
     return;
   }
-  const existing = await readFile4(configPath, "utf-8");
+  const existing = await readFile2(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -813,9 +914,9 @@ ${statusBlock}
   await writeFileForce(configPath, newContent);
 }
 async function deleteStatusConfig() {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return;
-  const existing = await readFile4(configPath, "utf-8");
+  const existing = await readFile2(configPath, "utf-8");
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) return;
   const fmBlock = fmMatch[2];
@@ -827,13 +928,13 @@ ${cleanedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateIntegrationConfig(integrations) {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   const nextIntegrations = {
     ...(await readConfig()).integrations,
     ...integrations
   };
   const integrationBlock = serializeIntegrationConfig(nextIntegrations);
-  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -857,13 +958,13 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateOnboardingConfig(onboarding) {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   const nextOnboarding = {
     ...(await readConfig()).onboarding,
     ...onboarding
   };
   const onboardingBlock = serializeOnboardingConfig(nextOnboarding);
-  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -887,7 +988,7 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function updateBackupConfig(backup) {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   const current = (await readConfig()).backup;
   const nextBackup = {
     repo: current?.repo ?? null,
@@ -897,7 +998,7 @@ async function updateBackupConfig(backup) {
     ...backup
   };
   const backupBlock = serializeBackupConfig(nextBackup);
-  const existing = await fileExists(configPath) ? await readFile4(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
   const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
   if (!fmMatch) {
     const content = `---
@@ -921,19 +1022,19 @@ ${normalizedFm}
   await writeFileForce(configPath, newContent);
 }
 async function readConfig() {
-  const configPath = resolve5(syntaurRoot(), "config.md");
+  const configPath = resolve3(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
-    return { ...DEFAULT_CONFIG };
+    return cloneDefaultConfig();
   }
   if (!migratedConfigPaths.has(configPath)) {
     migratedConfigPaths.add(configPath);
     await migrateLegacyConfig(configPath);
   }
-  const content = await readFile4(configPath, "utf-8");
+  const content = await readFile2(configPath, "utf-8");
   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)) {
@@ -942,6 +1043,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,
@@ -973,7 +1075,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;
@@ -1001,12 +1104,119 @@ var init_config2 = __esm({
       },
       backup: null,
       statuses: null,
-      types: null
+      types: null,
+      playbooks: {
+        disabled: []
+      }
     };
     migratedConfigPaths = /* @__PURE__ */ new Set();
   }
 });
 
+// src/utils/playbooks.ts
+import { resolve as resolve4 } from "path";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+function isVisiblePlaybookFile(name, isFile) {
+  return isFile && name.endsWith(".md") && !name.startsWith("_") && name !== "manifest.md";
+}
+async function resolvePlaybookSlug(playbooksDir3, slug) {
+  if (!await fileExists(playbooksDir3)) return null;
+  const entries = await readdir2(playbooksDir3, { withFileTypes: true });
+  let filenameStemFallback = null;
+  for (const entry of entries) {
+    if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
+    const filePath = resolve4(playbooksDir3, entry.name);
+    const raw = await readFile3(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(playbooksDir3, slug, enabled) {
+  const resolved = await resolvePlaybookSlug(playbooksDir3, slug);
+  if (!resolved) {
+    throw new Error(`Playbook "${slug}" not found in ${playbooksDir3}`);
+  }
+  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(playbooksDir3);
+  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(playbooksDir3) {
+  if (!await fileExists(playbooksDir3)) return;
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
+  const entries = await readdir2(playbooksDir3, { withFileTypes: true });
+  const rows = [];
+  for (const entry of entries) {
+    if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
+    const raw = await readFile3(resolve4(playbooksDir3, 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(resolve4(playbooksDir3, "manifest.md"), lines.join("\n"));
+}
+var init_playbooks = __esm({
+  "src/utils/playbooks.ts"() {
+    "use strict";
+    init_fs();
+    init_parser();
+    init_timestamp();
+    init_config2();
+  }
+});
+
 // src/lifecycle/types.ts
 var DEFAULT_STATUSES, DEFAULT_TERMINAL_STATUSES;
 var init_types = __esm({
@@ -1409,12 +1619,20 @@ async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
   const standaloneDir = resolve9(assignmentsDir2, id);
   const standalonePath = resolve9(standaloneDir, "assignment.md");
   if (await fileExists(standalonePath)) {
+    let workspaceGroup = null;
+    try {
+      const content = await readFile6(standalonePath, "utf-8");
+      const [fm] = extractFrontmatter(content);
+      workspaceGroup = getField(fm, "workspaceGroup");
+    } catch {
+    }
     standaloneMatch = {
       assignmentDir: standaloneDir,
       projectSlug: null,
       assignmentSlug: id,
       id,
-      standalone: true
+      standalone: true,
+      workspaceGroup
     };
   }
   if (await fileExists(projectsDir2)) {
@@ -1440,7 +1658,8 @@ async function resolveAssignmentById(projectsDir2, assignmentsDir2, id) {
                 projectSlug: p.name,
                 assignmentSlug: a.name,
                 id,
-                standalone: false
+                standalone: false,
+                workspaceGroup: null
               };
               break;
             }
@@ -1816,8 +2035,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 = [
@@ -2541,10 +2770,11 @@ async function writeWorkspaceRegistry(projectsDir2, workspaces) {
   const registryPath = resolve12(dirname3(projectsDir2), "workspaces.json");
   await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
-async function listWorkspaces(projectsDir2) {
-  const [projectRecords, registered] = await Promise.all([
+async function listWorkspaces(projectsDir2, assignmentsDir2) {
+  const [projectRecords, registered, standaloneRecords] = await Promise.all([
     listProjectRecords(projectsDir2),
-    readWorkspaceRegistry(projectsDir2)
+    readWorkspaceRegistry(projectsDir2),
+    listStandaloneRecords(assignmentsDir2)
   ]);
   const workspaceSet = new Set(registered);
   let hasUngrouped = false;
@@ -2555,6 +2785,13 @@ async function listWorkspaces(projectsDir2) {
       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 };
 }
@@ -2703,7 +2940,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)
   };
 }
@@ -3644,6 +3881,8 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
 }
 async function listPlaybooks(playbooksDir3) {
   if (!await fileExists(playbooksDir3)) return [];
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
   const entries = await readdir7(playbooksDir3, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
@@ -3659,25 +3898,28 @@ async function listPlaybooks(playbooksDir3) {
       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(playbooksDir3, slug) {
-  const filePath = resolve12(playbooksDir3, `${slug}.md`);
-  if (!await fileExists(filePath)) return null;
-  const raw = await readFile9(filePath, "utf-8");
-  const parsed = parsePlaybook(raw);
+  const resolved = await resolvePlaybookSlug(playbooksDir3, 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;
@@ -3687,6 +3929,7 @@ var init_api = __esm({
     init_lifecycle();
     init_fs();
     init_config2();
+    init_playbooks();
     init_fs_migration();
     init_assignment_resolver();
     init_parser();
@@ -4546,8 +4789,8 @@ __export(launch_exports, {
   launchAgent: () => launchAgent
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile9 } from "fs/promises";
-import { resolve as resolve31 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
+import { resolve as resolve32 } from "path";
 async function launchAgent(options) {
   const { projectsDir: projectsDir2, projectSlug, assignmentSlug, agent } = options;
   const command = AGENT_COMMANDS[agent];
@@ -4557,10 +4800,10 @@ async function launchAgent(options) {
     process.exit(1);
   }
   const workspaceDir = detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null) ?? process.cwd();
-  const projectDir = resolve31(projectsDir2, projectSlug);
-  const assignmentDir = resolve31(projectDir, "assignments", assignmentSlug);
-  const contextDir = resolve31(workspaceDir, ".syntaur");
-  await mkdir4(contextDir, { recursive: true });
+  const projectDir = resolve32(projectsDir2, projectSlug);
+  const assignmentDir = resolve32(projectDir, "assignments", assignmentSlug);
+  const contextDir = resolve32(workspaceDir, ".syntaur");
+  await mkdir5(contextDir, { recursive: true });
   const context = {
     projectSlug,
     assignmentSlug,
@@ -4572,7 +4815,7 @@ async function launchAgent(options) {
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFile9(
-    resolve31(contextDir, "context.json"),
+    resolve32(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   return new Promise((resolvePromise, reject) => {
@@ -4613,62 +4856,16 @@ import { Command as Command4 } from "commander";
 init_paths();
 init_fs();
 init_config();
-import { resolve as resolve3, dirname as dirname2 } from "path";
-import { readdir as readdir2, readFile as readFile2 } from "fs/promises";
+init_playbooks();
+import { resolve as resolve5, dirname as dirname2 } from "path";
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
 import { fileURLToPath } from "url";
-
-// src/utils/playbooks.ts
-init_fs();
-init_parser();
-init_timestamp();
-import { resolve as resolve2 } from "path";
-import { readdir, readFile } from "fs/promises";
-async function rebuildPlaybookManifest(playbooksDir3) {
-  if (!await fileExists(playbooksDir3)) return;
-  const entries = await readdir(playbooksDir3, { 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 readFile(resolve2(playbooksDir3, 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(resolve2(playbooksDir3, "manifest.md"), lines.join("\n"));
-}
-
-// src/commands/init.ts
 async function initCommand(options) {
   const root = syntaurRoot();
   const projectsDir2 = defaultProjectDir();
   const standaloneAssignmentsDir = assignmentsDir();
-  const configPath = resolve3(root, "config.md");
-  const playbooksDir3 = resolve3(root, "playbooks");
+  const configPath = resolve5(root, "config.md");
+  const playbooksDir3 = resolve5(root, "playbooks");
   await ensureDir(root);
   await ensureDir(projectsDir2);
   await ensureDir(standaloneAssignmentsDir);
@@ -4704,16 +4901,16 @@ async function initCommand(options) {
 }
 async function seedDefaultPlaybooks(playbooksDir3) {
   const __filename = fileURLToPath(import.meta.url);
-  const packageRoot = resolve3(dirname2(__filename), "..");
-  const examplesDir = resolve3(packageRoot, "examples", "playbooks");
+  const packageRoot = resolve5(dirname2(__filename), "..");
+  const examplesDir = resolve5(packageRoot, "examples", "playbooks");
   if (!await fileExists(examplesDir)) return 0;
-  const entries = await readdir2(examplesDir, { withFileTypes: true });
+  const entries = await readdir3(examplesDir, { withFileTypes: true });
   let count = 0;
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const targetPath = resolve3(playbooksDir3, entry.name);
+    const targetPath = resolve5(playbooksDir3, entry.name);
     if (await fileExists(targetPath)) continue;
-    const content = await readFile2(resolve3(examplesDir, entry.name), "utf-8");
+    const content = await readFile4(resolve5(examplesDir, entry.name), "utf-8");
     await writeFileSafe(targetPath, content);
     count++;
   }
@@ -4749,14 +4946,14 @@ init_config2();
 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)
@@ -4783,24 +4980,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
 
@@ -4813,24 +5010,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}
@@ -4844,7 +5054,7 @@ workspace:
 tags: []
 ---
 
-# ${params.title}
+# ${params2.title}
 
 ## Objective
 
@@ -4856,17 +5066,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. -->
 
@@ -4881,10 +5081,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
@@ -4894,10 +5094,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
 ---
 
@@ -4908,12 +5108,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
@@ -4923,12 +5123,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
@@ -4956,10 +5156,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
 ---
 
@@ -4970,10 +5170,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
@@ -4990,10 +5190,10 @@ by_status:
 |------|-------|--------|----------|----------|--------------|---------|
 `;
 }
-function renderIndexPlans(params) {
+function renderIndexPlans(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
 # Plans
@@ -5002,10 +5202,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
@@ -5014,10 +5214,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
@@ -5033,7 +5233,7 @@ needsAttention:
   openQuestions: 0
 ---
 
-# Project Status: ${params.title}
+# Project Status: ${params2.title}
 
 **Status:** pending
 **Progress:** 0/0 assignments complete
@@ -5053,10 +5253,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
 ---
 
@@ -5066,10 +5266,10 @@ total: 0
 |------|----------|--------|---------------------|---------|
 `;
 }
-function renderMemoriesIndex(params) {
+function renderMemoriesIndex(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 ---
 
@@ -5081,19 +5281,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. -->
 `;
@@ -5236,58 +5436,58 @@ Follow the rules in each playbook. They take precedence over default conventions
 - Commit frequently with messages referencing the assignment slug.
 `;
 }
-function renderCursorAssignment(params) {
+function renderCursorAssignment(params2) {
   return `---
-description: Syntaur assignment context for ${params.projectSlug}/${params.assignmentSlug}
+description: Syntaur assignment context for ${params2.projectSlug}/${params2.assignmentSlug}
 globs:
 alwaysApply: true
 ---
 
 # Current Assignment Context
 
-- **Project:** ${params.projectSlug}
-- **Assignment:** ${params.assignmentSlug}
-- **Project directory:** ${params.projectDir}
-- **Assignment directory:** ${params.assignmentDir}
+- **Project:** ${params2.projectSlug}
+- **Assignment:** ${params2.assignmentSlug}
+- **Project directory:** ${params2.projectDir}
+- **Assignment directory:** ${params2.assignmentDir}
 
 ## Reading Order
 
 Before starting work, read these files in order:
-1. \`${params.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
-2. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
-3. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
-4. \`${params.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
-5. \`${params.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
-6. \`${params.assignmentDir}/handoff.md\` -- previous session handoff notes
+1. \`${params2.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+2. \`${params2.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+3. any \`${params2.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+4. \`${params2.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+5. \`${params2.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
+6. \`${params2.assignmentDir}/handoff.md\` -- previous session handoff notes
 
 ## Your Writable Files
 
 You may write directly to these files inside your assignment folder:
-- \`${params.assignmentDir}/assignment.md\`
-- \`${params.assignmentDir}/plan*.md\` (0 or more versioned plan files, e.g., \`plan.md\`, \`plan-v2.md\`)
-- \`${params.assignmentDir}/progress.md\` (append timestamped entries, newest first)
-- \`${params.assignmentDir}/scratchpad.md\`
-- \`${params.assignmentDir}/handoff.md\`
-- \`${params.assignmentDir}/decision-record.md\`
+- \`${params2.assignmentDir}/assignment.md\`
+- \`${params2.assignmentDir}/plan*.md\` (0 or more versioned plan files, e.g., \`plan.md\`, \`plan-v2.md\`)
+- \`${params2.assignmentDir}/progress.md\` (append timestamped entries, newest first)
+- \`${params2.assignmentDir}/scratchpad.md\`
+- \`${params2.assignmentDir}/handoff.md\`
+- \`${params2.assignmentDir}/decision-record.md\`
 
-Do NOT edit \`${params.assignmentDir}/comments.md\` directly \u2014 use \`syntaur comment\`. Do NOT edit other assignments' files \u2014 use \`syntaur request\` for cross-assignment todos.
+Do NOT edit \`${params2.assignmentDir}/comments.md\` directly \u2014 use \`syntaur comment\`. Do NOT edit other assignments' files \u2014 use \`syntaur request\` for cross-assignment todos.
 
 And source code files in your workspace. Read the \`workspace\` field from your assignment's frontmatter to determine the exact boundary. If not set, the current working directory is your workspace.
 `;
 }
 
 // src/templates/codex-agents.ts
-function renderCodexAgents(params) {
+function renderCodexAgents(params2) {
   return `# Syntaur Protocol -- Agent Instructions
 
 This project uses the Syntaur protocol for multi-agent project coordination.
 
 ## Current Assignment
 
-- **Project:** ${params.projectSlug}
-- **Assignment:** ${params.assignmentSlug}
-- **Project directory:** ${params.projectDir}
-- **Assignment directory:** ${params.assignmentDir}
+- **Project:** ${params2.projectSlug}
+- **Assignment:** ${params2.assignmentSlug}
+- **Project directory:** ${params2.projectDir}
+- **Assignment directory:** ${params2.assignmentDir}
 
 ## Preferred Workflow
 
@@ -5307,13 +5507,13 @@ If the plugin is unavailable, follow the same workflow manually with the \`synta
 ## Reading Order
 
 Before starting work, read these files in order:
-1. \`${params.projectDir}/manifest.md\` -- root navigation entry point (project-nested assignments only)
-2. \`${params.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
-3. \`${params.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter now includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
-4. any \`${params.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
-5. \`${params.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
-6. \`${params.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
-7. \`${params.assignmentDir}/handoff.md\` -- previous session handoff notes
+1. \`${params2.projectDir}/manifest.md\` -- root navigation entry point (project-nested assignments only)
+2. \`${params2.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+3. \`${params2.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter now includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+4. any \`${params2.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+5. \`${params2.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+6. \`${params2.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
+7. \`${params2.assignmentDir}/handoff.md\` -- previous session handoff notes
 
 ## Context File
 
@@ -5365,10 +5565,10 @@ Before starting work, read these files in order:
 ### Files you may WRITE:
 1. **Your assignment folder** -- only the assignment you are currently working on:
    - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`progress.md\`, \`scratchpad.md\`, \`handoff.md\`, \`decision-record.md\`
-   - Path: \`${params.assignmentDir}/\`
+   - Path: \`${params2.assignmentDir}/\`
 2. **Shared resources and memories** at the project level:
-   - \`${params.projectDir}/resources/<slug>.md\`
-   - \`${params.projectDir}/memories/<slug>.md\`
+   - \`${params2.projectDir}/resources/<slug>.md\`
+   - \`${params2.projectDir}/memories/<slug>.md\`
 3. **Your workspace** -- source code files in the current working directory (the directory where this AGENTS.md lives). If your assignment's frontmatter specifies a \`workspace\` field, read it at runtime to determine the exact boundary.
 
 > **Note:** Workspace boundaries are resolved by the agent at runtime by reading \`assignment.md\` frontmatter. If no \`workspace\` field is set, treat the current working directory as your workspace.
@@ -5413,15 +5613,15 @@ Before starting work, read these files in order:
 ## Lifecycle Commands
 
 Use the \`syntaur\` CLI for state transitions and coordination:
-- \`syntaur assign ${params.assignmentSlug} --agent <name> --project ${params.projectSlug}\` -- set assignee
-- \`syntaur start ${params.assignmentSlug} --project ${params.projectSlug}\` -- pending -> in_progress
-- \`syntaur review ${params.assignmentSlug} --project ${params.projectSlug}\` -- in_progress -> review
-- \`syntaur complete ${params.assignmentSlug} --project ${params.projectSlug}\` -- in_progress/review -> completed
-- \`syntaur block ${params.assignmentSlug} --project ${params.projectSlug} --reason <text>\` -- block
-- \`syntaur unblock ${params.assignmentSlug} --project ${params.projectSlug}\` -- unblock
-- \`syntaur fail ${params.assignmentSlug} --project ${params.projectSlug}\` -- mark as failed
-- \`syntaur comment ${params.assignmentSlug} "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (use for all Q&A; questions support resolve toggle)
-- \`syntaur request ${params.assignmentSlug} <target-slug-or-uuid> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: ${params.assignmentSlug})\`
+- \`syntaur assign ${params2.assignmentSlug} --agent <name> --project ${params2.projectSlug}\` -- set assignee
+- \`syntaur start ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- pending -> in_progress
+- \`syntaur review ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- in_progress -> review
+- \`syntaur complete ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- in_progress/review -> completed
+- \`syntaur block ${params2.assignmentSlug} --project ${params2.projectSlug} --reason <text>\` -- block
+- \`syntaur unblock ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- unblock
+- \`syntaur fail ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- mark as failed
+- \`syntaur comment ${params2.assignmentSlug} "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (use for all Q&A; questions support resolve toggle)
+- \`syntaur request ${params2.assignmentSlug} <target-slug-or-uuid> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: ${params2.assignmentSlug})\`
 
 ## Troubleshooting
 
@@ -5452,11 +5652,11 @@ Read each linked playbook and follow the rules in its body section. The \`when_t
 }
 
 // src/templates/opencode-config.ts
-function renderOpenCodeConfig(params) {
+function renderOpenCodeConfig(params2) {
   const config = {
     instructions: [
       `Read AGENTS.md in this directory for Syntaur protocol (v2.0) instructions.`,
-      `Read ${params.projectDir}/project.md for project overview (project-nested assignments only).`,
+      `Read ${params2.projectDir}/project.md for project overview (project-nested assignments only).`,
       `Append timestamped progress entries to the assignment's progress.md (not to assignment.md).`,
       `Use 'syntaur comment <slug-or-uuid> "body" --type question|note|feedback' to append to comments.md \u2014 never edit it directly.`,
       `Use 'syntaur request <source> <target> "text"' to append a todo to another assignment's ## Todos.`,
@@ -5552,6 +5752,14 @@ async function createAssignmentCommand(title, options) {
   if (!title.trim()) {
     throw new Error("Assignment title cannot be empty.");
   }
+  if (options.workspace && options.project) {
+    throw new Error(
+      "Cannot use --workspace with --project (projects already carry a workspace via project.workspace)."
+    );
+  }
+  if (options.workspace && !options.oneOff) {
+    throw new Error("--workspace requires --one-off.");
+  }
   if (!options.project && !options.oneOff) {
     throw new Error(
       "Either --project <slug> or --one-off is required."
@@ -5567,6 +5775,11 @@ async function createAssignmentCommand(title, options) {
       `Invalid project slug "${options.project}". Slugs must be lowercase, hyphen-separated, with no special characters.`
     );
   }
+  if (options.workspace && !isValidSlug(options.workspace)) {
+    throw new Error(
+      `Invalid workspace slug "${options.workspace}". Slugs must be lowercase, hyphen-separated, with no special characters.`
+    );
+  }
   if (options.oneOff && options.dependsOn) {
     throw new Error("Standalone assignments cannot have dependencies (--depends-on is not allowed with --one-off).");
   }
@@ -5657,7 +5870,9 @@ Use --slug to specify a different slug.`
         dependsOn,
         links,
         project: projectSlug,
-        type: options.type
+        workspaceGroup: options.workspace ?? null,
+        type: options.type,
+        includeTodos: options.withTodos === true
       })
     ],
     [
@@ -5737,7 +5952,7 @@ Use --slug to specify a different slug.`
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve21, dirname as dirname4 } from "path";
+import { resolve as resolve22, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -5746,7 +5961,7 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -5909,8 +6124,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile29 } = await import("fs/promises");
-  const raw = await readFile29(filePath, "utf-8");
+  const { readFile: readFile30 } = await import("fs/promises");
+  const raw = await readFile30(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -6097,18 +6312,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,
@@ -6434,7 +6656,15 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     });
     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",
@@ -6442,7 +6672,9 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
       timestamp: nowTimestamp(),
       priority: "medium",
       dependsOn: [],
-      links: []
+      links: [],
+      project: standalone ? null : void 0,
+      workspaceGroup: standalone && workspaceParam ? workspaceParam : null
     });
     res.json({ content });
   });
@@ -7171,6 +7403,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 = resolve15(assignmentsDir2, 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(resolve15(assignmentDir2, "assignment.md"), normalizedContent);
+        await writeFileForce(
+          resolve15(assignmentDir2, "scratchpad.md"),
+          renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve15(assignmentDir2, "handoff.md"),
+          renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve15(assignmentDir2, "decision-record.md"),
+          renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve15(assignmentDir2, "progress.md"),
+          renderProgress({ assignment: id2, timestamp: timestamp2 })
+        );
+        await writeFileForce(
+          resolve15(assignmentDir2, "comments.md"),
+          renderComments({ assignment: id2, timestamp: timestamp2 })
+        );
+        const detail2 = await getAssignmentDetailById(projectsDir2, assignmentsDir2, 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" });
@@ -7953,6 +8255,7 @@ import { resolve as resolve17 } from "path";
 import { readFile as readFile12, unlink as unlink2 } from "fs/promises";
 init_timestamp();
 init_fs();
+init_playbooks();
 function createPlaybooksRouter(playbooksDir3) {
   const router = Router4();
   router.get("/", async (_req, res) => {
@@ -7976,6 +8279,32 @@ function createPlaybooksRouter(playbooksDir3) {
       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(playbooksDir3, 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(playbooksDir3, 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(playbooksDir3, req.params.slug);
@@ -7990,17 +8319,18 @@ function createPlaybooksRouter(playbooksDir3) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir3, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve17(playbooksDir3, resolved.filename);
       const content = await readFile12(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" });
@@ -8039,14 +8369,15 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir3, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve17(playbooksDir3, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir3);
-      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" });
     }
@@ -8057,14 +8388,16 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve17(playbooksDir3, `${req.params.slug}.md`);
-      if (!await fileExists(filePath)) {
+      const resolved = await resolvePlaybookSlug(playbooksDir3, req.params.slug);
+      if (!resolved) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
+      const filePath = resolve17(playbooksDir3, resolved.filename);
       await unlink2(filePath);
+      await removeFromDisabledList(resolved.slug);
       await rebuildPlaybookManifest(playbooksDir3);
-      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" });
     }
@@ -8088,14 +8421,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() {
@@ -8154,7 +8490,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);
@@ -8183,7 +8519,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 = [];
@@ -8218,8 +8554,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: resolve45 } = await import("path");
-      const { readFile: readFile29 } = await import("fs/promises");
+      const { resolve: resolve46 } = await import("path");
+      const { readFile: readFile30 } = 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);
@@ -8235,10 +8571,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve45(todosDir2, "archive"));
+      await ensureDir(resolve46(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile29(archFile, "utf-8");
+        archContent = await readFile30(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -8307,7 +8643,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;
@@ -8329,7 +8665,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;
@@ -8350,7 +8686,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" };
@@ -8377,7 +8713,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;
@@ -8411,7 +8747,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;
@@ -8444,7 +8780,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;
@@ -8466,7 +8802,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;
@@ -8488,21 +8824,618 @@ 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();
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-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 resolve19, join as join2 } from "path";
-import { tmpdir } from "os";
-var exec2 = promisify2(execFile2);
-var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
+init_paths();
+import { Router as Router6 } from "express";
+import { mkdir as mkdir2, readFile as readFile14 } from "fs/promises";
+import { resolve as resolve19 } 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(projectsDir2, slug) {
+  return fileExists(resolve19(projectsDir2, slug, "project.md"));
+}
+async function ensureProjectTodosDir(projectsDir2, slug) {
+  const todosDir2 = projectTodosDir(projectsDir2, slug);
+  try {
+    await mkdir2(todosDir2, { recursive: false });
+  } catch (err2) {
+    const code = err2.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err2;
+  }
+  try {
+    await mkdir2(resolve19(todosDir2, "archive"), { recursive: false });
+  } catch (err2) {
+    const code = err2.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err2;
+  }
+}
+function notFound(res, slug) {
+  res.status(404).json({ error: `Project "${slug}" not found` });
+}
+function createProjectTodosRouter(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const item = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return null;
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const items = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return null;
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir2, slug);
+      await ensureProjectTodosDir(projectsDir2, 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 readFile14(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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const deleted = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return { error: "gone" };
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, 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 readFile15, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve20, join as join2 } from "path";
+import { tmpdir } from "os";
+var exec2 = promisify2(execFile2);
+var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
 var LOCK_FILE_NAME = ".backup-lock";
 function parseCategoriesStrict(cats) {
   const unknown = [];
@@ -8539,7 +9472,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve19(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve20(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -8550,7 +9483,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve19(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve20(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -8559,7 +9492,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile14(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile15(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.`
       );
@@ -8597,7 +9530,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve19(dest, ".."));
+    await ensureDir(resolve20(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -8606,7 +9539,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile14(configPath, "utf-8");
+  const content = await readFile15(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -8645,7 +9578,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve19(destPath, ".."));
+        await ensureDir(resolve20(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -8699,7 +9632,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve19(localPath, ".."));
+    await ensureDir(resolve20(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -8800,7 +9733,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve19(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve20(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -8813,7 +9746,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();
@@ -9137,7 +10070,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve20(syntaurRoot(), "config.md")
+        resolve21(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir2);
       const summary = summarizeMigration(projectResult, configResult);
@@ -9244,7 +10177,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/workspaces", async (_req, res) => {
     try {
-      const result = await listWorkspaces(projectsDir2);
+      const result = await listWorkspaces(projectsDir2, assignmentsDir2);
       res.json(result);
     } catch (error) {
       console.error("Error listing workspaces:", error);
@@ -9361,18 +10294,28 @@ function createDashboardServer(options) {
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
+  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir2, broadcast));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
-    app.use(express.static(dashboardDistPath));
-    app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve20(dashboardDistPath, "index.html");
-      if (await fileExists(indexPath)) {
-        res.sendFile(indexPath);
-      } else {
+    app.use("/assets", express.static(resolve21(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 = resolve21(dashboardDistPath, "index.html");
+      if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
         );
+        return;
       }
+      res.sendFile(indexPath, (err2) => {
+        if (err2) {
+          console.error("Error sending dashboard index.html:", err2);
+          if (!res.headersSent) res.status(500).send("Dashboard load error");
+        }
+      });
     });
   }
   let watcherHandle = null;
@@ -9398,7 +10341,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve20(syntaurRoot(), "dashboard-port");
+          const portFile = resolve21(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -9415,7 +10358,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve20(syntaurRoot(), "dashboard-port");
+      const portFile = resolve21(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();
@@ -9495,8 +10438,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve21(dirname4(thisFile), "..");
-  const dashboardDist = resolve21(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve22(dirname4(thisFile), "..");
+  const dashboardDist = resolve22(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
@@ -9510,8 +10453,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve21(packageRoot, "dashboard");
-    const viteBin = resolve21(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve22(packageRoot, "dashboard");
+    const viteBin = resolve22(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -9583,7 +10526,7 @@ async function dashboardCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 init_lifecycle();
 init_assignment_resolver();
 async function runTransition(assignment, command, options = {}) {
@@ -9596,8 +10539,8 @@ async function runTransition(assignment, command, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve22(baseDir, options.project);
-    const projectMdPath = resolve22(projectDir, "project.md");
+    const projectDir = resolve23(baseDir, options.project);
+    const projectMdPath = resolve23(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -9628,8 +10571,8 @@ async function runAssign(assignment, agent, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve22(baseDir, options.project);
-    const projectMdPath = resolve22(projectDir, "project.md");
+    const projectDir = resolve23(baseDir, options.project);
+    const projectMdPath = resolve23(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -9715,7 +10658,7 @@ import {
   readdir as readdir10,
   symlink,
   lstat,
-  readFile as readFile15,
+  readFile as readFile16,
   readlink,
   rm as rm3,
   unlink as unlink5,
@@ -9723,20 +10666,20 @@ import {
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve24 } from "path";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve25 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname5, resolve as resolve23 } from "path";
+import { dirname as dirname5, resolve as resolve24 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
   let currentDir = dirname5(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve23(currentDir, expectedRelativePath);
+    const candidate = resolve24(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve23(currentDir, "..");
+    const parentDir = resolve24(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -9757,25 +10700,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir2();
-  return pluginKind === "claude" ? resolve24(home, ".claude", "plugins", "syntaur") : resolve24(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve25(home, ".claude", "plugins", "syntaur") : resolve25(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve24(homedir2(), ".agents", "plugins", "marketplace.json");
+  return resolve25(homedir2(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve24(homedir2(), ".claude", "plugins", "marketplaces");
+  return resolve25(homedir2(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve24(homedir2(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve25(homedir2(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve24(homedir2(), ".claude", "plugins", "installed_plugins.json");
+  return resolve25(homedir2(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve24(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve25(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile15(resolve24(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile16(resolve25(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -9783,7 +10726,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile15(pathValue, "utf-8");
+    const raw = await readFile16(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9791,15 +10734,15 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve24(pluginDir, ".claude-plugin", "plugin.json")
+    resolve25(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve24(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve25(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile15(manifestPath, "utf-8");
+  const raw = await readFile16(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -9809,7 +10752,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile15(markerPath, "utf-8");
+    const raw = await readFile16(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9822,7 +10765,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve24(dirname6(targetDir), symlinkTarget);
+    const resolvedTarget = resolve25(dirname6(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -9868,7 +10811,7 @@ async function installLink(paths) {
   await ensureDir(dirname6(paths.targetDir));
   await rm3(paths.targetDir, { recursive: true, force: true });
   await ensureDir(dirname6(paths.targetDir));
-  await symlink(resolve24(paths.sourceDir), paths.targetDir, "dir");
+  await symlink(resolve25(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
@@ -9882,13 +10825,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute2(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve24(expanded);
+  return resolve25(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve24(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve25(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -9992,8 +10935,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve24(rootDir, entry.name);
-    const manifestPath = resolve24(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve25(rootDir, entry.name);
+    const manifestPath = resolve25(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -10020,11 +10963,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve24(expandHome(installLocation));
+    const candidateRoot = resolve25(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve24(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve25(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -10052,7 +10995,7 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve24(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve25(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function registerKnownClaudeMarketplace(name, rootDir) {
@@ -10079,9 +11022,9 @@ async function ensureClaudeUserMarketplace() {
   if (existing) {
     return existing;
   }
-  const rootDir = resolve24(getClaudeMarketplacesRoot(), "user-plugins");
-  const manifestPath = resolve24(rootDir, ".claude-plugin", "marketplace.json");
-  await ensureDir(resolve24(rootDir, "plugins"));
+  const rootDir = resolve25(getClaudeMarketplacesRoot(), "user-plugins");
+  const manifestPath = resolve25(rootDir, ".claude-plugin", "marketplace.json");
+  await ensureDir(resolve25(rootDir, "plugins"));
   if (!await fileExists(manifestPath)) {
     const scaffold = {
       plugins: []
@@ -10100,7 +11043,7 @@ async function ensureClaudeUserMarketplace() {
     name: "user-plugins",
     rootDir,
     manifestPath,
-    targetDir: resolve24(rootDir, "plugins", "syntaur")
+    targetDir: resolve25(rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
@@ -10110,7 +11053,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const rootDir = dirname6(pluginsDir);
-  const manifestPath = resolve24(rootDir, ".claude-plugin", "marketplace.json");
+  const manifestPath = resolve25(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
@@ -10126,7 +11069,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve24(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve25(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -10251,7 +11194,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve24(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve25(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -10303,7 +11246,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile15(marketplacePath, "utf-8");
+  const raw = await readFile16(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -10464,13 +11407,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve24(syntaurRoot(), "config.md"));
+  return fileExists(resolve25(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
   await rm3(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve24(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve25(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -10539,8 +11482,8 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile16, readdir as readdir11, mkdir as mkdir2, copyFile, rm as rm4 } from "fs/promises";
-import { dirname as dirname7, resolve as resolve25, relative as relative3, join as join3 } from "path";
+import { readFile as readFile17, readdir as readdir11, mkdir as mkdir3, copyFile, rm as rm4 } from "fs/promises";
+import { dirname as dirname7, resolve as resolve26, relative as relative3, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { homedir as homedir3 } from "os";
 var REQUIRED_SKILLS = [
@@ -10553,11 +11496,11 @@ var REQUIRED_SKILLS = [
 ];
 function getVendoredSkillsDir() {
   const here = dirname7(fileURLToPath4(import.meta.url));
-  return resolve25(here, "..", "vendor", "syntaur-skills", "skills");
+  return resolve26(here, "..", "vendor", "syntaur-skills", "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve25(homedir3(), ".claude", "skills");
-  return resolve25(homedir3(), ".codex", "skills");
+  if (target === "claude") return resolve26(homedir3(), ".claude", "skills");
+  return resolve26(homedir3(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
@@ -10577,7 +11520,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile16(a), readFile16(b)]);
+    const [ba, bb] = await Promise.all([readFile17(a), readFile17(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -10585,7 +11528,7 @@ async function filesEqual(a, b) {
   }
 }
 async function copyDir(srcDir, destDir) {
-  await mkdir2(destDir, { recursive: true });
+  await mkdir3(destDir, { recursive: true });
   const entries = await readdir11(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const src = join3(srcDir, entry.name);
@@ -10619,7 +11562,7 @@ async function installSkills(options) {
     );
   }
   const results = [];
-  await mkdir2(targetRoot, { recursive: true });
+  await mkdir3(targetRoot, { recursive: true });
   for (const skill of REQUIRED_SKILLS) {
     const srcDir = join3(source, skill);
     const destDir = join3(targetRoot, skill);
@@ -10668,7 +11611,7 @@ async function uninstallSkills(options) {
     if (!await fileExists(destDir)) continue;
     const skillMd = join3(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile16(skillMd, "utf-8").catch(() => "");
+    const content = await readFile17(skillMd, "utf-8").catch(() => "");
     const match = content.match(/^name:\s*(\S+)\s*$/m);
     if (!match || match[1] !== skill) continue;
     await rm4(destDir, { recursive: true, force: true });
@@ -10805,16 +11748,16 @@ async function installPluginCommand(options) {
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile18, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat3, symlink as symlink2, unlink as unlink6, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve27, dirname as dirname9 } from "path";
+import { readFile as readFile19, writeFile as writeFile8, copyFile as copyFile2, rm as rm5, stat as stat3, symlink as symlink2, unlink as unlink6, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve28, dirname as dirname9 } from "path";
 import { homedir as homedir4 } from "os";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile17, writeFile as writeFile7 } from "fs/promises";
-import { resolve as resolve26, dirname as dirname8 } from "path";
+import { readFile as readFile18, writeFile as writeFile7 } from "fs/promises";
+import { resolve as resolve27, dirname as dirname8 } from "path";
 import { spawnSync } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -10835,12 +11778,12 @@ var PRESETS = {
   tracker: { segments: ["git", "assignment", "external", "session"], separator: " \xB7 " }
 };
 function getConfigPath(installRoot) {
-  return resolve26(installRoot, "statusline.config.json");
+  return resolve27(installRoot, "statusline.config.json");
 }
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile17(path, "utf-8");
+    const raw = await readFile18(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
@@ -10993,7 +11936,7 @@ async function configureStatuslineCommand(options = {}) {
   console.log(`  segments:  ${config.segments.join(", ")}`);
   console.log(`  separator: ${JSON.stringify(config.separator)}`);
   if (config.wrap) console.log(`  wrap:      ${config.wrap}`);
-  const script = options.statuslineScript ?? resolve26(installRoot, "statusline.sh");
+  const script = options.statuslineScript ?? resolve27(installRoot, "statusline.sh");
   if (await fileExists(script)) {
     console.log("");
     console.log("Live preview:");
@@ -11024,11 +11967,11 @@ async function writeDefaultConfigIfMissing(installRoot) {
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
   const here = dirname9(fileURLToPath5(import.meta.url));
-  return resolve27(here, "..", "statusline", "statusline.sh");
+  return resolve28(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw = await readFile18(settingsPath, "utf-8");
+  const raw = await readFile19(settingsPath, "utf-8");
   if (raw.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw);
@@ -11108,12 +12051,12 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve27(homedir4(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve28(homedir4(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
-  const destScript = resolve27(installRoot, "statusline.sh");
-  const confPath = resolve27(installRoot, "statusline.conf");
-  const backupPath = resolve27(installRoot, "statusline.backup.json");
+  const destScript = resolve28(installRoot, "statusline.sh");
+  const confPath = resolve28(installRoot, "statusline.conf");
+  const backupPath = resolve28(installRoot, "statusline.backup.json");
   if (!await fileExists(sourceScript)) {
     throw new Error(
       `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
@@ -11149,7 +12092,7 @@ async function installStatuslineCommand(options = {}) {
     if (parsed) {
       wrapTarget = parsed;
     } else {
-      const wrapperPath = resolve27(installRoot, "statusline-wrapped.sh");
+      const wrapperPath = resolve28(installRoot, "statusline-wrapped.sh");
       const wrapperBody = `#!/usr/bin/env bash
 # Auto-generated by syntaur install-statusline.
 # Executes the previously configured statusLine command.
@@ -11204,19 +12147,19 @@ async function chmodExec(path) {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve27(homedir4(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve28(homedir4(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
-  const destScript = resolve27(installRoot, "statusline.sh");
-  const confPath = resolve27(installRoot, "statusline.conf");
-  const backupPath = resolve27(installRoot, "statusline.backup.json");
-  const wrapperPath = resolve27(installRoot, "statusline-wrapped.sh");
+  const destScript = resolve28(installRoot, "statusline.sh");
+  const confPath = resolve28(installRoot, "statusline.conf");
+  const backupPath = resolve28(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve28(installRoot, "statusline-wrapped.sh");
   const settings = await readSettingsJson(settingsPath);
   const existing = extractExistingCommand(settings);
   const ourCommand = `bash ${destScript}`;
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw = await readFile18(backupPath, "utf-8");
+      const raw = await readFile19(backupPath, "utf-8");
       const parsed = JSON.parse(raw);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -11237,7 +12180,7 @@ async function uninstallStatuslineCommand(options = {}) {
     await writeSettingsJson(settingsPath, settings);
   }
   if (!options.keepScript) {
-    const configPath = resolve27(installRoot, "statusline.config.json");
+    const configPath = resolve28(installRoot, "statusline.config.json");
     for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
       try {
         await rm5(path, { force: true });
@@ -11492,7 +12435,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -11572,7 +12515,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve28(configuredProjectDir) !== resolve28(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve29(configuredProjectDir) !== resolve29(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -11587,7 +12530,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -11613,19 +12556,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve29(baseDir, options.project);
-  const assignmentDir = resolve29(
+  const projectDir = resolve30(baseDir, options.project);
+  const assignmentDir = resolve30(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve29(projectDir, "project.md");
+  const projectMdPath = resolve30(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath = resolve29(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve30(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -11653,15 +12596,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve29(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve29(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve30(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve30(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve29(cwd, "AGENTS.md");
+    const agentsPath = resolve30(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve29(cwd, "opencode.json");
+      const configPath = resolve30(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -11686,7 +12629,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 async function trackSessionCommand(options) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -11699,7 +12642,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve30(baseDir, options.project);
+    const projectDir = resolve31(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -11754,10 +12697,11 @@ async function browseCommand(options) {
 }
 
 // src/commands/create-playbook.ts
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
+init_playbooks();
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -11770,7 +12714,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve32(dir, `${slug}.md`);
+  const filePath = resolve33(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -11791,32 +12735,97 @@ Use --slug to specify a different slug.`
 init_paths();
 init_fs();
 init_parser();
-import { readdir as readdir12, readFile as readFile19 } from "fs/promises";
-import { resolve as resolve33 } from "path";
-async function listPlaybooksCommand() {
+init_config2();
+import { readdir as readdir12, readFile as readFile20 } from "fs/promises";
+import { resolve as resolve34 } from "path";
+async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
     console.log('No playbooks directory found. Run "syntaur init" first.');
     return;
   }
+  const config = await readConfig();
+  const disabledSet = new Set(config.playbooks.disabled);
   const entries = await readdir12(dir, { withFileTypes: true });
-  const mdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md");
-  if (mdFiles.length === 0) {
-    console.log('No playbooks found. Create one with "syntaur create-playbook <name>".');
+  const mdFiles = entries.filter(
+    (e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md"
+  );
+  const rows = [];
+  for (const entry of mdFiles) {
+    const filePath = resolve34(dir, entry.name);
+    const raw = await readFile20(filePath, "utf-8");
+    const parsed = parsePlaybook(raw);
+    const slug = parsed.slug || entry.name.replace(/\.md$/, "");
+    const disabled = disabledSet.has(slug);
+    if (disabled && !options.all) continue;
+    rows.push({
+      slug,
+      name: parsed.name || slug,
+      desc: parsed.description || "",
+      disabled
+    });
+  }
+  if (rows.length === 0) {
+    if (!options.all && disabledSet.size > 0) {
+      console.log(
+        `No enabled playbooks found (${disabledSet.size} disabled). Use --all to include disabled playbooks.`
+      );
+    } else {
+      console.log('No playbooks found. Create one with "syntaur create-playbook <name>".');
+    }
     return;
   }
-  console.log(`Found ${mdFiles.length} playbook(s):
+  const totalLabel = options.all ? `Found ${rows.length} playbook(s) (${[...disabledSet].length} disabled):` : `Found ${rows.length} enabled playbook(s):`;
+  console.log(`${totalLabel}
 `);
   console.log(`${"Slug".padEnd(30)} ${"Name".padEnd(30)} Description`);
   console.log(`${"\u2500".repeat(30)} ${"\u2500".repeat(30)} ${"\u2500".repeat(40)}`);
-  for (const entry of mdFiles) {
-    const filePath = resolve33(dir, entry.name);
-    const raw = await readFile19(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
-    const slug = parsed.slug || entry.name.replace(/\.md$/, "");
-    const name = parsed.name || slug;
-    const desc = parsed.description || "";
-    console.log(`${slug.padEnd(30)} ${name.padEnd(30)} ${desc}`);
+  for (const row of rows) {
+    const suffix = row.disabled ? " (disabled)" : "";
+    const desc = `${row.desc}${suffix}`;
+    console.log(`${row.slug.padEnd(30)} ${row.name.padEnd(30)} ${desc}`);
+  }
+}
+
+// src/commands/enable-playbook.ts
+init_paths();
+init_playbooks();
+async function enablePlaybookCommand(slug) {
+  if (!slug.trim()) {
+    throw new Error("Playbook slug cannot be empty.");
+  }
+  if (!isValidSlug(slug)) {
+    throw new Error(
+      `Invalid slug "${slug}". Slugs must be lowercase, hyphen-separated, with no special characters.`
+    );
+  }
+  const dir = playbooksDir();
+  const { slug: canonical, changed } = await setPlaybookEnabled(dir, slug, true);
+  if (changed) {
+    console.log(`Playbook "${canonical}" enabled.`);
+  } else {
+    console.log(`Playbook "${canonical}" is already enabled.`);
+  }
+}
+
+// src/commands/disable-playbook.ts
+init_paths();
+init_playbooks();
+async function disablePlaybookCommand(slug) {
+  if (!slug.trim()) {
+    throw new Error("Playbook slug cannot be empty.");
+  }
+  if (!isValidSlug(slug)) {
+    throw new Error(
+      `Invalid slug "${slug}". Slugs must be lowercase, hyphen-separated, with no special characters.`
+    );
+  }
+  const dir = playbooksDir();
+  const { slug: canonical, changed } = await setPlaybookEnabled(dir, slug, false);
+  if (changed) {
+    console.log(`Playbook "${canonical}" disabled.`);
+  } else {
+    console.log(`Playbook "${canonical}" is already disabled.`);
   }
 }
 
@@ -11824,28 +12833,44 @@ async function listPlaybooksCommand() {
 init_paths();
 init_parser2();
 init_fs();
+init_config2();
 import { Command } from "commander";
-import { readFile as readFile20 } from "fs/promises";
-import { resolve as resolve34 } from "path";
+import { readFile as readFile21 } from "fs/promises";
+import { resolve as resolve35 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
-function resolveWorkspace(options) {
-  if (options.global) return "_global";
+async function resolveScope(options) {
+  const flagCount = [Boolean(options.project), Boolean(options.workspace), Boolean(options.global)].filter(Boolean).length;
+  if (flagCount > 1) {
+    throw new Error("Use at most one of --project, --workspace, --global.");
+  }
+  if (options.project) {
+    if (!isValidSlug(options.project)) {
+      throw new Error(`Invalid project slug: "${options.project}".`);
+    }
+    const config = await readConfig();
+    const projectMd = resolve35(config.defaultProjectDir, options.project, "project.md");
+    if (!await fileExists(projectMd)) {
+      throw new Error(`Project "${options.project}" not found.`);
+    }
+    return { kind: "project", id: options.project, todosPath: projectTodosDir(config.defaultProjectDir, options.project) };
+  }
   if (options.workspace) {
     if (!WORKSPACE_REGEX2.test(options.workspace)) {
       throw new Error(`Invalid workspace name: "${options.workspace}". Use lowercase letters, numbers, hyphens, and underscores.`);
     }
-    return options.workspace;
+    return { kind: "workspace", id: options.workspace, todosPath: todosDir() };
   }
-  return "_global";
+  return { kind: "workspace", id: "_global", todosPath: todosDir() };
 }
 function nowISO() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 var todoCommand = new Command("todo").description("Manage quick todos");
-todoCommand.command("add").description("Add a new todo item").argument("<description>", "Todo description").option("--tags <tags>", "Comma-separated tags").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (description, options) => {
+todoCommand.command("add").description("Add a new todo item").argument("<description>", "Todo description").option("--tags <tags>", "Comma-separated tags").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (description, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const existingIds = new Set(checklist.items.map((i) => i.id));
     const id = generateUniqueId(existingIds);
@@ -11859,10 +12884,11 @@ todoCommand.command("add").description("Add a new todo item").argument("<descrip
     process.exit(1);
   }
 });
-todoCommand.command("list").description("List todo items").option("--tag <tag>", "Filter by tag").option("--status <status>", "Filter by status (open|in_progress|completed|blocked)").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (options) => {
+todoCommand.command("list").description("List todo items").option("--tag <tag>", "Filter by tag").option("--status <status>", "Filter by status (open|in_progress|completed|blocked)").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     let items = checklist.items;
     if (options.tag) {
@@ -11897,10 +12923,11 @@ ${counts.total} items: ${counts.open} open, ${counts.in_progress} active, ${coun
 function findItem(items, id) {
   return items.find((i) => i.id === id);
 }
-todoCommand.command("start").description("Mark a todo as in-progress").argument("<id>", "Todo short ID (e.g. a3f1)").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("start").description("Mark a todo as in-progress").argument("<id>", "Todo short ID (e.g. a3f1)").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -11920,10 +12947,11 @@ todoCommand.command("start").description("Mark a todo as in-progress").argument(
     process.exit(1);
   }
 });
-todoCommand.command("complete").description("Mark a todo as completed").argument("<id>", "Todo short ID").option("--summary <summary>", "Completion summary").option("--branch <branch>", "Git branch name").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("complete").description("Mark a todo as completed").argument("<id>", "Todo short ID").option("--summary <summary>", "Completion summary").option("--branch <branch>", "Git branch name").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -11950,10 +12978,11 @@ todoCommand.command("complete").description("Mark a todo as completed").argument
     process.exit(1);
   }
 });
-todoCommand.command("block").description("Mark a todo as blocked").argument("<id>", "Todo short ID").requiredOption("--reason <reason>", "Blocking reason").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("block").description("Mark a todo as blocked").argument("<id>", "Todo short ID").requiredOption("--reason <reason>", "Blocking reason").option("--session <session>", "Session ID").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -11980,10 +13009,11 @@ todoCommand.command("block").description("Mark a todo as blocked").argument("<id
     process.exit(1);
   }
 });
-todoCommand.command("unblock").description("Return a blocked todo to open").argument("<id>", "Todo short ID").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("unblock").description("Return a blocked todo to open").argument("<id>", "Todo short ID").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -11999,10 +13029,11 @@ todoCommand.command("unblock").description("Return a blocked todo to open").argu
     process.exit(1);
   }
 });
-todoCommand.command("delete").description("Delete a todo item (no log entry)").argument("<id>", "Todo short ID").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("delete").description("Delete a todo item (no log entry)").argument("<id>", "Todo short ID").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const idx = checklist.items.findIndex((i) => i.id === id);
     if (idx === -1) {
@@ -12018,10 +13049,11 @@ todoCommand.command("delete").description("Delete a todo item (no log entry)").a
     process.exit(1);
   }
 });
-todoCommand.command("edit").description("Update a todo description").argument("<id>", "Todo short ID").argument("<description>", "New description").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, description, options) => {
+todoCommand.command("edit").description("Update a todo description").argument("<id>", "Todo short ID").argument("<description>", "New description").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, description, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -12036,10 +13068,11 @@ todoCommand.command("edit").description("Update a todo description").argument("<
     process.exit(1);
   }
 });
-todoCommand.command("tag").description("Modify tags on a todo").argument("<id>", "Todo short ID").option("--add <tags>", "Tags to add (comma-separated)").option("--remove <tags>", "Tags to remove (comma-separated)").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("tag").description("Modify tags on a todo").argument("<id>", "Todo short ID").option("--add <tags>", "Tags to add (comma-separated)").option("--remove <tags>", "Tags to remove (comma-separated)").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -12063,10 +13096,11 @@ todoCommand.command("tag").description("Modify tags on a todo").argument("<id>",
     process.exit(1);
   }
 });
-todoCommand.command("log").description("Show log entries").argument("[id]", "Optional todo short ID to filter").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("log").description("Show log entries").argument("[id]", "Optional todo short ID to filter").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const log = await readLog(todosPath, workspace);
     let entries = log.entries;
     if (id) {
@@ -12090,10 +13124,11 @@ ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}`);
     process.exit(1);
   }
 });
-todoCommand.command("archive").description("Archive completed todos and their log entries").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (options) => {
+todoCommand.command("archive").description("Archive completed todos and their log entries").option("--workspace <slug>", "Workspace slug").option("--project <slug>", "Project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const log = await readLog(todosPath, workspace);
     const completedIds = new Set(
@@ -12107,10 +13142,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve34(todosPath, "archive"));
+    await ensureDir(resolve35(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile20(archFile, "utf-8");
+      archContent = await readFile21(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -12185,10 +13220,11 @@ workspace: ${workspace}
     process.exit(1);
   }
 });
-todoCommand.command("promote").description("Promote a todo to a full assignment").argument("<id>", "Todo short ID").requiredOption("--project <slug>", "Target project slug").option("--workspace <slug>", "Workspace slug").option("--global", "Use global todos").action(async (id, options) => {
+todoCommand.command("promote").description("Promote a todo to a full assignment").argument("<id>", "Todo short ID").requiredOption("--to-project <slug>", "Target project slug for the new assignment").option("--workspace <slug>", "Source workspace slug").option("--project <slug>", "Source project slug (mutually exclusive with --workspace/--global)").option("--global", "Use global todos").action(async (id, options) => {
   try {
-    const todosPath = todosDir();
-    const workspace = resolveWorkspace(options);
+    const scope = await resolveScope(options);
+    const todosPath = scope.todosPath;
+    const workspace = scope.id;
     const checklist = await readChecklist(todosPath, workspace);
     const item = findItem(checklist.items, id);
     if (!item) {
@@ -12204,13 +13240,13 @@ todoCommand.command("promote").description("Promote a todo to a full assignment"
       items: item.description,
       session: null,
       branch: null,
-      summary: `Promoted to assignment in project: ${options.project}`,
+      summary: `Promoted to assignment in project: ${options.toProject}`,
       blockers: null,
       status: null
     };
     await appendLogEntry2(todosPath, workspace, entry);
-    console.log(`Promoted [t:${id}] to assignment in project "${options.project}".`);
-    console.log(`Run: syntaur create-assignment --project ${options.project} "${item.description}"`);
+    console.log(`Promoted [t:${id}] to assignment in project "${options.toProject}".`);
+    console.log(`Run: syntaur create-assignment --project ${options.toProject} "${item.description}"`);
   } catch (error) {
     console.error("Error:", error instanceof Error ? error.message : String(error));
     process.exit(1);
@@ -12299,7 +13335,7 @@ import { Command as Command3 } from "commander";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { readFile as readFile24 } from "fs/promises";
+import { readFile as readFile25 } from "fs/promises";
 import { dirname as dirname11, join as join5 } from "path";
 
 // src/utils/doctor/context.ts
@@ -12307,11 +13343,11 @@ init_config2();
 init_paths();
 init_fs();
 import Database2 from "better-sqlite3";
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve35(root, "syntaur.db");
+  const dbPath = resolve36(root, "syntaur.db");
   let db2 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -12345,8 +13381,8 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve36, isAbsolute as isAbsolute3 } from "path";
-import { readFile as readFile21, stat as stat4 } from "fs/promises";
+import { resolve as resolve37, isAbsolute as isAbsolute3 } from "path";
+import { readFile as readFile22, stat as stat4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { dirname as dirname10, join as join4 } from "path";
 var CATEGORY = "env";
@@ -12386,7 +13422,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve36(ctx.syntaurRoot, "config.md");
+    const configPath = resolve37(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -12403,7 +13439,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile21(configPath, "utf-8");
+    const content = await readFile22(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -12683,7 +13719,7 @@ async function readLocalPkg() {
     for (let i = 0; i < 6; i++) {
       const candidate = join4(dir, "package.json");
       try {
-        const text = await readFile21(candidate, "utf-8");
+        const text = await readFile22(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
         dir = dirname10(dir);
@@ -12735,7 +13771,7 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 import { readdir as readdir13, stat as stat5 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
@@ -12755,7 +13791,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve37(ctx.syntaurRoot, "projects");
+    const p = resolve38(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12780,7 +13816,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve37(ctx.syntaurRoot, "playbooks");
+    const p = resolve38(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12805,7 +13841,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve37(ctx.syntaurRoot, "todos");
+    const p = resolve38(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12836,7 +13872,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve37(ctx.syntaurRoot, "servers");
+    const p = resolve38(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -12881,7 +13917,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve37(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve38(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -12910,7 +13946,7 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 import { readdir as readdir14, stat as stat6 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
@@ -12940,10 +13976,10 @@ async function listProjects2(ctx) {
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve38(dir, e.name);
+    const projectDir = resolve39(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve38(projectDir, marker))) {
+      if (await fileExists(resolve39(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -12962,7 +13998,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve38(projectDir, rel);
+        const p = resolve39(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -12972,7 +14008,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve38(projectDir, m)),
+        affected: missing.map((m) => resolve39(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -12995,7 +14031,7 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve38(projectDir, "manifest.md");
+      const manifestPath = resolve39(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
       const manifestMtime = (await stat6(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
@@ -13044,7 +14080,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve38(projectDir, o)),
+        affected: orphans.map((o) => resolve39(projectDir, o)),
         autoFixable: false
       });
     }
@@ -13054,7 +14090,7 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve38(projectDir, "assignments");
+  const assignmentsRoot = resolve39(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
@@ -13065,7 +14101,7 @@ async function newestAssignmentMtime(projectDir) {
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve38(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve39(assignmentsRoot, e.name, "assignment.md");
     try {
       const s = await stat6(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
@@ -13089,8 +14125,8 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve39 } from "path";
-import { readdir as readdir15, readFile as readFile22 } from "fs/promises";
+import { resolve as resolve40 } from "path";
+import { readdir as readdir15, readFile as readFile23 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 async function listAssignments(ctx) {
@@ -13101,16 +14137,16 @@ async function listAssignments(ctx) {
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve39(projectsDir2, m.name, "assignments");
+      const assignmentsDir2 = resolve40(projectsDir2, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
       const entries = await readdir15(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve39(assignmentsDir2, a.name);
-        const assignmentMd = resolve39(assignmentDir, "assignment.md");
+        const assignmentDir = resolve40(assignmentsDir2, a.name);
+        const assignmentMd = resolve40(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve39(projectsDir2, m.name),
+          projectDir: resolve40(projectsDir2, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -13130,8 +14166,8 @@ async function listAssignments(ctx) {
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve39(standaloneRoot, a.name);
-      const assignmentMd = resolve39(assignmentDir, "assignment.md");
+      const assignmentDir = resolve40(standaloneRoot, a.name);
+      const assignmentMd = resolve40(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneRoot,
         projectSlug: null,
@@ -13209,7 +14245,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve39(a.assignmentDir, "assignment.md");
+      const path = resolve40(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -13242,7 +14278,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve39(a.assignmentDir, "assignment.md");
+      const path = resolve40(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -13289,12 +14325,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve39(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve40(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve39(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve40(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -13304,7 +14340,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve39(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve40(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -13327,7 +14363,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve39(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve40(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -13339,7 +14375,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve39(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve40(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -13372,7 +14408,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve39(a.assignmentDir, "assignment.md");
+      const path = resolve40(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -13406,7 +14442,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve39(a.assignmentDir, "assignment.md");
+      const path = resolve40(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -13461,7 +14497,7 @@ var assignmentChecks = [
 ];
 async function parseSafe(path) {
   try {
-    const content = await readFile22(path, "utf-8");
+    const content = await readFile23(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -13480,7 +14516,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve40 } from "path";
+import { resolve as resolve41 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -13494,7 +14530,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve41(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -13512,7 +14548,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve41(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -13524,7 +14560,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve40(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve41(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -13550,7 +14586,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve40(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve41(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -13569,7 +14605,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve40(
+        const assignmentPath = resolve41(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -13726,8 +14762,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve41 } from "path";
-import { readFile as readFile23 } from "fs/promises";
+import { resolve as resolve42 } from "path";
+import { readFile as readFile24 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 function hasAnyAssignmentField(ctx) {
@@ -13739,12 +14775,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve41(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve42(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile23(path, "utf-8");
+    const raw = await readFile24(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -13819,7 +14855,7 @@ var contextAssignmentResolves = {
     if (!exists) return skipped3(this, "no context to resolve");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve41(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve42(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -13848,10 +14884,10 @@ var contextTerminal = {
     if (!exists) return skipped3(this, "no context to check");
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve41(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve42(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile23(assignmentMd, "utf-8");
+      const content = await readFile24(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -13998,7 +15034,7 @@ async function readVersion() {
     let dir = dirname11(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile24(join5(dir, "package.json"), "utf-8");
+        const raw = await readFile25(join5(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
@@ -14135,8 +15171,8 @@ var doctorCommand = new Command3("doctor").description("Diagnose Syntaur state a
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve42 } from "path";
-import { readFile as readFile25 } from "fs/promises";
+import { resolve as resolve43 } from "path";
+import { readFile as readFile26 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function shortId() {
@@ -14168,7 +15204,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve42(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve43(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -14178,13 +15214,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve42(assignmentDir, "comments.md");
+  const commentsPath = resolve43(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile25(commentsPath, "utf-8");
+    currentContent = await readFile26(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -14221,8 +15257,8 @@ ${entry}`;
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve43 } from "path";
-import { readFile as readFile26 } from "fs/promises";
+import { resolve as resolve44 } from "path";
+import { readFile as readFile27 } from "fs/promises";
 init_timestamp();
 init_assignment_resolver();
 function setTopLevelField3(content, key, value) {
@@ -14247,7 +15283,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve43(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve44(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -14257,12 +15293,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath = resolve43(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve44(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile26(assignmentMdPath, "utf-8");
+  let content = await readFile27(assignmentMdPath, "utf-8");
   const todoLine = `- [ ] ${text.trim()} (from: ${source})`;
   const todosHeading = /^## Todos\s*$/m;
   if (todosHeading.test(content)) {
@@ -14330,20 +15366,20 @@ async function getDefaultCommandName() {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { readFile as readFile28 } from "fs/promises";
-import { dirname as dirname13, join as join7, resolve as resolve44 } from "path";
+import { readFile as readFile29 } from "fs/promises";
+import { dirname as dirname13, join as join7, resolve as resolve45 } from "path";
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile28 } from "fs/promises";
 import { dirname as dirname12, join as join6 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath8(scriptUrl);
     const pkgRoot = dirname12(dirname12(scriptPath));
-    const raw = await readFile27(join6(pkgRoot, "package.json"), "utf-8");
+    const raw = await readFile28(join6(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -14352,7 +15388,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve44(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve45(syntaurRoot(), "npx-install.json");
 var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -14373,7 +15409,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile28(STATE_FILE, "utf-8");
+    const raw = await readFile29(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -14432,7 +15468,7 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join7(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile28(manifestPath, "utf-8");
+    const raw = await readFile29(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -14580,7 +15616,7 @@ program.command("create-assignment").description("Create a new assignment within
   "--priority <level>",
   "Priority level (low|medium|high|critical)",
   "medium"
-).option("--type <type>", "Assignment type (e.g. feature, bug, refactor)").option("--depends-on <slugs>", "Comma-separated dependency slugs (not allowed with --one-off)").option("--links <slugs>", "Comma-separated linked assignment slugs (projectSlug/assignmentSlug format)").option("--dir <path>", "Override default project directory (ignored for --one-off)").action(async (title, options) => {
+).option("--type <type>", "Assignment type (e.g. feature, bug, refactor)").option("--depends-on <slugs>", "Comma-separated dependency slugs (not allowed with --one-off)").option("--links <slugs>", "Comma-separated linked assignment slugs (projectSlug/assignmentSlug format)").option("--dir <path>", "Override default project directory (ignored for --one-off)").option("--with-todos", "Scaffold a ## Todos section in assignment.md (omitted by default; typically populated by /plan-assignment)").option("--workspace <slug>", "Workspace group slug (only valid with --one-off; mutually exclusive with --project)").action(async (title, options) => {
   try {
     await createAssignmentCommand(title, options);
   } catch (error) {
@@ -14864,9 +15900,31 @@ program.command("create-playbook").description("Create a new playbook").argument
     process.exit(1);
   }
 });
-program.command("list-playbooks").description("List all playbooks").action(async () => {
+program.command("list-playbooks").description("List playbooks (disabled playbooks are excluded unless --all is passed)").option("--all", "Include disabled playbooks").action(async (options) => {
+  try {
+    await listPlaybooksCommand({ all: Boolean(options?.all) });
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+});
+program.command("enable-playbook").description("Enable a previously-disabled playbook").argument("<slug>", "Playbook slug").action(async (slug) => {
+  try {
+    await enablePlaybookCommand(slug);
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+});
+program.command("disable-playbook").description("Disable a playbook so agents no longer load it").argument("<slug>", "Playbook slug").action(async (slug) => {
   try {
-    await listPlaybooksCommand();
+    await disablePlaybookCommand(slug);
   } catch (error) {
     console.error(
       "Error:",