syntaur 0.1.13 → 0.1.14

package/dist/index.js

@@ -93,10 +93,11 @@ onboarding:
 agentDefaults:
   trustLevel: medium
   autoApprove: false
-sync:
-  enabled: false
-  endpoint: null
-  interval: 300
+backup:
+  repo: null
+  categories: missions, playbooks, todos, servers, config
+  lastBackup: null
+  lastRestore: null
 ---
 
 # Syntaur Configuration
@@ -516,6 +517,14 @@ function serializeIntegrationConfig(integrations) {
 function serializeOnboardingConfig(onboarding) {
   return ["onboarding:", `  completed: ${onboarding.completed ? "true" : "false"}`].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) {
@@ -680,6 +689,40 @@ ${normalizedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+async function updateBackupConfig(backup) {
+  const configPath = resolve4(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 readFile3(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 = resolve4(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) {
@@ -722,6 +765,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)
   };
 }
@@ -747,6 +796,7 @@ var init_config2 = __esm({
         codexPluginDir: null,
         codexMarketplacePath: null
       },
+      backup: null,
       statuses: null
     };
   }
@@ -3768,8 +3818,8 @@ __export(launch_exports, {
   launchAgent: () => launchAgent
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile5 } from "fs/promises";
-import { resolve as resolve32 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile6 } from "fs/promises";
+import { resolve as resolve33 } from "path";
 async function launchAgent(options) {
   const { missionsDir, missionSlug, assignmentSlug, agent } = options;
   const command = AGENT_COMMANDS[agent];
@@ -3779,9 +3829,9 @@ async function launchAgent(options) {
     process.exit(1);
   }
   const workspaceDir = detail.workspace.worktreePath ?? (detail.workspace.repository?.startsWith("/") ? detail.workspace.repository : null) ?? process.cwd();
-  const missionDir = resolve32(missionsDir, missionSlug);
-  const assignmentDir = resolve32(missionDir, "assignments", assignmentSlug);
-  const contextDir = resolve32(workspaceDir, ".syntaur");
+  const missionDir = resolve33(missionsDir, missionSlug);
+  const assignmentDir = resolve33(missionDir, "assignments", assignmentSlug);
+  const contextDir = resolve33(workspaceDir, ".syntaur");
   await mkdir2(contextDir, { recursive: true });
   const context = {
     missionSlug,
@@ -3793,8 +3843,8 @@ async function launchAgent(options) {
     branch: detail.workspace.branch ?? null,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile5(
-    resolve32(contextDir, "context.json"),
+  await writeFile6(
+    resolve33(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   return new Promise((resolvePromise, reject) => {
@@ -3829,7 +3879,7 @@ var init_launch = __esm({
 });
 
 // src/index.ts
-import { Command as Command2 } from "commander";
+import { Command as Command3 } from "commander";
 
 // src/commands/init.ts
 init_paths();
@@ -4907,16 +4957,16 @@ Use --slug to specify a different slug.`
 init_config2();
 import { spawn } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve18, dirname as dirname4 } from "path";
+import { resolve as resolve19, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
 init_api();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } 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
@@ -6096,8 +6146,8 @@ async function migrateFromMarkdown(missionsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, missionSlug) {
-  const { readFile: readFile15 } = await import("fs/promises");
-  const raw = await readFile15(filePath, "utf-8");
+  const { readFile: readFile16 } = await import("fs/promises");
+  const raw = await readFile16(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -6604,8 +6654,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: resolve36 } = await import("path");
-      const { readFile: readFile15 } = await import("fs/promises");
+      const { resolve: resolve37 } = await import("path");
+      const { readFile: readFile16 } = 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);
@@ -6621,10 +6671,10 @@ function createTodosRouter(todosDir2, broadcast) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve36(todosDir2, "archive"));
+      await ensureDir(resolve37(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile15(archFile, "utf-8");
+        archContent = await readFile16(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -6874,6 +6924,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 readFile12, writeFile as writeFile3, unlink as unlink3, stat, open, rename as rename2 } from "fs/promises";
+import { resolve as resolve17, 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: resolve17(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 = resolve17(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 readFile12(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(resolve17(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 readFile12(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(resolve17(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(resolve17(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 = resolve17(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();
@@ -7299,10 +7754,11 @@ function createDashboardServer(options) {
   app.use("/api/agent-sessions", createAgentSessionsRouter(missionsDir, 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 = resolve17(dashboardDistPath, "index.html");
+      const indexPath = resolve18(dashboardDistPath, "index.html");
       if (await fileExists(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -7334,8 +7790,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve17(homedir2(), ".syntaur", "dashboard-port");
-          writeFile3(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve18(homedir2(), ".syntaur", "dashboard-port");
+          writeFile4(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -7351,8 +7807,8 @@ function createDashboardServer(options) {
         client.close();
       }
       clients.clear();
-      const portFile = resolve17(homedir2(), ".syntaur", "dashboard-port");
-      await unlink3(portFile).catch(() => {
+      const portFile = resolve18(homedir2(), ".syntaur", "dashboard-port");
+      await unlink4(portFile).catch(() => {
       });
       return new Promise((resolvePromise) => {
         server.close(() => resolvePromise());
@@ -7430,8 +7886,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve18(dirname4(thisFile), "..");
-  const dashboardDist = resolve18(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve19(dirname4(thisFile), "..");
+  const dashboardDist = resolve19(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     missionsDir,
@@ -7444,8 +7900,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve18(packageRoot, "dashboard");
-    const viteBin = resolve18(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve19(packageRoot, "dashboard");
+    const viteBin = resolve19(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -7497,7 +7953,7 @@ async function dashboardCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 init_lifecycle();
 async function assignCommand(assignment, options) {
   if (!options.mission) {
@@ -7518,8 +7974,8 @@ async function assignCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve19(baseDir, options.mission);
-  const missionMdPath = resolve19(missionDir, "mission.md");
+  const missionDir = resolve20(baseDir, options.mission);
+  const missionMdPath = resolve20(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7536,7 +7992,7 @@ async function assignCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 init_lifecycle();
 async function startCommand(assignment, options) {
   if (!options.mission) {
@@ -7554,8 +8010,8 @@ async function startCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve20(baseDir, options.mission);
-  const missionMdPath = resolve20(missionDir, "mission.md");
+  const missionDir = resolve21(baseDir, options.mission);
+  const missionMdPath = resolve21(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7579,7 +8035,7 @@ async function startCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 init_lifecycle();
 async function completeCommand(assignment, options) {
   if (!options.mission) {
@@ -7597,8 +8053,8 @@ async function completeCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve21(baseDir, options.mission);
-  const missionMdPath = resolve21(missionDir, "mission.md");
+  const missionDir = resolve22(baseDir, options.mission);
+  const missionMdPath = resolve22(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7615,7 +8071,7 @@ async function completeCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 init_lifecycle();
 async function blockCommand(assignment, options) {
   if (!options.mission) {
@@ -7633,8 +8089,8 @@ async function blockCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve22(baseDir, options.mission);
-  const missionMdPath = resolve22(missionDir, "mission.md");
+  const missionDir = resolve23(baseDir, options.mission);
+  const missionMdPath = resolve23(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7653,7 +8109,7 @@ async function blockCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 init_lifecycle();
 async function unblockCommand(assignment, options) {
   if (!options.mission) {
@@ -7671,8 +8127,8 @@ async function unblockCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve23(baseDir, options.mission);
-  const missionMdPath = resolve23(missionDir, "mission.md");
+  const missionDir = resolve24(baseDir, options.mission);
+  const missionMdPath = resolve24(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7689,7 +8145,7 @@ async function unblockCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 init_lifecycle();
 async function reviewCommand(assignment, options) {
   if (!options.mission) {
@@ -7707,8 +8163,8 @@ async function reviewCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve24(baseDir, options.mission);
-  const missionMdPath = resolve24(missionDir, "mission.md");
+  const missionDir = resolve25(baseDir, options.mission);
+  const missionMdPath = resolve25(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7725,7 +8181,7 @@ async function reviewCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 init_lifecycle();
 async function failCommand(assignment, options) {
   if (!options.mission) {
@@ -7743,8 +8199,8 @@ async function failCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve25(baseDir, options.mission);
-  const missionMdPath = resolve25(missionDir, "mission.md");
+  const missionDir = resolve26(baseDir, options.mission);
+  const missionMdPath = resolve26(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7761,7 +8217,7 @@ async function failCommand(assignment, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 init_lifecycle();
 async function reopenCommand(assignment, options) {
   if (!options.mission) {
@@ -7779,8 +8235,8 @@ async function reopenCommand(assignment, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve26(baseDir, options.mission);
-  const missionMdPath = resolve26(missionDir, "mission.md");
+  const missionDir = resolve27(baseDir, options.mission);
+  const missionMdPath = resolve27(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
@@ -7800,32 +8256,32 @@ init_config2();
 init_config2();
 init_fs();
 import {
-  cp,
+  cp as cp2,
   readdir as readdir8,
   symlink,
   lstat,
-  readFile as readFile12,
+  readFile as readFile13,
   readlink,
-  rm as rm2,
-  unlink as unlink4,
-  writeFile as writeFile4
+  rm as rm3,
+  unlink as unlink5,
+  writeFile as writeFile5
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve28 } from "path";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve29 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname5, resolve as resolve27 } from "path";
+import { dirname as dirname5, resolve as resolve28 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
   let currentDir = dirname5(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve27(currentDir, expectedRelativePath);
+    const candidate = resolve28(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve27(currentDir, "..");
+    const parentDir = resolve28(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -7846,25 +8302,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir3();
-  return pluginKind === "claude" ? resolve28(home, ".claude", "plugins", "syntaur") : resolve28(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve29(home, ".claude", "plugins", "syntaur") : resolve29(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve28(homedir3(), ".agents", "plugins", "marketplace.json");
+  return resolve29(homedir3(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve28(homedir3(), ".claude", "plugins", "marketplaces");
+  return resolve29(homedir3(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve28(homedir3(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve29(homedir3(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve28(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  return resolve29(homedir3(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve28(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve29(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile12(resolve28(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile13(resolve29(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -7872,7 +8328,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile12(pathValue, "utf-8");
+    const raw = await readFile13(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7880,15 +8336,15 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve28(pluginDir, ".claude-plugin", "plugin.json")
+    resolve29(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve28(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve29(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile12(manifestPath, "utf-8");
+  const raw = await readFile13(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -7898,7 +8354,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile12(markerPath, "utf-8");
+    const raw = await readFile13(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -7911,7 +8367,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve28(dirname6(targetDir), symlinkTarget);
+    const resolvedTarget = resolve29(dirname6(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -7940,7 +8396,7 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
     installMode,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile4(
+  await writeFile5(
     getInstallMarkerPath(targetDir),
     `${JSON.stringify(metadata, null, 2)}
 `,
@@ -7949,20 +8405,20 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
 }
 async function installCopy(paths, pluginKind) {
   await ensureDir(dirname6(paths.targetDir));
-  await cp(paths.sourceDir, paths.targetDir, { recursive: true });
+  await cp2(paths.sourceDir, paths.targetDir, { recursive: true });
   const packageManifest = await readPackageManifest(paths.packageRoot);
   await writeInstallMetadata(paths.targetDir, pluginKind, "copy", packageManifest);
 }
 async function installLink(paths) {
   await ensureDir(dirname6(paths.targetDir));
-  await rm2(paths.targetDir, { recursive: true, force: true });
+  await rm3(paths.targetDir, { recursive: true, force: true });
   await ensureDir(dirname6(paths.targetDir));
-  await symlink(resolve28(paths.sourceDir), paths.targetDir, "dir");
+  await symlink(resolve29(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
   if (await fileExists(markerPath)) {
-    await unlink4(markerPath).catch(() => {
+    await unlink5(markerPath).catch(() => {
     });
   }
 }
@@ -7971,13 +8427,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute2(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve28(expanded);
+  return resolve29(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve28(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve29(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -8012,7 +8468,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   await ensureDir(dirname6(manifestPath));
-  await writeFile4(manifestPath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile5(manifestPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 function buildClaudeMarketplaceSourcePath(pluginTargetDir, marketplaceRootDir) {
@@ -8081,8 +8537,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve28(rootDir, entry.name);
-    const manifestPath = resolve28(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve29(rootDir, entry.name);
+    const manifestPath = resolve29(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -8109,11 +8565,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve28(expandHome(installLocation));
+    const candidateRoot = resolve29(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve28(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve29(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -8141,7 +8597,7 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve28(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve29(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
@@ -8151,7 +8607,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const rootDir = dirname6(pluginsDir);
-  const manifestPath = resolve28(rootDir, ".claude-plugin", "marketplace.json");
+  const manifestPath = resolve29(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
@@ -8167,7 +8623,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve28(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve29(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -8292,7 +8748,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve28(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve29(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -8301,7 +8757,7 @@ async function installManagedPlugin(options) {
     };
   }
   if (existing.exists) {
-    await rm2(paths.targetDir, { recursive: true, force: true });
+    await rm3(paths.targetDir, { recursive: true, force: true });
   }
   if (desiredMode === "link") {
     await installLink(paths);
@@ -8344,7 +8800,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile12(marketplacePath, "utf-8");
+  const raw = await readFile13(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -8354,7 +8810,7 @@ async function readMarketplaceFile(marketplacePath) {
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
   await ensureDir(dirname6(marketplacePath));
-  await writeFile4(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile5(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
@@ -8440,7 +8896,7 @@ async function removeMarketplaceEntry(options) {
     return { marketplacePath, removed: false };
   }
   if (marketplace.plugins.length === 0 && isDefaultMarketplaceShell(marketplace)) {
-    await rm2(marketplacePath, { force: true });
+    await rm3(marketplacePath, { force: true });
     return { marketplacePath, removed: true };
   }
   await writeMarketplaceFile(marketplacePath, marketplace);
@@ -8461,7 +8917,7 @@ async function uninstallManagedPlugin(pluginKind, targetDir = getDefaultPluginTa
     );
   }
   await removeInstallMarker(normalizedTarget);
-  await rm2(normalizedTarget, { recursive: true, force: true });
+  await rm3(normalizedTarget, { recursive: true, force: true });
   return { removed: true, targetDir: normalizedTarget };
 }
 async function getConfiguredOrLegacyManagedPluginDir(pluginKind) {
@@ -8505,13 +8961,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve28(syntaurRoot(), "config.md"));
+  return fileExists(resolve29(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
-  await rm2(syntaurRoot(), { recursive: true, force: true });
+  await rm3(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredMissionDir() {
-  if (!await fileExists(resolve28(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve29(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultMissionDir;
@@ -8857,7 +9313,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -8937,7 +9393,7 @@ async function uninstallCommand(options) {
     const configuredMissionDir = await getConfiguredMissionDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredMissionDir && resolve29(configuredMissionDir) !== resolve29(syntaurRoot(), "missions")) {
+    if (configuredMissionDir && resolve30(configuredMissionDir) !== resolve30(syntaurRoot(), "missions")) {
       console.warn(
         `Warning: config.md pointed to an external mission directory (${configuredMissionDir}). That directory was not removed automatically.`
       );
@@ -8952,7 +9408,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -8978,19 +9434,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-  const missionDir = resolve30(baseDir, options.mission);
-  const assignmentDir = resolve30(
+  const missionDir = resolve31(baseDir, options.mission);
+  const assignmentDir = resolve31(
     missionDir,
     "assignments",
     options.assignment
   );
-  const missionMdPath = resolve30(missionDir, "mission.md");
+  const missionMdPath = resolve31(missionDir, "mission.md");
   if (!await fileExists(missionDir) || !await fileExists(missionMdPath)) {
     throw new Error(
       `Mission "${options.mission}" not found at ${missionDir}.`
     );
   }
-  const assignmentMdPath = resolve30(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve31(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -9018,15 +9474,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve30(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve30(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve31(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve31(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve30(cwd, "AGENTS.md");
+    const agentsPath = resolve31(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve30(cwd, "opencode.json");
+      const configPath = resolve31(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ missionDir }));
     }
   }
@@ -9051,7 +9507,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 async function trackSessionCommand(options) {
   if (!options.agent) {
@@ -9060,7 +9516,7 @@ async function trackSessionCommand(options) {
   if (options.mission) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultMissionDir;
-    const missionDir = resolve31(baseDir, options.mission);
+    const missionDir = resolve32(baseDir, options.mission);
     if (!await fileExists(missionDir)) {
       throw new Error(
         `Mission "${options.mission}" not found at ${missionDir}.`
@@ -9112,7 +9568,7 @@ async function browseCommand(options) {
 }
 
 // src/commands/create-playbook.ts
-import { resolve as resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 init_timestamp();
 init_paths();
 init_fs();
@@ -9128,7 +9584,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve33(dir, `${slug}.md`);
+  const filePath = resolve34(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -9149,8 +9605,8 @@ Use --slug to specify a different slug.`
 init_paths();
 init_fs();
 init_parser();
-import { readdir as readdir9, readFile as readFile13 } from "fs/promises";
-import { resolve as resolve34 } from "path";
+import { readdir as readdir9, readFile as readFile14 } from "fs/promises";
+import { resolve as resolve35 } from "path";
 async function listPlaybooksCommand() {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -9168,8 +9624,8 @@ async function listPlaybooksCommand() {
   console.log(`${"Slug".padEnd(30)} ${"Name".padEnd(30)} Description`);
   console.log(`${"\u2500".repeat(30)} ${"\u2500".repeat(30)} ${"\u2500".repeat(40)}`);
   for (const entry of mdFiles) {
-    const filePath = resolve34(dir, entry.name);
-    const raw = await readFile13(filePath, "utf-8");
+    const filePath = resolve35(dir, entry.name);
+    const raw = await readFile14(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const name = parsed.name || slug;
@@ -9183,8 +9639,8 @@ init_paths();
 init_parser2();
 init_fs();
 import { Command } from "commander";
-import { readFile as readFile14 } from "fs/promises";
-import { resolve as resolve35 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { resolve as resolve36 } from "path";
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function resolveWorkspace(options) {
   if (options.global) return "_global";
@@ -9465,10 +9921,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve35(todosPath, "archive"));
+    await ensureDir(resolve36(todosPath, "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 = `---
@@ -9575,6 +10031,83 @@ todoCommand.command("promote").description("Promote a todo to a full assignment"
   }
 });
 
+// src/commands/backup.ts
+init_config2();
+import { Command as Command2 } from "commander";
+function parseCategoryOption(csv) {
+  if (!csv) return void 0;
+  const parts = csv.split(",").map((s) => s.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error(`No categories provided. Valid: ${VALID_CATEGORIES.join(", ")}`);
+  }
+  return parseCategoriesStrict(parts);
+}
+var backupCommand = new Command2("backup").description("Back up Syntaur files to a GitHub repository");
+backupCommand.command("push").description("Push a backup to the configured GitHub repo").option("--repo <url>", "Override the configured repo URL").option("--categories <list>", "Comma-separated categories to back up (missions, playbooks, todos, servers, config)").action(async (options) => {
+  try {
+    const result = await backupToGithub({
+      repo: options.repo,
+      categories: parseCategoryOption(options.categories)
+    });
+    console.log(result.message);
+    if (result.committed) {
+      console.log(`  timestamp: ${result.timestamp}`);
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+backupCommand.command("pull").description("Restore Syntaur files from the configured GitHub repo").option("--repo <url>", "Override the configured repo URL").option("--categories <list>", "Comma-separated categories to restore").action(async (options) => {
+  try {
+    const result = await restoreFromGithub({
+      repo: options.repo,
+      categories: parseCategoryOption(options.categories)
+    });
+    console.log(result.message);
+    console.log(`  timestamp: ${result.timestamp}`);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+backupCommand.command("config").description("Show or update backup configuration").option("--repo <url>", "Set the backup repo URL").option("--categories <list>", "Set the default categories (comma-separated)").action(async (options) => {
+  try {
+    const updates = {};
+    if (options.repo !== void 0) {
+      const trimmed = typeof options.repo === "string" ? options.repo.trim() : options.repo;
+      if (!validateRepoUrl(trimmed)) {
+        throw new Error(`Invalid repo URL: "${options.repo}". Must start with https:// or git@.`);
+      }
+      updates.repo = trimmed;
+    }
+    if (options.categories !== void 0) {
+      const parts = options.categories.split(",").map((s) => s.trim()).filter(Boolean);
+      if (parts.length === 0) {
+        throw new Error(`No categories provided. Valid: ${VALID_CATEGORIES.join(", ")}`);
+      }
+      const valid = parseCategoriesStrict(parts);
+      updates.categories = valid.join(", ");
+    }
+    if (Object.keys(updates).length > 0) {
+      await updateBackupConfig(updates);
+      console.log("Backup configuration updated.");
+    }
+    const status = await getBackupStatus();
+    console.log("\nBackup configuration:");
+    console.log(`  repo:        ${status.repo ?? "(not set)"}`);
+    console.log(`  categories:  ${status.categories}`);
+    console.log(`  lastBackup:  ${status.lastBackup ?? "(never)"}`);
+    console.log(`  lastRestore: ${status.lastRestore ?? "(never)"}`);
+    if (status.locked) {
+      console.log("  \u26A0 locked:    a backup operation is in progress or the lock is stale");
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
 // src/cli-default-command.ts
 init_config2();
 import { readdir as readdir10 } from "fs/promises";
@@ -9614,7 +10147,7 @@ async function getDefaultCommandName() {
 }
 
 // src/index.ts
-var program = new Command2();
+var program = new Command3();
 program.name("syntaur").description("CLI scaffolding tool for the Syntaur protocol").version("0.1.0");
 program.command("init").description("Initialize ~/.syntaur/ directory structure and config").option("--force", "Overwrite existing config file").action(async (options) => {
   try {
@@ -9856,6 +10389,7 @@ program.command("list-playbooks").description("List all playbooks").action(async
   }
 });
 program.addCommand(todoCommand);
+program.addCommand(backupCommand);
 if (process.argv.length <= 2) {
   process.argv.push(await getDefaultCommandName());
 }