syntaur 0.1.13 → 0.1.14

package/dist/dashboard/server.js

@@ -389,6 +389,15 @@ function syntaurRoot() {
 function defaultMissionDir() {
   return resolve2(syntaurRoot(), "missions");
 }
+function serversDir() {
+  return resolve2(syntaurRoot(), "servers");
+}
+function playbooksDir() {
+  return resolve2(syntaurRoot(), "playbooks");
+}
+function todosDir() {
+  return resolve2(syntaurRoot(), "todos");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -396,6 +405,27 @@ var init_paths = __esm({
 });
 
 // src/templates/config.ts
+function renderConfig(params) {
+  return `---
+version: "1.0"
+defaultMissionDir: ${params.defaultMissionDir}
+onboarding:
+  completed: false
+agentDefaults:
+  trustLevel: medium
+  autoApprove: false
+backup:
+  repo: null
+  categories: missions, playbooks, todos, servers, config
+  lastBackup: null
+  lastRestore: null
+---
+
+# Syntaur Configuration
+
+Global configuration for the Syntaur CLI.
+`;
+}
 var init_config = __esm({
   "src/templates/config.ts"() {
     "use strict";
@@ -549,6 +579,14 @@ function serializeStatusConfig(statuses) {
   }
   return lines.join("\n");
 }
+function serializeBackupConfig(backup) {
+  const lines = ["backup:"];
+  lines.push(`  repo: ${backup.repo ?? "null"}`);
+  lines.push(`  categories: ${backup.categories}`);
+  lines.push(`  lastBackup: ${backup.lastBackup ?? "null"}`);
+  lines.push(`  lastRestore: ${backup.lastRestore ?? "null"}`);
+  return lines.join("\n");
+}
 function stripTopLevelBlock(fmBlock, key) {
   const blockStart = fmBlock.match(new RegExp(`^${key}:\\s*$`, "m"));
   if (!blockStart) {
@@ -653,6 +691,40 @@ ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+async function updateBackupConfig(backup) {
+  const configPath = resolve3(syntaurRoot(), "config.md");
+  const current = (await readConfig()).backup;
+  const nextBackup = {
+    repo: current?.repo ?? null,
+    categories: current?.categories ?? "missions, playbooks, todos, servers, config",
+    lastBackup: current?.lastBackup ?? null,
+    lastRestore: current?.lastRestore ?? null,
+    ...backup
+  };
+  const backupBlock = serializeBackupConfig(nextBackup);
+  const existing = await fileExists(configPath) ? await readFile2(configPath, "utf-8") : renderConfig({ defaultMissionDir: defaultMissionDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "1.0"
+defaultMissionDir: ${defaultMissionDir()}
+${backupBlock}
+---
+${existing}`;
+    await writeFileForce(configPath, content.replace(/\n\n---/, "\n---"));
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  const cleanedFm = stripTopLevelBlock(fmBlock, "backup");
+  const newFm = `${cleanedFm}
+${backupBlock}`.replace(/^\n+/, "");
+  const normalizedFm = newFm.replace(/\n+$/, "");
+  const newContent = `---
+${normalizedFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 async function readConfig() {
   const configPath = resolve3(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
@@ -695,6 +767,12 @@ async function readConfig() {
         "integrations.codexMarketplacePath"
       )
     },
+    backup: fm["backup.repo"] || fm["backup.categories"] ? {
+      repo: fm["backup.repo"] && fm["backup.repo"] !== "null" ? fm["backup.repo"] : null,
+      categories: fm["backup.categories"] || "missions, playbooks, todos, servers, config",
+      lastBackup: fm["backup.lastBackup"] && fm["backup.lastBackup"] !== "null" ? fm["backup.lastBackup"] : null,
+      lastRestore: fm["backup.lastRestore"] && fm["backup.lastRestore"] !== "null" ? fm["backup.lastRestore"] : null
+    } : null,
     statuses: parseStatusConfig(content)
   };
 }
@@ -720,6 +798,7 @@ var init_config2 = __esm({
         codexPluginDir: null,
         codexMarketplacePath: null
       },
+      backup: null,
       statuses: null
     };
   }
@@ -1863,17 +1942,17 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
     windows: [{ index: 0, name: "process", panes: [pane] }]
   };
 }
-async function scanAllSessions(serversDir, missionsDir, options) {
+async function scanAllSessions(serversDir2, missionsDir, options) {
   if (!options?.bypassCache && cache && Date.now() < cache.expiry) {
     return cache.data;
   }
   const tmuxAvailable = await checkTmuxAvailable();
-  const names = await listSessionFiles(serversDir);
+  const names = await listSessionFiles(serversDir2);
   const lsofOutput = await getLsofOutput();
   const workspaceRecords = await loadWorkspaceRecords(missionsDir);
   const sessions = [];
   for (const name of names) {
-    const data = await readSessionFile(serversDir, name);
+    const data = await readSessionFile(serversDir2, name);
     if (!data) continue;
     if (data.kind === "process") {
       sessions.push(await scanProcessSession(data, lsofOutput, workspaceRecords));
@@ -1885,8 +1964,8 @@ async function scanAllSessions(serversDir, missionsDir, options) {
   cache = { data: result, expiry: Date.now() + CACHE_TTL_MS };
   return result;
 }
-async function scanSingleSession(serversDir, missionsDir, name) {
-  const data = await readSessionFile(serversDir, name);
+async function scanSingleSession(serversDir2, missionsDir, name) {
+  const data = await readSessionFile(serversDir2, name);
   if (!data) return null;
   const lsofOutput = await getLsofOutput();
   const workspaceRecords = await loadWorkspaceRecords(missionsDir);
@@ -2014,15 +2093,15 @@ async function deleteWorkspace(missionsDir, name) {
   const filtered = registered.filter((w) => w !== name);
   await writeWorkspaceRegistry(missionsDir, filtered);
 }
-async function getOverview(missionsDir, serversDir) {
+async function getOverview(missionsDir, serversDir2) {
   const missionRecords = await listMissionRecords(missionsDir);
   const attention = buildAttentionItems(missionRecords);
   const recentActivity = buildRecentActivity(missionRecords);
   let serverStats;
-  if (serversDir) {
+  if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir, missionsDir);
+      const servers = await scanAllSessions2(serversDir2, missionsDir);
       if (servers.tmuxAvailable) {
         const alive = servers.sessions.filter((s) => s.alive).length;
         const totalPorts = servers.sessions.reduce((sum, s) => sum + s.windows.reduce((ws, w) => ws + w.panes.reduce((ps, p) => ps + p.ports.length, 0), 0), 0);
@@ -2068,13 +2147,13 @@ async function getOverview(missionsDir, serversDir) {
     serverStats
   };
 }
-async function getAttention(missionsDir, serversDir) {
+async function getAttention(missionsDir, serversDir2) {
   const missionRecords = await listMissionRecords(missionsDir);
   const items = buildAttentionItems(missionRecords);
-  if (serversDir) {
+  if (serversDir2) {
     try {
       const { scanAllSessions: scanAllSessions2 } = await Promise.resolve().then(() => (init_scanner(), scanner_exports));
-      const servers = await scanAllSessions2(serversDir, missionsDir);
+      const servers = await scanAllSessions2(serversDir2, missionsDir);
       for (const session of servers.sessions) {
         if (!session.alive) {
           items.push({
@@ -2745,13 +2824,13 @@ function getEditableDocumentTitle(documentType, missionSlug, assignmentSlug) {
       return missionSlug;
   }
 }
-async function listPlaybooks(playbooksDir) {
-  if (!await fileExists(playbooksDir)) return [];
-  const entries = await readdir3(playbooksDir, { withFileTypes: true });
+async function listPlaybooks(playbooksDir2) {
+  if (!await fileExists(playbooksDir2)) return [];
+  const entries = await readdir3(playbooksDir2, { withFileTypes: true });
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve6(playbooksDir, entry.name);
+    const filePath = resolve6(playbooksDir2, entry.name);
     const raw = await readFile5(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
@@ -2767,8 +2846,8 @@ async function listPlaybooks(playbooksDir) {
   }
   return playbooks.sort((a, b) => (b.updated || b.created).localeCompare(a.updated || a.created));
 }
-async function getPlaybookDetail(playbooksDir, slug) {
-  const filePath = resolve6(playbooksDir, `${slug}.md`);
+async function getPlaybookDetail(playbooksDir2, slug) {
+  const filePath = resolve6(playbooksDir2, `${slug}.md`);
   if (!await fileExists(filePath)) return null;
   const raw = await readFile5(filePath, "utf-8");
   const parsed = parsePlaybook(raw);
@@ -3042,13 +3121,13 @@ function serializeLogEntry(entry) {
   if (entry.status) lines.push(`**Status:** ${entry.status}`);
   return lines.join("\n");
 }
-function checklistPath(todosDir, workspace) {
-  return resolve13(todosDir, `${workspace}.md`);
+function checklistPath(todosDir2, workspace) {
+  return resolve13(todosDir2, `${workspace}.md`);
 }
-function logPath(todosDir, workspace) {
-  return resolve13(todosDir, `${workspace}-log.md`);
+function logPath(todosDir2, workspace) {
+  return resolve13(todosDir2, `${workspace}-log.md`);
 }
-function archivePath(todosDir, workspace, interval, now = /* @__PURE__ */ new Date()) {
+function archivePath(todosDir2, workspace, interval, now = /* @__PURE__ */ new Date()) {
   const year = now.getFullYear();
   const month = String(now.getMonth() + 1).padStart(2, "0");
   const day = String(now.getDate()).padStart(2, "0");
@@ -3070,32 +3149,32 @@ function archivePath(todosDir, workspace, interval, now = /* @__PURE__ */ new Da
     default:
       suffix = `${year}-${month}-${day}`;
   }
-  return resolve13(todosDir, "archive", `${workspace}-${suffix}.md`);
+  return resolve13(todosDir2, "archive", `${workspace}-${suffix}.md`);
 }
-async function readChecklist(todosDir, workspace) {
-  const path = checklistPath(todosDir, workspace);
+async function readChecklist(todosDir2, workspace) {
+  const path = checklistPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, archiveInterval: "weekly", items: [] };
   }
   const content = await readFile10(path, "utf-8");
   return parseChecklist(content);
 }
-async function writeChecklist(todosDir, checklist) {
-  await ensureDir(todosDir);
-  const path = checklistPath(todosDir, checklist.workspace);
+async function writeChecklist(todosDir2, checklist) {
+  await ensureDir(todosDir2);
+  const path = checklistPath(todosDir2, checklist.workspace);
   await writeFileForce(path, serializeChecklist(checklist));
 }
-async function readLog(todosDir, workspace) {
-  const path = logPath(todosDir, workspace);
+async function readLog(todosDir2, workspace) {
+  const path = logPath(todosDir2, workspace);
   if (!await fileExists(path)) {
     return { workspace, entries: [] };
   }
   const content = await readFile10(path, "utf-8");
   return parseLog(content);
 }
-async function appendLogEntry2(todosDir, workspace, entry) {
-  await ensureDir(todosDir);
-  const path = logPath(todosDir, workspace);
+async function appendLogEntry2(todosDir2, workspace, entry) {
+  await ensureDir(todosDir2);
+  const path = logPath(todosDir2, workspace);
   let content;
   if (await fileExists(path)) {
     content = await readFile10(path, "utf-8");
@@ -3135,16 +3214,16 @@ var init_parser2 = __esm({
 init_api();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 import { homedir as homedir2 } from "os";
-import { writeFile as writeFile3, unlink as unlink3 } from "fs/promises";
+import { writeFile as writeFile4, unlink as unlink4 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/watcher.ts
 import { watch } from "chokidar";
 import { relative, sep } from "path";
 function createWatcher(options) {
-  const { missionsDir, serversDir, playbooksDir, todosDir, onMessage, debounceMs = 300 } = options;
+  const { missionsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, onMessage, debounceMs = 300 } = options;
   const pendingEvents = /* @__PURE__ */ new Map();
   const missionsWatcher = watch(missionsDir, {
     ignoreInitial: true,
@@ -3183,7 +3262,7 @@ function createWatcher(options) {
   missionsWatcher.on("add", handleMissionChange);
   missionsWatcher.on("unlink", handleMissionChange);
   let serversWatcher = null;
-  if (serversDir) {
+  if (serversDir2) {
     let handleServerChange2 = function() {
       const debounceKey = "__servers__";
       const existing = pendingEvents.get(debounceKey);
@@ -3201,7 +3280,7 @@ function createWatcher(options) {
       );
     };
     var handleServerChange = handleServerChange2;
-    serversWatcher = watch(serversDir, {
+    serversWatcher = watch(serversDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -3212,7 +3291,7 @@ function createWatcher(options) {
     serversWatcher.on("unlink", handleServerChange2);
   }
   let playbooksWatcher = null;
-  if (playbooksDir) {
+  if (playbooksDir2) {
     let handlePlaybookChange2 = function() {
       const debounceKey = "__playbooks__";
       const existing = pendingEvents.get(debounceKey);
@@ -3230,7 +3309,7 @@ function createWatcher(options) {
       );
     };
     var handlePlaybookChange = handlePlaybookChange2;
-    playbooksWatcher = watch(playbooksDir, {
+    playbooksWatcher = watch(playbooksDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -3241,7 +3320,7 @@ function createWatcher(options) {
     playbooksWatcher.on("unlink", handlePlaybookChange2);
   }
   let todosWatcher = null;
-  if (todosDir) {
+  if (todosDir2) {
     let handleTodoChange2 = function() {
       const debounceKey = "__todos__";
       const existing = pendingEvents.get(debounceKey);
@@ -3259,7 +3338,7 @@ function createWatcher(options) {
       );
     };
     var handleTodoChange = handleTodoChange2;
-    todosWatcher = watch(todosDir, {
+    todosWatcher = watch(todosDir2, {
       ignoreInitial: true,
       persistent: true,
       depth: 1,
@@ -4470,11 +4549,11 @@ function createWriteRouter(missionsDir) {
 init_servers();
 init_scanner();
 import { Router as Router2 } from "express";
-function createServersRouter(serversDir, missionsDir) {
+function createServersRouter(serversDir2, missionsDir) {
   const router = Router2();
   router.get("/", async (_req, res) => {
     try {
-      const result = await scanAllSessions(serversDir, missionsDir);
+      const result = await scanAllSessions(serversDir2, missionsDir);
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Scan failed" });
@@ -4482,7 +4561,7 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.get("/:name", async (req, res) => {
     try {
-      const session = await scanSingleSession(serversDir, missionsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, missionsDir, req.params.name);
       if (!session) {
         res.status(404).json({ error: "Session not found" });
         return;
@@ -4500,12 +4579,12 @@ function createServersRouter(serversDir, missionsDir) {
         return;
       }
       const sanitized = sanitizeSessionName(name);
-      const existing = await readSessionFile(serversDir, sanitized);
+      const existing = await readSessionFile(serversDir2, sanitized);
       if (existing) {
         res.status(409).json({ error: `Session "${sanitized}" already registered` });
         return;
       }
-      await registerSession(serversDir, name);
+      await registerSession(serversDir2, name);
       clearScanCache();
       res.status(201).json({ name: sanitized });
     } catch (error) {
@@ -4514,12 +4593,12 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.delete("/:name", async (req, res) => {
     try {
-      const data = await readSessionFile(serversDir, req.params.name);
+      const data = await readSessionFile(serversDir2, req.params.name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      await removeSession(serversDir, req.params.name);
+      await removeSession(serversDir2, req.params.name);
       clearScanCache();
       res.json({ removed: req.params.name });
     } catch (error) {
@@ -4528,12 +4607,12 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.post("/refresh", async (_req, res) => {
     try {
-      const names = await listSessionFiles(serversDir);
+      const names = await listSessionFiles(serversDir2);
       for (const name of names) {
-        await updateLastRefreshed(serversDir, name);
+        await updateLastRefreshed(serversDir2, name);
       }
       clearScanCache();
-      const result = await scanAllSessions(serversDir, missionsDir, { bypassCache: true });
+      const result = await scanAllSessions(serversDir2, missionsDir, { bypassCache: true });
       res.json(result);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4541,14 +4620,14 @@ function createServersRouter(serversDir, missionsDir) {
   });
   router.post("/:name/refresh", async (req, res) => {
     try {
-      const data = await readSessionFile(serversDir, req.params.name);
+      const data = await readSessionFile(serversDir2, req.params.name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      await updateLastRefreshed(serversDir, req.params.name);
+      await updateLastRefreshed(serversDir2, req.params.name);
       clearScanCache();
-      const session = await scanSingleSession(serversDir, missionsDir, req.params.name);
+      const session = await scanSingleSession(serversDir2, missionsDir, req.params.name);
       res.json(session);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Refresh failed" });
@@ -4557,7 +4636,7 @@ function createServersRouter(serversDir, missionsDir) {
   router.patch("/:name/panes/:windowIndex/:paneIndex/assignment", async (req, res) => {
     try {
       const { name, windowIndex, paneIndex } = req.params;
-      const data = await readSessionFile(serversDir, name);
+      const data = await readSessionFile(serversDir2, name);
       if (!data) {
         res.status(404).json({ error: "Session not found" });
         return;
@@ -4565,7 +4644,7 @@ function createServersRouter(serversDir, missionsDir) {
       const body = req.body;
       if (body === null || body && body.mission && body.assignment) {
         await setOverride(
-          serversDir,
+          serversDir2,
           name,
           parseInt(windowIndex, 10),
           parseInt(paneIndex, 10),
@@ -4701,8 +4780,8 @@ async function migrateFromMarkdown(missionsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, missionSlug) {
-  const { readFile: readFile11 } = await import("fs/promises");
-  const raw = await readFile11(filePath, "utf-8");
+  const { readFile: readFile12 } = await import("fs/promises");
+  const raw = await readFile12(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -4954,13 +5033,13 @@ init_parser();
 init_timestamp();
 import { resolve as resolve11 } from "path";
 import { readdir as readdir5, readFile as readFile8 } from "fs/promises";
-async function rebuildPlaybookManifest(playbooksDir) {
-  if (!await fileExists(playbooksDir)) return;
-  const entries = await readdir5(playbooksDir, { withFileTypes: true });
+async function rebuildPlaybookManifest(playbooksDir2) {
+  if (!await fileExists(playbooksDir2)) return;
+  const entries = await readdir5(playbooksDir2, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const raw = await readFile8(resolve11(playbooksDir, entry.name), "utf-8");
+    const raw = await readFile8(resolve11(playbooksDir2, entry.name), "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     rows.push({
@@ -4990,15 +5069,15 @@ async function rebuildPlaybookManifest(playbooksDir) {
     }
   }
   lines.push("");
-  await writeFileForce(resolve11(playbooksDir, "manifest.md"), lines.join("\n"));
+  await writeFileForce(resolve11(playbooksDir2, "manifest.md"), lines.join("\n"));
 }
 
 // src/dashboard/api-playbooks.ts
-function createPlaybooksRouter(playbooksDir) {
+function createPlaybooksRouter(playbooksDir2) {
   const router = Router4();
   router.get("/", async (_req, res) => {
     try {
-      const playbooks = await listPlaybooks(playbooksDir);
+      const playbooks = await listPlaybooks(playbooksDir2);
       res.json({ playbooks, generatedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to list playbooks" });
@@ -5019,7 +5098,7 @@ function createPlaybooksRouter(playbooksDir) {
   });
   router.get("/:slug", async (req, res) => {
     try {
-      const detail = await getPlaybookDetail(playbooksDir, req.params.slug);
+      const detail = await getPlaybookDetail(playbooksDir2, req.params.slug);
       if (!detail) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5031,7 +5110,7 @@ function createPlaybooksRouter(playbooksDir) {
   });
   router.get("/:slug/edit", async (req, res) => {
     try {
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
@@ -5060,14 +5139,14 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(400).json({ error: `Invalid or missing slug: "${slug}"` });
         return;
       }
-      await ensureDir(playbooksDir);
-      const filePath = resolve12(playbooksDir, `${slug}.md`);
+      await ensureDir(playbooksDir2);
+      const filePath = resolve12(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
       }
       await writeFileForce(filePath, content);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.status(201).json({ slug, path: filePath });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to create playbook" });
@@ -5080,13 +5159,13 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(400).json({ error: "content is required" });
         return;
       }
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
       await writeFileForce(filePath, content);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: req.params.slug, path: filePath });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to update playbook" });
@@ -5098,13 +5177,13 @@ function createPlaybooksRouter(playbooksDir) {
         res.status(403).json({ error: "The playbook manifest cannot be deleted" });
         return;
       }
-      const filePath = resolve12(playbooksDir, `${req.params.slug}.md`);
+      const filePath = resolve12(playbooksDir2, `${req.params.slug}.md`);
       if (!await fileExists(filePath)) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
       await unlink2(filePath);
-      await rebuildPlaybookManifest(playbooksDir);
+      await rebuildPlaybookManifest(playbooksDir2);
       res.json({ deleted: req.params.slug });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to delete playbook" });
@@ -5134,7 +5213,7 @@ function withLock(workspace, fn) {
   }));
   return next;
 }
-function createTodosRouter(todosDir, broadcast) {
+function createTodosRouter(todosDir2, broadcast) {
   const router = Router5();
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -5150,14 +5229,14 @@ function createTodosRouter(todosDir, broadcast) {
   router.param("workspace", validateWorkspace);
   router.get("/", async (_req, res) => {
     try {
-      await ensureDir(todosDir);
-      const files = await readdir6(todosDir).catch(() => []);
+      await ensureDir(todosDir2);
+      const files = await readdir6(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
         if (!file.endsWith(".md") || file.endsWith("-log.md")) continue;
         const workspace = file.replace(".md", "");
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         workspaces.push({
           workspace: checklist.workspace,
           archiveInterval: checklist.archiveInterval,
@@ -5173,7 +5252,7 @@ function createTodosRouter(todosDir, broadcast) {
   router.get("/:workspace", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const checklist = await readChecklist(todosDir, workspace);
+      const checklist = await readChecklist(todosDir2, workspace);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
@@ -5193,7 +5272,7 @@ function createTodosRouter(todosDir, broadcast) {
         return;
       }
       const item = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const existingIds = new Set(checklist.items.map((i) => i.id));
         const id = generateUniqueId(existingIds);
         const newItem = {
@@ -5204,7 +5283,7 @@ function createTodosRouter(todosDir, broadcast) {
           session: null
         };
         checklist.items.push(newItem);
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return newItem;
       });
       broadcastUpdate();
@@ -5222,7 +5301,7 @@ function createTodosRouter(todosDir, broadcast) {
         return;
       }
       const items = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const itemMap = new Map(checklist.items.map((i) => [i.id, i]));
         const reordered = [];
         for (const id of ids) {
@@ -5236,7 +5315,7 @@ function createTodosRouter(todosDir, broadcast) {
           reordered.push(item);
         }
         checklist.items = reordered;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return reordered;
       });
       broadcastUpdate();
@@ -5247,7 +5326,7 @@ function createTodosRouter(todosDir, broadcast) {
   });
   router.get("/:workspace/log", async (req, res) => {
     try {
-      const log = await readLog(todosDir, getWorkspaceParam(req.params.workspace));
+      const log = await readLog(todosDir2, getWorkspaceParam(req.params.workspace));
       res.json(log);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get log" });
@@ -5256,12 +5335,12 @@ function createTodosRouter(todosDir, broadcast) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve15 } = await import("path");
-      const { readFile: readFile11 } = await import("fs/promises");
+      const { resolve: resolve16 } = await import("path");
+      const { readFile: readFile12 } = 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(todosDir, workspace);
-      const log = await readLog(todosDir, workspace);
+      const checklist = await readChecklist(todosDir2, workspace);
+      const log = await readLog(todosDir2, workspace);
       const completedIds = new Set(
         checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
       );
@@ -5272,11 +5351,11 @@ function createTodosRouter(todosDir, broadcast) {
       const toArchive = log.entries.filter(
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
-      const archFile = archivePath2(todosDir, workspace, checklist.archiveInterval);
-      await ensureDir(resolve15(todosDir, "archive"));
+      const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
+      await ensureDir(resolve16(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile11(archFile, "utf-8");
+        archContent = await readFile12(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -5310,7 +5389,7 @@ workspace: ${workspace}
       }
       await writeFileForce2(archFile, archContent);
       checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir, checklist);
+      await writeChecklist(todosDir2, checklist);
       broadcastUpdate();
       res.json({ archived: completedIds.size, logEntries: toArchive.length });
     } catch (error) {
@@ -5319,7 +5398,7 @@ workspace: ${workspace}
   });
   router.get("/:workspace/log/:id", async (req, res) => {
     try {
-      const log = await readLog(todosDir, getWorkspaceParam(req.params.workspace));
+      const log = await readLog(todosDir2, getWorkspaceParam(req.params.workspace));
       const entries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
       res.json({ workspace: log.workspace, entries });
     } catch (error) {
@@ -5329,13 +5408,13 @@ workspace: ${workspace}
   router.get("/:workspace/:id", async (req, res) => {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
-      const checklist = await readChecklist(todosDir, workspace);
+      const checklist = await readChecklist(todosDir2, workspace);
       const item = checklist.items.find((i) => i.id === req.params.id);
       if (!item) {
         res.status(404).json({ error: `Todo "${req.params.id}" not found` });
         return;
       }
-      const log = await readLog(todosDir, workspace);
+      const log = await readLog(todosDir2, workspace);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
       res.json({ ...item, log: logEntries });
     } catch (error) {
@@ -5346,12 +5425,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.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;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5368,11 +5447,11 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const deleted = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const idx = checklist.items.findIndex((i) => i.id === req.params.id);
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return true;
       });
       if (!deleted) {
@@ -5389,13 +5468,13 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.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;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { item: { ...item } };
       });
       if ("error" in result) {
@@ -5416,12 +5495,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "completed";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           itemIds: [item.id],
@@ -5432,7 +5511,7 @@ workspace: ${workspace}
           blockers: null,
           status: null
         };
-        await appendLogEntry2(todosDir, workspace, entry);
+        await appendLogEntry2(todosDir2, workspace, entry);
         return { ...item };
       });
       if (!result) {
@@ -5450,12 +5529,12 @@ workspace: ${workspace}
       const reason = req.body.reason || null;
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "blocked";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         const entry = {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           itemIds: [item.id],
@@ -5466,7 +5545,7 @@ workspace: ${workspace}
           blockers: reason,
           status: "blocked"
         };
-        await appendLogEntry2(todosDir, workspace, entry);
+        await appendLogEntry2(todosDir2, workspace, entry);
         return { ...item };
       });
       if (!result) {
@@ -5483,12 +5562,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "open";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5505,12 +5584,12 @@ workspace: ${workspace}
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const result = await withLock(workspace, async () => {
-        const checklist = await readChecklist(todosDir, workspace);
+        const checklist = await readChecklist(todosDir2, workspace);
         const item = checklist.items.find((i) => i.id === req.params.id);
         if (!item) return null;
         item.status = "open";
         item.session = null;
-        await writeChecklist(todosDir, checklist);
+        await writeChecklist(todosDir2, checklist);
         return { ...item };
       });
       if (!result) {
@@ -5526,6 +5605,411 @@ workspace: ${workspace}
   return router;
 }
 
+// src/dashboard/api-backup.ts
+init_config2();
+import { Router as Router6 } from "express";
+
+// src/utils/github-backup.ts
+init_paths();
+init_fs();
+init_config2();
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { cp, mkdtemp, rm as rm2, readFile as readFile11, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
+import { resolve as resolve14, join as join2 } from "path";
+import { tmpdir } from "os";
+var exec2 = promisify2(execFile2);
+var VALID_CATEGORIES = ["missions", "playbooks", "todos", "servers", "config"];
+var LOCK_FILE_NAME = ".backup-lock";
+function parseCategoriesStrict(cats) {
+  const unknown = [];
+  const valid = [];
+  for (const cat of cats) {
+    if (VALID_CATEGORIES.includes(cat)) {
+      valid.push(cat);
+    } else {
+      unknown.push(cat);
+    }
+  }
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown categor${unknown.length === 1 ? "y" : "ies"}: ${unknown.map((c) => `"${c}"`).join(", ")}. Valid: ${VALID_CATEGORIES.join(", ")}`
+    );
+  }
+  return valid;
+}
+function validateRepoUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const trimmed = url.trim();
+  return trimmed.startsWith("https://") || trimmed.startsWith("git@");
+}
+async function resolveCategoryPath(category) {
+  switch (category) {
+    case "missions": {
+      const config = await readConfig();
+      return { sourcePath: config.defaultMissionDir, repoPath: "missions", isFile: false };
+    }
+    case "playbooks":
+      return { sourcePath: playbooksDir(), repoPath: "playbooks", isFile: false };
+    case "todos":
+      return { sourcePath: todosDir(), repoPath: "todos", isFile: false };
+    case "servers":
+      return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
+    case "config":
+      return { sourcePath: resolve14(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+  }
+}
+async function checkGitInstalled() {
+  try {
+    await exec2("git", ["--version"]);
+  } catch {
+    throw new Error("git is not installed or not on PATH. Install git and try again.");
+  }
+}
+async function acquireLock() {
+  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  await ensureDir(syntaurRoot());
+  try {
+    const handle = await open(lockPath, "wx");
+    await handle.write(String(process.pid));
+    await handle.close();
+    return lockPath;
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      const pid = await readFile11(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.`
+      );
+    }
+    throw err;
+  }
+}
+async function releaseLock(lockPath) {
+  try {
+    await unlink3(lockPath);
+  } catch {
+  }
+}
+async function runGit(args, cwd) {
+  return exec2("git", args, { cwd });
+}
+async function cloneOrInit(repoUrl, destDir) {
+  try {
+    await exec2("git", ["clone", "--depth", "1", repoUrl, destDir]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("Repository not found") || message.includes("does not appear to be a git repository")) {
+      throw new Error(`Repository not found or inaccessible: ${repoUrl}. Check URL and credentials.`);
+    }
+    if (message.includes("Authentication failed") || message.includes("could not read Username")) {
+      throw new Error(`Authentication failed for ${repoUrl}. Check SSH keys or credentials.`);
+    }
+    throw new Error(`git clone failed: ${message}`);
+  }
+}
+async function copyRecursive(src, dest) {
+  if (!await fileExists(src)) return;
+  const s = await stat(src);
+  if (s.isDirectory()) {
+    await ensureDir(dest);
+    await cp(src, dest, { recursive: true, force: true });
+  } else {
+    await ensureDir(resolve14(dest, ".."));
+    await cp(src, dest, { force: true });
+  }
+}
+function resolveCategoriesStrict(csv) {
+  const parts = csv.split(",").map((s) => s.trim()).filter(Boolean);
+  return parseCategoriesStrict(parts);
+}
+async function readSanitizedConfig(configPath) {
+  const content = await readFile11(configPath, "utf-8");
+  return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
+}
+async function backupToGithub(overrides) {
+  await checkGitInstalled();
+  const config = await readConfig();
+  const rawRepo = overrides?.repo ?? config.backup?.repo ?? null;
+  if (!rawRepo) {
+    throw new Error("No backup repo configured. Set it via `syntaur backup config --repo <url>` or the dashboard.");
+  }
+  const repo = rawRepo.trim();
+  if (!validateRepoUrl(repo)) {
+    throw new Error(`Invalid repo URL: "${rawRepo}". Must start with https:// or git@.`);
+  }
+  const categoriesCsv = config.backup?.categories ?? "missions, playbooks, todos, servers, config";
+  const categories = overrides?.categories ?? resolveCategoriesStrict(categoriesCsv);
+  if (categories.length === 0) {
+    throw new Error("No valid backup categories selected.");
+  }
+  const lockPath = await acquireLock();
+  let tmpDir = null;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    tmpDir = await mkdtemp(join2(tmpdir(), "syntaur-backup-"));
+    await cloneOrInit(repo, tmpDir);
+    for (const category of categories) {
+      const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
+      const destPath = join2(tmpDir, repoPath);
+      if (isFile) {
+        await rm2(destPath, { force: true });
+      } else {
+        await rm2(destPath, { recursive: true, force: true });
+      }
+      if (!await fileExists(sourcePath)) {
+        console.warn(`Category "${category}": no local data at ${sourcePath}; backup will reflect deletion.`);
+        continue;
+      }
+      if (category === "config") {
+        const sanitized = await readSanitizedConfig(sourcePath);
+        await ensureDir(resolve14(destPath, ".."));
+        await writeFile3(destPath, sanitized, "utf-8");
+      } else {
+        await copyRecursive(sourcePath, destPath);
+      }
+    }
+    await runGit(["add", "-A"], tmpDir);
+    const { stdout: status } = await runGit(["status", "--porcelain"], tmpDir);
+    if (!status.trim()) {
+      await updateBackupConfig({ lastBackup: timestamp }).catch(() => {
+      });
+      return {
+        success: true,
+        timestamp,
+        message: "No changes to back up.",
+        committed: false
+      };
+    }
+    try {
+      await runGit(["config", "user.email", "syntaur@local"], tmpDir);
+      await runGit(["config", "user.name", "Syntaur Backup"], tmpDir);
+    } catch {
+    }
+    await runGit(["commit", "-m", `Syntaur backup ${timestamp}`], tmpDir);
+    try {
+      await runGit(["push"], tmpDir);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("non-fast-forward") || message.includes("rejected")) {
+        throw new Error("Push rejected (non-fast-forward). Pull and resolve manually, or delete remote contents.");
+      }
+      if (message.includes("Authentication") || message.includes("could not read Username")) {
+        throw new Error("Push authentication failed. Check SSH keys or credentials.");
+      }
+      throw new Error(`git push failed: ${message}`);
+    }
+    await updateBackupConfig({ lastBackup: timestamp }).catch(() => {
+    });
+    return {
+      success: true,
+      timestamp,
+      message: `Backed up ${categories.length} categor${categories.length === 1 ? "y" : "ies"} to ${repo}.`,
+      committed: true
+    };
+  } finally {
+    if (tmpDir) {
+      await rm2(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await releaseLock(lockPath);
+  }
+}
+async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
+  if (isFile) {
+    await ensureDir(resolve14(localPath, ".."));
+    await cp(repoSrcPath, localPath, { force: true });
+    return;
+  }
+  const stagingPath = `${localPath}.syntaur-restore-staging`;
+  const backupPath = `${localPath}.syntaur-restore-backup`;
+  await rm2(stagingPath, { recursive: true, force: true });
+  const backupExistsBefore = await fileExists(backupPath);
+  const localExistsBefore = await fileExists(localPath);
+  if (backupExistsBefore) {
+    if (!localExistsBefore) {
+      await rename2(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.`
+      );
+    }
+  }
+  let localMovedAside = false;
+  try {
+    await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
+    const localExists = await fileExists(localPath);
+    if (localExists) {
+      await rename2(localPath, backupPath);
+      localMovedAside = true;
+    }
+    await rename2(stagingPath, localPath);
+    await rm2(backupPath, { recursive: true, force: true }).catch(() => {
+    });
+  } catch (err) {
+    if (localMovedAside && await fileExists(backupPath)) {
+      await rename2(backupPath, localPath).catch(() => {
+      });
+    }
+    await rm2(stagingPath, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function restoreFromGithub(overrides) {
+  await checkGitInstalled();
+  const config = await readConfig();
+  const rawRepo = overrides?.repo ?? config.backup?.repo ?? null;
+  if (!rawRepo) {
+    throw new Error("No backup repo configured.");
+  }
+  const repo = rawRepo.trim();
+  if (!validateRepoUrl(repo)) {
+    throw new Error(`Invalid repo URL: "${rawRepo}".`);
+  }
+  const categoriesCsv = config.backup?.categories ?? "missions, playbooks, todos, servers, config";
+  const categories = overrides?.categories ?? resolveCategoriesStrict(categoriesCsv);
+  if (categories.length === 0) {
+    throw new Error("No valid restore categories selected.");
+  }
+  const lockPath = await acquireLock();
+  let tmpDir = null;
+  const restored = [];
+  const failed = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await updateBackupConfig({ lastRestore: timestamp });
+    tmpDir = await mkdtemp(join2(tmpdir(), "syntaur-restore-"));
+    await cloneOrInit(repo, tmpDir);
+    for (const category of categories) {
+      if (category === "config") {
+        console.warn('Skipping "config" on restore (would overwrite local backup settings).');
+        continue;
+      }
+      try {
+        const { sourcePath: localPath, repoPath, isFile } = await resolveCategoryPath(category);
+        const repoSrcPath = join2(tmpDir, repoPath);
+        if (!await fileExists(repoSrcPath)) {
+          console.warn(`Category "${category}" not found in backup repo, skipping.`);
+          continue;
+        }
+        await safeRestoreCategory(localPath, repoSrcPath, isFile);
+        restored.push(category);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to restore "${category}": ${msg}`);
+        failed.push(category);
+      }
+    }
+    const success = failed.length === 0;
+    return {
+      success,
+      timestamp,
+      message: success ? `Restored ${restored.length} categor${restored.length === 1 ? "y" : "ies"} from ${repo}.` : `Partial restore: ${restored.length} succeeded, ${failed.length} failed (${failed.join(", ")}).`,
+      committed: false
+    };
+  } finally {
+    if (tmpDir) {
+      await rm2(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await releaseLock(lockPath);
+  }
+}
+async function getBackupStatus() {
+  const config = await readConfig();
+  const lockPath = resolve14(syntaurRoot(), LOCK_FILE_NAME);
+  const locked = await fileExists(lockPath);
+  return {
+    repo: config.backup?.repo ?? null,
+    categories: config.backup?.categories ?? "missions, playbooks, todos, servers, config",
+    lastBackup: config.backup?.lastBackup ?? null,
+    lastRestore: config.backup?.lastRestore ?? null,
+    locked
+  };
+}
+
+// src/dashboard/api-backup.ts
+function createBackupRouter() {
+  const router = Router6();
+  router.get("/", async (_req, res) => {
+    try {
+      const status = await getBackupStatus();
+      res.json(status);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.put("/config", async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      const updates = {};
+      if (body.repo !== void 0) {
+        const trimmed = typeof body.repo === "string" ? body.repo.trim() : body.repo;
+        if (trimmed !== null && trimmed !== "" && !validateRepoUrl(trimmed)) {
+          return res.status(400).json({
+            error: `Invalid repo URL. Must start with https:// or git@.`
+          });
+        }
+        updates.repo = trimmed || null;
+      }
+      if (body.categories !== void 0) {
+        let cats;
+        if (Array.isArray(body.categories)) {
+          cats = body.categories.map((s) => String(s).trim()).filter(Boolean);
+        } else if (typeof body.categories === "string") {
+          cats = body.categories.split(",").map((s) => s.trim()).filter(Boolean);
+        } else {
+          return res.status(400).json({ error: "categories must be a string or array" });
+        }
+        if (cats.length === 0) {
+          return res.status(400).json({
+            error: `No categories provided. Valid: ${VALID_CATEGORIES.join(", ")}`
+          });
+        }
+        try {
+          const valid = parseCategoriesStrict(cats);
+          updates.categories = valid.join(", ");
+        } catch (err) {
+          return res.status(400).json({
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      if (Object.keys(updates).length === 0) {
+        return res.status(400).json({ error: "No fields to update" });
+      }
+      await updateBackupConfig(updates);
+      const status = await getBackupStatus();
+      res.json(status);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  router.post("/push", async (_req, res) => {
+    try {
+      const result = await backupToGithub();
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  router.post("/pull", async (_req, res) => {
+    try {
+      const result = await restoreFromGithub();
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  });
+  return router;
+}
+
 // src/dashboard/autodiscovery.ts
 init_scanner();
 init_servers();
@@ -5599,7 +6083,7 @@ async function listAllTmuxSessions() {
   if (!output) return [];
   return output.split("\n").filter((line) => line.length > 0);
 }
-async function discoverTmuxSessions(serversDir, missionsDir, existingNames) {
+async function discoverTmuxSessions(serversDir2, missionsDir, existingNames) {
   const tmuxAvailable = await checkTmuxAvailable();
   if (!tmuxAvailable) return false;
   const workspaceRecords = await loadWorkspaceRecords(missionsDir);
@@ -5627,7 +6111,7 @@ async function discoverTmuxSessions(serversDir, missionsDir, existingNames) {
       }
     }
     if (matched) {
-      await registerAutoSession(serversDir, sessionName, { kind: "tmux" });
+      await registerAutoSession(serversDir2, sessionName, { kind: "tmux" });
       changed = true;
     }
   }
@@ -5643,7 +6127,7 @@ async function getProcessCwd(pid) {
   }
   return null;
 }
-async function discoverProcesses(serversDir, missionsDir, existingFiles, excludePids) {
+async function discoverProcesses(serversDir2, missionsDir, existingFiles, excludePids) {
   const workspaceRecords = await loadWorkspaceRecords(missionsDir);
   if (workspaceRecords.length === 0) return false;
   const lsofOutput = await getLsofOutput();
@@ -5668,7 +6152,7 @@ async function discoverProcesses(serversDir, missionsDir, existingFiles, exclude
     const sanitized = sanitizeSessionName(sessionName);
     if (existingFiles.has(sanitized)) continue;
     const ports = parsePortsForPid(lsofOutput, proc.pid);
-    await registerAutoSession(serversDir, sessionName, {
+    await registerAutoSession(serversDir2, sessionName, {
       kind: "process",
       pid: proc.pid,
       ports: ports.length > 0 ? ports : [proc.port],
@@ -5678,7 +6162,7 @@ async function discoverProcesses(serversDir, missionsDir, existingFiles, exclude
   }
   return changed;
 }
-async function cleanupDeadAutoSessions(serversDir, existingFiles) {
+async function cleanupDeadAutoSessions(serversDir2, existingFiles) {
   let changed = false;
   const removedNames = /* @__PURE__ */ new Set();
   const tmuxAvailable = await checkTmuxAvailable();
@@ -5694,7 +6178,7 @@ async function cleanupDeadAutoSessions(serversDir, existingFiles) {
       continue;
     }
     if (!alive) {
-      await removeSession(serversDir, name);
+      await removeSession(serversDir2, name);
       removedNames.add(name);
       changed = true;
     }
@@ -5709,20 +6193,20 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir, missionsDir, excludePids) {
-  const names = await listSessionFiles(serversDir);
+async function reconcile(serversDir2, missionsDir, excludePids) {
+  const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
-    const data = await readSessionFile(serversDir, name);
+    const data = await readSessionFile(serversDir2, name);
     if (data) existingFiles.set(name, data);
   }
-  const { changed: cleanupChanged, removedNames } = await cleanupDeadAutoSessions(serversDir, existingFiles);
+  const { changed: cleanupChanged, removedNames } = await cleanupDeadAutoSessions(serversDir2, existingFiles);
   for (const name of removedNames) {
     existingFiles.delete(name);
   }
   const existingNames = new Set(existingFiles.keys());
-  const tmuxChanged = await discoverTmuxSessions(serversDir, missionsDir, existingNames);
-  const processChanged = await discoverProcesses(serversDir, missionsDir, existingFiles, excludePids);
+  const tmuxChanged = await discoverTmuxSessions(serversDir2, missionsDir, existingNames);
+  const processChanged = await discoverProcesses(serversDir2, missionsDir, existingFiles, excludePids);
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
@@ -5730,7 +6214,7 @@ async function reconcile(serversDir, missionsDir, excludePids) {
 
 // src/dashboard/server.ts
 function createDashboardServer(options) {
-  const { port, missionsDir, serversDir, playbooksDir, todosDir, serveStaticUi, dashboardDistPath } = options;
+  const { port, missionsDir, serversDir: serversDir2, playbooksDir: playbooksDir2, todosDir: todosDir2, serveStaticUi, dashboardDistPath } = options;
   const app = express();
   const server = createServer(app);
   const wss = new WebSocketServer({ noServer: true });
@@ -5770,7 +6254,7 @@ function createDashboardServer(options) {
   app.use(express.json());
   app.get("/api/overview", async (_req, res) => {
     try {
-      const overview = await getOverview(missionsDir, serversDir);
+      const overview = await getOverview(missionsDir, serversDir2);
       res.json(overview);
     } catch (error) {
       console.error("Error getting overview:", error);
@@ -5779,7 +6263,7 @@ function createDashboardServer(options) {
   });
   app.get("/api/attention", async (_req, res) => {
     try {
-      const attention = await getAttention(missionsDir, serversDir);
+      const attention = await getAttention(missionsDir, serversDir2);
       res.json(attention);
     } catch (error) {
       console.error("Error getting attention queue:", error);
@@ -5947,14 +6431,15 @@ function createDashboardServer(options) {
     }
   });
   app.use(createWriteRouter(missionsDir));
-  app.use("/api/servers", createServersRouter(serversDir, missionsDir));
+  app.use("/api/servers", createServersRouter(serversDir2, missionsDir));
   app.use("/api/agent-sessions", createAgentSessionsRouter(missionsDir, broadcast));
-  app.use("/api/playbooks", createPlaybooksRouter(playbooksDir));
-  app.use("/api/todos", createTodosRouter(todosDir, broadcast));
+  app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
+  app.use("/api/todos", createTodosRouter(todosDir2, broadcast));
+  app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     app.use(express.static(dashboardDistPath));
     app.get("{*path}", async (_req, res) => {
-      const indexPath = resolve14(dashboardDistPath, "index.html");
+      const indexPath = resolve15(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -5969,12 +6454,12 @@ function createDashboardServer(options) {
     async start() {
       watcherHandle = createWatcher({
         missionsDir,
-        serversDir,
-        playbooksDir,
-        todosDir,
+        serversDir: serversDir2,
+        playbooksDir: playbooksDir2,
+        todosDir: todosDir2,
         onMessage: broadcast
       });
-      startAutodiscovery({ serversDir, missionsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
+      startAutodiscovery({ serversDir: serversDir2, missionsDir, excludePids: /* @__PURE__ */ new Set([process.pid]) });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
@@ -5986,8 +6471,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve14(homedir2(), ".syntaur", "dashboard-port");
-          writeFile3(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve15(homedir2(), ".syntaur", "dashboard-port");
+          writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -6003,8 +6488,8 @@ function createDashboardServer(options) {
         client.close();
       }
       clients.clear();
-      const portFile = resolve14(homedir2(), ".syntaur", "dashboard-port");
-      await unlink3(portFile).catch(() => {
+      const portFile = resolve15(homedir2(), ".syntaur", "dashboard-port");
+      await unlink4(portFile).catch(() => {
       });
       return new Promise((resolvePromise) => {
         server.close(() => resolvePromise());