syntaur 0.76.0 → 0.77.0

package/dist/dashboard/server.js

@@ -2547,6 +2547,14 @@ function agentNameArgs(agent) {
   const n = agent.agentName?.trim();
   return n ? ["--agent", n] : [];
 }
+function resolveRunner(agent) {
+  if (agent.runner) return agent.runner;
+  if (agent.agentName && agent.agentName.trim() !== "") return "claude";
+  const cmd = agent.command ?? "";
+  if (/claude/i.test(cmd) || agent.id === "claude") return "claude";
+  if (/codex/i.test(cmd) || agent.id === "codex") return "codex";
+  return "pi";
+}
 function stripModelFlags(args) {
   const out = [];
   for (let i = 0; i < args.length; i++) {
@@ -3817,6 +3825,7 @@ __export(config_exports, {
   parseStatusConfig: () => parseStatusConfig,
   parseTerminalConfig: () => parseTerminalConfig,
   readConfig: () => readConfig,
+  serializeAgentDiscoveryConfig: () => serializeAgentDiscoveryConfig,
   serializeSearchConfig: () => serializeSearchConfig,
   serializeStatusConfig: () => serializeStatusConfig,
   toTitleCase: () => toTitleCase,
@@ -3830,6 +3839,7 @@ __export(config_exports, {
   validateDeriveShape: () => validateDeriveShape,
   validateFactDeclarations: () => validateFactDeclarations,
   validateStalenessConfig: () => validateStalenessConfig,
+  writeAgentDiscoveryConfig: () => writeAgentDiscoveryConfig,
   writeAgentsConfig: () => writeAgentsConfig,
   writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
   writeSearchConfig: () => writeSearchConfig,
@@ -3922,6 +3932,50 @@ function validateAgentList(agents) {
         `agent "${agent.id}" sets both agentName and model \u2014 the agent definition's own model is authoritative; remove the profile model`
       );
     }
+    if (agent.runner !== void 0 && !RUNNER_KINDS.includes(agent.runner)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid runner "${agent.runner}" \u2014 must be one of ${RUNNER_KINDS.join(", ")}`
+      );
+    }
+    if (agent.sourceKind !== void 0 && !AGENT_SOURCE_KINDS.includes(agent.sourceKind)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid sourceKind "${agent.sourceKind}" \u2014 must be one of ${AGENT_SOURCE_KINDS.join(", ")}`
+      );
+    }
+    if (agent.sourcePath !== void 0 && /[\r\n]/.test(agent.sourcePath)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid sourcePath \u2014 must be a single line (no newlines)`
+      );
+    }
+    if (agent.sourceRepo !== void 0 && /[\r\n]/.test(agent.sourceRepo)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid sourceRepo \u2014 must be a single line (no newlines)`
+      );
+    }
+    if (agent.runner === "claude" && agent.workdir !== void 0 && agent.workdir.trim() !== "") {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has runner "claude" but sets workdir \u2014 a claude agent uses agentName, not workdir`
+      );
+    }
+    if ((agent.runner === "pi" || agent.runner === "codex") && agent.agentName !== void 0 && agent.agentName.trim() !== "") {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has runner "${agent.runner}" but sets agentName \u2014 a directory agent uses workdir, not agentName`
+      );
+    }
+    if (agent.runner !== void 0 && agent.sourceKind !== void 0) {
+      const directorySource = agent.sourceKind === "directory";
+      const claudeRunner = agent.runner === "claude";
+      if (directorySource && claudeRunner) {
+        throw new AgentConfigError(
+          `agent "${agent.id}" has sourceKind "directory" but runner "claude" \u2014 a directory source is a pi/codex agent`
+        );
+      }
+      if (!directorySource && !claudeRunner) {
+        throw new AgentConfigError(
+          `agent "${agent.id}" has sourceKind "${agent.sourceKind}" but runner "${agent.runner}" \u2014 a ${agent.sourceKind} source is a claude agent`
+        );
+      }
+    }
     validateSessionInvocation(agent, "resume", agent.resume);
     validateSessionInvocation(agent, "fork", agent.fork);
     if (agent.default) defaults++;
@@ -4024,6 +4078,21 @@ function parseInstalledAgents(fm) {
   }
   return Object.keys(installedAgents).length > 0 ? { installedAgents } : {};
 }
+function parseAgentDiscoveryFromFm(fm) {
+  const flag = (key, def) => {
+    const v = fm[key];
+    if (v === void 0) return def;
+    return String(v).toLowerCase() === "true";
+  };
+  const rootsRaw = fm["agentDiscovery.roots"];
+  const roots = rootsRaw !== void 0 && String(rootsRaw).trim() !== "" ? String(rootsRaw).split(":").map((r) => r.trim()).filter((r) => r.length > 0) : [];
+  return {
+    claudeGlobal: flag("agentDiscovery.claudeGlobal", true),
+    claudeProject: flag("agentDiscovery.claudeProject", true),
+    directory: flag("agentDiscovery.directory", true),
+    roots: roots.length > 0 ? roots : DEFAULT_CONFIG.agentDiscovery.roots.slice()
+  };
+}
 function parseStatusConfig(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return null;
@@ -4532,6 +4601,43 @@ ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath, newContent);
 }
+function serializeAgentDiscoveryConfig(cfg) {
+  return [
+    "agentDiscovery:",
+    `  claudeGlobal: ${cfg.claudeGlobal}`,
+    `  claudeProject: ${cfg.claudeProject}`,
+    `  directory: ${cfg.directory}`,
+    `  roots: ${cfg.roots.join(":")}`
+  ].join("\n");
+}
+async function writeAgentDiscoveryConfig(cfg, standaloneDefaultCwd) {
+  const configPath = resolve7(syntaurRoot(), "config.md");
+  const block = serializeAgentDiscoveryConfig(cfg);
+  const scalarLine = standaloneDefaultCwd ? `standaloneDefaultCwd: ${standaloneDefaultCwd}` : "";
+  const additions = [block, scalarLine].filter(Boolean).join("\n");
+  const existing = await fileExists(configPath) ? await readFile5(configPath, "utf-8") : renderConfig({ defaultProjectDir: defaultProjectDir() });
+  const fmMatch = existing.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!fmMatch) {
+    const content = `---
+version: "2.0"
+defaultProjectDir: ${defaultProjectDir()}
+${additions}
+---
+${existing}`;
+    await writeFileForce(configPath, content);
+    return;
+  }
+  const fmBlock = fmMatch[2];
+  const afterFrontmatter = existing.slice(fmMatch[0].length);
+  let cleanedFm = stripTopLevelBlock(fmBlock, "agentDiscovery");
+  cleanedFm = stripTopLevelScalar(cleanedFm, "standaloneDefaultCwd");
+  const newFm = `${cleanedFm}
+${additions}`.replace(/^\n+/, "").replace(/\n+$/, "");
+  const newContent = `---
+${newFm}
+---${afterFrontmatter}`;
+  await writeFileForce(configPath, newContent);
+}
 function stripTopLevelScalar(fmBlock, key) {
   const lines = fmBlock.split("\n");
   const keyRegex = new RegExp(`^${key}:\\s*\\S`);
@@ -4744,6 +4850,10 @@ function parseAgentsConfig(content) {
       ...current.launchPrompt ? { launchPrompt: current.launchPrompt } : {},
       ...current.agentName ? { agentName: current.agentName } : {},
       ...current.workdir ? { workdir: current.workdir } : {},
+      ...current.runner ? { runner: current.runner } : {},
+      ...current.sourceKind ? { sourceKind: current.sourceKind } : {},
+      ...current.sourcePath ? { sourcePath: current.sourcePath } : {},
+      ...current.sourceRepo ? { sourceRepo: current.sourceRepo } : {},
       ...current.resume ? { resume: current.resume } : {},
       ...current.fork ? { fork: current.fork } : {}
     });
@@ -4941,6 +5051,18 @@ function assignAgentField(target, key, rawValue) {
     case "workdir":
       target.workdir = value;
       break;
+    case "runner":
+      target.runner = value;
+      break;
+    case "sourceKind":
+      target.sourceKind = value;
+      break;
+    case "sourcePath":
+      target.sourcePath = value;
+      break;
+    case "sourceRepo":
+      target.sourceRepo = value;
+      break;
   }
 }
 function yamlQuoteScalar(value) {
@@ -4976,6 +5098,18 @@ function serializeAgentsConfig(agents) {
     if (a.workdir) {
       lines.push(`    workdir: ${yamlQuoteScalar(a.workdir)}`);
     }
+    if (a.runner) {
+      lines.push(`    runner: ${yamlQuoteScalar(a.runner)}`);
+    }
+    if (a.sourceKind) {
+      lines.push(`    sourceKind: ${yamlQuoteScalar(a.sourceKind)}`);
+    }
+    if (a.sourcePath) {
+      lines.push(`    sourcePath: ${yamlQuoteScalar(a.sourcePath)}`);
+    }
+    if (a.sourceRepo) {
+      lines.push(`    sourceRepo: ${yamlQuoteScalar(a.sourceRepo)}`);
+    }
     if (a.args && a.args.length > 0) {
       lines.push(`    args:`);
       for (const arg of a.args) {
@@ -5461,7 +5595,12 @@ async function readConfig() {
     searchConfig: parseSearchConfig(content),
     workspaceVisibility: parseWorkspaceVisibilityConfig(fmBlock),
     staleness: parseStalenessConfig(content),
-    stalenessWatchdog: String(fm["stalenessWatchdog"]).toLowerCase() === "true"
+    stalenessWatchdog: String(fm["stalenessWatchdog"]).toLowerCase() === "true",
+    standaloneDefaultCwd: parseOptionalAbsolutePath(
+      fm["standaloneDefaultCwd"],
+      "standaloneDefaultCwd"
+    ),
+    agentDiscovery: parseAgentDiscoveryFromFm(fm)
   };
 }
 function getAssignmentTypes(config) {
@@ -5524,7 +5663,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var STALENESS_KEY_TO_FIELD, DURATION_RE, DURATION_UNIT_MS, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, SESSION_AUTO_TRACK_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var STALENESS_KEY_TO_FIELD, DURATION_RE, DURATION_UNIT_MS, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, SESSION_AUTO_TRACK_VALUES, RUNNER_KINDS, AGENT_SOURCE_KINDS, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -5600,10 +5739,23 @@ var init_config2 = __esm({
         hidden: []
       },
       staleness: null,
-      stalenessWatchdog: false
+      stalenessWatchdog: false,
+      standaloneDefaultCwd: null,
+      agentDiscovery: {
+        claudeGlobal: true,
+        claudeProject: true,
+        directory: true,
+        roots: ["~"]
+      }
     };
     AUTO_CREATE_WORKTREE_VALUES = ["skip", "ask", "always"];
     SESSION_AUTO_TRACK_VALUES = ["all", "workspaces-only", "off"];
+    RUNNER_KINDS = ["claude", "pi", "codex"];
+    AGENT_SOURCE_KINDS = [
+      "claude-global",
+      "claude-project",
+      "directory"
+    ];
     AgentConfigError = class extends Error {
     };
     DEFAULT_STATUS_COLORS = {
@@ -5625,7 +5777,11 @@ var init_config2 = __esm({
       "playbook",
       "launchPrompt",
       "agentName",
-      "workdir"
+      "workdir",
+      "runner",
+      "sourceKind",
+      "sourcePath",
+      "sourceRepo"
     ]);
     migratedConfigPaths = /* @__PURE__ */ new Set();
     TerminalConfigError = class extends Error {
@@ -6023,6 +6179,7 @@ var init_assignment_resolver = __esm({
 
 // src/launch/cwd.ts
 import { existsSync, statSync } from "fs";
+import { homedir as homedir2 } from "os";
 import { isAbsolute as isAbsolute2 } from "path";
 function isExistingDir(p) {
   if (!p || !isAbsolute2(p)) return false;
@@ -6068,6 +6225,31 @@ function resolveLaunchCwd(agent, worktreeCwd) {
   }
   return { spawnCwd: worktreeCwd, worktreePath: worktreeCwd, invalidReason: null };
 }
+function resolveStandaloneCwd(agent, standaloneDefaultCwd) {
+  const wd = agent.workdir?.trim();
+  if (wd) {
+    const expanded = expandHome(wd);
+    if (!isExistingDir(expanded)) {
+      return {
+        cwd: null,
+        invalidReason: `agent "${agent.id}" workdir ${agent.workdir} (resolved ${expanded}) is not an existing directory \u2014 a standalone launch requires a valid workdir.`
+      };
+    }
+    return { cwd: expanded, invalidReason: null };
+  }
+  if (resolveRunner(agent) === "claude") {
+    const configured = standaloneDefaultCwd?.trim();
+    if (configured) {
+      const expanded = expandHome(configured);
+      if (isExistingDir(expanded)) return { cwd: expanded, invalidReason: null };
+    }
+    return { cwd: homedir2(), invalidReason: null };
+  }
+  return {
+    cwd: null,
+    invalidReason: `agent "${agent.id}" has no workdir \u2014 a standalone launch of a ${resolveRunner(agent)} agent requires a valid workdir.`
+  };
+}
 function formatFallbackCwdWarning(opts) {
   const missing = [];
   if (!opts.worktreePath) missing.push("worktreePath");
@@ -6079,6 +6261,7 @@ function formatFallbackCwdWarning(opts) {
 var init_cwd = __esm({
   "src/launch/cwd.ts"() {
     "use strict";
+    init_agents_schema();
     init_paths();
   }
 });
@@ -7913,8 +8096,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile32 } = await import("fs/promises");
-  const raw2 = await readFile32(filePath, "utf-8");
+  const { readFile: readFile34 } = await import("fs/promises");
+  const raw2 = await readFile34(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -8734,7 +8917,7 @@ function emptyScan() {
   return { sessions: [], tmuxAvailable: false };
 }
 function scanKey(serversDir2, projectsDir, assignmentsDir2) {
-  return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
+  return JSON.stringify([serversDir2, projectsDir, assignmentsDir2 ?? ""]);
 }
 function delay(ms) {
   return new Promise((resolve49) => {
@@ -12157,12 +12340,12 @@ var init_transcript = __esm({
 // src/usage/cwd-extractor.ts
 import { open as open3, readdir as readdir13, stat as stat4 } from "fs/promises";
 import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 async function extractClaudeSessionMeta(jsonlPath) {
   const cwd = await derivePathFromTranscript(jsonlPath);
   if (!cwd) return null;
-  const basename7 = jsonlPath.split("/").pop() ?? "";
-  const sessionId = basename7.replace(/\.jsonl$/, "");
+  const basename8 = jsonlPath.split("/").pop() ?? "";
+  const sessionId = basename8.replace(/\.jsonl$/, "");
   if (!sessionId) return null;
   const startTs = await readFirstTimestamp(jsonlPath);
   const endTs = await readLastTimestamp(jsonlPath);
@@ -12257,8 +12440,8 @@ async function* walkClaudeProjects(opts = {}) {
 async function* walkCodexSessions(opts = {}) {
   const root = resolveCodexSessionsRoot(opts.root);
   for await (const filePath of walkJsonlRecursive(root)) {
-    const basename7 = filePath.split("/").pop() ?? "";
-    if (!basename7.endsWith(".jsonl")) continue;
+    const basename8 = filePath.split("/").pop() ?? "";
+    if (!basename8.endsWith(".jsonl")) continue;
     if (opts.sinceMtimeMs !== void 0) {
       const mtime = await mtimeMs(filePath);
       if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -12273,13 +12456,13 @@ function resolveCodexSessionsRoot(override3) {
   if (fromSessionsEnv && fromSessionsEnv.length > 0) return expandHome(fromSessionsEnv);
   const fromHomeEnv = process.env.CODEX_HOME;
   if (fromHomeEnv && fromHomeEnv.length > 0) return join3(expandHome(fromHomeEnv), "sessions");
-  return join3(homedir2(), ".codex", "sessions");
+  return join3(homedir3(), ".codex", "sessions");
 }
 async function extractPiSessionMeta(jsonlPath) {
-  const basename7 = jsonlPath.split("/").pop() ?? "";
-  const underscoreIdx = basename7.lastIndexOf("_");
+  const basename8 = jsonlPath.split("/").pop() ?? "";
+  const underscoreIdx = basename8.lastIndexOf("_");
   if (underscoreIdx === -1) return null;
-  const sessionId = basename7.slice(underscoreIdx + 1).replace(/\.jsonl$/, "");
+  const sessionId = basename8.slice(underscoreIdx + 1).replace(/\.jsonl$/, "");
   if (!sessionId) return null;
   let handle;
   try {
@@ -12331,7 +12514,7 @@ function resolvePiSessionsRoot(override3) {
   if (override3) return expandHome(override3);
   const fromHomeEnv = process.env.PI_AGENT_DIR;
   if (fromHomeEnv && fromHomeEnv.length > 0) return join3(expandHome(fromHomeEnv), "sessions");
-  return join3(homedir2(), ".pi", "agent", "sessions");
+  return join3(homedir3(), ".pi", "agent", "sessions");
 }
 async function* walkPiSessions(opts = {}) {
   const root = resolvePiSessionsRoot(opts.root);
@@ -12495,7 +12678,7 @@ var init_cwd_extractor = __esm({
 // src/utils/session-id.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { mkdirSync, readFileSync as readFileSync2, statSync as statSync4, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { dirname as dirname5, join as join4 } from "path";
 function isSafeSessionId(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 256 && SAFE_SESSION_ID.test(value);
@@ -12562,10 +12745,10 @@ var init_user_descriptors = __esm({
 });
 
 // src/targets/registry.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join5, resolve as resolve27 } from "path";
 function home(...segments) {
-  return resolve27(homedir4(), ...segments);
+  return resolve27(homedir5(), ...segments);
 }
 function hermesHome() {
   const env = process.env.HERMES_HOME;
@@ -13146,7 +13329,7 @@ init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
 import { resolve as resolve48 } from "path";
-import { writeFile as writeFile8, unlink as unlink9 } from "fs/promises";
+import { writeFile as writeFile9, unlink as unlink9 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/session-liveness.ts
@@ -18203,6 +18386,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
 init_config2();
 init_agents_schema();
 import { Router as Router5 } from "express";
+import { access as access4 } from "fs/promises";
 
 // src/targets/agent-definitions.ts
 init_parser();
@@ -18251,7 +18435,293 @@ async function discoverClaudeAgents(root) {
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 
+// src/targets/agent-discovery.ts
+init_paths();
+init_parser();
+import { access as access2, readdir as readdir16, readFile as readFile21 } from "fs/promises";
+import { join as join7 } from "path";
+async function pathExists(p) {
+  try {
+    await access2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function coerceRunner(raw2) {
+  return raw2 === "claude" || raw2 === "pi" || raw2 === "codex" ? raw2 : void 0;
+}
+async function readSyntaurMeta(file) {
+  let content;
+  try {
+    content = await readFile21(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const [fm] = extractFrontmatter2(content);
+  if (!fm) return null;
+  if (!/^syntaur:[ \t]*$/m.test(fm)) return null;
+  return {
+    name: getNestedField(fm, "syntaur", "name")?.trim() || void 0,
+    runner: coerceRunner(getNestedField(fm, "syntaur", "runner")?.trim() || void 0),
+    description: getNestedField(fm, "syntaur", "description")?.trim() || void 0
+  };
+}
+async function fileHasSyntaurBlock(file) {
+  return await readSyntaurMeta(file) !== null;
+}
+function claudeAlreadyRegistered(agents, path, name) {
+  return agents.some((a) => a.sourcePath === path || !!a.agentName && a.agentName === name);
+}
+function directoryAlreadyRegistered(agents, dir) {
+  return agents.some((a) => a.sourcePath === dir || a.workdir === dir);
+}
+async function toClaudeCandidate(d, source, agents, sourceRepo) {
+  return {
+    name: d.name,
+    runner: "claude",
+    description: d.description,
+    path: d.path,
+    source,
+    ...sourceRepo ? { sourceRepo } : {},
+    recommended: await fileHasSyntaurBlock(d.path),
+    alreadyRegistered: claudeAlreadyRegistered(agents, d.path, d.name)
+  };
+}
+async function inspectDirCandidate(dir, basename8, agents) {
+  const hasPi = await pathExists(join7(dir, ".pi"));
+  const hasMcp = await pathExists(join7(dir, ".mcp.json"));
+  const hasSyntaurMd = await pathExists(join7(dir, "SYNTAUR.md"));
+  const hasAgentsMd = await pathExists(join7(dir, "AGENTS.md"));
+  let syntaur = null;
+  if (hasSyntaurMd) syntaur = await readSyntaurMeta(join7(dir, "SYNTAUR.md"));
+  if (!syntaur && hasAgentsMd) syntaur = await readSyntaurMeta(join7(dir, "AGENTS.md"));
+  const strong = hasPi || hasMcp || syntaur !== null;
+  if (!strong) return null;
+  return {
+    name: syntaur?.name ?? basename8,
+    // A directory agent is pi/codex by definition; a contradictory
+    // `syntaur.runner: claude` opt-in is clamped to pi so the candidate never
+    // carries an impossible directory+claude combo.
+    runner: syntaur?.runner === "codex" ? "codex" : "pi",
+    description: syntaur?.description,
+    path: dir,
+    source: "directory",
+    recommended: syntaur !== null,
+    alreadyRegistered: directoryAlreadyRegistered(agents, dir)
+  };
+}
+async function discoverAgents(input) {
+  const out = [];
+  if (input.claudeGlobal) {
+    for (const d of await discoverClaudeAgents()) {
+      out.push(await toClaudeCandidate(d, "claude-global", input.agents));
+    }
+  }
+  if (input.claudeProject && input.repo) {
+    const projRoot = join7(input.repo, ".claude", "agents");
+    for (const d of await discoverClaudeAgents(projRoot)) {
+      out.push(await toClaudeCandidate(d, "claude-project", input.agents, input.repo));
+    }
+  }
+  if (input.directory || input.claudeProject) {
+    for (const rawRoot of input.roots) {
+      const root = expandHome(rawRoot);
+      let entries;
+      try {
+        entries = await readdir16(root, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const dir = join7(root, e.name);
+        if (input.directory) {
+          const dirCand = await inspectDirCandidate(dir, e.name, input.agents);
+          if (dirCand) out.push(dirCand);
+        }
+        if (input.claudeProject && await pathExists(join7(dir, ".claude", "agents"))) {
+          const projRoot = join7(dir, ".claude", "agents");
+          for (const d of await discoverClaudeAgents(projRoot)) {
+            out.push(await toClaudeCandidate(d, "claude-project", input.agents, dir));
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const c of out) {
+    const key = JSON.stringify([c.source, c.path, c.name]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(c);
+  }
+  deduped.sort(
+    (a, b) => a.recommended === b.recommended ? a.name.localeCompare(b.name) : a.recommended ? -1 : 1
+  );
+  return deduped;
+}
+
+// src/targets/agent-authoring.ts
+init_paths();
+init_parser();
+init_agents_schema();
+import { mkdir as mkdir2, writeFile as writeFile4, access as access3, readFile as readFile22, stat as stat5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute5, join as join8 } from "path";
+var RUNNER_COMMAND = {
+  claude: "claude",
+  pi: "pi",
+  codex: "codex"
+};
+function requireAbsolutePath(raw2, what = "path") {
+  const p = expandHome(raw2.trim());
+  if (!isAbsolute5(p)) {
+    throw new Error(`${what} must be an absolute path (got ${JSON.stringify(raw2)})`);
+  }
+  return p;
+}
+function slugifyAgentId(name) {
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const safe = /^[a-z0-9]/.test(slug) ? slug : `agent-${slug}`;
+  return AGENT_ID_PATTERN.test(safe) ? safe : "agent";
+}
+function uniqueAgentId(base, existingIds) {
+  const taken = new Set(existingIds);
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+function buildRegisteredAgent(input) {
+  const id = uniqueAgentId(slugifyAgentId(input.name), input.existingIds);
+  const agent = {
+    id,
+    label: input.name,
+    command: RUNNER_COMMAND[input.runner],
+    runner: input.runner,
+    sourceKind: input.sourceKind,
+    sourcePath: input.sourcePath
+  };
+  if (input.sourceRepo) agent.sourceRepo = input.sourceRepo;
+  if (input.runner === "claude") {
+    agent.agentName = input.name;
+  } else {
+    agent.workdir = input.sourcePath;
+  }
+  return agent;
+}
+async function pathExists2(p) {
+  try {
+    await access3(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function frontmatterLines(fields) {
+  const lines = [];
+  for (const [k, v] of Object.entries(fields)) {
+    if (v !== void 0 && v !== "") lines.push(`${k}: ${JSON.stringify(v)}`);
+  }
+  return lines;
+}
+function syntaurBlock(name, runner, description) {
+  const lines = ["syntaur:", `  name: ${JSON.stringify(name)}`, `  runner: ${runner}`];
+  if (description) lines.push(`  description: ${JSON.stringify(description)}`);
+  return lines;
+}
+async function authorAgentDef(input) {
+  const slug = slugifyAgentId(input.name);
+  if (input.runner === "claude") {
+    const dir2 = input.location ? requireAbsolutePath(input.location, "location") : join8(homedir6(), ".claude", "agents");
+    const path = join8(dir2, `${slug}.md`);
+    if (await pathExists2(path)) {
+      throw new Error(`refusing to overwrite existing def at ${path}`);
+    }
+    const fm2 = [
+      "---",
+      ...frontmatterLines({
+        name: input.name,
+        description: input.description,
+        model: input.model
+      }),
+      ...syntaurBlock(input.name, "claude", input.description),
+      "---"
+    ];
+    await mkdir2(dir2, { recursive: true });
+    await writeFile4(path, `${fm2.join("\n")}
+
+${input.instructions.trim()}
+`);
+    if (!input.location) {
+      return { path, sourceKind: "claude-global" };
+    }
+    const sourceRepo = basename5(dir2) === "agents" && basename5(dirname6(dir2)) === ".claude" ? dirname6(dirname6(dir2)) : void 0;
+    return { path, sourceKind: "claude-project", ...sourceRepo ? { sourceRepo } : {} };
+  }
+  const parent = input.location ? requireAbsolutePath(input.location, "location") : homedir6();
+  const dir = join8(parent, slug);
+  const agentsMd = join8(dir, "AGENTS.md");
+  if (await pathExists2(agentsMd)) {
+    throw new Error(`refusing to overwrite existing def at ${agentsMd}`);
+  }
+  const fm = ["---", ...syntaurBlock(input.name, input.runner, input.description), "---"];
+  await mkdir2(dir, { recursive: true });
+  await writeFile4(agentsMd, `${fm.join("\n")}
+
+${input.instructions.trim()}
+`);
+  return { path: dir, sourceKind: "directory" };
+}
+async function inferManualAdd(rawPath) {
+  const path = requireAbsolutePath(rawPath);
+  const info = await stat5(path);
+  if (info.isFile()) {
+    const content = await readFile22(path, "utf-8");
+    const [fm] = extractFrontmatter2(content);
+    const name = getNestedField(fm, "syntaur", "name")?.trim() || getField(fm, "name")?.trim() || basename5(path).replace(/\.md$/, "");
+    const description = getNestedField(fm, "syntaur", "description")?.trim() || getField(fm, "description")?.trim() || void 0;
+    return { name, runner: "claude", sourceKind: "claude-global", sourcePath: path, description };
+  }
+  let syntaurName;
+  let syntaurRunner;
+  let syntaurDesc;
+  for (const f of ["SYNTAUR.md", "AGENTS.md"]) {
+    const p = join8(path, f);
+    if (await pathExists2(p)) {
+      const [fm] = extractFrontmatter2(await readFile22(p, "utf-8"));
+      syntaurName = getNestedField(fm, "syntaur", "name")?.trim() || syntaurName;
+      const r = getNestedField(fm, "syntaur", "runner")?.trim();
+      if (r === "claude" || r === "pi" || r === "codex") syntaurRunner = r;
+      syntaurDesc = getNestedField(fm, "syntaur", "description")?.trim() || syntaurDesc;
+      if (syntaurName || syntaurRunner) break;
+    }
+  }
+  return {
+    name: syntaurName ?? basename5(path),
+    // A directory (pi/codex) agent is never claude — clamp a contradictory
+    // `syntaur.runner: claude` opt-in to pi (parity with inspectDirCandidate).
+    runner: syntaurRunner === "codex" ? "codex" : "pi",
+    sourceKind: "directory",
+    sourcePath: path,
+    description: syntaurDesc
+  };
+}
+
 // src/dashboard/api-agents.ts
+async function pathExists3(p) {
+  try {
+    await access4(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var RUNNER_KINDS_SET = /* @__PURE__ */ new Set(["claude", "pi", "codex"]);
+var SOURCE_KINDS_SET = /* @__PURE__ */ new Set(["claude-global", "claude-project", "directory"]);
 function mapAgentErrorToFieldErrors(err) {
   const message = err.message;
   let match = message.match(/^agent id "([^"]*)" is invalid/);
@@ -18546,6 +19016,22 @@ function coerceAgentRow(raw2, index) {
     const workdir = entry.workdir.trim();
     if (workdir) cleaned.workdir = workdir;
   }
+  for (const field of ["runner", "sourceKind", "sourcePath", "sourceRepo"]) {
+    const raw3 = entry[field];
+    if (raw3 === void 0) continue;
+    if (typeof raw3 !== "string") {
+      return {
+        ok: false,
+        status: 400,
+        body: {
+          error: `agents[${index}].${field} must be a string`,
+          fieldErrors: [{ id, field, message: `${field} must be a string` }]
+        }
+      };
+    }
+    const v = raw3.trim();
+    if (v) cleaned[field] = v;
+  }
   return { ok: true, value: cleaned };
 }
 function createAgentsRouter() {
@@ -18559,6 +19045,164 @@ function createAgentsRouter() {
       res.status(500).json({ error: "Failed to discover Claude agents" });
     }
   });
+  router.get("/discovered", async (req2, res) => {
+    try {
+      const config = await readConfig();
+      const agents = config.agents ?? BUILTIN_AGENTS;
+      const repo = typeof req2.query.repo === "string" && req2.query.repo ? req2.query.repo : null;
+      const d = config.agentDiscovery;
+      const candidates = await discoverAgents({
+        claudeGlobal: d.claudeGlobal,
+        claudeProject: d.claudeProject,
+        directory: d.directory,
+        roots: d.roots,
+        repo,
+        agents
+      });
+      res.json({ candidates });
+    } catch (err) {
+      console.error("Error discovering agents:", err);
+      res.status(500).json({ error: "Failed to discover agents" });
+    }
+  });
+  async function appendAndPersist(agent, res) {
+    const config = await readConfig();
+    const base = config.agents ?? BUILTIN_AGENTS;
+    if (agent.sourcePath && base.some((a) => a.sourcePath === agent.sourcePath)) {
+      res.status(409).json({ error: `already registered: ${agent.sourcePath}` });
+      return null;
+    }
+    const next = [...base, agent];
+    try {
+      await writeAgentsConfig(next);
+    } catch (err) {
+      if (err instanceof AgentConfigError) {
+        res.status(400).json(mapAgentErrorToFieldErrors(err));
+        return null;
+      }
+      throw err;
+    }
+    return next;
+  }
+  router.post("/register", async (req2, res) => {
+    try {
+      const b = req2.body ?? {};
+      if (!b.path || !b.name || !b.runner || !b.sourceKind) {
+        res.status(400).json({ error: "register requires path, name, runner, sourceKind" });
+        return;
+      }
+      if (!RUNNER_KINDS_SET.has(b.runner) || !SOURCE_KINDS_SET.has(b.sourceKind)) {
+        res.status(400).json({ error: "invalid runner or sourceKind" });
+        return;
+      }
+      let regPath;
+      let sourceRepo;
+      try {
+        regPath = requireAbsolutePath(b.path);
+        sourceRepo = b.sourceRepo ? requireAbsolutePath(b.sourceRepo, "sourceRepo") : void 0;
+      } catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : "invalid path" });
+        return;
+      }
+      if (!await pathExists3(regPath)) {
+        res.status(400).json({ error: `path not found: ${regPath}` });
+        return;
+      }
+      const config = await readConfig();
+      const base = config.agents ?? BUILTIN_AGENTS;
+      const agent = buildRegisteredAgent({
+        name: b.name,
+        runner: b.runner,
+        sourceKind: b.sourceKind,
+        sourcePath: regPath,
+        sourceRepo,
+        description: b.description,
+        existingIds: base.map((a) => a.id)
+      });
+      const next = await appendAndPersist(agent, res);
+      if (!next) return;
+      res.json({ agent, agents: next, custom: true });
+    } catch (err) {
+      console.error("Error registering agent:", err);
+      res.status(500).json({ error: "Failed to register agent" });
+    }
+  });
+  router.post("/manual-add", async (req2, res) => {
+    try {
+      const p = (req2.body ?? {}).path;
+      if (typeof p !== "string" || !p) {
+        res.status(400).json({ error: "manual-add requires a path" });
+        return;
+      }
+      let inferred;
+      try {
+        inferred = await inferManualAdd(p);
+      } catch {
+        res.status(400).json({ error: `path not found or unreadable: ${p}` });
+        return;
+      }
+      const config = await readConfig();
+      const base = config.agents ?? BUILTIN_AGENTS;
+      const agent = buildRegisteredAgent({
+        name: inferred.name,
+        runner: inferred.runner,
+        sourceKind: inferred.sourceKind,
+        sourcePath: inferred.sourcePath,
+        description: inferred.description,
+        existingIds: base.map((a) => a.id)
+      });
+      const next = await appendAndPersist(agent, res);
+      if (!next) return;
+      res.json({ agent, agents: next, custom: true });
+    } catch (err) {
+      console.error("Error manual-adding agent:", err);
+      res.status(500).json({ error: "Failed to manual-add agent" });
+    }
+  });
+  router.post("/create", async (req2, res) => {
+    try {
+      const b = req2.body ?? {};
+      if (!b.name || !b.runner || typeof b.instructions !== "string") {
+        res.status(400).json({ error: "create requires name, runner, instructions" });
+        return;
+      }
+      if (!RUNNER_KINDS_SET.has(b.runner)) {
+        res.status(400).json({ error: "invalid runner" });
+        return;
+      }
+      let authored;
+      try {
+        authored = await authorAgentDef({
+          name: b.name,
+          runner: b.runner,
+          model: b.model,
+          description: b.description,
+          instructions: b.instructions,
+          location: b.location
+        });
+      } catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : "failed to author def" });
+        return;
+      }
+      const config = await readConfig();
+      const base = config.agents ?? BUILTIN_AGENTS;
+      const agent = buildRegisteredAgent({
+        name: b.name,
+        runner: b.runner,
+        sourceKind: authored.sourceKind,
+        sourcePath: authored.path,
+        sourceRepo: authored.sourceRepo,
+        description: b.description,
+        existingIds: base.map((a) => a.id)
+      });
+      const next = await appendAndPersist(agent, res);
+      if (!next) return;
+      res.json({ agent, path: authored.path, agents: next, custom: true });
+    } catch (err) {
+      console.error("Error creating agent:", err);
+      res.status(500).json({ error: "Failed to create agent" });
+    }
+  });
   router.get("/", async (_req, res) => {
     try {
       const config = await readConfig();
@@ -18621,8 +19265,8 @@ import { Router as Router6 } from "express";
 // src/utils/terminal-probe.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
 var APP_BUNDLE_IDS = {
   "terminal-app": "com.apple.Terminal",
   iterm: "com.googlecode.iterm2",
@@ -18639,7 +19283,7 @@ var APP_FIXED_PATHS = {
   "terminal-app": "/System/Applications/Utilities/Terminal.app"
 };
 function defaultApplicationsDirs() {
-  return ["/Applications", join7(homedir5(), "Applications")];
+  return ["/Applications", join9(homedir7(), "Applications")];
 }
 function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const fixed = APP_FIXED_PATHS[terminal];
@@ -18647,7 +19291,7 @@ function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const bundleName = APP_BUNDLE_NAMES[terminal];
   if (bundleName) {
     for (const dir of dirs) {
-      const candidate = join7(dir, bundleName);
+      const candidate = join9(dir, bundleName);
       if (existsSync2(candidate)) return candidate;
     }
   }
@@ -18677,11 +19321,11 @@ var defaultCmuxLsappinfoRunner = () => {
 function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunnerOverride) {
   const bundle = findAppBundle("cmux", applicationsDirsOverride);
   if (bundle) {
-    const cli = join7(bundle, "Contents/Resources/bin/cmux");
+    const cli = join9(bundle, "Contents/Resources/bin/cmux");
     if (existsSync2(cli)) return cli;
   }
   for (const dir of cliDirsOverride ?? CMUX_CLI_DIRS) {
-    const cli = join7(dir, "cmux");
+    const cli = join9(dir, "cmux");
     if (existsSync2(cli)) return cli;
   }
   if (process.platform === "darwin") {
@@ -18690,7 +19334,7 @@ function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunn
     if (stdout) {
       const match = stdout.match(/"LSBundlePath"="([^"]+)"/);
       if (match) {
-        const cli = join7(match[1], "Contents/Resources/bin/cmux");
+        const cli = join9(match[1], "Contents/Resources/bin/cmux");
         if (existsSync2(cli)) return cli;
       }
     }
@@ -18861,15 +19505,15 @@ init_agent_sessions();
 
 // src/launch/argv.ts
 init_agents_schema();
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
 
 // src/tui/launch.ts
 init_api();
 init_agents_schema();
 init_cwd();
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve28 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile5 } from "fs/promises";
+import { isAbsolute as isAbsolute6, resolve as resolve28 } from "path";
 init_paths();
 init_playbooks();
 init_cwd();
@@ -18887,7 +19531,7 @@ function buildAgentArgv(agent, prompt, env = process.env) {
     const requested = env.SHELL;
     let shell = requested;
     let warning = null;
-    if (!shell || !isAbsolute5(shell)) {
+    if (!shell || !isAbsolute6(shell)) {
       warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
       shell = "/bin/sh";
     }
@@ -18922,7 +19566,7 @@ function buildSessionArgv(agent, sessionId, mode, env = process.env) {
     const requested = env.SHELL;
     let shell = requested;
     let warning = null;
-    if (!shell || !isAbsolute6(shell)) {
+    if (!shell || !isAbsolute7(shell)) {
       warning = `syntaur: $SHELL ${requested ? `("${requested}") is not absolute` : "is unset"} \u2014 falling back to /bin/sh for shell-alias resolution`;
       shell = "/bin/sh";
     }
@@ -18982,18 +19626,14 @@ async function resolveStandalonePlan(input, terminal) {
       `Agent "${agentId}" requested for a standalone launch is not in your agents list.`
     );
   }
-  const wd = agent.workdir?.trim();
-  if (!wd) {
-    throw new LaunchError(
-      "workspace-path-invalid",
-      `Agent "${agent.id}" has no workdir \u2014 a standalone launch requires a valid workdir.`
-    );
-  }
-  const expanded = expandHome(wd);
-  if (!isExistingDir(expanded)) {
+  const { cwd: spawnCwd, invalidReason } = resolveStandaloneCwd(
+    agent,
+    input.config.standaloneDefaultCwd
+  );
+  if (spawnCwd === null) {
     throw new LaunchError(
       "workspace-path-invalid",
-      `Agent "${agent.id}" workdir ${agent.workdir} (resolved ${expanded}) is not an existing directory \u2014 a standalone launch requires a valid workdir.`
+      invalidReason ?? `Agent "${agent.id}" has no valid standalone launch directory.`
     );
   }
   const knownPlaybookSlugs = await listPlaybookSlugs(playbooksDir());
@@ -19007,7 +19647,7 @@ async function resolveStandalonePlan(input, terminal) {
   const { argv, shellFallbackWarning } = buildFreshArgv(agent, prompt);
   return {
     terminal,
-    cwd: expanded,
+    cwd: spawnCwd,
     argv,
     env: process.env,
     agentId: agent.id,
@@ -19174,8 +19814,8 @@ async function resolveSessionPlan(input, terminal) {
 
 // src/launch/execute.ts
 import { spawn as spawn3 } from "child_process";
-import { homedir as homedir6 } from "os";
-import { basename as basename5, join as join8, resolve as resolve29 } from "path";
+import { homedir as homedir8 } from "os";
+import { basename as basename6, join as join10, resolve as resolve29 } from "path";
 init_fs();
 init_config2();
 init_session_id();
@@ -19195,7 +19835,7 @@ var TerminalNotFoundError = class extends Error {
 var realSpawn = (command, args, options) => spawn3(command, args, options);
 var WRAPPER_COMMANDS = /* @__PURE__ */ new Set(["osascript", "open", "sh"]);
 function isWrapperCommand(command) {
-  return WRAPPER_COMMANDS.has(basename5(command));
+  return WRAPPER_COMMANDS.has(basename6(command));
 }
 var WRAPPER_EXIT_TIMEOUT_MS = 1500;
 async function executeLaunchPlan(plan, spawnFn = realSpawn) {
@@ -19281,7 +19921,7 @@ async function registerLaunchAtBirth(plan, child) {
     const sessionId = plan.session?.sessionId ?? null;
     const procStart = captureProcessStartedAt(pid);
     const envDir = process.env.SYNTAUR_RUNTIME_SESSIONS_DIR;
-    const markerDir = envDir && envDir.length > 0 ? envDir : join8(homedir6(), ".syntaur", "runtime", "sessions");
+    const markerDir = envDir && envDir.length > 0 ? envDir : join10(homedir8(), ".syntaur", "runtime", "sessions");
     writeRuntimeMarker(
       pid,
       {
@@ -19470,7 +20110,7 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname6, resolve as resolve30, join as join9 } from "path";
+import { dirname as dirname7, resolve as resolve30, join as join11 } from "path";
 import { realpathSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
 
 // src/dashboard/api-launch-preflight.ts
@@ -19863,21 +20503,78 @@ function createWorkspaceVisibilityConfigRouter() {
   return router;
 }
 
+// src/dashboard/api-agent-discovery-config.ts
+init_config2();
+import { Router as Router11 } from "express";
+function createAgentDiscoveryConfigRouter() {
+  const router = Router11();
+  router.get("/", async (_req, res) => {
+    try {
+      const config = await readConfig();
+      res.json({
+        agentDiscovery: config.agentDiscovery,
+        standaloneDefaultCwd: config.standaloneDefaultCwd
+      });
+    } catch (error) {
+      console.error("Error getting agent-discovery config:", error);
+      res.status(500).json({ error: "Failed to get agent-discovery config" });
+    }
+  });
+  router.post("/", async (req2, res) => {
+    try {
+      const b = req2.body ?? {};
+      const d = b.agentDiscovery ?? {};
+      let roots;
+      try {
+        roots = (Array.isArray(d.roots) ? d.roots : []).filter((r) => typeof r === "string" && r.trim() !== "").map((r) => {
+          requireAbsolutePath(r, "root");
+          return r.trim();
+        });
+      } catch (err) {
+        res.status(400).json({ error: err instanceof Error ? err.message : "invalid root" });
+        return;
+      }
+      const cfg = {
+        // Default-true semantics: only an explicit `false` turns a source off.
+        claudeGlobal: d.claudeGlobal !== false,
+        claudeProject: d.claudeProject !== false,
+        directory: d.directory !== false,
+        roots: roots.length > 0 ? roots : ["~"]
+      };
+      let cwd = null;
+      if (typeof b.standaloneDefaultCwd === "string" && b.standaloneDefaultCwd.trim()) {
+        try {
+          cwd = requireAbsolutePath(b.standaloneDefaultCwd, "standaloneDefaultCwd");
+        } catch (err) {
+          res.status(400).json({ error: err instanceof Error ? err.message : "invalid cwd" });
+          return;
+        }
+      }
+      await writeAgentDiscoveryConfig(cfg, cwd);
+      res.json({ agentDiscovery: cfg, standaloneDefaultCwd: cwd });
+    } catch (error) {
+      console.error("Error saving agent-discovery config:", error);
+      res.status(500).json({ error: "Failed to save agent-discovery config" });
+    }
+  });
+  return router;
+}
+
 // src/dashboard/api-status-config.ts
 init_config2();
 init_fact_registry();
 init_state_machine();
 init_api();
 init_derive();
-import { Router as Router11 } from "express";
+import { Router as Router12 } from "express";
 
 // src/utils/status-config-resolution.ts
 init_frontmatter();
 init_event_emit();
 init_assignment_walk();
 init_timestamp();
-import { readFile as readFile21, writeFile as writeFile5, rm as rm2 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { readFile as readFile23, writeFile as writeFile6, rm as rm2 } from "fs/promises";
+import { dirname as dirname8 } from "path";
 var StatusResolutionError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -19895,7 +20592,7 @@ async function scanAssignmentsByStatus(projectsDir, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile21(assignmentPath, "utf-8");
+      content = await readFile23(assignmentPath, "utf-8");
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
@@ -19958,7 +20655,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile21(a.path, "utf-8");
+        const content = await readFile23(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err) {
         const code = err?.code;
@@ -19987,7 +20684,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile21(a.path, "utf-8");
+          current = await readFile23(a.path, "utf-8");
         } catch (err) {
           const code = err?.code;
           if (code === "ENOENT") {
@@ -20010,7 +20707,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
           }),
           { at: now, from: r.id, to: r.target, command: "remap", by: null }
         );
-        await writeFile5(a.path, next, "utf-8");
+        await writeFile6(a.path, next, "utf-8");
         pendingRemapEvents.push({
           assignmentId: fm.id,
           projectSlug: a.projectSlug,
@@ -20028,7 +20725,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     for (const p of writtenPaths) {
       const original = buffer.get(p);
       if (original !== void 0) {
-        await writeFile5(p, original, "utf-8").catch((rollbackErr) => {
+        await writeFile6(p, original, "utf-8").catch((rollbackErr) => {
           console.error(
             `status-config-resolution: rollback write failed for ${p}:`,
             rollbackErr
@@ -20058,7 +20755,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile21(a.path, "utf-8");
+        const current = await readFile23(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -20069,7 +20766,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       } catch {
         continue;
       }
-      const assignmentDir = dirname7(a.path);
+      const assignmentDir = dirname8(a.path);
       try {
         await rm2(assignmentDir, { recursive: true, force: true });
         deleted++;
@@ -20212,7 +20909,7 @@ function mapResolutionErrorToHttp(err, applied) {
   }
 }
 function createStatusConfigRouter(projectsDir, assignmentsDir2) {
-  const router = Router11();
+  const router = Router12();
   installRecordsInvalidation(router);
   router.get("/", async (_req, res) => {
     try {
@@ -20532,7 +21229,7 @@ function createStatusConfigRouter(projectsDir, assignmentsDir2) {
 }
 
 // src/dashboard/api-leases.ts
-import { Router as Router12 } from "express";
+import { Router as Router13 } from "express";
 
 // src/db/leases-db.ts
 init_paths();
@@ -20714,7 +21411,7 @@ function forceReleaseLease(lease_id) {
 
 // src/dashboard/api-leases.ts
 function createLeasesRouter(broadcast) {
-  const router = Router12();
+  const router = Router13();
   router.get("/", (_req, res) => {
     try {
       initLeasesDb();
@@ -20770,14 +21467,14 @@ function createLeasesRouter(broadcast) {
 
 // src/dashboard/api-schedules.ts
 init_timestamp();
-import { Router as Router13 } from "express";
+import { Router as Router14 } from "express";
 
 // src/schedules/store.ts
 init_fs();
 init_paths();
 init_timestamp();
 import { randomUUID as randomUUID4 } from "crypto";
-import { readFile as readFile22, readdir as readdir16, rm as rm3 } from "fs/promises";
+import { readFile as readFile24, readdir as readdir17, rm as rm3 } from "fs/promises";
 import { resolve as resolve32 } from "path";
 function schedulesDir() {
   const override3 = process.env.SYNTAUR_SCHEDULES_DIR;
@@ -20910,7 +21607,7 @@ function validateJob(raw2) {
 async function readJob(id) {
   const path = jobPath(id);
   if (!await fileExists(path)) return null;
-  return parseJobFile(await readFile22(path, "utf-8"));
+  return parseJobFile(await readFile24(path, "utf-8"));
 }
 async function writeJob(job) {
   const next = { ...job, updatedAt: nowTimestamp() };
@@ -20920,7 +21617,7 @@ async function writeJob(job) {
 async function listJobs() {
   let names;
   try {
-    names = await readdir16(schedulesDir());
+    names = await readdir17(schedulesDir());
   } catch {
     return [];
   }
@@ -20928,7 +21625,7 @@ async function listJobs() {
   for (const name of names) {
     if (!name.endsWith(".md")) continue;
     try {
-      jobs.push(parseJobFile(await readFile22(resolve32(schedulesDir(), name), "utf-8")));
+      jobs.push(parseJobFile(await readFile24(resolve32(schedulesDir(), name), "utf-8")));
     } catch {
     }
   }
@@ -20938,8 +21635,8 @@ async function listJobs() {
 
 // src/schedules/event-log.ts
 init_timestamp();
-import { appendFile, readFile as readFile23, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname8, resolve as resolve33 } from "path";
+import { appendFile, readFile as readFile25, mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname9, resolve as resolve33 } from "path";
 function eventLogPath(jobId) {
   if (!/^[A-Za-z0-9_-]+$/.test(jobId)) {
     throw new Error(`Unsafe schedule id: ${JSON.stringify(jobId)}`);
@@ -20949,7 +21646,7 @@ function eventLogPath(jobId) {
 async function appendEvent(jobId, type, data) {
   const event = { type, at: nowTimestamp(), ...data ? { data } : {} };
   const path = eventLogPath(jobId);
-  await mkdir3(dirname8(path), { recursive: true });
+  await mkdir4(dirname9(path), { recursive: true });
   await appendFile(path, `${JSON.stringify(event)}
 `, "utf-8");
   return event;
@@ -20957,7 +21654,7 @@ async function appendEvent(jobId, type, data) {
 async function readEvents(jobId) {
   let content;
   try {
-    content = await readFile23(eventLogPath(jobId), "utf-8");
+    content = await readFile25(eventLogPath(jobId), "utf-8");
   } catch {
     return [];
   }
@@ -20976,7 +21673,7 @@ async function readEvents(jobId) {
 
 // src/schedules/attempt.ts
 import { createHash as createHash3 } from "crypto";
-import { open as open4, readFile as readFile24, stat as stat5, unlink as unlink6 } from "fs/promises";
+import { open as open4, readFile as readFile26, stat as stat6, unlink as unlink6 } from "fs/promises";
 import { resolve as resolve34 } from "path";
 
 // src/schedules/triggers.ts
@@ -21165,7 +21862,7 @@ async function acquireJobLock(id) {
       await handle.close();
       return async () => {
         try {
-          const current = await readFile24(lockPath, "utf-8");
+          const current = await readFile26(lockPath, "utf-8");
           if (current === token) await unlink6(lockPath);
         } catch {
         }
@@ -21174,7 +21871,7 @@ async function acquireJobLock(id) {
       const code = err.code;
       if (code !== "EEXIST") throw err;
       try {
-        const info = await stat5(lockPath);
+        const info = await stat6(lockPath);
         if (Date.now() - info.mtimeMs > LOCK_STALE_MS2) {
           await unlink6(lockPath).catch(() => {
           });
@@ -21513,7 +22210,7 @@ function canFire(job, deps) {
 init_agent_sessions();
 init_session_db();
 function createSchedulesRouter(broadcast) {
-  const router = Router13();
+  const router = Router14();
   const notify = () => broadcast?.({ type: "schedules-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   router.get("/", async (_req, res) => {
     try {
@@ -21638,20 +22335,20 @@ init_config2();
 init_paths();
 init_assignment_resolver();
 init_frontmatter();
-import { readFile as readFile25 } from "fs/promises";
+import { readFile as readFile27 } from "fs/promises";
 import { resolve as resolve36 } from "path";
 
 // src/schedules/launch-ack.ts
 init_session_id();
 import { readdirSync as readdirSync2 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join12 } from "path";
 function defaultSleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function runtimeSessionsDir() {
   const override3 = process.env.SYNTAUR_RUNTIME_SESSIONS_DIR;
-  return override3 && override3.length > 0 ? override3 : join10(homedir7(), ".syntaur", "runtime", "sessions");
+  return override3 && override3.length > 0 ? override3 : join12(homedir9(), ".syntaur", "runtime", "sessions");
 }
 function defaultAckProbe(handle) {
   const dir = runtimeSessionsDir();
@@ -21699,7 +22396,7 @@ async function defaultReadAssignment(assignmentId) {
   const resolved = await resolveAssignmentById(projectsDir, assignmentsDir(), assignmentId);
   if (!resolved) return null;
   try {
-    const content = await readFile25(resolve36(resolved.assignmentDir, "assignment.md"), "utf-8");
+    const content = await readFile27(resolve36(resolved.assignmentDir, "assignment.md"), "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -21786,7 +22483,7 @@ async function runTick(deps = {}) {
 }
 
 // src/dashboard/api-usage.ts
-import { Router as Router14 } from "express";
+import { Router as Router15 } from "express";
 
 // src/db/usage-db.ts
 init_paths();
@@ -22236,7 +22933,7 @@ function projectWindowCosts(opts) {
 
 // src/dashboard/api-usage.ts
 function createUsageRouter(projectsDir, assignmentsDir2) {
-  const router = Router14();
+  const router = Router15();
   router.get("/facets", (_req, res) => {
     try {
       initUsageDb();
@@ -22477,11 +23174,11 @@ function projectAssignmentRollup(projectSlug, rows, common) {
 init_fs();
 init_parser();
 init_events_db();
-import { Router as Router15 } from "express";
+import { Router as Router16 } from "express";
 import { resolve as resolve38 } from "path";
-import { readFile as readFile26 } from "fs/promises";
+import { readFile as readFile28 } from "fs/promises";
 function createEventsRouter(projectsDir, assignmentsDir2) {
-  const router = Router15();
+  const router = Router16();
   router.get("/projects/:slug/assignments/:aslug/events", async (req2, res) => {
     try {
       const { slug, aslug } = req2.params;
@@ -22518,7 +23215,7 @@ function createEventsRouter(projectsDir, assignmentsDir2) {
 }
 async function readAssignmentId2(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
-  const content = await readFile26(assignmentMdPath, "utf-8");
+  const content = await readFile28(assignmentMdPath, "utf-8");
   const [fm] = extractFrontmatter2(content);
   const id = getField(fm, "id");
   return id && id.length > 0 ? id : null;
@@ -22555,7 +23252,7 @@ function parseFilters(query) {
 }
 
 // src/dashboard/api-inbox.ts
-import { Router as Router16 } from "express";
+import { Router as Router17 } from "express";
 
 // src/inbox/index.ts
 init_fs();
@@ -22564,7 +23261,7 @@ init_parser();
 init_facts();
 init_state_machine();
 import { resolve as resolve39 } from "path";
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile29 } from "fs/promises";
 
 // src/inbox/types.ts
 var INBOX_CATEGORIES = [
@@ -22744,7 +23441,7 @@ async function computeInbox(opts) {
     if (opts.project !== void 0 && entry.projectSlug !== opts.project) continue;
     let parsed;
     try {
-      const content = await readFile27(resolve39(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile29(resolve39(entry.assignmentDir, "assignment.md"), "utf-8");
       parsed = parseAssignmentFull(content);
     } catch {
       continue;
@@ -22790,7 +23487,7 @@ async function computeInbox(opts) {
       const commentsPath = resolve39(entry.assignmentDir, "comments.md");
       if (await fileExists(commentsPath)) {
         try {
-          const content = await readFile27(commentsPath, "utf-8");
+          const content = await readFile29(commentsPath, "utf-8");
           const parsedComments = parseComments(content);
           for (const c of unresolvedQuestions(parsedComments.entries)) {
             const since = resolveSince("question", parsed, now, c);
@@ -22846,7 +23543,7 @@ async function computeInbox(opts) {
 init_api();
 init_config2();
 function createInboxRouter(projectsDir, assignmentsDir2) {
-  const router = Router16();
+  const router = Router17();
   router.get("/inbox", async (req2, res) => {
     try {
       const project = typeof req2.query.project === "string" && req2.query.project.length > 0 ? req2.query.project : void 0;
@@ -22900,9 +23597,9 @@ init_parser();
 init_slug();
 init_timestamp();
 init_fs();
-import { Router as Router17 } from "express";
+import { Router as Router18 } from "express";
 import { resolve as resolve40 } from "path";
-import { readFile as readFile28 } from "fs/promises";
+import { readFile as readFile30 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
   switch (code) {
@@ -22917,7 +23614,7 @@ function statusForPlaybookError(code) {
   }
 }
 function createPlaybooksRouter(playbooksDir2) {
-  const router = Router17();
+  const router = Router18();
   router.get("/", async (_req, res) => {
     try {
       const playbooks = await listPlaybooks(playbooksDir2);
@@ -22985,7 +23682,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       const filePath = resolve40(playbooksDir2, resolved.filename);
-      const content = await readFile28(filePath, "utf-8");
+      const content = await readFile30(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -23081,10 +23778,10 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router19 } from "express";
-import { readdir as readdir18 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname10 } from "path";
-import { rename as rename6, mkdir as mkdir5 } from "fs/promises";
+import { Router as Router20 } from "express";
+import { readdir as readdir19 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname11 } from "path";
+import { rename as rename6, mkdir as mkdir6 } from "fs/promises";
 init_slug();
 
 // src/utils/promote-todos.ts
@@ -23429,8 +24126,8 @@ init_api();
 import { raw } from "express";
 
 // src/todos/attachments.ts
-import { mkdir as mkdir4, readdir as readdir17, stat as stat6, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve42, basename as basename6, dirname as dirname9, extname } from "path";
+import { mkdir as mkdir5, readdir as readdir18, stat as stat7, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile7, cp } from "fs/promises";
+import { resolve as resolve42, basename as basename7, dirname as dirname10, extname } from "path";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -23503,7 +24200,7 @@ function isSafeInlineMime(mime) {
   return SAFE_INLINE_MIME.has(mime);
 }
 function sanitizeAttachmentName(name) {
-  let n = basename6(name || "").replace(/["'\\/]/g, "_");
+  let n = basename7(name || "").replace(/["'\\/]/g, "_");
   n = Array.from(n, (ch) => {
     const code = ch.charCodeAt(0);
     return code < 32 || code === 127 ? "_" : ch;
@@ -23526,17 +24223,17 @@ function attachmentDirFor(todosDir2, scopeId, todoId) {
 }
 async function dirExists(p) {
   try {
-    return (await stat6(p)).isDirectory();
+    return (await stat7(p)).isDirectory();
   } catch {
     return false;
   }
 }
 async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
-  await mkdir4(dir, { recursive: true });
+  await mkdir5(dir, { recursive: true });
   const id = generateArtifactId();
   const filename = sanitizeAttachmentName(originalName);
-  await writeFile6(resolve42(dir, `${id}__${filename}`), bytes);
+  await writeFile7(resolve42(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -23549,7 +24246,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir17(dir);
+    names = await readdir18(dir);
   } catch {
     return [];
   }
@@ -23561,7 +24258,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
     if (!ATTACHMENT_ID_RE.test(id)) continue;
     const filename = stored.slice(sep2 + 2);
     try {
-      const st = await stat6(resolve42(dir, stored));
+      const st = await stat7(resolve42(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -23575,7 +24272,7 @@ async function readScopeAttachments(todosDir2, scopeId) {
   const scopeDir = resolve42(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
-    todoIds = await readdir17(scopeDir);
+    todoIds = await readdir18(scopeDir);
   } catch {
     return {};
   }
@@ -23592,7 +24289,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir17(dir);
+    names = await readdir18(dir);
   } catch {
     return null;
   }
@@ -23620,7 +24317,7 @@ async function moveAttachments(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId,
   const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
   if (!await dirExists(src)) return;
   const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
-  await mkdir4(dirname9(dst), { recursive: true });
+  await mkdir5(dirname10(dst), { recursive: true });
   try {
     await rename5(src, dst);
   } catch (err) {
@@ -23762,7 +24459,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir) {
-  const router = Router19();
+  const router = Router20();
   installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -23896,7 +24593,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir18(todosDir2).catch(() => []);
+      const files = await readdir19(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -24017,7 +24714,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
       const { resolve: resolve49 } = await import("path");
-      const { readFile: readFile32 } = await import("fs/promises");
+      const { readFile: readFile34 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req2.params.workspace);
       const outcome = await wsLock(workspace, async () => {
@@ -24036,7 +24733,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
         await ensureDir(resolve49(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile32(archFile, "utf-8");
+          archContent = await readFile34(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -24337,7 +25034,7 @@ workspace: ${workspace}
         const { readConfig: readConfig2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const { readFile: readFile32 } = await import("fs/promises");
+        const { readFile: readFile34 } = await import("fs/promises");
         const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
         const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
         let assignmentRef;
@@ -24358,7 +25055,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile32(assignmentMdPath, "utf-8");
+        let content = await readFile34(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -24475,7 +25172,7 @@ workspace: ${workspace}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir5(dirname10(newPlanDir), { recursive: true });
+          await mkdir6(dirname11(newPlanDir), { recursive: true });
           await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -24552,9 +25249,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router20 } from "express";
-import { mkdir as mkdir6, readFile as readFile29, rename as rename7 } from "fs/promises";
-import { resolve as resolve43, dirname as dirname11 } from "path";
+import { Router as Router21 } from "express";
+import { mkdir as mkdir7, readFile as readFile31, rename as rename7 } from "fs/promises";
+import { resolve as resolve43, dirname as dirname12 } from "path";
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -24575,7 +25272,7 @@ async function projectExists(projectsDir, slug) {
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
   try {
-    await mkdir6(todosDir2, { recursive: false });
+    await mkdir7(todosDir2, { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -24587,7 +25284,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir6(resolve43(todosDir2, "archive"), { recursive: false });
+    await mkdir7(resolve43(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -24603,7 +25300,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
-  const router = Router20({ mergeParams: true });
+  const router = Router21({ mergeParams: true });
   installRecordsInvalidation(router);
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -24795,7 +25492,7 @@ function createProjectTodosRouter(projectsDir, broadcast, workspaceTodosDir) {
         const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile29(archFile, "utf-8");
+          archContent = await readFile31(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -25276,7 +25973,7 @@ workspace: ${slug}
         }
         const assignmentMdPath = resolve43(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile29(assignmentMdPath, "utf-8");
+        let content = await readFile31(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -25415,7 +26112,7 @@ workspace: ${slug}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir6(dirname11(newPlanDir), { recursive: true });
+          await mkdir7(dirname12(newPlanDir), { recursive: true });
           await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -25478,8 +26175,8 @@ workspace: ${slug}
 }
 
 // src/dashboard/api-bundles.ts
-import { Router as Router21 } from "express";
-import { readdir as readdir19 } from "fs/promises";
+import { Router as Router22 } from "express";
+import { readdir as readdir20 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -25487,7 +26184,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile30 } from "fs/promises";
+import { readFile as readFile32 } from "fs/promises";
 var BUNDLE_ID_REGEX = /^[a-f0-9]{4}$/;
 var SCOPE_VALUES = /* @__PURE__ */ new Set(["workspace", "project", "global"]);
 var SCOPE_ID_REGEX = /^[a-z0-9_][a-z0-9_-]*$/;
@@ -25554,7 +26251,7 @@ function parseBundles(content) {
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile30(path, "utf-8");
+  const content = await readFile32(path, "utf-8");
   return parseBundles(content).bundles;
 }
 
@@ -25589,7 +26286,7 @@ function annotate(bundle, items) {
 }
 function createBundlesRouter(todosDir2, broadcast) {
   void broadcast;
-  const router = Router21();
+  const router = Router22();
   function validateWorkspace(req2, res, next) {
     const workspace = getWorkspaceParam2(req2.params.workspace);
     if (workspace && !WORKSPACE_REGEX3.test(workspace)) {
@@ -25603,7 +26300,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir19(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir20(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -25655,7 +26352,7 @@ function createBundlesRouter(todosDir2, broadcast) {
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router22 } from "express";
+import { Router as Router23 } from "express";
 import { resolve as resolve44 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
@@ -25685,7 +26382,7 @@ function notFound2(res, slug) {
 }
 function createProjectBundlesRouter(projectsDir, broadcast) {
   void broadcast;
-  const router = Router22({ mergeParams: true });
+  const router = Router23({ mergeParams: true });
   function validateProjectId(req2, res, next) {
     const slug = getProjectIdParam2(req2.params.projectId);
     if (!slug || !isValidSlug(slug)) {
@@ -25719,7 +26416,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
 init_config2();
 init_api();
 init_scanner();
-import { Router as Router23 } from "express";
+import { Router as Router24 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -25727,8 +26424,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp as cp2, mkdtemp, rm as rm5, readFile as readFile31, writeFile as writeFile7, unlink as unlink8, stat as stat7, open as open5, rename as rename8 } from "fs/promises";
-import { resolve as resolve45, join as join11 } from "path";
+import { cp as cp2, mkdtemp, rm as rm5, readFile as readFile33, writeFile as writeFile8, unlink as unlink8, stat as stat8, open as open5, rename as rename8 } from "fs/promises";
+import { resolve as resolve45, join as join13 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -25788,7 +26485,7 @@ async function acquireLock2() {
     return lockPath;
   } catch (err) {
     if (err.code === "EEXIST") {
-      const pid = await readFile31(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile33(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.`
       );
@@ -25821,7 +26518,7 @@ async function cloneOrInit(repoUrl, destDir) {
 }
 async function copyRecursive(src, dest) {
   if (!await fileExists(src)) return;
-  const s = await stat7(src);
+  const s = await stat8(src);
   if (s.isDirectory()) {
     await ensureDir(dest);
     await cp2(src, dest, { recursive: true, force: true });
@@ -25835,7 +26532,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath) {
-  const content = await readFile31(configPath, "utf-8");
+  const content = await readFile33(configPath, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -25858,11 +26555,11 @@ async function backupToGithub(overrides) {
   let tmpDir = null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    tmpDir = await mkdtemp(join11(tmpdir(), "syntaur-backup-"));
+    tmpDir = await mkdtemp(join13(tmpdir(), "syntaur-backup-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
-      const destPath = join11(tmpDir, repoPath);
+      const destPath = join13(tmpDir, repoPath);
       if (isFile) {
         await rm5(destPath, { force: true });
       } else {
@@ -25875,7 +26572,7 @@ async function backupToGithub(overrides) {
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
         await ensureDir(resolve45(destPath, ".."));
-        await writeFile7(destPath, sanitized, "utf-8");
+        await writeFile8(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -25990,7 +26687,7 @@ async function restoreFromGithub(overrides) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
     await updateBackupConfig({ lastRestore: timestamp });
-    tmpDir = await mkdtemp(join11(tmpdir(), "syntaur-restore-"));
+    tmpDir = await mkdtemp(join13(tmpdir(), "syntaur-restore-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       if (category === "config") {
@@ -25999,7 +26696,7 @@ async function restoreFromGithub(overrides) {
       }
       try {
         const { sourcePath: localPath, repoPath, isFile } = await resolveCategoryPath(category);
-        const repoSrcPath = join11(tmpDir, repoPath);
+        const repoSrcPath = join13(tmpDir, repoPath);
         if (!await fileExists(repoSrcPath)) {
           console.warn(`Category "${category}" not found in backup repo, skipping.`);
           continue;
@@ -26042,7 +26739,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router23();
+  const router = Router24();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -27410,6 +28107,7 @@ function createDashboardServer(options) {
   app.use("/api", createInboxRouter(projectsDir, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2));
   app.use("/api/config/agents", createAgentsRouter());
+  app.use("/api/config/agent-discovery", createAgentDiscoveryConfigRouter());
   app.use(
     "/api/launch",
     createLaunchPreflightRouter(projectsDir, assignmentsDir2)
@@ -27607,7 +28305,7 @@ function createDashboardServer(options) {
         });
         server.listen(port, () => {
           const portFile = resolve48(syntaurRoot(), "dashboard-port");
-          writeFile8(portFile, String(port), "utf-8").catch(() => {
+          writeFile9(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });