syntaur 0.6.0 → 0.6.1

package/dist/dashboard/server.js

@@ -8172,37 +8172,62 @@ init_fs_migration();
 // src/dashboard/api-todos.ts
 init_parser2();
 init_fs();
+init_paths();
 import { Router as Router5 } from "express";
 import { readdir as readdir8 } 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 dirname3 } 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, projectsDir) {
   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)) {
@@ -8601,7 +8626,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: readConfig2 } = 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));
@@ -8631,18 +8656,18 @@ workspace: ${workspace}
             const parts = tg.split("/");
             if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
             const config = await readConfig2();
-            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 readFile15(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
@@ -8686,6 +8711,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 (!projectsDir) {
+          res.status(500).json({ error: "Server not configured with projectsDir; cannot move to project scope" });
+          return;
+        }
+        const slug = to.project;
+        const projectMd = resolvePath(projectsDir, 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(projectsDir, 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(dirname3(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);
@@ -8718,18 +8852,9 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router6 } from "express";
-import { mkdir as mkdir2, readFile as readFile13 } from "fs/promises";
-import { resolve as resolve17 } 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 readFile13, rename as rename4 } from "fs/promises";
+import { resolve as resolve17, dirname as dirname4 } 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;
@@ -8748,7 +8873,7 @@ async function projectExists(projectsDir, slug) {
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
   try {
-    await mkdir2(todosDir2, { recursive: false });
+    await mkdir3(todosDir2, { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -8760,7 +8885,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir2(resolve17(todosDir2, "archive"), { recursive: false });
+    await mkdir3(resolve17(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -8775,11 +8900,14 @@ async function ensureProjectTodosDir(projectsDir, slug) {
 function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
-function createProjectTodosRouter(projectsDir, broadcast) {
+function createProjectTodosRouter(projectsDir, 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)) {
@@ -9327,6 +9455,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(projectsDir, 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(projectsDir, slug)) return { gone: true };
+        await ensureProjectTodosDir(projectsDir, slug);
+        const todosDir2 = projectTodosDir(projectsDir, 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 = resolve17(projectsDir, 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 = resolve17(assignmentsDirFn(), tg);
+            assignmentRef = tg;
+          } else {
+            return { error: `Invalid target.assignment "${tg}"` };
+          }
+          const assignmentMdPath2 = resolve17(assignmentDir, "assignment.md");
+          if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
+        }
+        const assignmentMdPath = resolve17(assignmentDir, "assignment.md");
+        let content = await readFile13(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(projectsDir, 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(projectsDir, tslug)) {
+          res.status(404).json({ error: `Target project "${tslug}" not found` });
+          return;
+        }
+        target = {
+          kind: "project",
+          id: tslug,
+          todosPath: projectTodosDir(projectsDir, 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(projectsDir, sourceSlug)) return { status: "gone" };
+        if (target.kind === "project" && !await projectExists(projectsDir, target.id)) {
+          return { status: "targetGone" };
+        }
+        await ensureProjectTodosDir(projectsDir, sourceSlug);
+        const sourceTodosDir = projectTodosDir(projectsDir, 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(dirname4(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;
 }
 
@@ -9340,7 +9721,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 readFile14, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename3 } from "fs/promises";
+import { cp, mkdtemp, rm as rm2, readFile as readFile14, writeFile as writeFile4, unlink as unlink3, stat, open, rename as rename5 } from "fs/promises";
 import { resolve as resolve18, join as join2 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
@@ -9552,7 +9933,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.`
@@ -9564,15 +9945,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 (err) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename3(backupPath, localPath).catch(() => {
+      await rename5(backupPath, localPath).catch(() => {
       });
     }
     await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
@@ -10311,8 +10692,8 @@ function createDashboardServer(options) {
   app.use("/api/servers", createServersRouter(serversDir2, projectsDir, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2));
   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/todos", createTodosRouter(todosDir2, broadcast, projectsDir));
+  app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir, broadcast, todosDir2));
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };