syntaur 0.4.5 → 0.5.0

package/dist/dashboard/server.js

@@ -36,6 +36,9 @@ function playbooksDir() {
 function todosDir() {
   return resolve(syntaurRoot(), "todos");
 }
+function projectTodosDir(projectsDir, projectSlug) {
+  return resolve(projectsDir, projectSlug, "todos");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -457,10 +460,10 @@ var init_lifecycle = __esm({
 });
 
 // src/templates/config.ts
-function renderConfig(params) {
+function renderConfig(params2) {
   return `---
 version: "1.0"
-defaultProjectDir: ${params.defaultProjectDir}
+defaultProjectDir: ${params2.defaultProjectDir}
 onboarding:
   completed: false
 agentDefaults:
@@ -4162,7 +4165,7 @@ init_api();
 init_assignment_resolver();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 import { writeFile as writeFile5, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -4325,8 +4328,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile14 } = await import("fs/promises");
-  const raw = await readFile14(filePath, "utf-8");
+  const { readFile: readFile15 } = await import("fs/promises");
+  const raw = await readFile15(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4513,18 +4516,25 @@ function createWatcher(options) {
     if (parts.length === 0) return;
     const projectSlug = parts[0];
     let assignmentSlug;
+    let isProjectTodos = false;
     if (parts.length >= 3 && parts[1] === "assignments") {
       assignmentSlug = parts[2];
+    } else if (parts.length >= 2 && parts[1] === "todos") {
+      isProjectTodos = true;
     }
-    const debounceKey = assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
+    const debounceKey = isProjectTodos ? `todos:${projectSlug}` : assignmentSlug ? `${projectSlug}/${assignmentSlug}` : projectSlug;
     const existing = pendingEvents.get(debounceKey);
     if (existing) clearTimeout(existing);
-    const messageType = assignmentSlug ? "assignment-updated" : "project-updated";
+    const messageType = isProjectTodos ? "todos-updated" : assignmentSlug ? "assignment-updated" : "project-updated";
     pendingEvents.set(
       debounceKey,
       setTimeout(() => {
         pendingEvents.delete(debounceKey);
-        const message = {
+        const message = isProjectTodos ? {
+          type: "todos-updated",
+          projectSlug,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        } : {
           type: messageType,
           projectSlug,
           assignmentSlug,
@@ -4754,14 +4764,14 @@ init_assignment_resolver();
 init_config();
 
 // src/templates/manifest.ts
-function renderManifest(params) {
+function renderManifest(params2) {
   return `---
 version: "2.0"
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
-# Project: ${params.slug}
+# Project: ${params2.slug}
 
 ## Overview
 - [Project Overview](./project.md)
@@ -4788,24 +4798,24 @@ function escapeYamlString(value) {
 }
 
 // src/templates/project.ts
-function renderProject(params) {
-  const safeTitle = escapeYamlString(params.title);
-  const workspaceLine = params.workspace ? `
-workspace: ${params.workspace}` : "";
+function renderProject(params2) {
+  const safeTitle = escapeYamlString(params2.title);
+  const workspaceLine = params2.workspace ? `
+workspace: ${params2.workspace}` : "";
   return `---
-id: ${params.id}
-slug: ${params.slug}
+id: ${params2.id}
+slug: ${params2.slug}
 title: ${safeTitle}
 archived: false
 archivedAt: null
 archivedReason: null
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 externalIds: []
 tags: []${workspaceLine}
 ---
 
-# ${params.title}
+# ${params2.title}
 
 ## Overview
 
@@ -4818,17 +4828,17 @@ 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 workspaceGroupLine = params.workspaceGroup ? `
-workspaceGroup: ${params.workspaceGroup}` : "";
-  const typeYaml = `type: ${params.type ?? "feature"}`;
-  const todosSection = params.includeTodos ? `## Todos
+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
@@ -4840,15 +4850,15 @@ Never delete superseded todos \u2014 preserve the history.
 
 ` : "";
   return `---
-id: ${params.id}
-slug: ${params.slug}
+id: ${params2.id}
+slug: ${params2.slug}
 title: ${safeTitle}
 ${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}
@@ -4862,7 +4872,7 @@ workspace:
 tags: []
 ---
 
-# ${params.title}
+# ${params2.title}
 
 ## Objective
 
@@ -4889,10 +4899,10 @@ ${todosSection}## Context
 }
 
 // src/templates/scratchpad.ts
-function renderScratchpad(params) {
+function renderScratchpad(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 ---
 
 # Scratchpad
@@ -4902,10 +4912,10 @@ No working notes yet.
 }
 
 // src/templates/handoff.ts
-function renderHandoff(params) {
+function renderHandoff(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 handoffCount: 0
 ---
 
@@ -4916,12 +4926,12 @@ No handoffs recorded yet.
 }
 
 // src/templates/progress.ts
-function renderProgress(params) {
+function renderProgress(params2) {
   return `---
-assignment: ${params.assignment}
+assignment: ${params2.assignment}
 entryCount: 0
-generated: "${params.timestamp}"
-updated: "${params.timestamp}"
+generated: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 ---
 
 # Progress
@@ -4931,12 +4941,12 @@ No progress yet.
 }
 
 // src/templates/comments.ts
-function renderComments(params) {
+function renderComments(params2) {
   return `---
-assignment: ${params.assignment}
+assignment: ${params2.assignment}
 entryCount: 0
-generated: "${params.timestamp}"
-updated: "${params.timestamp}"
+generated: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 ---
 
 # Comments
@@ -4964,10 +4974,10 @@ function formatCommentEntry(comment) {
 }
 
 // src/templates/decision-record.ts
-function renderDecisionRecord(params) {
+function renderDecisionRecord(params2) {
   return `---
-assignment: ${params.assignmentSlug}
-updated: "${params.timestamp}"
+assignment: ${params2.assignmentSlug}
+updated: "${params2.timestamp}"
 decisionCount: 0
 ---
 
@@ -4978,10 +4988,10 @@ No decisions recorded yet.
 }
 
 // src/templates/index-stubs.ts
-function renderIndexAssignments(params) {
+function renderIndexAssignments(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 by_status:
   pending: 0
@@ -4998,10 +5008,10 @@ by_status:
 |------|-------|--------|----------|----------|--------------|---------|
 `;
 }
-function renderIndexPlans(params) {
+function renderIndexPlans(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
 # Plans
@@ -5010,10 +5020,10 @@ generated: "${params.timestamp}"
 |------------|-------------|---------|
 `;
 }
-function renderIndexDecisions(params) {
+function renderIndexDecisions(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 ---
 
 # Decision Records
@@ -5022,10 +5032,10 @@ generated: "${params.timestamp}"
 |------------|-------|-----------------|---------------|---------|
 `;
 }
-function renderStatus(params) {
+function renderStatus(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 status: pending
 progress:
   total: 0
@@ -5041,7 +5051,7 @@ needsAttention:
   openQuestions: 0
 ---
 
-# Project Status: ${params.title}
+# Project Status: ${params2.title}
 
 **Status:** pending
 **Progress:** 0/0 assignments complete
@@ -5061,10 +5071,10 @@ No dependencies yet.
 - **0 unanswered** questions
 `;
 }
-function renderResourcesIndex(params) {
+function renderResourcesIndex(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 ---
 
@@ -5074,10 +5084,10 @@ total: 0
 |------|----------|--------|---------------------|---------|
 `;
 }
-function renderMemoriesIndex(params) {
+function renderMemoriesIndex(params2) {
   return `---
-project: ${params.slug}
-generated: "${params.timestamp}"
+project: ${params2.slug}
+generated: "${params2.timestamp}"
 total: 0
 ---
 
@@ -5089,19 +5099,19 @@ total: 0
 }
 
 // src/templates/playbook.ts
-function renderPlaybook(params) {
-  const whenToUse = params.whenToUse ? escapeYamlString(params.whenToUse) : "null";
+function renderPlaybook(params2) {
+  const whenToUse = params2.whenToUse ? escapeYamlString(params2.whenToUse) : "null";
   return `---
-name: ${escapeYamlString(params.name)}
-slug: ${params.slug}
-description: ${escapeYamlString(params.description)}
+name: ${escapeYamlString(params2.name)}
+slug: ${params2.slug}
+description: ${escapeYamlString(params2.description)}
 when_to_use: ${whenToUse}
-created: "${params.timestamp}"
-updated: "${params.timestamp}"
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
 tags: []
 ---
 
-# ${params.name}
+# ${params2.name}
 
 <!-- Write imperative rules and workflows here. Keep it under 50 lines. -->
 `;
@@ -6987,14 +6997,17 @@ function getWorkspaceParam(value) {
   return value ?? "";
 }
 var writeLocks = /* @__PURE__ */ new Map();
-function withLock(workspace, fn) {
-  const prev = writeLocks.get(workspace) ?? Promise.resolve();
+function withLock(lockKey, fn) {
+  const prev = writeLocks.get(lockKey) ?? Promise.resolve();
   const next = prev.then(fn);
-  writeLocks.set(workspace, next.then(() => {
+  writeLocks.set(lockKey, next.then(() => {
   }, () => {
   }));
   return next;
 }
+function wsLock(workspace, fn) {
+  return withLock(`ws:${workspace}`, fn);
+}
 function createTodosRouter(todosDir2, broadcast) {
   const router = Router5();
   function broadcastUpdate() {
@@ -7053,7 +7066,7 @@ function createTodosRouter(todosDir2, broadcast) {
         res.status(400).json({ error: "description is required" });
         return;
       }
-      const item = await withLock(workspace, async () => {
+      const item = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const existingIds = new Set(checklist.items.map((i) => i.id));
         const id = generateUniqueId(existingIds);
@@ -7082,7 +7095,7 @@ function createTodosRouter(todosDir2, broadcast) {
         res.status(400).json({ error: "ids must be an array of strings" });
         return;
       }
-      const items = await withLock(workspace, async () => {
+      const items = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
         const reordered = [];
@@ -7117,8 +7130,8 @@ function createTodosRouter(todosDir2, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve18 } = await import("path");
-      const { readFile: readFile14 } = await import("fs/promises");
+      const { resolve: resolve19 } = await import("path");
+      const { readFile: readFile15 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
@@ -7134,10 +7147,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve18(todosDir2, "archive"));
+      await ensureDir(resolve19(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile14(archFile, "utf-8");
+        archContent = await readFile15(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -7206,7 +7219,7 @@ workspace: ${workspace}
   router.patch("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7228,7 +7241,7 @@ workspace: ${workspace}
   router.delete("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const deleted = await withLock(workspace, async () => {
+      const deleted = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const idx = checklist.items.findIndex((i) => i.id === req.params.id);
         if (idx === -1) return false;
@@ -7249,7 +7262,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/start", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return { error: "not_found" };
@@ -7276,7 +7289,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/complete", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7310,7 +7323,7 @@ workspace: ${workspace}
     try {
       const reason = req.body.reason || null;
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7343,7 +7356,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/reopen", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7365,7 +7378,7 @@ workspace: ${workspace}
   router.post("/:workspace/:id/unblock", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const result = await withLock(workspace, async () => {
+      const result = await wsLock(workspace, async () => {
         const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
@@ -7387,9 +7400,606 @@ workspace: ${workspace}
   return router;
 }
 
+// src/dashboard/api-project-todos.ts
+init_parser2();
+init_fs();
+init_paths();
+import { Router as Router6 } from "express";
+import { mkdir as mkdir2, readFile as readFile13 } from "fs/promises";
+import { resolve as resolve16 } from "path";
+var writeLocks2 = /* @__PURE__ */ new Map();
+function projLock(slug, fn) {
+  const key = `proj:${slug}`;
+  const prev = writeLocks2.get(key) ?? Promise.resolve();
+  const next = prev.then(fn);
+  writeLocks2.set(key, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+function getProjectIdParam(value) {
+  if (Array.isArray(value)) return value[0] ?? "";
+  return value ?? "";
+}
+function params(req) {
+  return req.params;
+}
+async function projectExists(projectsDir, slug) {
+  return fileExists(resolve16(projectsDir, slug, "project.md"));
+}
+async function ensureProjectTodosDir(projectsDir, slug) {
+  const todosDir2 = projectTodosDir(projectsDir, slug);
+  try {
+    await mkdir2(todosDir2, { recursive: false });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err;
+  }
+  try {
+    await mkdir2(resolve16(todosDir2, "archive"), { recursive: false });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EEXIST") return;
+    if (code === "ENOENT") {
+      const e = new Error("PROJECT_GONE");
+      e.code = "PROJECT_GONE";
+      throw e;
+    }
+    throw err;
+  }
+}
+function notFound(res, slug) {
+  res.status(404).json({ error: `Project "${slug}" not found` });
+}
+function createProjectTodosRouter(projectsDir, broadcast) {
+  const router = Router6({ mergeParams: true });
+  function broadcastUpdate(projectSlug) {
+    broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  function validateProjectId(req, res, next) {
+    const slug = getProjectIdParam(params(req).projectId);
+    if (!slug || !isValidSlug(slug)) {
+      res.status(400).json({ error: `Invalid project slug: "${slug}"` });
+      return;
+    }
+    next();
+  }
+  router.use(validateProjectId);
+  router.get("/", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      res.json({
+        workspace: checklist.workspace,
+        archiveInterval: checklist.archiveInterval,
+        items: checklist.items,
+        counts: computeCounts(checklist.items)
+      });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todos" });
+    }
+  });
+  router.post("/", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const { description, tags } = req.body;
+      if (!description || typeof description !== "string") {
+        res.status(400).json({ error: "description is required" });
+        return;
+      }
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const item = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return null;
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const existingIds = new Set(checklist.items.map((i) => i.id));
+        const id = generateUniqueId(existingIds);
+        const newItem = {
+          id,
+          description,
+          status: "open",
+          tags: Array.isArray(tags) ? tags : [],
+          session: null
+        };
+        checklist.workspace = slug;
+        checklist.items.push(newItem);
+        await writeChecklist(todosDir2, checklist);
+        return newItem;
+      });
+      if (!item) {
+        notFound(res, slug);
+        return;
+      }
+      broadcastUpdate(slug);
+      res.status(201).json(item);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to add todo" });
+    }
+  });
+  router.post("/reorder", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const { ids } = req.body;
+      if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string")) {
+        res.status(400).json({ error: "ids must be an array of strings" });
+        return;
+      }
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const items = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return null;
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
+        const reordered = [];
+        for (const id of ids) {
+          const item = itemMap.get(id);
+          if (item) {
+            reordered.push(item);
+            itemMap.delete(id);
+          }
+        }
+        for (const item of itemMap.values()) reordered.push(item);
+        checklist.workspace = slug;
+        checklist.items = reordered;
+        await writeChecklist(todosDir2, checklist);
+        return reordered;
+      });
+      if (!items) {
+        notFound(res, slug);
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json({ items });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to reorder todos" });
+    }
+  });
+  router.get("/log", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const log = await readLog(todosDir2, slug);
+      res.json(log);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
+    }
+  });
+  router.post("/archive", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      await ensureProjectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      const log = await readLog(todosDir2, slug);
+      const completedIds = new Set(
+        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+      );
+      if (completedIds.size === 0) {
+        res.json({ archived: 0, message: "No completed items to archive" });
+        return;
+      }
+      const toArchive = log.entries.filter(
+        (e) => e.itemIds.every((id) => completedIds.has(id))
+      );
+      const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
+      let archContent = "";
+      if (await fileExists(archFile)) {
+        archContent = await readFile13(archFile, "utf-8");
+        archContent = archContent.trimEnd() + "\n\n";
+      } else {
+        archContent = `---
+workspace: ${slug}
+---
+
+# Archive
+
+`;
+      }
+      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+      for (const item of completedItems) {
+        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+`;
+      }
+      archContent += "\n";
+      for (const entry of toArchive) {
+        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+`;
+        if (entry.items) archContent += `**Items:** ${entry.items}
+`;
+        if (entry.session) archContent += `**Session:** ${entry.session}
+`;
+        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+`;
+        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+`;
+        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+`;
+        archContent += "\n";
+      }
+      await writeFileForce(archFile, archContent);
+      checklist.workspace = slug;
+      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+      await writeChecklist(todosDir2, checklist);
+      broadcastUpdate(slug);
+      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to archive" });
+    }
+  });
+  router.get("/log/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const log = await readLog(todosDir2, slug);
+      const entries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
+      res.json({ workspace: log.workspace, entries });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
+    }
+  });
+  router.get("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const todosDir2 = projectTodosDir(projectsDir, slug);
+      const checklist = await readChecklist(todosDir2, slug);
+      const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+      if (!item) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      const log = await readLog(todosDir2, slug);
+      const logEntries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
+      res.json({ ...item, log: logEntries });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
+    }
+  });
+  router.patch("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        if (req.body.description !== void 0) item.description = req.body.description;
+        if (Array.isArray(req.body.tags)) item.tags = req.body.tags;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to update todo" });
+    }
+  });
+  router.delete("/:id", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const deleted = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const idx = checklist.items.findIndex((i) => i.id === (params(req).id ?? ""));
+        if (idx === -1) return false;
+        checklist.items.splice(idx, 1);
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return true;
+      });
+      if (deleted === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!deleted) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json({ deleted: params(req).id ?? "" });
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to delete todo" });
+    }
+  });
+  router.post("/:id/start", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return { error: "gone" };
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return { error: "not_found" };
+        if (item.status === "in_progress") return { error: "conflict", session: item.session };
+        item.status = "in_progress";
+        item.session = req.body.session || null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { item: { ...item } };
+      });
+      if ("error" in result) {
+        if (result.error === "gone") {
+          notFound(res, slug);
+          return;
+        }
+        if (result.error === "not_found") {
+          res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+          return;
+        }
+        res.status(409).json({ error: `Todo is already in progress (session: ${result.session})` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result.item);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to start todo" });
+    }
+  });
+  router.post("/:id/complete", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "completed";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        const entry = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          itemIds: [item.id],
+          items: item.description,
+          session: req.body.session || null,
+          branch: req.body.branch || null,
+          summary: req.body.summary || "Completed.",
+          blockers: null,
+          status: null
+        };
+        await appendLogEntry2(todosDir2, slug, entry);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to complete todo" });
+    }
+  });
+  router.post("/:id/block", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      const reason = req.body.reason || null;
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "blocked";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        const entry = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          itemIds: [item.id],
+          items: item.description,
+          session: req.body.session || null,
+          branch: null,
+          summary: reason || "Blocked.",
+          blockers: reason,
+          status: "blocked"
+        };
+        await appendLogEntry2(todosDir2, slug, entry);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to block todo" });
+    }
+  });
+  router.post("/:id/reopen", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "open";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to reopen todo" });
+    }
+  });
+  router.post("/:id/unblock", async (req, res) => {
+    try {
+      const slug = getProjectIdParam(params(req).projectId);
+      if (!await projectExists(projectsDir, slug)) {
+        notFound(res, slug);
+        return;
+      }
+      const result = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const item = checklist.items.find((i) => i.id === (params(req).id ?? ""));
+        if (!item) return null;
+        item.status = "open";
+        item.session = null;
+        checklist.workspace = slug;
+        await writeChecklist(todosDir2, checklist);
+        return { ...item };
+      });
+      if (result === "gone") {
+        notFound(res, slug);
+        return;
+      }
+      if (!result) {
+        res.status(404).json({ error: `Todo "${params(req).id ?? ""}" not found` });
+        return;
+      }
+      broadcastUpdate(slug);
+      res.json(result);
+    } catch (error) {
+      if (error.code === "PROJECT_GONE") {
+        notFound(res, getProjectIdParam(params(req).projectId));
+        return;
+      }
+      res.status(500).json({ error: error instanceof Error ? error.message : "Failed to unblock todo" });
+    }
+  });
+  return router;
+}
+
 // src/dashboard/api-backup.ts
 init_config2();
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -7397,8 +8007,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm2, readFile as readFile13, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
-import { resolve as resolve16, join as join2 } from "path";
+import { cp, mkdtemp, rm as rm2, readFile as readFile14, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { resolve as resolve17, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -7438,7 +8048,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve16(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve17(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -7449,7 +8059,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open(lockPath, "wx");
@@ -7458,7 +8068,7 @@ async function acquireLock() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile13(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile14(lockPath, "utf-8").catch(() => "");
       throw new Error(
         `Backup operation already in progress (lock file at ${lockPath}, pid ${pid.trim() || "unknown"}). If stale, delete the file and retry.`
       );
@@ -7496,7 +8106,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve16(dest, ".."));
+    await ensureDir(resolve17(dest, ".."));
     await cp(src, dest, { force: true });
   }
 }
@@ -7505,7 +8115,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile13(configPath, "utf-8");
+  const content = await readFile14(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -7544,7 +8154,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve16(destPath, ".."));
+        await ensureDir(resolve17(destPath, ".."));
         await writeFile4(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -7598,7 +8208,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve16(localPath, ".."));
+    await ensureDir(resolve17(localPath, ".."));
     await cp(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -7699,7 +8309,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve16(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve17(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -7712,7 +8322,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router6();
+  const router = Router7();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -8036,7 +8646,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve17(syntaurRoot(), "config.md")
+        resolve18(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -8260,15 +8870,16 @@ function createDashboardServer(options) {
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
+  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir, broadcast));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
-    app.use("/assets", express.static(resolve17(dashboardDistPath, "assets")));
+    app.use("/assets", express.static(resolve18(dashboardDistPath, "assets")));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve17(dashboardDistPath, "index.html");
+      const indexPath = resolve18(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -8306,7 +8917,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve17(syntaurRoot(), "dashboard-port");
+          const portFile = resolve18(syntaurRoot(), "dashboard-port");
           writeFile5(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -8323,7 +8934,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve17(syntaurRoot(), "dashboard-port");
+      const portFile = resolve18(syntaurRoot(), "dashboard-port");
       await unlink4(portFile).catch(() => {
       });
       server.closeAllConnections?.();