syntaur 0.6.0 → 0.6.1

package/dist/index.js

@@ -6684,7 +6684,7 @@ __export(launch_exports, {
   shellQuote: () => shellQuote
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
 import { isAbsolute as isAbsolute3, resolve as resolve32 } from "path";
 function formatFallbackCwdWarning(opts) {
   const missing = [];
@@ -6743,7 +6743,7 @@ async function launchAgent(options) {
     if (warning) console.warn(warning);
   }
   const contextDir = resolve32(workspaceDir, ".syntaur");
-  await mkdir5(contextDir, { recursive: true });
+  await mkdir6(contextDir, { recursive: true });
   const context = {
     projectSlug,
     assignmentSlug,
@@ -7070,7 +7070,7 @@ init_create_assignment();
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve22, dirname as dirname4 } from "path";
+import { resolve as resolve22, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -9536,37 +9536,62 @@ init_fs_migration();
 // src/dashboard/api-todos.ts
 init_parser2();
 init_fs();
+init_paths();
 import { Router as Router5 } from "express";
 import { readdir as readdir9 } from "fs/promises";
-var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
-function getWorkspaceParam(value) {
-  if (Array.isArray(value)) {
-    return value[0] ?? "";
-  }
-  return value ?? "";
-}
+import { resolve as resolvePath, dirname as dirname4 } from "path";
+import { rename as rename3, mkdir as mkdir2 } from "fs/promises";
+
+// src/dashboard/todos-locks.ts
 var writeLocks = /* @__PURE__ */ new Map();
 function withLock(lockKey, fn) {
   const prev = writeLocks.get(lockKey) ?? Promise.resolve();
   const next = prev.then(fn);
-  writeLocks.set(lockKey, next.then(() => {
-  }, () => {
-  }));
+  writeLocks.set(
+    lockKey,
+    next.then(
+      () => {
+      },
+      () => {
+      }
+    )
+  );
   return next;
 }
 function wsLock(workspace, fn) {
   return withLock(`ws:${workspace}`, fn);
 }
+function projLock(slug, fn) {
+  return withLock(`proj:${slug}`, fn);
+}
+function withTwoLocks(keyA, keyB, fn) {
+  if (keyA === keyB) return withLock(keyA, fn);
+  const [first, second] = keyA < keyB ? [keyA, keyB] : [keyB, keyA];
+  return withLock(first, () => withLock(second, fn));
+}
+
+// src/dashboard/api-todos.ts
+init_slug();
+var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
+function getWorkspaceParam(value) {
+  if (Array.isArray(value)) {
+    return value[0] ?? "";
+  }
+  return value ?? "";
+}
 function touchItem(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (item.createdAt === null) item.createdAt = now;
   item.updatedAt = now;
 }
-function createTodosRouter(todosDir2, broadcast) {
+function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   const router = Router5();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
+  function broadcastProject(slug) {
+    broadcast({ type: "todos-updated", projectSlug: slug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
   function validateWorkspace(req, res, next) {
     const workspace = getWorkspaceParam(req.params.workspace);
     if (workspace && !WORKSPACE_REGEX.test(workspace)) {
@@ -9965,7 +9990,7 @@ workspace: ${workspace}
           items.push(item);
         }
         const scopeLabel = workspace === "_global" ? "_global" : `workspace:${workspace}`;
-        const { resolve: resolvePath } = await import("path");
+        const { resolve: resolvePath2 } = await import("path");
         const { readConfig: readConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
@@ -9995,18 +10020,18 @@ workspace: ${workspace}
             const parts = tg.split("/");
             if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
             const config = await readConfig3();
-            assignmentDir = resolvePath(config.defaultProjectDir, parts[0], "assignments", parts[1]);
+            assignmentDir = resolvePath2(config.defaultProjectDir, parts[0], "assignments", parts[1]);
             assignmentRef = `${parts[0]}/${parts[1]}`;
           } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-            assignmentDir = resolvePath(assignmentsDirFn(), tg);
+            assignmentDir = resolvePath2(assignmentsDirFn(), tg);
             assignmentRef = tg;
           } else {
             return { error: `Invalid target.assignment "${tg}"` };
           }
-          const assignmentMdPath2 = resolvePath(assignmentDir, "assignment.md");
+          const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
           if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
         }
-        const assignmentMdPath = resolvePath(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         let content = await readFile32(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
@@ -10050,6 +10075,115 @@ workspace: ${workspace}
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to promote todos" });
     }
   });
+  router.post("/:workspace/:id/move", async (req, res) => {
+    try {
+      const sourceWs = getWorkspaceParam(req.params.workspace);
+      const id = req.params.id;
+      const to = req.body?.to;
+      if (!to || typeof to !== "object") {
+        res.status(400).json({ error: "body.to is required" });
+        return;
+      }
+      const targetCount = [Boolean(to.workspace), Boolean(to.project), Boolean(to.global)].filter(Boolean).length;
+      if (targetCount !== 1) {
+        res.status(400).json({ error: "body.to must specify exactly one of workspace, project, or global" });
+        return;
+      }
+      if (to.project && !isValidSlug(to.project)) {
+        res.status(400).json({ error: `Invalid target project slug: "${to.project}"` });
+        return;
+      }
+      if (to.workspace && !WORKSPACE_REGEX.test(to.workspace)) {
+        res.status(400).json({ error: `Invalid target workspace name: "${to.workspace}"` });
+        return;
+      }
+      let target;
+      if (to.global) {
+        target = { kind: "workspace", id: "_global", todosPath: todosDir2, lockKey: "ws:_global" };
+      } else if (to.workspace) {
+        target = { kind: "workspace", id: to.workspace, todosPath: todosDir2, lockKey: `ws:${to.workspace}` };
+      } else {
+        if (!projectsDir2) {
+          res.status(500).json({ error: "Server not configured with projectsDir; cannot move to project scope" });
+          return;
+        }
+        const slug = to.project;
+        const projectMd = resolvePath(projectsDir2, slug, "project.md");
+        if (!await fileExists(projectMd)) {
+          res.status(404).json({ error: `Target project "${slug}" not found` });
+          return;
+        }
+        target = {
+          kind: "project",
+          id: slug,
+          todosPath: projectTodosDir(projectsDir2, slug),
+          lockKey: `proj:${slug}`
+        };
+      }
+      const sourceLockKey = `ws:${sourceWs}`;
+      if (sourceLockKey === target.lockKey) {
+        res.status(400).json({ error: "cannot move to the same scope" });
+        return;
+      }
+      const result = await withTwoLocks(sourceLockKey, target.lockKey, async () => {
+        const sourceChecklist = await readChecklist(todosDir2, sourceWs);
+        const targetChecklist = await readChecklist(target.todosPath, target.id);
+        const idx = sourceChecklist.items.findIndex((i) => i.id === id);
+        if (idx === -1) return { status: 404, error: `Todo "${id}" not found` };
+        if (targetChecklist.items.some((i) => i.id === id)) {
+          return { status: 409, error: "id already exists in target" };
+        }
+        const item = sourceChecklist.items[idx];
+        if (item.planDir) {
+          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          if (await fileExists(newPlanDir)) {
+            return { status: 409, error: "plan dir already exists in target" };
+          }
+          await mkdir2(dirname4(newPlanDir), { recursive: true });
+          await rename3(item.planDir, newPlanDir);
+          item.planDir = newPlanDir;
+        }
+        sourceChecklist.items.splice(idx, 1);
+        targetChecklist.items.push(item);
+        await writeChecklist(todosDir2, sourceChecklist);
+        await writeChecklist(target.todosPath, targetChecklist);
+        const sourceLabel = sourceWs === "_global" ? "_global" : `workspace:${sourceWs}`;
+        const targetLabel = target.kind === "project" ? `project:${target.id}` : target.id === "_global" ? "_global" : `workspace:${target.id}`;
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        await appendLogEntry2(todosDir2, sourceWs, {
+          timestamp: ts,
+          itemIds: [id],
+          items: item.description,
+          session: null,
+          branch: item.branch || null,
+          summary: `Moved to ${targetLabel}`,
+          blockers: null,
+          status: null
+        });
+        await appendLogEntry2(target.todosPath, target.id, {
+          timestamp: ts,
+          itemIds: [id],
+          items: item.description,
+          session: null,
+          branch: item.branch || null,
+          summary: `Moved from ${sourceLabel}`,
+          blockers: null,
+          status: null
+        });
+        return { status: 200, item };
+      });
+      if (result.status !== 200) {
+        res.status(result.status).json({ error: result.error });
+        return;
+      }
+      broadcastUpdate();
+      if (target.kind === "project") broadcastProject(target.id);
+      else broadcastUpdate();
+      res.json({ moved: id, to: target });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to move todo" });
+    }
+  });
   router.post("/:workspace/:id/unblock", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
@@ -10082,18 +10216,9 @@ init_fs();
 init_paths();
 init_slug();
 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;
-}
+import { mkdir as mkdir3, readFile as readFile14, rename as rename4 } from "fs/promises";
+import { resolve as resolve19, dirname as dirname5 } from "path";
+var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem2(item) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (item.createdAt === null) item.createdAt = now;
@@ -10112,7 +10237,7 @@ async function projectExists(projectsDir2, slug) {
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
   try {
-    await mkdir2(todosDir2, { recursive: false });
+    await mkdir3(todosDir2, { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -10124,7 +10249,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir2(resolve19(todosDir2, "archive"), { recursive: false });
+    await mkdir3(resolve19(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -10139,11 +10264,14 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
 function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
-function createProjectTodosRouter(projectsDir2, broadcast) {
+function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
   const router = Router6({ mergeParams: true });
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
+  function broadcastWorkspace() {
+    broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
   function validateProjectId(req, res, next) {
     const slug = getProjectIdParam(params(req).projectId);
     if (!slug || !isValidSlug(slug)) {
@@ -10691,6 +10819,259 @@ workspace: ${slug}
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to unblock todo" });
     }
   });
+  router.post("/promote", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir2, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const { todoIds, mode, target, title, type, priority, keepSource } = req.body ?? {};
+      if (!Array.isArray(todoIds) || todoIds.length === 0) {
+        res.status(400).json({ error: "todoIds (non-empty array of strings) is required" });
+        return;
+      }
+      if (mode !== "new-assignment" && mode !== "to-assignment") {
+        res.status(400).json({ error: 'mode must be "new-assignment" or "to-assignment"' });
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return { gone: true };
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const items = [];
+        for (const id of todoIds) {
+          const item = checklist.items.find((i) => i.id === id);
+          if (!item) return { error: `Todo "${id}" not found` };
+          if (item.status === "completed") return { error: `Todo "${id}" is already completed` };
+          items.push(item);
+        }
+        const scopeLabel = `project:${slug}`;
+        const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
+        const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
+        let assignmentRef;
+        let assignmentDir;
+        if (mode === "new-assignment") {
+          const targetProject = target?.project ?? slug;
+          if (!targetProject) return { error: "target.project is required for new-assignment mode" };
+          if (items.length > 1 && !title) return { error: "title is required when promoting multiple todos" };
+          const { createAssignmentCommand: createAssignmentCommand2 } = await Promise.resolve().then(() => (init_create_assignment(), create_assignment_exports));
+          const created = await createAssignmentCommand2(title || items[0].description, {
+            project: targetProject,
+            type,
+            priority,
+            withTodos: true,
+            silent: true
+          });
+          assignmentDir = created.assignmentDir;
+          assignmentRef = `${created.projectSlug}/${created.slug}`;
+        } else {
+          const tg = target?.assignment || "";
+          if (!tg) return { error: "target.assignment is required for to-assignment mode" };
+          if (tg.includes("/")) {
+            const parts = tg.split("/");
+            if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
+            assignmentDir = resolve19(projectsDir2, parts[0], "assignments", parts[1]);
+            assignmentRef = `${parts[0]}/${parts[1]}`;
+          } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
+            assignmentDir = resolve19(assignmentsDirFn(), tg);
+            assignmentRef = tg;
+          } else {
+            return { error: `Invalid target.assignment "${tg}"` };
+          }
+          const assignmentMdPath2 = resolve19(assignmentDir, "assignment.md");
+          if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
+        }
+        const assignmentMdPath = resolve19(assignmentDir, "assignment.md");
+        let content = await readFile14(assignmentMdPath, "utf-8");
+        content = appendTodosToAssignmentBody2(
+          content,
+          items.map((it) => ({
+            description: it.description,
+            trace: `promoted from t:${it.id} in ${scopeLabel}`
+          }))
+        );
+        content = touchAssignmentUpdated2(content, nowTimestamp3());
+        await writeFileForce(assignmentMdPath, content);
+        if (!keepSource) {
+          for (const item of items) {
+            item.status = "completed";
+            item.session = null;
+            touchItem2(item);
+          }
+          checklist.workspace = slug;
+          await writeChecklist(todosDir2, checklist);
+          for (const item of items) {
+            const entry = {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              itemIds: [item.id],
+              items: item.description,
+              session: null,
+              branch: item.branch || null,
+              summary: `Promoted to assignment ${assignmentRef}`,
+              blockers: null,
+              status: null
+            };
+            await appendLogEntry2(todosDir2, slug, entry);
+          }
+        }
+        return { assignmentRef, assignmentDir, promoted: items.map((i) => i.id) };
+      });
+      if ("gone" in result) {
+        notFound(res, slug);
+        return;
+      }
+      if ("error" in result) {
+        res.status(400).json({ error: result.error });
+        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 promote todos" });
+    }
+  });
+  router.post("/:id/move", async (req, res) => {
+    try {
+      const sourceSlug = getProjectIdParam(params(req).projectId);
+      const id = params(req).id ?? "";
+      if (!await projectExists(projectsDir2, sourceSlug)) {
+        notFound(res, sourceSlug);
+        return;
+      }
+      const to = req.body?.to;
+      if (!to || typeof to !== "object") {
+        res.status(400).json({ error: "body.to is required" });
+        return;
+      }
+      const targetCount = [Boolean(to.workspace), Boolean(to.project), Boolean(to.global)].filter(Boolean).length;
+      if (targetCount !== 1) {
+        res.status(400).json({ error: "body.to must specify exactly one of workspace, project, or global" });
+        return;
+      }
+      if (to.project && !isValidSlug(to.project)) {
+        res.status(400).json({ error: `Invalid target project slug: "${to.project}"` });
+        return;
+      }
+      if (to.workspace && !WORKSPACE_REGEX2.test(to.workspace)) {
+        res.status(400).json({ error: `Invalid target workspace name: "${to.workspace}"` });
+        return;
+      }
+      let target;
+      if (to.global) {
+        if (!workspaceTodosDir) {
+          res.status(500).json({ error: "Server not configured with workspaceTodosDir; cannot move to global scope" });
+          return;
+        }
+        target = { kind: "workspace", id: "_global", todosPath: workspaceTodosDir, lockKey: "ws:_global" };
+      } else if (to.workspace) {
+        if (!workspaceTodosDir) {
+          res.status(500).json({ error: "Server not configured with workspaceTodosDir; cannot move to workspace scope" });
+          return;
+        }
+        target = { kind: "workspace", id: to.workspace, todosPath: workspaceTodosDir, lockKey: `ws:${to.workspace}` };
+      } else {
+        const tslug = to.project;
+        if (!await projectExists(projectsDir2, tslug)) {
+          res.status(404).json({ error: `Target project "${tslug}" not found` });
+          return;
+        }
+        target = {
+          kind: "project",
+          id: tslug,
+          todosPath: projectTodosDir(projectsDir2, tslug),
+          lockKey: `proj:${tslug}`
+        };
+      }
+      const sourceLockKey = `proj:${sourceSlug}`;
+      if (sourceLockKey === target.lockKey) {
+        res.status(400).json({ error: "cannot move to the same scope" });
+        return;
+      }
+      const result = await withTwoLocks(sourceLockKey, target.lockKey, async () => {
+        if (!await projectExists(projectsDir2, sourceSlug)) return { status: "gone" };
+        if (target.kind === "project" && !await projectExists(projectsDir2, target.id)) {
+          return { status: "targetGone" };
+        }
+        await ensureProjectTodosDir(projectsDir2, sourceSlug);
+        const sourceTodosDir = projectTodosDir(projectsDir2, sourceSlug);
+        const sourceChecklist = await readChecklist(sourceTodosDir, sourceSlug);
+        const targetChecklist = await readChecklist(target.todosPath, target.id);
+        const idx = sourceChecklist.items.findIndex((i) => i.id === id);
+        if (idx === -1) return { status: 404, error: `Todo "${id}" not found` };
+        if (targetChecklist.items.some((i) => i.id === id)) {
+          return { status: 409, error: "id already exists in target" };
+        }
+        const item = sourceChecklist.items[idx];
+        if (item.planDir) {
+          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          if (await fileExists(newPlanDir)) {
+            return { status: 409, error: "plan dir already exists in target" };
+          }
+          await mkdir3(dirname5(newPlanDir), { recursive: true });
+          await rename4(item.planDir, newPlanDir);
+          item.planDir = newPlanDir;
+        }
+        sourceChecklist.items.splice(idx, 1);
+        targetChecklist.items.push(item);
+        sourceChecklist.workspace = sourceSlug;
+        await writeChecklist(sourceTodosDir, sourceChecklist);
+        await writeChecklist(target.todosPath, targetChecklist);
+        const sourceLabel = `project:${sourceSlug}`;
+        const targetLabel = target.kind === "project" ? `project:${target.id}` : target.id === "_global" ? "_global" : `workspace:${target.id}`;
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        await appendLogEntry2(sourceTodosDir, sourceSlug, {
+          timestamp: ts,
+          itemIds: [id],
+          items: item.description,
+          session: null,
+          branch: item.branch || null,
+          summary: `Moved to ${targetLabel}`,
+          blockers: null,
+          status: null
+        });
+        await appendLogEntry2(target.todosPath, target.id, {
+          timestamp: ts,
+          itemIds: [id],
+          items: item.description,
+          session: null,
+          branch: item.branch || null,
+          summary: `Moved from ${sourceLabel}`,
+          blockers: null,
+          status: null
+        });
+        return { status: 200, item };
+      });
+      if (result.status === "gone") {
+        notFound(res, sourceSlug);
+        return;
+      }
+      if (result.status === "targetGone") {
+        res.status(404).json({ error: `Target project "${target.id}" not found` });
+        return;
+      }
+      if (result.status !== 200) {
+        res.status(result.status).json({ error: result.error });
+        return;
+      }
+      broadcastUpdate(sourceSlug);
+      if (target.kind === "project") broadcastUpdate(target.id);
+      else broadcastWorkspace();
+      res.json({ moved: id, to: target });
+    } 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 move todo" });
+    }
+  });
   return router;
 }
 
@@ -10704,7 +11085,7 @@ 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 { cp, mkdtemp, rm as rm2, readFile as readFile15, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename5 } from "fs/promises";
 import { resolve as resolve20, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
@@ -10916,7 +11297,7 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   const localExistsBefore = await fileExists(localPath);
   if (backupExistsBefore) {
     if (!localExistsBefore) {
-      await rename3(backupPath, localPath);
+      await rename5(backupPath, localPath);
     } else {
       throw new Error(
         `Cannot restore "${localPath}": a stale crash-recovery backup exists at ${backupPath} while the current path also exists. Inspect both and remove the one you don't need, then retry.`
@@ -10928,15 +11309,15 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
     await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
     const localExists = await fileExists(localPath);
     if (localExists) {
-      await rename3(localPath, backupPath);
+      await rename5(localPath, backupPath);
       localMovedAside = true;
     }
-    await rename3(stagingPath, localPath);
+    await rename5(stagingPath, localPath);
     await rm2(backupPath, { recursive: true, force: true }).catch(() => {
     });
   } catch (err2) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename3(backupPath, localPath).catch(() => {
+      await rename5(backupPath, localPath).catch(() => {
       });
     }
     await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
@@ -11675,8 +12056,8 @@ function createDashboardServer(options) {
   app.use("/api/servers", createServersRouter(serversDir2, projectsDir2, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
-  app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
-  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir2, broadcast));
+  app.use("/api/todos", createTodosRouter(todosDir2, broadcast, projectsDir2));
+  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir2, broadcast, todosDir2));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
@@ -11822,7 +12203,7 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve22(dirname4(thisFile), "..");
+  const packageRoot = resolve22(dirname6(thisFile), "..");
   const dashboardDist = resolve22(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
@@ -12051,14 +12432,14 @@ 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 resolve25 } from "path";
+import { basename, dirname as dirname8, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve25 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname5, resolve as resolve24 } from "path";
+import { dirname as dirname7, resolve as resolve24 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
-  let currentDir = dirname5(fileURLToPath3(import.meta.url));
+  let currentDir = dirname7(fileURLToPath3(import.meta.url));
   while (true) {
     const candidate = resolve24(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
@@ -12150,7 +12531,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve25(dirname6(targetDir), symlinkTarget);
+    const resolvedTarget = resolve25(dirname8(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -12187,15 +12568,15 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
   );
 }
 async function installCopy(paths, pluginKind) {
-  await ensureDir(dirname6(paths.targetDir));
+  await ensureDir(dirname8(paths.targetDir));
   await cp2(paths.sourceDir, paths.targetDir, { recursive: true });
   const packageManifest = await readPackageManifest(paths.packageRoot);
   await writeInstallMetadata(paths.targetDir, pluginKind, "copy", packageManifest);
 }
 async function installLink(paths) {
-  await ensureDir(dirname6(paths.targetDir));
+  await ensureDir(dirname8(paths.targetDir));
   await rm3(paths.targetDir, { recursive: true, force: true });
-  await ensureDir(dirname6(paths.targetDir));
+  await ensureDir(dirname8(paths.targetDir));
   await symlink(resolve25(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
@@ -12250,7 +12631,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
   };
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
-  await ensureDir(dirname6(manifestPath));
+  await ensureDir(dirname8(manifestPath));
   await writeFile6(manifestPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
@@ -12398,7 +12779,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   };
   existing[name].lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   existing[name].autoUpdate = true;
-  await ensureDir(dirname6(manifestPath));
+  await ensureDir(dirname8(manifestPath));
   await writeFile6(manifestPath, `${JSON.stringify(existing, null, 2)}
 `, "utf-8");
 }
@@ -12433,11 +12814,11 @@ async function ensureClaudeUserMarketplace() {
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
   const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
-  const pluginsDir = dirname6(normalizedTargetDir);
+  const pluginsDir = dirname8(normalizedTargetDir);
   if (basename(pluginsDir) !== "plugins") {
     return null;
   }
-  const rootDir = dirname6(pluginsDir);
+  const rootDir = dirname8(pluginsDir);
   const manifestPath = resolve25(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
@@ -12603,7 +12984,7 @@ async function installManagedPlugin(options) {
   };
 }
 function buildMarketplaceSourcePath(pluginTargetDir, marketplacePath) {
-  const relPath = relative2(dirname6(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
+  const relPath = relative2(dirname8(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
   if (relPath === "") {
     return ".";
   }
@@ -12640,7 +13021,7 @@ async function readMarketplaceFile(marketplacePath) {
   };
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
-  await ensureDir(dirname6(marketplacePath));
+  await ensureDir(dirname8(marketplacePath));
   await writeFile6(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
@@ -12867,8 +13248,8 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-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 { readFile as readFile17, readdir as readdir11, mkdir as mkdir4, copyFile, rm as rm4 } from "fs/promises";
+import { dirname as dirname9, 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 = [
@@ -12880,7 +13261,7 @@ var REQUIRED_SKILLS = [
   "create-project"
 ];
 function getVendoredSkillsDir() {
-  const here = dirname7(fileURLToPath4(import.meta.url));
+  const here = dirname9(fileURLToPath4(import.meta.url));
   return resolve26(here, "..", "vendor", "syntaur-skills", "skills");
 }
 function defaultSkillTargetDir(target) {
@@ -12913,7 +13294,7 @@ async function filesEqual(a, b) {
   }
 }
 async function copyDir(srcDir, destDir) {
-  await mkdir3(destDir, { recursive: true });
+  await mkdir4(destDir, { recursive: true });
   const entries = await readdir11(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const src = join3(srcDir, entry.name);
@@ -12947,7 +13328,7 @@ async function installSkills(options) {
     );
   }
   const results = [];
-  await mkdir3(targetRoot, { recursive: true });
+  await mkdir4(targetRoot, { recursive: true });
   for (const skill of REQUIRED_SKILLS) {
     const srcDir = join3(source, skill);
     const destDir = join3(targetRoot, skill);
@@ -13134,7 +13515,7 @@ async function installPluginCommand(options) {
 init_paths();
 init_fs();
 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 { resolve as resolve28, dirname as dirname11 } from "path";
 import { homedir as homedir4 } from "os";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
@@ -13142,7 +13523,7 @@ import { fileURLToPath as fileURLToPath5 } from "url";
 init_paths();
 init_fs();
 import { readFile as readFile18, writeFile as writeFile7 } from "fs/promises";
-import { resolve as resolve27, dirname as dirname8 } from "path";
+import { resolve as resolve27, dirname as dirname10 } from "path";
 import { spawnSync } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -13263,7 +13644,7 @@ function renderPreview(config, statuslineScript, cwd) {
     env: {
       ...process.env,
       // Force the child to pick up the freshly-written config from install root.
-      HOME: dirname8(dirname8(statuslineScript))
+      HOME: dirname10(dirname10(statuslineScript))
     }
   });
   if (res.status !== 0) return null;
@@ -13314,7 +13695,7 @@ async function configureStatuslineCommand(options = {}) {
     console.log("(preview mode \u2014 config NOT written)");
     return;
   }
-  await ensureDir(dirname8(configPath));
+  await ensureDir(dirname10(configPath));
   await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log("Wrote statusline config:");
   console.log(`  path:      ${configPath}`);
@@ -13341,7 +13722,7 @@ async function configureStatuslineCommand(options = {}) {
 async function writeDefaultConfigIfMissing(installRoot) {
   const path = getConfigPath(installRoot);
   if (await fileExists(path)) return;
-  await ensureDir(dirname8(path));
+  await ensureDir(dirname10(path));
   const defaultConfig = {
     segments: ["git", "assignment", "session"],
     separator: " \xB7 "
@@ -13351,7 +13732,7 @@ async function writeDefaultConfigIfMissing(installRoot) {
 
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
-  const here = dirname9(fileURLToPath5(import.meta.url));
+  const here = dirname11(fileURLToPath5(import.meta.url));
   return resolve28(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
@@ -13368,7 +13749,7 @@ async function readSettingsJson(settingsPath) {
   }
 }
 async function writeSettingsJson(settingsPath, data) {
-  await ensureDir(dirname9(settingsPath));
+  await ensureDir(dirname11(settingsPath));
   await writeFile8(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 async function resolveMode(mode, existingCommand, ourCommand) {
@@ -13403,7 +13784,7 @@ function extractExistingCommand(settings) {
   };
 }
 async function backupSettings(settingsSnapshot, backupPath) {
-  await ensureDir(dirname9(backupPath));
+  await ensureDir(dirname11(backupPath));
   await writeFile8(
     backupPath,
     JSON.stringify(
@@ -13420,7 +13801,7 @@ async function backupSettings(settingsSnapshot, backupPath) {
   );
 }
 async function installScript(sourceScript, destScript, link) {
-  await ensureDir(dirname9(destScript));
+  await ensureDir(dirname11(destScript));
   try {
     const s = await lstat2(destScript);
     if (s.isSymbolicLink() || s.isFile()) {
@@ -13488,7 +13869,7 @@ exec ${existingCommand}
       wrapTarget = wrapperPath;
     }
   }
-  await ensureDir(dirname9(confPath));
+  await ensureDir(dirname11(confPath));
   await writeFile8(
     confPath,
     wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
@@ -14408,6 +14789,19 @@ async function disablePlaybookCommand(slug) {
   }
 }
 
+// src/commands/regen-playbook-manifest.ts
+init_paths();
+init_playbooks();
+init_fs();
+async function regenPlaybookManifestCommand() {
+  const dir = playbooksDir();
+  if (!await fileExists(dir)) {
+    throw new Error(`Playbooks directory not found at ${dir}. Run "syntaur init" first.`);
+  }
+  await rebuildPlaybookManifest(dir);
+  console.log(`Rebuilt playbook manifest at ${dir}/manifest.md`);
+}
+
 // src/commands/todo.ts
 init_paths();
 init_parser2();
@@ -14417,7 +14811,7 @@ init_slug();
 import { Command } from "commander";
 import { readFile as readFile23 } from "fs/promises";
 import { resolve as resolve36 } from "path";
-var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
+var WORKSPACE_REGEX3 = /^[a-z0-9_][a-z0-9-]*$/;
 async function resolveScope(options) {
   const flagCount = [Boolean(options.project), Boolean(options.workspace), Boolean(options.global)].filter(Boolean).length;
   if (flagCount > 1) {
@@ -14435,7 +14829,7 @@ async function resolveScope(options) {
     return { kind: "project", id: options.project, todosPath: projectTodosDir(config.defaultProjectDir, options.project) };
   }
   if (options.workspace) {
-    if (!WORKSPACE_REGEX2.test(options.workspace)) {
+    if (!WORKSPACE_REGEX3.test(options.workspace)) {
       throw new Error(`Invalid workspace name: "${options.workspace}". Use lowercase letters, numbers, hyphens, and underscores.`);
     }
     return { kind: "workspace", id: options.workspace, todosPath: todosDir() };
@@ -14886,7 +15280,7 @@ async function promoteTodos(ids, options) {
     return;
   }
   const target = options.toAssignment;
-  const { resolve: resolvePath } = await import("path");
+  const { resolve: resolvePath2 } = await import("path");
   const { readConfig: readConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
   const config = await readConfig3();
@@ -14897,16 +15291,16 @@ async function promoteTodos(ids, options) {
     if (parts.length !== 2 || !isValidSlug(parts[0]) || !isValidSlug(parts[1])) {
       throw new Error(`Invalid --to-assignment target "${target}". Use <project>/<slug> or a bare UUID.`);
     }
-    assignmentDir = resolvePath(config.defaultProjectDir, parts[0], "assignments", parts[1]);
+    assignmentDir = resolvePath2(config.defaultProjectDir, parts[0], "assignments", parts[1]);
     displayRef = `${parts[0]}/${parts[1]}`;
   } else if (UUID_REGEX.test(target)) {
-    assignmentDir = resolvePath(assignmentsDirFn(), target);
+    assignmentDir = resolvePath2(assignmentsDirFn(), target);
     displayRef = target;
   } else {
     throw new Error(`Invalid --to-assignment target "${target}". Use <project>/<slug> or a bare UUID.`);
   }
   const { fileExists: fileExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  const assignmentMdPath = resolvePath(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
   if (!await fileExists2(assignmentMdPath)) {
     throw new Error(`Target assignment not found: ${assignmentMdPath}`);
   }
@@ -14922,12 +15316,12 @@ function describeScope(scope) {
   return `workspace:${scope.id}`;
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
-  const { resolve: resolvePath } = await import("path");
+  const { resolve: resolvePath2 } = await import("path");
   const { readFile: readFile32 } = await import("fs/promises");
   const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
   const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
-  const assignmentMdPath = resolvePath(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
   let content = await readFile32(assignmentMdPath, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
@@ -15014,6 +15408,90 @@ ${item.description}
     process.exit(1);
   }
 });
+todoCommand.command("move").description("Move a todo between scopes (workspace \u2194 project \u2194 global) without converting it").argument("<id>", "Todo short ID").option("--to-workspace <slug>", "Target workspace slug").option("--to-project <slug>", "Target project slug").option("--to-global", "Move to global todos").option("--workspace <slug>", "Source workspace slug").option("--project <slug>", "Source project slug (mutually exclusive with --workspace/--global)").option("--global", "Source: global todos").action(async (id, options) => {
+  try {
+    await moveTodo(id, options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+async function moveTodo(id, options) {
+  const targetCount = [
+    Boolean(options.toWorkspace),
+    Boolean(options.toProject),
+    Boolean(options.toGlobal)
+  ].filter(Boolean).length;
+  if (targetCount !== 1) {
+    throw new Error("Specify exactly one of --to-workspace <slug>, --to-project <slug>, --to-global.");
+  }
+  const sourceScope = await resolveScope({
+    project: options.project,
+    workspace: options.workspace,
+    global: options.global
+  });
+  const targetScope = await resolveScope({
+    project: options.toProject,
+    workspace: options.toWorkspace,
+    global: options.toGlobal
+  });
+  if (sourceScope.kind === targetScope.kind && sourceScope.id === targetScope.id) {
+    throw new Error("Source and target scopes are the same; nothing to move.");
+  }
+  const sourceChecklist = await readChecklist(sourceScope.todosPath, sourceScope.id);
+  const targetChecklist = sourceScope.todosPath === targetScope.todosPath && sourceScope.id === targetScope.id ? sourceChecklist : await readChecklist(targetScope.todosPath, targetScope.id);
+  const idx = sourceChecklist.items.findIndex((i) => i.id === id);
+  if (idx === -1) {
+    throw new Error(`Todo [t:${id}] not found in scope ${describeScope(sourceScope)}.`);
+  }
+  const item = sourceChecklist.items[idx];
+  if (targetChecklist.items.some((i) => i.id === id)) {
+    throw new Error(`Todo id [t:${id}] already exists in target scope ${describeScope(targetScope)}; refusing to move (collision).`);
+  }
+  if (item.planDir) {
+    const newPlanDir = todoPlanDir(targetScope.todosPath, targetScope.id, id);
+    if (await fileExists(newPlanDir)) {
+      throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
+    }
+    const { rename: rename6, mkdir: mkdir7 } = await import("fs/promises");
+    const { dirname: dirname16 } = await import("path");
+    await mkdir7(dirname16(newPlanDir), { recursive: true });
+    await rename6(item.planDir, newPlanDir);
+    item.planDir = newPlanDir;
+  }
+  sourceChecklist.items.splice(idx, 1);
+  targetChecklist.items.push(item);
+  await writeChecklist(sourceScope.todosPath, sourceChecklist);
+  if (targetChecklist !== sourceChecklist) {
+    await writeChecklist(targetScope.todosPath, targetChecklist);
+  }
+  const sourceLabel = describeScope(sourceScope);
+  const targetLabel = describeScope(targetScope);
+  const ts = nowISO();
+  const sourceEntry = {
+    timestamp: ts,
+    itemIds: [id],
+    items: item.description,
+    session: null,
+    branch: item.branch || null,
+    summary: `Moved to ${targetLabel}`,
+    blockers: null,
+    status: null
+  };
+  const targetEntry = {
+    timestamp: ts,
+    itemIds: [id],
+    items: item.description,
+    session: null,
+    branch: item.branch || null,
+    summary: `Moved from ${sourceLabel}`,
+    blockers: null,
+    status: null
+  };
+  await appendLogEntry2(sourceScope.todosPath, sourceScope.id, sourceEntry);
+  await appendLogEntry2(targetScope.todosPath, targetScope.id, targetEntry);
+  console.log(`Moved [t:${id}] from ${sourceLabel} to ${targetLabel}`);
+}
 
 // src/commands/backup.ts
 init_config2();
@@ -15098,7 +15576,7 @@ import { Command as Command3 } from "commander";
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { readFile as readFile27 } from "fs/promises";
-import { dirname as dirname11, join as join5 } from "path";
+import { dirname as dirname13, join as join5 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
@@ -15146,7 +15624,7 @@ init_paths();
 import { resolve as resolve38, isAbsolute as isAbsolute5 } from "path";
 import { readFile as readFile24, stat as stat4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname10, join as join4 } from "path";
+import { dirname as dirname12, join as join4 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -15477,14 +15955,14 @@ async function readLocalVersion() {
 async function readLocalPkg() {
   try {
     const here = fileURLToPath6(import.meta.url);
-    let dir = dirname10(here);
+    let dir = dirname12(here);
     for (let i = 0; i < 6; i++) {
       const candidate = join4(dir, "package.json");
       try {
         const text = await readFile24(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname10(dir);
+        dir = dirname12(dir);
       }
     }
     return null;
@@ -16885,14 +17363,14 @@ async function finalize(checks) {
 async function readVersion() {
   try {
     const here = fileURLToPath7(import.meta.url);
-    let dir = dirname11(here);
+    let dir = dirname13(here);
     for (let i = 0; i < 6; i++) {
       try {
         const raw = await readFile27(join5(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname11(dir);
+        dir = dirname13(dir);
       }
     }
     return null;
@@ -17408,18 +17886,18 @@ init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath9 } from "url";
 import { readFile as readFile31 } from "fs/promises";
-import { dirname as dirname13, join as join7, resolve as resolve46 } from "path";
+import { dirname as dirname15, join as join7, resolve as resolve46 } from "path";
 import { spawn as spawn4 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { readFile as readFile30 } from "fs/promises";
-import { dirname as dirname12, join as join6 } from "path";
+import { dirname as dirname14, join as join6 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath8(scriptUrl);
-    const pkgRoot = dirname12(dirname12(scriptPath));
+    const pkgRoot = dirname14(dirname14(scriptPath));
     const raw = await readFile30(join6(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
@@ -17461,7 +17939,7 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname13(process.execPath);
+  const nodeDir = dirname15(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
   const nearNode = join7(nodeDir, npmName);
@@ -17974,6 +18452,17 @@ program.command("disable-playbook").description("Disable a playbook so agents no
     process.exit(1);
   }
 });
+program.command("regen-playbook-manifest").description("Rebuild ~/.syntaur/playbooks/manifest.md from current playbook files").action(async () => {
+  try {
+    await regenPlaybookManifestCommand();
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+});
 program.addCommand(todoCommand);
 program.addCommand(backupCommand);
 program.addCommand(doctorCommand);