syntaur 0.76.0 → 0.77.0

package/dist/index.js

@@ -2647,6 +2647,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++) {
@@ -3917,6 +3925,7 @@ __export(config_exports, {
   parseStatusConfig: () => parseStatusConfig,
   parseTerminalConfig: () => parseTerminalConfig,
   readConfig: () => readConfig,
+  serializeAgentDiscoveryConfig: () => serializeAgentDiscoveryConfig,
   serializeSearchConfig: () => serializeSearchConfig,
   serializeStatusConfig: () => serializeStatusConfig,
   toTitleCase: () => toTitleCase,
@@ -3930,6 +3939,7 @@ __export(config_exports, {
   validateDeriveShape: () => validateDeriveShape,
   validateFactDeclarations: () => validateFactDeclarations,
   validateStalenessConfig: () => validateStalenessConfig,
+  writeAgentDiscoveryConfig: () => writeAgentDiscoveryConfig,
   writeAgentsConfig: () => writeAgentsConfig,
   writeHotkeyBindingsConfig: () => writeHotkeyBindingsConfig,
   writeSearchConfig: () => writeSearchConfig,
@@ -4022,6 +4032,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++;
@@ -4124,6 +4178,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;
@@ -4632,6 +4701,43 @@ ${cleanedFm}
 ---${afterFrontmatter}`;
   await writeFileForce(configPath2, 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 configPath2 = 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(configPath2) ? await readFile5(configPath2, "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(configPath2, 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(configPath2, newContent);
+}
 function stripTopLevelScalar(fmBlock, key) {
   const lines = fmBlock.split("\n");
   const keyRegex = new RegExp(`^${key}:\\s*\\S`);
@@ -4844,6 +4950,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 } : {}
     });
@@ -5041,6 +5151,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) {
@@ -5076,6 +5198,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) {
@@ -5561,7 +5695,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) {
@@ -5624,7 +5763,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";
@@ -5700,10 +5839,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 = {
@@ -5725,7 +5877,11 @@ var init_config2 = __esm({
       "playbook",
       "launchPrompt",
       "agentName",
-      "workdir"
+      "workdir",
+      "runner",
+      "sourceKind",
+      "sourcePath",
+      "sourceRepo"
     ]);
     migratedConfigPaths = /* @__PURE__ */ new Set();
     TerminalConfigError = class extends Error {
@@ -7279,6 +7435,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;
@@ -7324,6 +7481,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");
@@ -7335,6 +7517,7 @@ function formatFallbackCwdWarning(opts) {
 var init_cwd = __esm({
   "src/launch/cwd.ts"() {
     "use strict";
+    init_agents_schema();
     init_paths();
   }
 });
@@ -9276,8 +9459,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile82 } = await import("fs/promises");
-  const raw2 = await readFile82(filePath, "utf-8");
+  const { readFile: readFile85 } = await import("fs/promises");
+  const raw2 = await readFile85(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -10123,7 +10306,7 @@ function emptyScan() {
   return { sessions: [], tmuxAvailable: false };
 }
 function scanKey(serversDir2, projectsDir2, assignmentsDir2) {
-  return `${serversDir2}\0${projectsDir2}\0${assignmentsDir2 ?? ""}`;
+  return JSON.stringify([serversDir2, projectsDir2, assignmentsDir2 ?? ""]);
 }
 function delay(ms) {
   return new Promise((resolve112) => {
@@ -13121,12 +13304,12 @@ var init_transcript = __esm({
 // src/usage/cwd-extractor.ts
 import { open as open3, readdir as readdir14, 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 basename10 = jsonlPath.split("/").pop() ?? "";
-  const sessionId = basename10.replace(/\.jsonl$/, "");
+  const basename11 = jsonlPath.split("/").pop() ?? "";
+  const sessionId = basename11.replace(/\.jsonl$/, "");
   if (!sessionId) return null;
   const startTs = await readFirstTimestamp(jsonlPath);
   const endTs = await readLastTimestamp(jsonlPath);
@@ -13221,8 +13404,8 @@ async function* walkClaudeProjects(opts = {}) {
 async function* walkCodexSessions(opts = {}) {
   const root = resolveCodexSessionsRoot(opts.root);
   for await (const filePath of walkJsonlRecursive(root)) {
-    const basename10 = filePath.split("/").pop() ?? "";
-    if (!basename10.endsWith(".jsonl")) continue;
+    const basename11 = filePath.split("/").pop() ?? "";
+    if (!basename11.endsWith(".jsonl")) continue;
     if (opts.sinceMtimeMs !== void 0) {
       const mtime = await mtimeMs(filePath);
       if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -13237,13 +13420,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 basename10 = jsonlPath.split("/").pop() ?? "";
-  const underscoreIdx = basename10.lastIndexOf("_");
+  const basename11 = jsonlPath.split("/").pop() ?? "";
+  const underscoreIdx = basename11.lastIndexOf("_");
   if (underscoreIdx === -1) return null;
-  const sessionId = basename10.slice(underscoreIdx + 1).replace(/\.jsonl$/, "");
+  const sessionId = basename11.slice(underscoreIdx + 1).replace(/\.jsonl$/, "");
   if (!sessionId) return null;
   let handle;
   try {
@@ -13295,7 +13478,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);
@@ -13459,7 +13642,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 dirname6, join as join4 } from "path";
 function isSafeSessionId(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 256 && SAFE_SESSION_ID.test(value);
@@ -13549,7 +13732,7 @@ async function resolveOwnSessionId(opts = {}, deps = {}) {
   }
   const sideChannel = await resolveSideChannelSessionId(opts, deps);
   if (sideChannel) return { id: sideChannel, provenance: "EXPLICIT" };
-  const home2 = deps.homeDir ?? homedir3();
+  const home2 = deps.homeDir ?? homedir4();
   const claudeSessionsDir = deps.claudeSessionsDir ?? join4(home2, ".claude", "sessions");
   const runtimeSessionsDir2 = deps.runtimeSessionsDir ?? join4(home2, ".syntaur", "runtime", "sessions");
   const startPid = deps.startPid ?? process.ppid;
@@ -13832,10 +14015,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 resolve30 } from "path";
 function home(...segments) {
-  return resolve30(homedir4(), ...segments);
+  return resolve30(homedir5(), ...segments);
 }
 function hermesHome() {
   const env = process.env.HERMES_HOME;
@@ -14130,8 +14313,8 @@ __export(launch_exports, {
   shellQuote: () => shellQuote
 });
 import { spawn as spawn2 } from "child_process";
-import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve31 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile5 } from "fs/promises";
+import { isAbsolute as isAbsolute6, resolve as resolve31 } from "path";
 function shellQuote(arg) {
   if (arg === "") return "''";
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -14146,7 +14329,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";
     }
@@ -14211,7 +14394,7 @@ async function launchAgent(options) {
   const spawnCwd = launchCwd.spawnCwd;
   const worktreePath = launchCwd.worktreePath;
   const contextDir = resolve31(worktreePath, ".syntaur");
-  await mkdir2(contextDir, { recursive: true });
+  await mkdir3(contextDir, { recursive: true });
   const context = {
     repository: detail.workspace.repository ?? null,
     branch: detail.workspace.branch ?? null,
@@ -14219,7 +14402,7 @@ async function launchAgent(options) {
     workspaceRoot: worktreePath,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile4(
+  await writeFile5(
     resolve31(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
@@ -14852,15 +15035,15 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath9, pathToFileURL } from "url";
-import { dirname as dirname21, resolve as resolve74, join as join17 } from "path";
-import { homedir as homedir13, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname22, resolve as resolve74, join as join19 } from "path";
+import { homedir as homedir15, tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
 function syntaurRootMjs() {
   const override3 = process.env.SYNTAUR_HOME;
   if (override3 && override3.length > 0) {
     return override3;
   }
-  return join17(homedir13(), ".syntaur");
+  return join19(homedir15(), ".syntaur");
 }
 async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   const { throwOnFailure } = options;
@@ -14890,22 +15073,22 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
     throw err2;
   }
   try {
-    const pkgRoot = resolve74(dirname21(fileURLToPath9(import.meta.url)), "..");
+    const pkgRoot = resolve74(dirname22(fileURLToPath9(import.meta.url)), "..");
     const cliBin = realpathSync4(resolve74(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
-    const bundleParent = join17(
-      homedir13(),
+    const bundleParent = join19(
+      homedir15(),
       "Library",
       "Application Support",
       "Syntaur"
     );
-    const bundlePath = join17(bundleParent, "syntaur-url.app");
+    const bundlePath = join19(bundleParent, "syntaur-url.app");
     mkdirSync3(bundleParent, { recursive: true });
     if (existsSync6(bundlePath)) {
       rmSync(bundlePath, { recursive: true, force: true });
     }
     const installedTerminals = detectInstalledTerminals();
-    const scriptPath = join17(
+    const scriptPath = join19(
       tmpdir2(),
       `syntaur-url-handler-${process.pid}.applescript`
     );
@@ -14924,7 +15107,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
         `osacompile exited with code ${compile.status}: ${compile.stderr || compile.stdout}`
       );
     }
-    const infoPlistPath = join17(bundlePath, "Contents", "Info.plist");
+    const infoPlistPath = join19(bundlePath, "Contents", "Info.plist");
     if (!existsSync6(infoPlistPath)) {
       throw new Error(`osacompile did not produce ${infoPlistPath}`);
     }
@@ -15019,7 +15202,7 @@ function detectInstalledTerminals() {
     ghostty: "Ghostty.app",
     warp: "Warp.app"
   };
-  const appDirs = ["/Applications", join17(homedir13(), "Applications")];
+  const appDirs = ["/Applications", join19(homedir15(), "Applications")];
   for (const [id, bundleId] of Object.entries(bundleIds)) {
     const r = spawnSync7(
       "mdfind",
@@ -15031,7 +15214,7 @@ function detectInstalledTerminals() {
       continue;
     }
     const name = bundleNames[id];
-    if (name && appDirs.some((dir) => existsSync6(join17(dir, name)))) {
+    if (name && appDirs.some((dir) => existsSync6(join19(dir, name)))) {
       installed.add(id);
     }
   }
@@ -15754,8 +15937,8 @@ __export(launchd_exports, {
 });
 import { execFileSync as execFileSync5 } from "child_process";
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, rmSync as rmSync2, realpathSync as realpathSync5, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import { homedir as homedir16, userInfo } from "os";
-import { dirname as dirname28, join as join27, resolve as resolve99 } from "path";
+import { homedir as homedir18, userInfo } from "os";
+import { dirname as dirname29, join as join29, resolve as resolve99 } from "path";
 function buildPlist(spec) {
   const args = [spec.nodePath, spec.syntaurBin, ...spec.command ?? ["schedule", "tick"]];
   const argXml = args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
@@ -15787,8 +15970,8 @@ function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function defaultAcquireInstallLock(home2) {
-  const lockPath = join27(home2, ".syntaur", "install-launch-agent.lock");
-  mkdirSync4(dirname28(lockPath), { recursive: true });
+  const lockPath = join29(home2, ".syntaur", "install-launch-agent.lock");
+  mkdirSync4(dirname29(lockPath), { recursive: true });
   const fd = openSync2(lockPath, "wx");
   return () => {
     try {
@@ -15815,7 +15998,7 @@ function defaultRun(command, args) {
   }
 }
 function resolveSpec(config, deps) {
-  const home2 = deps.homeDir ?? homedir16();
+  const home2 = deps.homeDir ?? homedir18();
   const uid = deps.uid ?? userInfo().uid;
   const spec = {
     label: config.label,
@@ -15823,22 +16006,22 @@ function resolveSpec(config, deps) {
     nodePath: deps.nodePath ?? process.execPath,
     syntaurBin: absolutize(deps.syntaurBin ?? process.argv[1] ?? "syntaur"),
     intervalSeconds: deps.intervalSeconds ?? config.defaultIntervalSeconds,
-    outLog: join27(home2, ".syntaur", "logs", config.outLogName),
-    errLog: join27(home2, ".syntaur", "logs", config.errLogName)
+    outLog: join29(home2, ".syntaur", "logs", config.outLogName),
+    errLog: join29(home2, ".syntaur", "logs", config.errLogName)
   };
-  const plistPath = join27(home2, "Library", "LaunchAgents", `${spec.label}.plist`);
+  const plistPath = join29(home2, "Library", "LaunchAgents", `${spec.label}.plist`);
   return { spec, plistPath, home: home2, uid };
 }
 function installAgent(config, deps) {
   const { spec, plistPath, home: home2, uid } = resolveSpec(config, deps);
   const mkdirp = deps.mkdirp ?? ((p) => mkdirSync4(p, { recursive: true }));
-  const writeFile17 = deps.writeFile ?? ((p, c2) => writeFileSync3(p, c2));
+  const writeFile18 = deps.writeFile ?? ((p, c2) => writeFileSync3(p, c2));
   const run3 = deps.run ?? defaultRun;
   const releaseLock2 = (deps.acquireInstallLock ?? (() => defaultAcquireInstallLock(home2)))();
   try {
-    mkdirp(join27(home2, ".syntaur", "logs"));
-    mkdirp(join27(home2, "Library", "LaunchAgents"));
-    writeFile17(plistPath, buildPlist(spec));
+    mkdirp(join29(home2, ".syntaur", "logs"));
+    mkdirp(join29(home2, "Library", "LaunchAgents"));
+    writeFile18(plistPath, buildPlist(spec));
     const domain = `gui/${uid}`;
     run3("launchctl", ["bootout", `${domain}/${spec.label}`]);
     const boot = run3("launchctl", ["bootstrap", domain, plistPath]);
@@ -16063,7 +16246,7 @@ init_create_assignment();
 init_config2();
 import { spawn as spawn5 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve51, dirname as dirname13 } from "path";
+import { resolve as resolve51, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/dashboard/server.ts
@@ -16074,7 +16257,7 @@ init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
 import { resolve as resolve50 } 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
@@ -20714,6 +20897,7 @@ function createAgentSessionsRouter(projectsDir2, 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();
@@ -20762,7 +20946,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 readdir17, readFile as readFile22 } 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 readFile22(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const [fm] = extractFrontmatter(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, basename11, 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 ?? basename11,
+    // 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(input4) {
+  const out = [];
+  if (input4.claudeGlobal) {
+    for (const d of await discoverClaudeAgents()) {
+      out.push(await toClaudeCandidate(d, "claude-global", input4.agents));
+    }
+  }
+  if (input4.claudeProject && input4.repo) {
+    const projRoot = join7(input4.repo, ".claude", "agents");
+    for (const d of await discoverClaudeAgents(projRoot)) {
+      out.push(await toClaudeCandidate(d, "claude-project", input4.agents, input4.repo));
+    }
+  }
+  if (input4.directory || input4.claudeProject) {
+    for (const rawRoot of input4.roots) {
+      const root = expandHome(rawRoot);
+      let entries;
+      try {
+        entries = await readdir17(root, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const dir = join7(root, e.name);
+        if (input4.directory) {
+          const dirCand = await inspectDirCandidate(dir, e.name, input4.agents);
+          if (dirCand) out.push(dirCand);
+        }
+        if (input4.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", input4.agents, dir));
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const c2 of out) {
+    const key = JSON.stringify([c2.source, c2.path, c2.name]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(c2);
+  }
+  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 readFile23, stat as stat5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { basename as basename5, dirname as dirname7, 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(input4) {
+  const id = uniqueAgentId(slugifyAgentId(input4.name), input4.existingIds);
+  const agent = {
+    id,
+    label: input4.name,
+    command: RUNNER_COMMAND[input4.runner],
+    runner: input4.runner,
+    sourceKind: input4.sourceKind,
+    sourcePath: input4.sourcePath
+  };
+  if (input4.sourceRepo) agent.sourceRepo = input4.sourceRepo;
+  if (input4.runner === "claude") {
+    agent.agentName = input4.name;
+  } else {
+    agent.workdir = input4.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(input4) {
+  const slug = slugifyAgentId(input4.name);
+  if (input4.runner === "claude") {
+    const dir2 = input4.location ? requireAbsolutePath(input4.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: input4.name,
+        description: input4.description,
+        model: input4.model
+      }),
+      ...syntaurBlock(input4.name, "claude", input4.description),
+      "---"
+    ];
+    await mkdir2(dir2, { recursive: true });
+    await writeFile4(path, `${fm2.join("\n")}
+
+${input4.instructions.trim()}
+`);
+    if (!input4.location) {
+      return { path, sourceKind: "claude-global" };
+    }
+    const sourceRepo = basename5(dir2) === "agents" && basename5(dirname7(dir2)) === ".claude" ? dirname7(dirname7(dir2)) : void 0;
+    return { path, sourceKind: "claude-project", ...sourceRepo ? { sourceRepo } : {} };
+  }
+  const parent = input4.location ? requireAbsolutePath(input4.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(input4.name, input4.runner, input4.description), "---"];
+  await mkdir2(dir, { recursive: true });
+  await writeFile4(agentsMd, `${fm.join("\n")}
+
+${input4.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 readFile23(path, "utf-8");
+    const [fm] = extractFrontmatter(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] = extractFrontmatter(await readFile23(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(err2) {
   const message = err2.message;
   let match = message.match(/^agent id "([^"]*)" is invalid/);
@@ -21057,6 +21527,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() {
@@ -21070,6 +21556,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 (err2) {
+      console.error("Error discovering agents:", err2);
+      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 (err2) {
+      if (err2 instanceof AgentConfigError) {
+        res.status(400).json(mapAgentErrorToFieldErrors(err2));
+        return null;
+      }
+      throw err2;
+    }
+    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 (err2) {
+        res.status(400).json({ error: err2 instanceof Error ? err2.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 (err2) {
+      console.error("Error registering agent:", err2);
+      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 (err2) {
+      console.error("Error manual-adding agent:", err2);
+      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 (err2) {
+        res.status(400).json({ error: err2 instanceof Error ? err2.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 (err2) {
+      console.error("Error creating agent:", err2);
+      res.status(500).json({ error: "Failed to create agent" });
+    }
+  });
   router.get("/", async (_req, res) => {
     try {
       const config = await readConfig();
@@ -21132,8 +21776,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",
@@ -21150,7 +21794,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];
@@ -21158,7 +21802,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;
     }
   }
@@ -21188,11 +21832,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") {
@@ -21201,7 +21845,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;
       }
     }
@@ -21460,7 +22104,7 @@ init_agent_sessions();
 // src/launch/argv.ts
 init_agents_schema();
 init_launch();
-import { isAbsolute as isAbsolute6 } from "path";
+import { isAbsolute as isAbsolute7 } from "path";
 var buildFreshArgv = buildAgentArgv;
 function buildSessionArgv(agent, sessionId, mode, env = process.env) {
   const invocation = agent[mode];
@@ -21479,7 +22123,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";
     }
@@ -21539,18 +22183,14 @@ async function resolveStandalonePlan(input4, 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,
+    input4.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());
@@ -21564,7 +22204,7 @@ async function resolveStandalonePlan(input4, terminal) {
   const { argv, shellFallbackWarning } = buildFreshArgv(agent, prompt);
   return {
     terminal,
-    cwd: expanded,
+    cwd: spawnCwd,
     argv,
     env: process.env,
     agentId: agent.id,
@@ -21732,8 +22372,8 @@ async function resolveSessionPlan(input4, terminal) {
 // src/launch/execute.ts
 init_launch();
 import { spawn as spawn3 } from "child_process";
-import { homedir as homedir6 } from "os";
-import { basename as basename5, join as join8, resolve as resolve32 } from "path";
+import { homedir as homedir8 } from "os";
+import { basename as basename6, join as join10, resolve as resolve32 } from "path";
 init_fs();
 init_config2();
 init_session_id();
@@ -21753,7 +22393,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) {
@@ -21839,7 +22479,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,
       {
@@ -22031,7 +22671,7 @@ init_launch_prompt();
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, resolve as resolve33, join as join9 } from "path";
+import { dirname as dirname8, resolve as resolve33, join as join11 } from "path";
 import { realpathSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -22057,7 +22697,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile82 = opts.readFile ?? ((p) => readFileSync3(p, "utf-8"));
+  const readFile85 = opts.readFile ?? ((p) => readFileSync3(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath3);
   if (resolved === null) {
@@ -22073,14 +22713,14 @@ function detectInstallKind(scriptUrl, opts = {}) {
   if (GLOBAL_PATTERN.test(norm)) {
     return "global";
   }
-  let dir = dirname7(resolved);
+  let dir = dirname8(resolved);
   for (let depth = 0; depth < 8; depth++) {
-    const pkgJsonPath = join9(dir, "package.json");
+    const pkgJsonPath = join11(dir, "package.json");
     let raw2;
     try {
-      raw2 = readFile82(pkgJsonPath);
+      raw2 = readFile85(pkgJsonPath);
     } catch {
-      const parent2 = dirname7(dir);
+      const parent2 = dirname8(dir);
       if (parent2 === dir) break;
       dir = parent2;
       continue;
@@ -22092,7 +22732,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
       }
     } catch {
     }
-    const parent = dirname7(dir);
+    const parent = dirname8(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -22116,7 +22756,7 @@ function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
 }
 function nudgeStampPath(hash) {
-  return join9(nudgeStampDir(), sanitizeHash(hash));
+  return join11(nudgeStampDir(), sanitizeHash(hash));
 }
 async function hasNudgedHash(hash) {
   return fileExists(nudgeStampPath(hash));
@@ -22549,21 +23189,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 (err2) {
+        res.status(400).json({ error: err2 instanceof Error ? err2.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 (err2) {
+          res.status(400).json({ error: err2 instanceof Error ? err2.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 readFile22, writeFile as writeFile5, rm as rm2 } from "fs/promises";
-import { dirname as dirname8 } from "path";
+import { readFile as readFile24, writeFile as writeFile6, rm as rm2 } from "fs/promises";
+import { dirname as dirname9 } from "path";
 var StatusResolutionError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -22581,7 +23278,7 @@ async function scanAssignmentsByStatus(projectsDir2, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile22(assignmentPath, "utf-8");
+      content = await readFile24(assignmentPath, "utf-8");
     } catch (err2) {
       const code = err2?.code;
       if (code === "ENOENT") {
@@ -22644,7 +23341,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile22(a.path, "utf-8");
+        const content = await readFile24(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err2) {
         const code = err2?.code;
@@ -22673,7 +23370,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile22(a.path, "utf-8");
+          current = await readFile24(a.path, "utf-8");
         } catch (err2) {
           const code = err2?.code;
           if (code === "ENOENT") {
@@ -22696,7 +23393,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,
@@ -22714,7 +23411,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
@@ -22744,7 +23441,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile22(a.path, "utf-8");
+        const current = await readFile24(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -22755,7 +23452,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       } catch {
         continue;
       }
-      const assignmentDir = dirname8(a.path);
+      const assignmentDir = dirname9(a.path);
       try {
         await rm2(assignmentDir, { recursive: true, force: true });
         deleted++;
@@ -22795,7 +23492,7 @@ async function scanAssignmentsReferencingStatus(projectsDir2, standaloneDir, id)
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile22(assignmentPath, "utf-8");
+      content = await readFile24(assignmentPath, "utf-8");
     } catch (err2) {
       const code = err2?.code;
       if (code === "ENOENT") continue;
@@ -22929,7 +23626,7 @@ function mapResolutionErrorToHttp(err2, applied) {
   }
 }
 function createStatusConfigRouter(projectsDir2, assignmentsDir2) {
-  const router = Router11();
+  const router = Router12();
   installRecordsInvalidation(router);
   router.get("/", async (_req, res) => {
     try {
@@ -23249,7 +23946,7 @@ function createStatusConfigRouter(projectsDir2, 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();
@@ -23882,7 +24579,7 @@ function releaseLeasesByRequestedFor(tag) {
 
 // src/dashboard/api-leases.ts
 function createLeasesRouter(broadcast) {
-  const router = Router12();
+  const router = Router13();
   router.get("/", (_req, res) => {
     try {
       initLeasesDb();
@@ -23938,14 +24635,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 readFile23, readdir as readdir17, rm as rm3 } from "fs/promises";
+import { readFile as readFile25, readdir as readdir18, rm as rm3 } from "fs/promises";
 import { resolve as resolve35 } from "path";
 function schedulesDir() {
   const override3 = process.env.SYNTAUR_SCHEDULES_DIR;
@@ -24078,7 +24775,7 @@ function validateJob(raw2) {
 async function readJob(id) {
   const path = jobPath(id);
   if (!await fileExists(path)) return null;
-  return parseJobFile(await readFile23(path, "utf-8"));
+  return parseJobFile(await readFile25(path, "utf-8"));
 }
 async function writeJob(job) {
   const next = { ...job, updatedAt: nowTimestamp() };
@@ -24088,7 +24785,7 @@ async function writeJob(job) {
 async function listJobs() {
   let names;
   try {
-    names = await readdir17(schedulesDir());
+    names = await readdir18(schedulesDir());
   } catch {
     return [];
   }
@@ -24096,7 +24793,7 @@ async function listJobs() {
   for (const name of names) {
     if (!name.endsWith(".md")) continue;
     try {
-      jobs.push(parseJobFile(await readFile23(resolve35(schedulesDir(), name), "utf-8")));
+      jobs.push(parseJobFile(await readFile25(resolve35(schedulesDir(), name), "utf-8")));
     } catch {
     }
   }
@@ -24106,8 +24803,8 @@ async function listJobs() {
 
 // src/schedules/event-log.ts
 init_timestamp();
-import { appendFile, readFile as readFile24, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname9, resolve as resolve36 } from "path";
+import { appendFile, readFile as readFile26, mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname10, resolve as resolve36 } from "path";
 function eventLogPath(jobId) {
   if (!/^[A-Za-z0-9_-]+$/.test(jobId)) {
     throw new Error(`Unsafe schedule id: ${JSON.stringify(jobId)}`);
@@ -24117,7 +24814,7 @@ function eventLogPath(jobId) {
 async function appendEvent(jobId, type, data) {
   const event = { type, at: nowTimestamp(), ...data ? { data } : {} };
   const path = eventLogPath(jobId);
-  await mkdir3(dirname9(path), { recursive: true });
+  await mkdir4(dirname10(path), { recursive: true });
   await appendFile(path, `${JSON.stringify(event)}
 `, "utf-8");
   return event;
@@ -24125,7 +24822,7 @@ async function appendEvent(jobId, type, data) {
 async function readEvents(jobId) {
   let content;
   try {
-    content = await readFile24(eventLogPath(jobId), "utf-8");
+    content = await readFile26(eventLogPath(jobId), "utf-8");
   } catch {
     return [];
   }
@@ -24144,7 +24841,7 @@ async function readEvents(jobId) {
 
 // src/schedules/attempt.ts
 import { createHash as createHash3 } from "crypto";
-import { open as open4, readFile as readFile25, stat as stat5, unlink as unlink6 } from "fs/promises";
+import { open as open4, readFile as readFile27, stat as stat6, unlink as unlink6 } from "fs/promises";
 import { resolve as resolve37 } from "path";
 
 // src/schedules/triggers.ts
@@ -24333,7 +25030,7 @@ async function acquireJobLock(id) {
       await handle.close();
       return async () => {
         try {
-          const current = await readFile25(lockPath, "utf-8");
+          const current = await readFile27(lockPath, "utf-8");
           if (current === token) await unlink6(lockPath);
         } catch {
         }
@@ -24342,7 +25039,7 @@ async function acquireJobLock(id) {
       const code = err2.code;
       if (code !== "EEXIST") throw err2;
       try {
-        const info = await stat5(lockPath);
+        const info = await stat6(lockPath);
         if (Date.now() - info.mtimeMs > LOCK_STALE_MS2) {
           await unlink6(lockPath).catch(() => {
           });
@@ -24681,7 +25378,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 {
@@ -24806,20 +25503,20 @@ init_config2();
 init_paths();
 init_assignment_resolver();
 init_frontmatter();
-import { readFile as readFile26 } from "fs/promises";
+import { readFile as readFile28 } from "fs/promises";
 import { resolve as resolve39 } 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();
@@ -24867,7 +25564,7 @@ async function defaultReadAssignment(assignmentId) {
   const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir(), assignmentId);
   if (!resolved) return null;
   try {
-    const content = await readFile26(resolve39(resolved.assignmentDir, "assignment.md"), "utf-8");
+    const content = await readFile28(resolve39(resolved.assignmentDir, "assignment.md"), "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -24954,7 +25651,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();
@@ -25404,7 +26101,7 @@ function projectWindowCosts(opts) {
 
 // src/dashboard/api-usage.ts
 function createUsageRouter(projectsDir2, assignmentsDir2) {
-  const router = Router14();
+  const router = Router15();
   router.get("/facets", (_req, res) => {
     try {
       initUsageDb();
@@ -25645,11 +26342,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 resolve41 } from "path";
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile29 } from "fs/promises";
 function createEventsRouter(projectsDir2, assignmentsDir2) {
-  const router = Router15();
+  const router = Router16();
   router.get("/projects/:slug/assignments/:aslug/events", async (req2, res) => {
     try {
       const { slug, aslug } = req2.params;
@@ -25686,7 +26383,7 @@ function createEventsRouter(projectsDir2, assignmentsDir2) {
 }
 async function readAssignmentId2(assignmentMdPath2) {
   if (!await fileExists(assignmentMdPath2)) return null;
-  const content = await readFile27(assignmentMdPath2, "utf-8");
+  const content = await readFile29(assignmentMdPath2, "utf-8");
   const [fm] = extractFrontmatter(content);
   const id = getField(fm, "id");
   return id && id.length > 0 ? id : null;
@@ -25723,7 +26420,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();
@@ -25732,7 +26429,7 @@ init_parser();
 init_facts();
 init_state_machine();
 import { resolve as resolve42 } from "path";
-import { readFile as readFile28 } from "fs/promises";
+import { readFile as readFile30 } from "fs/promises";
 
 // src/inbox/types.ts
 var INBOX_CATEGORIES = [
@@ -25912,7 +26609,7 @@ async function computeInbox(opts) {
     if (opts.project !== void 0 && entry.projectSlug !== opts.project) continue;
     let parsed;
     try {
-      const content = await readFile28(resolve42(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile30(resolve42(entry.assignmentDir, "assignment.md"), "utf-8");
       parsed = parseAssignmentFull(content);
     } catch {
       continue;
@@ -25958,7 +26655,7 @@ async function computeInbox(opts) {
       const commentsPath = resolve42(entry.assignmentDir, "comments.md");
       if (await fileExists(commentsPath)) {
         try {
-          const content = await readFile28(commentsPath, "utf-8");
+          const content = await readFile30(commentsPath, "utf-8");
           const parsedComments = parseComments(content);
           for (const c2 of unresolvedQuestions(parsedComments.entries)) {
             const since = resolveSince("question", parsed, now, c2);
@@ -26014,7 +26711,7 @@ async function computeInbox(opts) {
 init_api();
 init_config2();
 function createInboxRouter(projectsDir2, 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;
@@ -26070,9 +26767,9 @@ init_timestamp();
 init_fs();
 init_playbook();
 init_playbooks();
-import { Router as Router17 } from "express";
+import { Router as Router18 } from "express";
 import { resolve as resolve43 } from "path";
-import { readFile as readFile29 } from "fs/promises";
+import { readFile as readFile31 } from "fs/promises";
 function statusForPlaybookError(code) {
   switch (code) {
     case "manifest":
@@ -26086,7 +26783,7 @@ function statusForPlaybookError(code) {
   }
 }
 function createPlaybooksRouter(playbooksDir3) {
-  const router = Router17();
+  const router = Router18();
   router.get("/", async (_req, res) => {
     try {
       const playbooks = await listPlaybooks(playbooksDir3);
@@ -26154,7 +26851,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       const filePath = resolve43(playbooksDir3, resolved.filename);
-      const content = await readFile29(filePath, "utf-8");
+      const content = await readFile31(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -26250,10 +26947,10 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router19 } from "express";
-import { readdir as readdir19 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname11 } from "path";
-import { rename as rename6, mkdir as mkdir5 } from "fs/promises";
+import { Router as Router20 } from "express";
+import { readdir as readdir20 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname12 } from "path";
+import { rename as rename6, mkdir as mkdir6 } from "fs/promises";
 init_slug();
 init_promote_todos();
 init_api();
@@ -26262,8 +26959,8 @@ init_api();
 import { raw } from "express";
 
 // src/todos/attachments.ts
-import { mkdir as mkdir4, readdir as readdir18, stat as stat6, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve44, basename as basename6, dirname as dirname10, extname } from "path";
+import { mkdir as mkdir5, readdir as readdir19, stat as stat7, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile7, cp } from "fs/promises";
+import { resolve as resolve44, basename as basename7, dirname as dirname11, extname } from "path";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -26360,7 +27057,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;
@@ -26383,17 +27080,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(resolve44(dir, `${id}__${filename}`), bytes);
+  await writeFile7(resolve44(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -26406,7 +27103,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir18(dir);
+    names = await readdir19(dir);
   } catch {
     return [];
   }
@@ -26418,7 +27115,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(resolve44(dir, stored));
+      const st = await stat7(resolve44(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -26432,7 +27129,7 @@ async function readScopeAttachments(todosDir2, scopeId) {
   const scopeDir = resolve44(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
-    todoIds = await readdir18(scopeDir);
+    todoIds = await readdir19(scopeDir);
   } catch {
     return {};
   }
@@ -26449,7 +27146,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir18(dir);
+    names = await readdir19(dir);
   } catch {
     return null;
   }
@@ -26477,7 +27174,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(dirname10(dst), { recursive: true });
+  await mkdir5(dirname11(dst), { recursive: true });
   try {
     await rename5(src, dst);
   } catch (err2) {
@@ -26619,7 +27316,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir2) {
-  const router = Router19();
+  const router = Router20();
   installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -26753,7 +27450,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir19(todosDir2).catch(() => []);
+      const files = await readdir20(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -26874,7 +27571,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
       const { resolve: resolve112 } = await import("path");
-      const { readFile: readFile82 } = await import("fs/promises");
+      const { readFile: readFile85 } = 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 () => {
@@ -26893,7 +27590,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         await ensureDir(resolve112(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile82(archFile, "utf-8");
+          archContent = await readFile85(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -27194,7 +27891,7 @@ workspace: ${workspace}
         const { readConfig: readConfig3 } = 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: readFile82 } = await import("fs/promises");
+        const { readFile: readFile85 } = 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;
@@ -27215,7 +27912,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile82(assignmentMdPath2, "utf-8");
+        let content = await readFile85(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -27332,7 +28029,7 @@ workspace: ${workspace}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir5(dirname11(newPlanDir), { recursive: true });
+          await mkdir6(dirname12(newPlanDir), { recursive: true });
           await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -27409,9 +28106,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router20 } from "express";
-import { mkdir as mkdir6, readFile as readFile30, rename as rename7 } from "fs/promises";
-import { resolve as resolve45, dirname as dirname12 } from "path";
+import { Router as Router21 } from "express";
+import { mkdir as mkdir7, readFile as readFile32, rename as rename7 } from "fs/promises";
+import { resolve as resolve45, dirname as dirname13 } from "path";
 init_promote_todos();
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
@@ -27433,7 +28130,7 @@ async function projectExists(projectsDir2, slug) {
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
   try {
-    await mkdir6(todosDir2, { recursive: false });
+    await mkdir7(todosDir2, { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -27445,7 +28142,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir6(resolve45(todosDir2, "archive"), { recursive: false });
+    await mkdir7(resolve45(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -27461,7 +28158,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir2, 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() });
@@ -27653,7 +28350,7 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
         const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile30(archFile, "utf-8");
+          archContent = await readFile32(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -28134,7 +28831,7 @@ workspace: ${slug}
         }
         const assignmentMdPath2 = resolve45(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile30(assignmentMdPath2, "utf-8");
+        let content = await readFile32(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -28273,7 +28970,7 @@ workspace: ${slug}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir6(dirname12(newPlanDir), { recursive: true });
+          await mkdir7(dirname13(newPlanDir), { recursive: true });
           await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -28336,8 +29033,8 @@ workspace: ${slug}
 }
 
 // src/dashboard/api-bundles.ts
-import { Router as Router21 } from "express";
-import { readdir as readdir20 } from "fs/promises";
+import { Router as Router22 } from "express";
+import { readdir as readdir21 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -28345,7 +29042,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile31 } from "fs/promises";
+import { readFile as readFile33 } 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_-]*$/;
@@ -28448,7 +29145,7 @@ ${lines}
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile31(path, "utf-8");
+  const content = await readFile33(path, "utf-8");
   return parseBundles(content).bundles;
 }
 async function writeBundles(todosDir2, bundles) {
@@ -28487,7 +29184,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)) {
@@ -28501,7 +29198,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir20(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir21(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -28553,7 +29250,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 resolve46 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
@@ -28583,7 +29280,7 @@ function notFound2(res, slug) {
 }
 function createProjectBundlesRouter(projectsDir2, 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)) {
@@ -28617,7 +29314,7 @@ function createProjectBundlesRouter(projectsDir2, 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();
@@ -28625,8 +29322,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 readFile32, writeFile as writeFile7, unlink as unlink8, stat as stat7, open as open5, rename as rename8 } from "fs/promises";
-import { resolve as resolve47, join as join11 } from "path";
+import { cp as cp2, mkdtemp, rm as rm5, readFile as readFile34, writeFile as writeFile8, unlink as unlink8, stat as stat8, open as open5, rename as rename8 } from "fs/promises";
+import { resolve as resolve47, join as join13 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -28686,7 +29383,7 @@ async function acquireLock2() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile32(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile34(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.`
       );
@@ -28719,7 +29416,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 });
@@ -28733,7 +29430,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath2) {
-  const content = await readFile32(configPath2, "utf-8");
+  const content = await readFile34(configPath2, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -28756,11 +29453,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 {
@@ -28773,7 +29470,7 @@ async function backupToGithub(overrides) {
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
         await ensureDir(resolve47(destPath, ".."));
-        await writeFile7(destPath, sanitized, "utf-8");
+        await writeFile8(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -28888,7 +29585,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") {
@@ -28897,7 +29594,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;
@@ -28940,7 +29637,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();
@@ -30308,6 +31005,7 @@ function createDashboardServer(options) {
   app.use("/api", createInboxRouter(projectsDir2, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/config/agents", createAgentsRouter());
+  app.use("/api/config/agent-discovery", createAgentDiscoveryConfigRouter());
   app.use(
     "/api/launch",
     createLaunchPreflightRouter(projectsDir2, assignmentsDir2)
@@ -30505,7 +31203,7 @@ function createDashboardServer(options) {
         });
         server.listen(port, () => {
           const portFile = resolve50(syntaurRoot(), "dashboard-port");
-          writeFile8(portFile, String(port), "utf-8").catch(() => {
+          writeFile9(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -30656,7 +31354,7 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath3(import.meta.url);
-  const packageRoot = resolve51(dirname13(thisFile), "..");
+  const packageRoot = resolve51(dirname14(thisFile), "..");
   const dashboardDist = resolve51(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
@@ -30883,8 +31581,8 @@ init_git_worktree();
 init_recompute();
 init_event_emit();
 init_transitions();
-import { readFile as readFile35 } from "fs/promises";
-import { resolve as resolve54, basename as basename7 } from "path";
+import { readFile as readFile37 } from "fs/promises";
+import { resolve as resolve54, basename as basename8 } from "path";
 
 // src/utils/assignment-target.ts
 init_paths();
@@ -30894,7 +31592,7 @@ init_slug();
 init_assignment_resolver();
 init_parser();
 import { resolve as resolve53 } from "path";
-import { readFile as readFile33 } from "fs/promises";
+import { readFile as readFile35 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 function classifyContext(ctx) {
@@ -30907,7 +31605,7 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   const path = resolve53(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile33(path, "utf-8");
+    const content = await readFile35(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -30918,7 +31616,7 @@ async function readContextJson(cwd) {
   const path = resolve53(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile33(path, "utf-8");
+    const raw2 = await readFile35(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -31103,7 +31801,7 @@ init_session_id();
 init_fs();
 init_frontmatter();
 init_recompute();
-import { readFile as readFile34 } from "fs/promises";
+import { readFile as readFile36 } from "fs/promises";
 function computeDelta(stage, prevStage, fm) {
   const writes = {};
   if (stage === "implement") {
@@ -31121,7 +31819,7 @@ async function assertStageFactOnOpen(input4) {
   const pre = computeDelta(
     input4.stage,
     input4.prevStage,
-    parseAssignmentFrontmatter(await readFile34(input4.assignmentPath, "utf-8"))
+    parseAssignmentFrontmatter(await readFile36(input4.assignmentPath, "utf-8"))
   );
   if (Object.keys(pre).length === 0) return;
   const context = await resolveDeriveContext();
@@ -31171,7 +31869,7 @@ async function resolveTarget(assignment, options) {
 async function inferActor(options) {
   if (options.agent) return `agent:${options.agent}`;
   try {
-    const raw2 = await readFile35(resolve54(process.cwd(), ".syntaur", "context.json"), "utf-8");
+    const raw2 = await readFile37(resolve54(process.cwd(), ".syntaur", "context.json"), "utf-8");
     const ctx = JSON.parse(raw2);
     if (ctx.sessionId) return `agent:${ctx.sessionId.slice(0, 8)}`;
   } catch {
@@ -31180,10 +31878,10 @@ async function inferActor(options) {
 }
 async function emitDeriveEvent(target, type, actor, details) {
   try {
-    const fm = parseAssignmentFrontmatter(await readFile35(target.assignmentPath, "utf-8"));
+    const fm = parseAssignmentFrontmatter(await readFile37(target.assignmentPath, "utf-8"));
     emitEvent({
       assignmentId: fm.id,
-      projectSlug: target.projectDir ? basename7(target.projectDir) : null,
+      projectSlug: target.projectDir ? basename8(target.projectDir) : null,
       type,
       actor,
       details
@@ -31241,7 +31939,7 @@ async function planApproveCommand(assignment, options) {
         throw new Error("No plan file found (plan.md / plan-v*.md). Write a plan before approving.");
       }
       approvedFile = planFile;
-      const planContent = await readFile35(resolve54(target2.assignmentDir, planFile), "utf-8");
+      const planContent = await readFile37(resolve54(target2.assignmentDir, planFile), "utf-8");
       return updatePlanApproval(content, {
         file: planFile,
         digest: planDigest(planContent),
@@ -31314,7 +32012,7 @@ async function attestCommand(assignment, fact, options) {
             "No plan file found (plan.md / plan-v*.md). Write a plan before attesting a binds:plan fact."
           );
         }
-        const planContent = await readFile35(resolve54(target2.assignmentDir, planFile), "utf-8");
+        const planContent = await readFile37(resolve54(target2.assignmentDir, planFile), "utf-8");
         record.file = planFile;
         record.digest = planDigest(planContent);
       } else if (binds === "commit") {
@@ -31405,13 +32103,13 @@ async function requestReviewCommand(assignment, options) {
   }
   const target = await resolveTarget(assignment, options);
   const context = await resolveDeriveContext();
-  const fm = parseAssignmentFrontmatter(await readFile35(target.assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile37(target.assignmentPath, "utf-8"));
   await applyStageFact(assignment, options, target, fm, "review", "Review requested", context);
 }
 async function implementStartedCommand(assignment, options) {
   const target = await resolveTarget(assignment, options);
   const context = await resolveDeriveContext();
-  const fm = parseAssignmentFrontmatter(await readFile35(target.assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile37(target.assignmentPath, "utf-8"));
   if (fm.dependsOn.length > 0 && target.projectDir) {
     const dep = await checkDependencies(target.projectDir, fm.dependsOn, context.terminalStatuses);
     if (!dep.satisfied) {
@@ -31542,7 +32240,7 @@ init_timestamp();
 init_assignment_resolver();
 init_event_emit();
 import { resolve as resolve55 } from "path";
-import { readFile as readFile36, writeFile as writeFile9 } from "fs/promises";
+import { readFile as readFile38, writeFile as writeFile10 } from "fs/promises";
 async function resolveTarget2(target, options) {
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
@@ -31574,19 +32272,19 @@ async function resolveTarget2(target, options) {
   return null;
 }
 async function writeArchiveState(filePath, archived, reason) {
-  const content = await readFile36(filePath, "utf-8");
+  const content = await readFile38(filePath, "utf-8");
   const updated = updateAssignmentFile(content, {
     archived,
     archivedAt: archived ? nowTimestamp() : null,
     archivedReason: archived ? reason : null,
     updated: nowTimestamp()
   });
-  await writeFile9(filePath, updated, "utf-8");
+  await writeFile10(filePath, updated, "utf-8");
 }
 async function emitArchiveEvent(resolved, type, reason) {
   if (resolved.kind !== "assignment") return;
   try {
-    const fm = parseAssignmentFrontmatter(await readFile36(resolved.filePath, "utf-8"));
+    const fm = parseAssignmentFrontmatter(await readFile38(resolved.filePath, "utf-8"));
     emitEvent({
       assignmentId: fm.id,
       projectSlug: fm.project,
@@ -31657,7 +32355,7 @@ init_frontmatter();
 init_timestamp();
 init_event_emit();
 import { resolve as resolve56 } from "path";
-import { readdir as readdir21, readFile as readFile37 } from "fs/promises";
+import { readdir as readdir22, readFile as readFile39 } from "fs/promises";
 var PROMOTABLE_STATUSES = /* @__PURE__ */ new Set(["pending"]);
 function objectiveIsFleshedOut(content) {
   const match = content.match(/##\s+Objective\s*\n([\s\S]*?)(?=\n##\s+|$)/);
@@ -31675,7 +32373,7 @@ async function collectCandidates(baseDirs) {
   const candidates = [];
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const projects = await readdir21(baseDir, { withFileTypes: true });
+    const projects = await readdir22(baseDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -31683,7 +32381,7 @@ async function collectCandidates(baseDirs) {
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
-          const content = await readFile37(directAssignmentMd, "utf-8");
+          const content = await readFile39(directAssignmentMd, "utf-8");
           if (objectiveIsFleshedOut(content) && hasAcceptanceCriteria(content)) {
             candidates.push({
               projectSlug: null,
@@ -31698,7 +32396,7 @@ async function collectCandidates(baseDirs) {
       }
       const assignmentsDir2 = resolve56(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir21(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir22(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -31706,7 +32404,7 @@ async function collectCandidates(baseDirs) {
         if (!await fileExists(assignmentMd)) continue;
         const fm = await parseSafe(assignmentMd);
         if (!fm || !PROMOTABLE_STATUSES.has(fm.status)) continue;
-        const content = await readFile37(assignmentMd, "utf-8");
+        const content = await readFile39(assignmentMd, "utf-8");
         if (!objectiveIsFleshedOut(content)) continue;
         if (!hasAcceptanceCriteria(content)) continue;
         candidates.push({
@@ -31723,7 +32421,7 @@ async function collectCandidates(baseDirs) {
 }
 async function parseSafe(path) {
   try {
-    const content = await readFile37(path, "utf-8");
+    const content = await readFile39(path, "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -31753,7 +32451,7 @@ async function migrateStatusesCommand(options) {
   let migrated = 0;
   await withSuppressedEvents(async () => {
     for (const c2 of candidates) {
-      const content = await readFile37(c2.assignmentMd, "utf-8");
+      const content = await readFile39(c2.assignmentMd, "utf-8");
       const updated = appendStatusHistoryEntry(
         updateAssignmentFile(content, {
           status: c2.toStatus,
@@ -31776,10 +32474,10 @@ init_frontmatter();
 init_event_emit();
 init_types();
 import { resolve as resolve57 } from "path";
-import { readdir as readdir22, readFile as readFile38 } from "fs/promises";
+import { readdir as readdir23, readFile as readFile40 } from "fs/promises";
 async function parseSafe2(path) {
   try {
-    return parseAssignmentFrontmatter(await readFile38(path, "utf-8"));
+    return parseAssignmentFrontmatter(await readFile40(path, "utf-8"));
   } catch {
     return null;
   }
@@ -31802,7 +32500,7 @@ async function collectTargets(baseDirs, terminalStatuses3) {
   const seen = /* @__PURE__ */ new Set();
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const entries = await readdir22(baseDir, { withFileTypes: true });
+    const entries = await readdir23(baseDir, { withFileTypes: true });
     for (const m of entries) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -31823,7 +32521,7 @@ async function collectTargets(baseDirs, terminalStatuses3) {
       }
       const assignmentsBase = resolve57(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsBase)) continue;
-      const slugs = await readdir22(assignmentsBase, { withFileTypes: true });
+      const slugs = await readdir23(assignmentsBase, { withFileTypes: true });
       for (const a of slugs) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -31871,7 +32569,7 @@ async function migrateStatusHistoryCommand(options) {
   await withSuppressedEvents(async () => {
     for (const t of targets) {
       try {
-        const content = await readFile38(t.assignmentMd, "utf-8");
+        const content = await readFile40(t.assignmentMd, "utf-8");
         if (parseAssignmentFrontmatter(content).statusHistory.length > 0) continue;
         const seededContent = appendStatusHistoryEntry(content, {
           at: t.seedAt,
@@ -31900,10 +32598,10 @@ init_config2();
 init_parser();
 init_events_db();
 import { resolve as resolve58 } from "path";
-import { readdir as readdir23, readFile as readFile39 } from "fs/promises";
+import { readdir as readdir24, readFile as readFile41 } from "fs/promises";
 async function parseSafe3(path) {
   try {
-    return parseAssignmentFull(await readFile39(path, "utf-8"));
+    return parseAssignmentFull(await readFile41(path, "utf-8"));
   } catch {
     return null;
   }
@@ -31936,7 +32634,7 @@ async function collectTargets2(baseDirs) {
   const seen = /* @__PURE__ */ new Set();
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const entries = await readdir23(baseDir, { withFileTypes: true });
+    const entries = await readdir24(baseDir, { withFileTypes: true });
     for (const m of entries) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -31960,7 +32658,7 @@ async function collectTargets2(baseDirs) {
       }
       const assignmentsBase = resolve58(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsBase)) continue;
-      const slugs = await readdir23(assignmentsBase, { withFileTypes: true });
+      const slugs = await readdir24(assignmentsBase, { withFileTypes: true });
       for (const a of slugs) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -32045,7 +32743,7 @@ init_frontmatter();
 init_facts();
 init_derive();
 init_recompute();
-import { readdir as readdir24, readFile as readFile40 } from "fs/promises";
+import { readdir as readdir25, readFile as readFile42 } from "fs/promises";
 import { resolve as resolve59 } from "path";
 var IMPLEMENTATION_STATUSES = /* @__PURE__ */ new Set(["in_progress", "review", "code_review"]);
 var REVIEW_STATUSES = /* @__PURE__ */ new Set(["review", "code_review"]);
@@ -32053,14 +32751,14 @@ async function listTargets(projectsDir2, standaloneDir) {
   const targets = [];
   let projects = [];
   try {
-    projects = await readdir24(projectsDir2);
+    projects = await readdir25(projectsDir2);
   } catch {
   }
   for (const project of projects) {
     const projectDir = resolve59(projectsDir2, project);
     let slugs = [];
     try {
-      slugs = await readdir24(resolve59(projectDir, "assignments"));
+      slugs = await readdir25(resolve59(projectDir, "assignments"));
     } catch {
       continue;
     }
@@ -32071,7 +32769,7 @@ async function listTargets(projectsDir2, standaloneDir) {
   }
   let ids = [];
   try {
-    ids = await readdir24(standaloneDir);
+    ids = await readdir25(standaloneDir);
   } catch {
   }
   for (const id of ids) {
@@ -32131,7 +32829,7 @@ async function migrateDeriveCommand(options) {
   for (const target of targets) {
     let content;
     try {
-      content = await readFile40(target.path, "utf-8");
+      content = await readFile42(target.path, "utf-8");
     } catch {
       continue;
     }
@@ -32345,26 +33043,26 @@ init_config2();
 init_fs();
 import {
   cp as cp3,
-  readdir as readdir25,
+  readdir as readdir26,
   symlink,
   lstat,
-  readFile as readFile41,
+  readFile as readFile43,
   readlink,
   rename as rename9,
   rm as rm6,
   unlink as unlink10,
-  writeFile as writeFile10
+  writeFile as writeFile11
 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir8 } from "os";
-import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute7, relative as relative2, resolve as resolve64 } from "path";
+import { homedir as homedir10 } from "os";
+import { basename as basename9, dirname as dirname16, isAbsolute as isAbsolute8, relative as relative2, resolve as resolve64 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname14, resolve as resolve63 } from "path";
+import { dirname as dirname15, resolve as resolve63 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 async function findPackageRoot(expectedRelativePath) {
-  let currentDir = dirname14(fileURLToPath4(import.meta.url));
+  let currentDir = dirname15(fileURLToPath4(import.meta.url));
   while (true) {
     const candidate = resolve63(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
@@ -32390,26 +33088,26 @@ function getPluginManifestRelativePath(pluginKind) {
   return pluginKind === "claude" ? ".claude-plugin/plugin.json" : ".codex-plugin/plugin.json";
 }
 function getDefaultPluginTargetDir(pluginKind) {
-  const home2 = homedir8();
+  const home2 = homedir10();
   return pluginKind === "claude" ? resolve64(home2, ".claude", "plugins", "syntaur") : resolve64(home2, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve64(homedir8(), ".agents", "plugins", "marketplace.json");
+  return resolve64(homedir10(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve64(homedir8(), ".claude", "plugins", "marketplaces");
+  return resolve64(homedir10(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve64(homedir8(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve64(homedir10(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve64(homedir8(), ".claude", "plugins", "installed_plugins.json");
+  return resolve64(homedir10(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
   return resolve64(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw2 = await readFile41(resolve64(packageRoot, "package.json"), "utf-8");
+  const raw2 = await readFile43(resolve64(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw2);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -32417,7 +33115,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw2 = await readFile41(pathValue, "utf-8");
+    const raw2 = await readFile43(pathValue, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -32433,7 +33131,7 @@ async function readPluginManifestName(targetDir, pluginKind) {
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw2 = await readFile41(manifestPath, "utf-8");
+  const raw2 = await readFile43(manifestPath, "utf-8");
   const parsed = JSON.parse(raw2);
   return parsed.name;
 }
@@ -32443,7 +33141,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw2 = await readFile41(markerPath, "utf-8");
+    const raw2 = await readFile43(markerPath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -32456,7 +33154,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve64(dirname15(targetDir), symlinkTarget);
+    const resolvedTarget = resolve64(dirname16(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -32485,7 +33183,7 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
     installMode,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile10(
+  await writeFile11(
     getInstallMarkerPath(targetDir),
     `${JSON.stringify(metadata, null, 2)}
 `,
@@ -32493,15 +33191,15 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
   );
 }
 async function installCopy(paths, pluginKind) {
-  await ensureDir(dirname15(paths.targetDir));
+  await ensureDir(dirname16(paths.targetDir));
   await cp3(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(dirname15(paths.targetDir));
+  await ensureDir(dirname16(paths.targetDir));
   await rm6(paths.targetDir, { recursive: true, force: true });
-  await ensureDir(dirname15(paths.targetDir));
+  await ensureDir(dirname16(paths.targetDir));
   await symlink(resolve64(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
@@ -32513,7 +33211,7 @@ async function removeInstallMarker(targetDir) {
 }
 function normalizeAbsoluteInstallPath(pathValue, label) {
   const expanded = expandHome(pathValue.trim());
-  if (!isAbsolute7(expanded)) {
+  if (!isAbsolute8(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
   return resolve64(expanded);
@@ -32556,7 +33254,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
   };
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
-  await ensureDir(dirname15(manifestPath));
+  await ensureDir(dirname16(manifestPath));
   if (Array.isArray(marketplace.plugins)) {
     marketplace.plugins = [...marketplace.plugins].sort((a, b) => {
       const an = a?.name ?? "";
@@ -32566,10 +33264,10 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   }
   if (await fileExists(manifestPath)) {
     try {
-      const prev = await readFile41(manifestPath, "utf-8");
+      const prev = await readFile43(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      await writeFile10(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+      await writeFile11(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
     } catch {
       throw new Error(
         `Refusing to overwrite ${manifestPath}: existing file is not valid JSON. Inspect and remove or repair it manually before re-running.`
@@ -32577,7 +33275,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
     }
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile10(tmpPath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile11(tmpPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
   await rename9(tmpPath, manifestPath);
 }
@@ -32639,7 +33337,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir25(rootDir, { withFileTypes: true })
+    readdir26(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -32714,7 +33412,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw2 = await readFile41(manifestPath, "utf-8");
+    const raw2 = await readFile43(manifestPath, "utf-8");
     try {
       const parsed = JSON.parse(raw2);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -32739,14 +33437,14 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   };
   existing[name].lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   existing[name].autoUpdate = true;
-  await ensureDir(dirname15(manifestPath));
+  await ensureDir(dirname16(manifestPath));
   if (await fileExists(manifestPath)) {
-    const prev = await readFile41(manifestPath, "utf-8");
+    const prev = await readFile43(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    await writeFile10(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+    await writeFile11(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile10(tmpPath, `${JSON.stringify(existing, null, 2)}
+  await writeFile11(tmpPath, `${JSON.stringify(existing, null, 2)}
 `, "utf-8");
   await rename9(tmpPath, manifestPath);
   return { added: !had, updated: had };
@@ -32755,11 +33453,11 @@ async function ensureKnownClaudeMarketplaceForRoot(options) {
   return registerKnownClaudeMarketplace(options.name, options.rootDir);
 }
 async function setSyntaurPluginEnabled(options) {
-  const settingsPath = resolve64(homedir8(), ".claude", "settings.json");
+  const settingsPath = resolve64(homedir10(), ".claude", "settings.json");
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw2 = await readFile41(settingsPath, "utf-8");
+    const raw2 = await readFile43(settingsPath, "utf-8");
     try {
       parsed = JSON.parse(raw2);
     } catch {
@@ -32775,14 +33473,14 @@ async function setSyntaurPluginEnabled(options) {
   }
   enabledPlugins[key] = options.enabled;
   parsed.enabledPlugins = enabledPlugins;
-  await ensureDir(dirname15(settingsPath));
+  await ensureDir(dirname16(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const prev = await readFile41(settingsPath, "utf-8");
-    await writeFile10(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
+    const prev = await readFile43(settingsPath, "utf-8");
+    await writeFile11(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
-  await writeFile10(tmpPath, `${JSON.stringify(parsed, null, 2)}
+  await writeFile11(tmpPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
   await rename9(tmpPath, settingsPath);
   return { key, previous, current: options.enabled, changed: true };
@@ -32818,17 +33516,17 @@ async function ensureClaudeUserMarketplace() {
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
   const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
-  const pluginsDir = dirname15(normalizedTargetDir);
-  if (basename8(pluginsDir) !== "plugins") {
+  const pluginsDir = dirname16(normalizedTargetDir);
+  if (basename9(pluginsDir) !== "plugins") {
     return null;
   }
-  const rootDir = dirname15(pluginsDir);
+  const rootDir = dirname16(pluginsDir);
   const manifestPath = resolve64(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
   const marketplace = await readClaudeMarketplaceFile(manifestPath);
-  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename8(rootDir);
+  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename9(rootDir);
   return {
     name,
     rootDir,
@@ -32988,7 +33686,7 @@ async function installManagedPlugin(options) {
   };
 }
 function buildMarketplaceSourcePath(pluginTargetDir, marketplacePath) {
-  const relPath = relative2(dirname15(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
+  const relPath = relative2(dirname16(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
   if (relPath === "") {
     return ".";
   }
@@ -33016,7 +33714,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw2 = await readFile41(marketplacePath, "utf-8");
+  const raw2 = await readFile43(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw2);
   return {
     name: parsed.name ?? "local",
@@ -33025,8 +33723,8 @@ async function readMarketplaceFile(marketplacePath) {
   };
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
-  await ensureDir(dirname15(marketplacePath));
-  await writeFile10(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+  await ensureDir(dirname16(marketplacePath));
+  await writeFile11(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
@@ -33258,24 +33956,24 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile43, readdir as readdir26, mkdir as mkdir7, copyFile, rm as rm7, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve66, relative as relative3, join as join12 } from "path";
-import { homedir as homedir10 } from "os";
+import { readFile as readFile45, readdir as readdir27, mkdir as mkdir8, copyFile, rm as rm7, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve66, relative as relative3, join as join14 } from "path";
+import { homedir as homedir12 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
-import { readFile as readFile42 } from "fs/promises";
+import { readFile as readFile44 } from "fs/promises";
 import { resolve as resolve65 } from "path";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir11 } from "os";
 function settingsPathFor(agent) {
-  if (agent === "claude") return resolve65(homedir9(), ".claude", "settings.json");
+  if (agent === "claude") return resolve65(homedir11(), ".claude", "settings.json");
   return null;
 }
 async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile42(path, "utf-8");
+    const raw2 = await readFile44(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -33328,15 +34026,15 @@ async function getSkillsDir() {
   return resolve66(packageRoot, "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve66(homedir10(), ".claude", "skills");
-  return resolve66(homedir10(), ".codex", "skills");
+  if (target === "claude") return resolve66(homedir12(), ".claude", "skills");
+  return resolve66(homedir12(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir26(dir, { withFileTypes: true });
+    const entries = await readdir27(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join12(dir, entry.name);
+      const full = join14(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
@@ -33349,7 +34047,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile43(a), readFile43(b)]);
+    const [ba, bb] = await Promise.all([readFile45(a), readFile45(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -33357,11 +34055,11 @@ async function filesEqual(a, b) {
   }
 }
 async function copyDir(srcDir, destDir) {
-  await mkdir7(destDir, { recursive: true });
-  const entries = await readdir26(srcDir, { withFileTypes: true });
+  await mkdir8(destDir, { recursive: true });
+  const entries = await readdir27(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const src = join12(srcDir, entry.name);
-    const dest = join12(destDir, entry.name);
+    const src = join14(srcDir, entry.name);
+    const dest = join14(destDir, entry.name);
     if (entry.isDirectory()) {
       await copyDir(src, dest);
     } else if (entry.isFile()) {
@@ -33374,7 +34072,7 @@ async function skillMatches(srcDir, destDir) {
   const srcFiles = await walkFiles(srcDir);
   for (const srcFile of srcFiles) {
     const rel = relative3(srcDir, srcFile);
-    const destFile = join12(destDir, rel);
+    const destFile = join14(destDir, rel);
     if (!await filesEqual(srcFile, destFile)) return false;
   }
   const destFiles = await walkFiles(destDir);
@@ -33383,8 +34081,8 @@ async function skillMatches(srcDir, destDir) {
 }
 async function isSymlink(path) {
   try {
-    const stat17 = await lstat2(path);
-    return stat17.isSymbolicLink();
+    const stat18 = await lstat2(path);
+    return stat18.isSymbolicLink();
   } catch {
     return false;
   }
@@ -33412,12 +34110,12 @@ async function installSkillDir(srcDir, destDir, skillName, force) {
   return { skill: skillName, status: "differs-preserved", targetPath: destDir };
 }
 async function discoverSkillNames(sourceDir) {
-  const entries = await readdir26(sourceDir, { withFileTypes: true });
+  const entries = await readdir27(sourceDir, { withFileTypes: true });
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    if (await fileExists(join12(sourceDir, entry.name, "SKILL.md"))) {
+    if (await fileExists(join14(sourceDir, entry.name, "SKILL.md"))) {
       names.push(entry.name);
     }
   }
@@ -33442,10 +34140,10 @@ async function installSkillsWithReport(options) {
   }
   const skillNames = await discoverSkillNames(source);
   const results = [];
-  await mkdir7(targetRoot, { recursive: true });
+  await mkdir8(targetRoot, { recursive: true });
   for (const skill of skillNames) {
-    const srcDir = join12(source, skill);
-    const destDir = join12(targetRoot, skill);
+    const srcDir = join14(source, skill);
+    const destDir = join14(targetRoot, skill);
     results.push(await installSkillDir(srcDir, destDir, skill, force));
   }
   return { results };
@@ -33459,11 +34157,11 @@ async function installSkillsToDir(options) {
   }
   const force = options.force ?? false;
   const skillNames = await discoverSkillNames(source);
-  await mkdir7(options.targetDir, { recursive: true });
+  await mkdir8(options.targetDir, { recursive: true });
   const results = [];
   for (const skill of skillNames) {
-    const srcDir = join12(source, skill);
-    const destDir = join12(options.targetDir, skill);
+    const srcDir = join14(source, skill);
+    const destDir = join14(options.targetDir, skill);
     results.push(await installSkillDir(srcDir, destDir, skill, force));
   }
   return results;
@@ -33484,12 +34182,12 @@ async function uninstallSkills(options) {
   }
   const removed = [];
   for (const skill of known) {
-    const destDir = join12(targetRoot, skill);
+    const destDir = join14(targetRoot, skill);
     if (!await fileExists(destDir)) continue;
     if (await isSymlink(destDir)) continue;
-    const skillMd = join12(destDir, "SKILL.md");
+    const skillMd = join14(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile43(skillMd, "utf-8").catch(() => "");
+    const content = await readFile45(skillMd, "utf-8").catch(() => "");
     const match = content.match(/^name:\s*(\S+)\s*$/m);
     if (!match || match[1] !== skill) continue;
     await rm7(destDir, { recursive: true, force: true });
@@ -33684,20 +34382,20 @@ import { realpathSync as realpathSync3 } from "fs";
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { readFile as readFile45 } from "fs/promises";
-import { dirname as dirname17, join as join14, resolve as resolve67 } from "path";
+import { readFile as readFile47 } from "fs/promises";
+import { dirname as dirname18, join as join16, resolve as resolve67 } from "path";
 import { spawn as spawn6 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { readFile as readFile44 } from "fs/promises";
-import { dirname as dirname16, join as join13 } from "path";
+import { readFile as readFile46 } from "fs/promises";
+import { dirname as dirname17, join as join15 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath5(scriptUrl);
-    const pkgRoot = dirname16(dirname16(scriptPath));
-    const raw2 = await readFile44(join13(pkgRoot, "package.json"), "utf-8");
+    const pkgRoot = dirname17(dirname17(scriptPath));
+    const raw2 = await readFile46(join15(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -33727,7 +34425,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw2 = await readFile45(STATE_FILE, "utf-8");
+    const raw2 = await readFile47(STATE_FILE, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -33738,10 +34436,10 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname17(process.execPath);
+  const nodeDir = dirname18(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
-  const nearNode = join14(nodeDir, npmName);
+  const nearNode = join16(nodeDir, npmName);
   if (await fileExists(nearNode)) {
     return { cmd: nearNode, shell: false };
   }
@@ -33784,9 +34482,9 @@ async function readGlobalVersion() {
   });
   if (!rootPath) return null;
   try {
-    const manifestPath = join14(rootPath, "syntaur", "package.json");
+    const manifestPath = join16(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw2 = await readFile45(manifestPath, "utf-8");
+    const raw2 = await readFile47(manifestPath, "utf-8");
     const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -33905,8 +34603,8 @@ async function maybePromptInstall(scriptUrl) {
 
 // src/commands/update.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join15 } from "path";
-import { homedir as homedir11 } from "os";
+import { join as join17 } from "path";
+import { homedir as homedir13 } from "os";
 var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 var LOCAL_MSG = "Running from a dev/linked checkout \u2014 `syntaur update` won't touch a linked install. Pull + rebuild in your repo, then `syntaur install-plugin --force` to refresh skills.";
 var NPX_MSG = "Running via npx \u2014 there's no durable global install to update. Install durably first: `npm i -g syntaur`.";
@@ -33947,12 +34645,12 @@ var defaultRunner = (cmd, args, opts) => new Promise((resolvePromise) => {
   child.on("close", (code) => resolvePromise({ code: code ?? -1, stdout, stderr }));
 });
 function bunGlobalNodeModulesDir(env) {
-  const globalDir = env.BUN_INSTALL_GLOBAL_DIR ?? join15(env.BUN_INSTALL ?? join15(homedir11(), ".bun"), "install", "global");
-  return join15(globalDir, "node_modules");
+  const globalDir = env.BUN_INSTALL_GLOBAL_DIR ?? join17(env.BUN_INSTALL ?? join17(homedir13(), ".bun"), "install", "global");
+  return join17(globalDir, "node_modules");
 }
 async function defaultResolveFreshBin(pm, runner, env) {
   const binFromPkgRoot = (pkgRoot) => {
-    const entry = join15(pkgRoot, "syntaur", "bin", "syntaur.js");
+    const entry = join17(pkgRoot, "syntaur", "bin", "syntaur.js");
     return existsSync5(entry) ? { cmd: process.execPath, baseArgs: [entry] } : null;
   };
   try {
@@ -33964,7 +34662,7 @@ async function defaultResolveFreshBin(pm, runner, env) {
     if (pm === "yarn") {
       const res = await runner("yarn", ["global", "dir"], { env, captureStdout: true });
       const dir = res.stdout.trim();
-      return dir ? binFromPkgRoot(join15(dir, "node_modules")) : null;
+      return dir ? binFromPkgRoot(join17(dir, "node_modules")) : null;
     }
     return binFromPkgRoot(bunGlobalNodeModulesDir(env));
   } catch {
@@ -34144,16 +34842,16 @@ async function refreshPluginSkills(options, pm, runner, getManagedDir, resolveFr
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile47, writeFile as writeFile12, copyFile as copyFile2, rm as rm8, stat as stat8, symlink as symlink2, unlink as unlink11, lstat as lstat3 } from "fs/promises";
-import { resolve as resolve69, dirname as dirname19 } from "path";
-import { homedir as homedir12 } from "os";
+import { readFile as readFile49, writeFile as writeFile13, copyFile as copyFile2, rm as rm8, stat as stat9, symlink as symlink2, unlink as unlink11, lstat as lstat3 } from "fs/promises";
+import { resolve as resolve69, dirname as dirname20 } from "path";
+import { homedir as homedir14 } from "os";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile46, writeFile as writeFile11 } from "fs/promises";
-import { resolve as resolve68, dirname as dirname18 } from "path";
+import { readFile as readFile48, writeFile as writeFile12 } from "fs/promises";
+import { resolve as resolve68, dirname as dirname19 } from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -34179,7 +34877,7 @@ function getConfigPath(installRoot) {
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile46(path, "utf-8");
+    const raw2 = await readFile48(path, "utf-8");
     const parsed = JSON.parse(raw2);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
@@ -34274,7 +34972,7 @@ function renderPreview(config, statuslineScript, cwd) {
     env: {
       ...process.env,
       // Force the child to pick up the freshly-written config from install root.
-      HOME: dirname18(dirname18(statuslineScript))
+      HOME: dirname19(dirname19(statuslineScript))
     }
   });
   if (res.status !== 0) return null;
@@ -34325,8 +35023,8 @@ async function configureStatuslineCommand(options = {}) {
     console.log("(preview mode \u2014 config NOT written)");
     return;
   }
-  await ensureDir(dirname18(configPath2));
-  await writeFile11(configPath2, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await ensureDir(dirname19(configPath2));
+  await writeFile12(configPath2, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log("Wrote statusline config:");
   console.log(`  path:      ${configPath2}`);
   console.log(`  segments:  ${config.segments.join(", ")}`);
@@ -34352,22 +35050,22 @@ async function configureStatuslineCommand(options = {}) {
 async function writeDefaultConfigIfMissing(installRoot) {
   const path = getConfigPath(installRoot);
   if (await fileExists(path)) return;
-  await ensureDir(dirname18(path));
+  await ensureDir(dirname19(path));
   const defaultConfig = {
     segments: ["git", "assignment", "session"],
     separator: " \xB7 "
   };
-  await writeFile11(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  await writeFile12(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
-  const here = dirname19(fileURLToPath8(import.meta.url));
+  const here = dirname20(fileURLToPath8(import.meta.url));
   return resolve69(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw2 = await readFile47(settingsPath, "utf-8");
+  const raw2 = await readFile49(settingsPath, "utf-8");
   if (raw2.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw2);
@@ -34379,8 +35077,8 @@ async function readSettingsJson(settingsPath) {
   }
 }
 async function writeSettingsJson(settingsPath, data) {
-  await ensureDir(dirname19(settingsPath));
-  await writeFile12(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await ensureDir(dirname20(settingsPath));
+  await writeFile13(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 async function resolveMode(mode, existingCommand, ourCommand) {
   if (mode !== "ask") return mode;
@@ -34414,8 +35112,8 @@ function extractExistingCommand(settings) {
   };
 }
 async function backupSettings(settingsSnapshot, backupPath) {
-  await ensureDir(dirname19(backupPath));
-  await writeFile12(
+  await ensureDir(dirname20(backupPath));
+  await writeFile13(
     backupPath,
     JSON.stringify(
       {
@@ -34431,7 +35129,7 @@ async function backupSettings(settingsSnapshot, backupPath) {
   );
 }
 async function installScript(sourceScript, destScript, link) {
-  await ensureDir(dirname19(destScript));
+  await ensureDir(dirname20(destScript));
   try {
     const s = await lstat3(destScript);
     if (s.isSymbolicLink() || s.isFile()) {
@@ -34447,7 +35145,7 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve69(homedir12(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve69(homedir14(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
   const destScript = resolve69(installRoot, "statusline.sh");
@@ -34494,13 +35192,13 @@ async function installStatuslineCommand(options = {}) {
 # Executes the previously configured statusLine command.
 exec ${existingCommand}
 `;
-      await writeFile12(wrapperPath, wrapperBody, "utf-8");
+      await writeFile13(wrapperPath, wrapperBody, "utf-8");
       await chmodExec(wrapperPath);
       wrapTarget = wrapperPath;
     }
   }
-  await ensureDir(dirname19(confPath));
-  await writeFile12(
+  await ensureDir(dirname20(confPath));
+  await writeFile13(
     confPath,
     wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
 # stdout becomes the leading segment of the statusline. Remove this
@@ -34537,13 +35235,13 @@ function parseWrapCommand(command) {
 async function chmodExec(path) {
   const fs = await import("fs/promises");
   try {
-    const s = await stat8(path);
+    const s = await stat9(path);
     await fs.chmod(path, s.mode | 73);
   } catch {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve69(homedir12(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve69(homedir14(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const destScript = resolve69(installRoot, "statusline.sh");
   const confPath = resolve69(installRoot, "statusline.conf");
@@ -34555,7 +35253,7 @@ async function uninstallStatuslineCommand(options = {}) {
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw2 = await readFile47(backupPath, "utf-8");
+      const raw2 = await readFile49(backupPath, "utf-8");
       const parsed = JSON.parse(raw2);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -34736,8 +35434,8 @@ init_config2();
 // src/commands/cross-agent-install.ts
 init_fs();
 import { spawnSync as spawnSync6 } from "child_process";
-import { dirname as dirname20, join as join16, resolve as resolve71 } from "path";
-import { cp as cp4, mkdir as mkdir9 } from "fs/promises";
+import { dirname as dirname21, join as join18, resolve as resolve71 } from "path";
+import { cp as cp4, mkdir as mkdir10 } from "fs/promises";
 
 // src/commands/setup-adapter.ts
 init_paths();
@@ -34847,7 +35545,7 @@ async function installTier3Plugin(t, opts = {}) {
     console.log(`${prefix}Tier 3 (${t.id}): ${plugin.source} -> ${installDir}`);
     return "dry-run";
   }
-  if (await fileExists(join16(installDir, plugin.entry)) && !opts.force) {
+  if (await fileExists(join18(installDir, plugin.entry)) && !opts.force) {
     console.log(
       `Tier 3 (${t.id}): already installed at ${installDir} (use --force to overwrite).`
     );
@@ -34855,7 +35553,7 @@ async function installTier3Plugin(t, opts = {}) {
   }
   try {
     const sourceDir = resolve71(await findPackageRoot(plugin.source), plugin.source);
-    await mkdir9(dirname20(installDir), { recursive: true });
+    await mkdir10(dirname21(installDir), { recursive: true });
     await cp4(sourceDir, installDir, { recursive: true, force: true });
     console.log(`Tier 3 (${t.id}): installed ${plugin.kind} -> ${installDir}`);
     return "installed";
@@ -35225,7 +35923,7 @@ init_cwd();
 init_session_db();
 init_agent_sessions();
 import { resolve as resolve73 } from "path";
-import { readFile as readFile48 } from "fs/promises";
+import { readFile as readFile50 } from "fs/promises";
 async function trackSessionCommand(options, deps = {}) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -35242,7 +35940,7 @@ async function trackSessionCommand(options, deps = {}) {
     const cwd = process.cwd();
     let legacyHint;
     try {
-      const raw2 = await readFile48(resolve73(cwd, ".syntaur", "context.json"), "utf-8");
+      const raw2 = await readFile50(resolve73(cwd, ".syntaur", "context.json"), "utf-8");
       const parsed = JSON.parse(raw2);
       if (typeof parsed.sessionId === "string") legacyHint = parsed.sessionId;
     } catch {
@@ -35406,8 +36104,8 @@ function formatInstallUrlHandlerError(err2) {
 init_config2();
 init_paths();
 init_fs();
-import { resolve as resolve75, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile49 } from "fs/promises";
+import { resolve as resolve75, isAbsolute as isAbsolute9 } from "path";
+import { readFile as readFile51 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -35486,7 +36184,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile49(assignmentPath, "utf-8");
+  const content = await readFile51(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -35556,7 +36254,7 @@ async function ensureWorktree(opts) {
 async function runCreate(opts) {
   const { createWorktreeAndRecord: createWorktreeAndRecord2, GitWorktreeError: GitWorktreeError2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
   const expandedWorktree = expandHome(opts.worktreePath);
-  const absWorktree = isAbsolute8(expandedWorktree) ? expandedWorktree : resolve75(expandedWorktree);
+  const absWorktree = isAbsolute9(expandedWorktree) ? expandedWorktree : resolve75(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -35620,7 +36318,7 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir27, readFile as readFile50 } from "fs/promises";
+import { readdir as readdir28, readFile as readFile52 } from "fs/promises";
 import { resolve as resolve77 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
@@ -35630,14 +36328,14 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir27(dir, { withFileTypes: true });
+  const entries = await readdir28(dir, { withFileTypes: true });
   const mdFiles = entries.filter(
     (e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_") && e.name !== "manifest.md"
   );
   const rows = [];
   for (const entry of mdFiles) {
     const filePath = resolve77(dir, entry.name);
-    const raw2 = await readFile50(filePath, "utf-8");
+    const raw2 = await readFile52(filePath, "utf-8");
     const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -35760,13 +36458,13 @@ init_fs();
 init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
-import { readFile as readFile52 } from "fs/promises";
+import { readFile as readFile54 } from "fs/promises";
 import { resolve as resolve79 } from "path";
 
 // src/commands/bundle.ts
 init_paths();
 import { Command } from "commander";
-import { mkdir as mkdir10, readFile as readFile51, readdir as readdir28, rm as rm9, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile53, readdir as readdir29, rm as rm9, writeFile as writeFile14 } from "fs/promises";
 import { resolve as resolve78 } from "path";
 init_parser2();
 init_fs();
@@ -36059,7 +36757,7 @@ bundleCommand.command("plan").description("Create or open the bundle's shared pl
     }
     const planDir = bundlePlanDir(sc.todosPath, sc.scopeId, id);
     await ensureDir(planDir);
-    const existing = (await readdir28(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
+    const existing = (await readdir29(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
     const { target } = pickNextPlanFile(planDir, existing);
     const checklist = await readChecklist(sc.todosPath, sc.checklistKey);
     if (!await fileExists(target)) {
@@ -36128,8 +36826,8 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
     }
     const bundlesFilePath = bundlesPath(sc.todosPath);
     const checklistFilePath = checklistPath(sc.todosPath, sc.checklistKey);
-    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile51(bundlesFilePath, "utf-8") : null;
-    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile51(checklistFilePath, "utf-8") : null;
+    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile53(bundlesFilePath, "utf-8") : null;
+    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile53(checklistFilePath, "utf-8") : null;
     const record = async () => {
       bundle.branch = options.branch;
       bundle.worktreePath = worktreePath;
@@ -36146,7 +36844,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
         await writeBundles(sc.todosPath, bundles);
         await writeChecklist(sc.todosPath, checklist);
         const ctxDir = resolve78(worktreePath, ".syntaur");
-        await mkdir10(ctxDir, { recursive: true });
+        await mkdir11(ctxDir, { recursive: true });
         const payload = {
           bundleId: bundle.id,
           bundleSlug: bundle.slug,
@@ -36159,7 +36857,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
           repository,
           boundAt: nowISO()
         };
-        await writeFile13(resolve78(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
+        await writeFile14(resolve78(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
       } catch (err2) {
         try {
           if (bundlesSnapshot === null) {
@@ -36685,7 +37383,7 @@ todoCommand.command("archive").description("Archive completed todos and their lo
     await ensureDir(resolve79(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile52(archFile, "utf-8");
+      archContent = await readFile54(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -36863,12 +37561,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile82 } = await import("fs/promises");
+  const { readFile: readFile85 } = await import("fs/promises");
   const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
   const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
   const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
-  let content = await readFile82(assignmentMdPath2, "utf-8");
+  let content = await readFile85(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -36913,8 +37611,8 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     }
     const planDir = todoPlanDir(todosPath, workspace, id);
     await ensureDir(planDir);
-    const { readdir: readdir41 } = await import("fs/promises");
-    const existingFiles = (await readdir41(planDir).catch(() => [])).filter(
+    const { readdir: readdir42 } = await import("fs/promises");
+    const existingFiles = (await readdir42(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
@@ -37004,9 +37702,9 @@ async function moveTodo(id, options) {
     if (await fileExists(newPlanDir)) {
       throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
     }
-    const { rename: rename11, mkdir: mkdir13 } = await import("fs/promises");
-    const { dirname: dirname30 } = await import("path");
-    await mkdir13(dirname30(newPlanDir), { recursive: true });
+    const { rename: rename11, mkdir: mkdir14 } = await import("fs/promises");
+    const { dirname: dirname31 } = await import("path");
+    await mkdir14(dirname31(newPlanDir), { recursive: true });
     await rename11(item.planDir, newPlanDir);
     item.planDir = newPlanDir;
   }
@@ -37123,13 +37821,13 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
-import { readFile as readFile64 } from "fs/promises";
-import { isAbsolute as isAbsolute11, resolve as resolve93 } from "path";
+import { readFile as readFile66 } from "fs/promises";
+import { isAbsolute as isAbsolute12, resolve as resolve93 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath12 } from "url";
-import { readFile as readFile63 } from "fs/promises";
-import { dirname as dirname25, join as join22 } from "path";
+import { readFile as readFile65 } from "fs/promises";
+import { dirname as dirname26, join as join24 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
@@ -37174,10 +37872,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve81, isAbsolute as isAbsolute9 } from "path";
-import { readFile as readFile53, stat as stat9 } from "fs/promises";
+import { resolve as resolve81, isAbsolute as isAbsolute10 } from "path";
+import { readFile as readFile55, stat as stat10 } from "fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { dirname as dirname22, join as join18 } from "path";
+import { dirname as dirname23, join as join20 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -37185,7 +37883,7 @@ var syntaurRootExists = {
   title: "~/.syntaur/ directory exists",
   async run(ctx) {
     try {
-      const s = await stat9(ctx.syntaurRoot);
+      const s = await stat10(ctx.syntaurRoot);
       if (!s.isDirectory()) {
         return err(this, `${ctx.syntaurRoot} exists but is not a directory`, [
           ctx.syntaurRoot
@@ -37232,7 +37930,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile53(configPath2, "utf-8");
+    const content = await readFile55(configPath2, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -37269,7 +37967,7 @@ var configValid = {
       };
     }
     const expanded = expandHome(rawProjectDir);
-    if (!isAbsolute9(expanded)) {
+    if (!isAbsolute10(expanded)) {
       return {
         id: this.id,
         category: this.category,
@@ -37508,14 +38206,14 @@ async function readLocalVersion() {
 async function readLocalPkg() {
   try {
     const here = fileURLToPath10(import.meta.url);
-    let dir = dirname22(here);
+    let dir = dirname23(here);
     for (let i = 0; i < 6; i++) {
-      const candidate = join18(dir, "package.json");
+      const candidate = join20(dir, "package.json");
       try {
-        const text = await readFile53(candidate, "utf-8");
+        const text = await readFile55(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname22(dir);
+        dir = dirname23(dir);
       }
     }
     return null;
@@ -37565,7 +38263,7 @@ function versionGte(a, b) {
 // src/utils/doctor/checks/structure.ts
 init_fs();
 import { resolve as resolve82 } from "path";
-import { readdir as readdir29, stat as stat10 } from "fs/promises";
+import { readdir as readdir30, stat as stat11 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -37645,7 +38343,7 @@ var todosDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat10(p);
+    const s = await stat11(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -37676,7 +38374,7 @@ var serversDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat10(p);
+    const s = await stat11(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -37696,7 +38394,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir29(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir30(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -37740,7 +38438,7 @@ function pass2(check) {
 // src/utils/doctor/checks/project.ts
 init_fs();
 import { resolve as resolve83 } from "path";
-import { readdir as readdir30, stat as stat11 } from "fs/promises";
+import { readdir as readdir31, stat as stat12 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -37764,7 +38462,7 @@ var PROJECT_MARKERS = ["project.md", "manifest.md", "assignments"];
 async function listProjects2(ctx) {
   const dir = ctx.config.defaultProjectDir;
   if (!await fileExists(dir)) return [];
-  const entries = await readdir30(dir, { withFileTypes: true });
+  const entries = await readdir31(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
@@ -37826,7 +38524,7 @@ var manifestStale = {
     for (const projectDir of projects) {
       const manifestPath = resolve83(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
-      const manifestMtime = (await stat11(manifestPath)).mtimeMs;
+      const manifestMtime = (await stat12(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
       if (newestAssignment === 0) continue;
       if (newestAssignment > manifestMtime) {
@@ -37858,7 +38556,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir30(projectDir, { withFileTypes: true });
+      const entries = await readdir31(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -37888,7 +38586,7 @@ async function newestAssignmentMtime(projectDir) {
   let newest = 0;
   let entries;
   try {
-    entries = await readdir30(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir31(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -37896,7 +38594,7 @@ async function newestAssignmentMtime(projectDir) {
     if (!e.isDirectory()) continue;
     const assignmentMd = resolve83(assignmentsRoot, e.name, "assignment.md");
     try {
-      const s = await stat11(assignmentMd);
+      const s = await stat12(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
     } catch {
     }
@@ -37920,7 +38618,7 @@ init_types();
 init_paths();
 init_assignment_walk();
 import { resolve as resolve84 } from "path";
-import { readFile as readFile54, readdir as readdir31 } from "fs/promises";
+import { readFile as readFile56, readdir as readdir32 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -38268,7 +38966,7 @@ var draftMissingObjective = {
       if (parsed.status !== "draft") continue;
       let raw2;
       try {
-        raw2 = await readFile54(path, "utf-8");
+        raw2 = await readFile56(path, "utf-8");
       } catch {
         continue;
       }
@@ -38305,12 +39003,12 @@ var readyToImplementMissingPlan = {
       const parsed = await parseSafe4(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir31(a.assignmentDir).catch(() => []);
+      const entries = await readdir32(a.assignmentDir).catch(() => []);
       const planFiles = entries.filter((f) => /^plan(?:-v\d+)?\.md$/i.test(f));
       let hasPlanContent = false;
       for (const f of planFiles) {
         try {
-          const c2 = await readFile54(resolve84(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile56(resolve84(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -38353,7 +39051,7 @@ var assignmentChecks = [
 ];
 async function parseSafe4(path) {
   try {
-    const content = await readFile54(path, "utf-8");
+    const content = await readFile56(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -38515,9 +39213,9 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve86, dirname as dirname23, basename as basename9 } from "path";
-import { readdir as readdir32, readFile as readFile55 } from "fs/promises";
-import { homedir as homedir14 } from "os";
+import { resolve as resolve86, dirname as dirname24, basename as basename10 } from "path";
+import { readdir as readdir33, readFile as readFile57 } from "fs/promises";
+import { homedir as homedir16 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
   id: "integrations.claude-plugin-linked",
@@ -38579,7 +39277,7 @@ var backupConfigured = {
     if (ctx.config.backup?.repo) return pass6(this);
     const projectsDir2 = ctx.config.defaultProjectDir;
     if (!await fileExists(projectsDir2)) return skipped2(this, "no projects dir");
-    const entries = await readdir32(projectsDir2, { withFileTypes: true });
+    const entries = await readdir33(projectsDir2, { withFileTypes: true });
     const hasProjects = entries.some((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_"));
     if (!hasProjects) return skipped2(this, "no projects yet");
     return {
@@ -38598,10 +39296,10 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve86(homedir14(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve86(homedir16(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw2 = await readFile55(path, "utf-8");
+    const raw2 = await readFile57(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -38617,8 +39315,8 @@ var claudeMarketplaceRegistered = {
     if (!await fileExists(dir)) {
       return skipped2(this, "claudePluginDir does not exist (run install-plugin)");
     }
-    const pluginsParent = dirname23(dir);
-    if (basename9(pluginsParent) !== "plugins") {
+    const pluginsParent = dirname24(dir);
+    if (basename10(pluginsParent) !== "plugins") {
       return {
         id: this.id,
         category: this.category,
@@ -38634,7 +39332,7 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceRoot = dirname23(pluginsParent);
+    const marketplaceRoot = dirname24(pluginsParent);
     const marketplaceManifest = resolve86(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
@@ -38654,7 +39352,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile55(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile57(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -38666,7 +39364,7 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceName = parsed.name ?? basename9(marketplaceRoot);
+    const marketplaceName = parsed.name ?? basename10(marketplaceRoot);
     const hasSyntaurEntry = (parsed.plugins ?? []).some((p) => p?.name === "syntaur");
     const known = await readKnownMarketplaces();
     const registered = known[marketplaceName]?.installLocation === marketplaceRoot || Object.values(known).some((v) => v.installLocation === marketplaceRoot);
@@ -38686,7 +39384,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve86(homedir14(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve86(homedir16(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -38727,7 +39425,7 @@ init_fs();
 init_parser();
 init_types();
 import { resolve as resolve87 } from "path";
-import { readFile as readFile56 } from "fs/promises";
+import { readFile as readFile58 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS2 = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 var BUNDLE_FIELDS = ["bundleId", "bundleScope", "bundleScopeId"];
@@ -38759,7 +39457,7 @@ async function loadContext(ctx) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw2 = await readFile56(path, "utf-8");
+    const raw2 = await readFile58(path, "utf-8");
     return { data: JSON.parse(raw2), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -38871,7 +39569,7 @@ var contextTerminal = {
     const assignmentMd = resolve87(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile56(assignmentMd, "utf-8");
+      const content = await readFile58(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -38925,8 +39623,8 @@ function skipped3(check, reason) {
 
 // src/utils/doctor/checks/agents.ts
 init_config2();
-import { isAbsolute as isAbsolute10 } from "path";
-import { access as access2, constants as fsConstants } from "fs/promises";
+import { isAbsolute as isAbsolute11 } from "path";
+import { access as access5, constants as fsConstants } from "fs/promises";
 import { spawnSync as spawnSync8 } from "child_process";
 var CATEGORY8 = "agents";
 var agentsResolvable = {
@@ -38971,9 +39669,9 @@ async function checkAgent(agent) {
       autoFixable: false
     };
   }
-  if (isAbsolute10(agent.command)) {
+  if (isAbsolute11(agent.command)) {
     try {
-      await access2(agent.command, fsConstants.X_OK);
+      await access5(agent.command, fsConstants.X_OK);
       return { ...base, status: "pass", autoFixable: false };
     } catch (err2) {
       const code = err2.code;
@@ -39017,7 +39715,7 @@ var agentChecks = [agentsResolvable];
 // src/utils/doctor/checks/terminal.ts
 init_config2();
 import { spawnSync as spawnSync9 } from "child_process";
-import { readFile as readFile57 } from "fs/promises";
+import { readFile as readFile59 } from "fs/promises";
 import { resolve as resolve88 } from "path";
 init_paths();
 init_fs();
@@ -39025,7 +39723,7 @@ var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
   const configPath2 = resolve88(syntaurRoot(), "config.md");
   if (!await fileExists(configPath2)) return null;
-  const content = await readFile57(configPath2, "utf-8");
+  const content = await readFile59(configPath2, "utf-8");
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) return null;
   const line = fmMatch[1].split("\n").find((l) => /^terminal:\s*/.test(l));
@@ -39175,13 +39873,13 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve89, join as join19 } from "path";
-import { readdir as readdir33, readFile as readFile58, lstat as lstat4 } from "fs/promises";
-import { homedir as homedir15 } from "os";
+import { resolve as resolve89, join as join21 } from "path";
+import { readdir as readdir34, readFile as readFile60, lstat as lstat4 } from "fs/promises";
+import { homedir as homedir17 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve89(homedir15(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve89(homedir15(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve89(homedir17(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve89(homedir17(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -39196,21 +39894,21 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir33(dir, { withFileTypes: true });
+        entries = await readdir34(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
         if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
         if (!KNOWN_SKILLS.includes(entry.name)) continue;
-        const skillMd = join19(dir, entry.name, "SKILL.md");
+        const skillMd = join21(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile58(skillMd, "utf-8").catch(() => "");
+        const content = await readFile60(skillMd, "utf-8").catch(() => "");
         const match = content.match(/^name:\s*(\S+)\s*$/m);
         if (!match || match[1] !== entry.name) continue;
         let isSymlink2 = false;
         try {
-          isSymlink2 = (await lstat4(join19(dir, entry.name))).isSymbolicLink();
+          isSymlink2 = (await lstat4(join21(dir, entry.name))).isSymbolicLink();
         } catch {
         }
         present.push({ name: entry.name, isSymlink: isSymlink2 });
@@ -39222,7 +39920,7 @@ var skillsDedupCheck = {
           findings.push(
             `${label}: ${nonSymlink.length} syntaur skill(s) installed globally while the syntaur plugin is enabled (${agent}) \u2014 duplicate registrations`
           );
-          for (const p of nonSymlink) affected.push(join19(dir, p.name));
+          for (const p of nonSymlink) affected.push(join21(dir, p.name));
         }
       }
     }
@@ -39255,12 +39953,12 @@ var skillsChecks = [skillsDedupCheck];
 
 // src/utils/doctor/checks/cross-agent.ts
 init_fs();
-import { join as join20, resolve as resolve90 } from "path";
-import { readFile as readFile60 } from "fs/promises";
+import { join as join22, resolve as resolve90 } from "path";
+import { readFile as readFile62 } from "fs/promises";
 
 // src/utils/skill-frontmatter.ts
 import { createHash as createHash4 } from "crypto";
-import { readFile as readFile59 } from "fs/promises";
+import { readFile as readFile61 } from "fs/promises";
 function stripQuotes(raw2) {
   const t = raw2.trim();
   if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
@@ -39304,7 +40002,7 @@ function readSkillIdentity(skillMdText) {
   return { name, hasDescription };
 }
 async function sha256File(path) {
-  return createHash4("sha256").update(await readFile59(path)).digest("hex");
+  return createHash4("sha256").update(await readFile61(path)).digest("hex");
 }
 
 // src/utils/doctor/checks/cross-agent.ts
@@ -39314,14 +40012,14 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
   const problems = [];
   let valid = 0;
   for (const skill of knownSkills) {
-    const installedPath = join20(installedDir, skill, "SKILL.md");
+    const installedPath = join22(installedDir, skill, "SKILL.md");
     if (!await fileExists(installedPath)) {
       problems.push({ skill, kind: "missing" });
       continue;
     }
     let text;
     try {
-      text = await readFile60(installedPath, "utf-8");
+      text = await readFile62(installedPath, "utf-8");
     } catch {
       problems.push({ skill, kind: "invalid-frontmatter" });
       continue;
@@ -39332,7 +40030,7 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
       continue;
     }
     valid++;
-    const canonicalPath2 = join20(canonicalSkillsDir, skill, "SKILL.md");
+    const canonicalPath2 = join22(canonicalSkillsDir, skill, "SKILL.md");
     if (await fileExists(canonicalPath2)) {
       const [installedHash, canonicalHash] = await Promise.all([
         sha256File(installedPath),
@@ -39407,7 +40105,7 @@ var crossAgentSkillsCheck = {
       }
       if (t.tier3) {
         const installDir = t.tier3.installDir();
-        const installed2 = await fileExists(join20(installDir, t.tier3.entry));
+        const installed2 = await fileExists(join22(installDir, t.tier3.entry));
         lines.push(
           `${t.displayName}: Tier-3 ${t.tier3.kind} ${installed2 ? "installed" : "absent"} (${installDir})`
         );
@@ -39475,7 +40173,7 @@ var crossAgentChecks = [crossAgentSkillsCheck];
 init_fs();
 init_paths();
 import { resolve as resolve91 } from "path";
-import { readdir as readdir34 } from "fs/promises";
+import { readdir as readdir35 } from "fs/promises";
 import { spawnSync as spawnSync10 } from "child_process";
 init_parser2();
 var CATEGORY12 = "bundles";
@@ -39483,7 +40181,7 @@ async function listScopes(ctx) {
   const out = [];
   const td = todosDir();
   if (await fileExists(td)) {
-    const entries = await readdir34(td).catch(() => []);
+    const entries = await readdir35(td).catch(() => []);
     for (const f of entries) {
       if (typeof f !== "string") continue;
       if (!f.endsWith(".md") || f.endsWith("-log.md")) continue;
@@ -39499,7 +40197,7 @@ async function listScopes(ctx) {
     }
   }
   if (await fileExists(ctx.config.defaultProjectDir)) {
-    const projectEntries = await readdir34(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
+    const projectEntries = await readdir35(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
     for (const e of projectEntries) {
       if (!e.isDirectory()) continue;
       const slug = e.name;
@@ -39697,21 +40395,21 @@ var bundleChecks = [
 ];
 
 // src/utils/doctor/checks/plugin.ts
-import { readFile as readFile61 } from "fs/promises";
-import { dirname as dirname24, join as join21 } from "path";
+import { readFile as readFile63 } from "fs/promises";
+import { dirname as dirname25, join as join23 } from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 var CATEGORY13 = "plugin";
 var PLUGIN_KINDS = ["claude", "codex"];
 async function readCliVersion() {
   try {
-    let dir = dirname24(fileURLToPath11(import.meta.url));
+    let dir = dirname25(fileURLToPath11(import.meta.url));
     for (let i = 0; i < 8; i += 1) {
       try {
-        const parsed = JSON.parse(await readFile61(join21(dir, "package.json"), "utf-8"));
+        const parsed = JSON.parse(await readFile63(join23(dir, "package.json"), "utf-8"));
         if (typeof parsed.version === "string" && parsed.version.length > 0) return parsed.version;
       } catch {
       }
-      dir = dirname24(dir);
+      dir = dirname25(dir);
     }
   } catch {
   }
@@ -39818,7 +40516,7 @@ var deriveConfigChecks = [deriveConfigValid];
 // src/utils/doctor/checks/staleness.ts
 init_config2();
 import { resolve as resolve92 } from "path";
-import { readFile as readFile62 } from "fs/promises";
+import { readFile as readFile64 } from "fs/promises";
 var CATEGORY15 = "staleness";
 var stalenessConfigValid = {
   id: "staleness.valid",
@@ -39827,7 +40525,7 @@ var stalenessConfigValid = {
   async run(ctx) {
     let content;
     try {
-      content = await readFile62(resolve92(ctx.syntaurRoot, "config.md"), "utf-8");
+      content = await readFile64(resolve92(ctx.syntaurRoot, "config.md"), "utf-8");
     } catch {
       return {
         id: this.id,
@@ -39977,14 +40675,14 @@ async function finalize(checks) {
 async function readVersion() {
   try {
     const here = fileURLToPath12(import.meta.url);
-    let dir = dirname25(here);
+    let dir = dirname26(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw2 = await readFile63(join22(dir, "package.json"), "utf-8");
+        const raw2 = await readFile65(join24(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw2);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname25(dir);
+        dir = dirname26(dir);
       }
     }
     return null;
@@ -40077,7 +40775,7 @@ var REQUIRED_WORKSPACE_FIELDS = [
 ];
 var ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
-  const absolute = isAbsolute11(inputPath) ? inputPath : resolve93(cwd, inputPath);
+  const absolute = isAbsolute12(inputPath) ? inputPath : resolve93(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -40090,7 +40788,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile64(absolute, "utf-8");
+    content = await readFile66(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -40218,6 +40916,7 @@ note: ${FIX_NOOP_NOTE}
 init_config2();
 init_paths();
 import { Command as Command5 } from "commander";
+import { readFile as readFile67 } from "fs/promises";
 var agentsCommand = new Command5("agents").description(
   "Manage configurable agents used by `syntaur browse` and future launch flows"
 );
@@ -40237,6 +40936,8 @@ agentsCommand.command("list").description("List configured agents (or built-in d
       if (agent.launchPrompt) flags.push(`launchPrompt=${truncateForList(agent.launchPrompt)}`);
       if (agent.agentName) flags.push(`agentName=${agent.agentName}`);
       if (agent.workdir) flags.push(`workdir=${truncateForList(agent.workdir)}`);
+      if (agent.runner) flags.push(`runner=${agent.runner}`);
+      if (agent.sourcePath) flags.push(`source=${truncateForList(agent.sourcePath)}`);
       const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
       const args = agent.args && agent.args.length > 0 ? ` ${agent.args.join(" ")}` : "";
       console.log(`  ${agent.id.padEnd(12)} ${agent.label.padEnd(20)} ${agent.command}${args}${flagStr}`);
@@ -40266,6 +40967,48 @@ agentsCommand.command("add").description("Add a new agent to ~/.syntaur/config.m
     reportAndExit(error);
   }
 });
+async function readInstructions(spec) {
+  if (!spec) return "";
+  if (spec.startsWith("@")) return readFile67(expandHome(spec.slice(1)), "utf-8");
+  return spec;
+}
+agentsCommand.command("new").description("Author a runner-native agent def on disk and register it").requiredOption("--name <name>", "Display name").requiredOption("--type <runner>", "Runner: claude | pi | codex").option("--model <model>", "Model (claude agent frontmatter)").option("--description <text>", "One-line description").option("--instructions <text|@file>", "System prompt / instructions body, or @path to read from a file").option("--location <path>", "claude: agents dir (default ~/.claude/agents); directory: parent dir to scaffold under").option("--dry-run", "Author the def but do not register it").action(async (options) => {
+  try {
+    const runner = options.type;
+    if (runner !== "claude" && runner !== "pi" && runner !== "codex") {
+      throw new AgentConfigError(`invalid --type "${options.type}" \u2014 must be claude, pi, or codex`);
+    }
+    const instructions = await readInstructions(options.instructions);
+    const authored = await authorAgentDef({
+      name: options.name,
+      runner,
+      model: options.model,
+      description: options.description,
+      instructions,
+      location: options.location
+    });
+    console.log(`Authored ${runner} def at ${authored.path}`);
+    if (options.dryRun) {
+      console.log("(dry-run: not registered)");
+      return;
+    }
+    const config = await readConfig();
+    const base = getAgents(config);
+    const agent = buildRegisteredAgent({
+      name: options.name,
+      runner,
+      sourceKind: authored.sourceKind,
+      sourcePath: authored.path,
+      sourceRepo: authored.sourceRepo,
+      description: options.description,
+      existingIds: base.map((a) => a.id)
+    });
+    await writeAgentsConfig([...base, agent]);
+    console.log(`Registered agent "${agent.id}" (${runner}).`);
+  } catch (error) {
+    reportAndExit(error);
+  }
+});
 agentsCommand.command("remove <id>").description("Remove an agent from ~/.syntaur/config.md").option("--dry-run", "Validate and print the proposed config without writing").action(async (id, options) => {
   try {
     const mutation = {
@@ -40505,7 +41248,7 @@ init_frontmatter();
 init_event_emit();
 init_templates();
 import { resolve as resolve94 } from "path";
-import { readFile as readFile65 } from "fs/promises";
+import { readFile as readFile68 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -40554,7 +41297,7 @@ async function commentCommand(target, text, options = {}) {
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile65(commentsPath, "utf-8");
+    currentContent = await readFile68(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -40584,7 +41327,7 @@ ${entry}`;
   try {
     const assignmentMd = resolve94(assignmentDir, "assignment.md");
     if (await fileExists(assignmentMd)) {
-      const fm = parseAssignmentFrontmatter(await readFile65(assignmentMd, "utf-8"));
+      const fm = parseAssignmentFrontmatter(await readFile68(assignmentMd, "utf-8"));
       emitEvent({
         assignmentId: fm.id,
         projectSlug,
@@ -40608,8 +41351,8 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve97, relative as relative4, dirname as dirname26 } from "path";
-import { copyFile as copyFile3, mkdir as mkdir12, realpath as realpath2, rm as rm14, stat as stat14, writeFile as writeFile15 } from "fs/promises";
+import { resolve as resolve97, relative as relative4, dirname as dirname27 } from "path";
+import { copyFile as copyFile3, mkdir as mkdir13, realpath as realpath2, rm as rm14, stat as stat15, writeFile as writeFile16 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 init_session_id();
 init_session_db();
@@ -40618,9 +41361,9 @@ init_fs();
 
 // src/utils/screencapture.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp2, rm as rm10, stat as stat12 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm10, stat as stat13 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 function argsFor(mode, pngPath) {
   switch (mode) {
     case "interactive":
@@ -40653,8 +41396,8 @@ async function captureScreenshot(mode) {
       "screencapture is only available on macOS. Use --file <path> to attach an existing image."
     );
   }
-  const tmpDir = await mkdtemp2(join23(tmpdir3(), "syntaur-screenshot-"));
-  const pngPath = join23(tmpDir, "shot.png");
+  const tmpDir = await mkdtemp2(join25(tmpdir3(), "syntaur-screenshot-"));
+  const pngPath = join25(tmpDir, "shot.png");
   const cleanup = async () => {
     await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -40676,7 +41419,7 @@ async function captureScreenshot(mode) {
     }
     let size = 0;
     try {
-      size = (await stat12(pngPath)).size;
+      size = (await stat13(pngPath)).size;
     } catch {
       throw new Error("screencapture exited 0 but produced no image.");
     }
@@ -40692,9 +41435,9 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn9 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile66, rm as rm11 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile69, rm as rm11 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
 function shellQuote2(s) {
   if (s.length === 0) return `''`;
@@ -40731,8 +41474,8 @@ function runAsciinema(args, stdio) {
   });
 }
 async function captureAsciinema(opts) {
-  const tmpDir = await mkdtemp3(join24(tmpdir4(), "syntaur-asciinema-"));
-  const castPath = join24(tmpDir, "session.cast");
+  const tmpDir = await mkdtemp3(join26(tmpdir4(), "syntaur-asciinema-"));
+  const castPath = join26(tmpDir, "session.cast");
   const cleanup = async () => {
     await rm11(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -40755,7 +41498,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile66(castPath, "utf8").catch(() => null);
+    const text = await readFile69(castPath, "utf8").catch(() => null);
     if (text === null) {
       throw new Error(
         `asciinema produced no cast file at ${castPath} (exit ${exitCode}). Try running 'asciinema rec ${castPath}' directly to diagnose.`
@@ -40783,9 +41526,9 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn10 } from "child_process";
-import { mkdir as mkdir11, mkdtemp as mkdtemp4, open as open6, readFile as readFile67, rm as rm12, stat as stat13, unlink as unlink12, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir12, mkdtemp as mkdtemp4, open as open6, readFile as readFile70, rm as rm12, stat as stat14, unlink as unlink12, writeFile as writeFile15 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join25, resolve as resolve95 } from "path";
+import { join as join27, resolve as resolve95 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
   const raw2 = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
@@ -40857,7 +41600,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile67(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile70(pidfile, "utf-8").catch(() => "")).trim();
       if (existing.startsWith(STARTING_SENTINEL_PREFIX)) {
         const parentPidRaw = existing.slice(STARTING_SENTINEL_PREFIX.length);
         const parentPid = Number.parseInt(parentPidRaw, 10);
@@ -40899,7 +41642,7 @@ async function startRecording(input4) {
     );
   }
   const root = syntaurRoot();
-  await mkdir11(root, { recursive: true });
+  await mkdir12(root, { recursive: true });
   const pidfile = pidfilePath();
   const log = logPath2();
   const sidecar = sidecarPath();
@@ -40910,8 +41653,8 @@ async function startRecording(input4) {
   let acquiredPid = null;
   try {
     logHandle = await open6(log, "w");
-    tmpDir = await mkdtemp4(join25(tmpdir5(), "syntaur-recording-"));
-    const mp4Path = join25(tmpDir, "recording.mp4");
+    tmpDir = await mkdtemp4(join27(tmpdir5(), "syntaur-recording-"));
+    const mp4Path = join27(tmpDir, "recording.mp4");
     let child;
     try {
       child = spawn10("ffmpeg", ffmpegArgs(input4.device, input4.fps, mp4Path), {
@@ -40954,12 +41697,12 @@ async function startRecording(input4) {
     const pid = await pidReady;
     acquiredPid = pid;
     child.unref();
-    await writeFile14(pidfile, String(pid));
+    await writeFile15(pidfile, String(pid));
     await logHandle.close();
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile67(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile70(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
       acquiredPid = null;
       throw new Error(
         `ffmpeg exited during startup \u2014 likely macOS Screen Recording permission missing. Grant access to your terminal in System Settings \u2192 Privacy & Security \u2192 Screen Recording, then retry. Log: ${log}
@@ -40982,7 +41725,7 @@ ${tail}`
       device: input4.device,
       fps: input4.fps
     };
-    await writeFile14(sidecar, JSON.stringify(sidecarData, null, 2));
+    await writeFile15(sidecar, JSON.stringify(sidecarData, null, 2));
     return {
       pid,
       logPath: log,
@@ -41016,7 +41759,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile67(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile70(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -41026,7 +41769,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile67(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile70(sidecar, "utf-8").catch(() => null);
   if (sidecarRaw === null) {
     throw new Error(
       `No recording sidecar at ${sidecar}. The recording state is inconsistent \u2014 delete ${pidfile} and re-run --start.`
@@ -41071,7 +41814,7 @@ async function stopRecording() {
   if (alive) {
     throw new Error(`ffmpeg (PID ${pid}) refused to die after SIGKILL`);
   }
-  const st = await stat13(sidecarData.mp4Path).catch(() => null);
+  const st = await stat14(sidecarData.mp4Path).catch(() => null);
   if (st === null || st.size === 0) {
     await unlink12(pidfile).catch(() => {
     });
@@ -41159,9 +41902,9 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn11 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile68, rm as rm13 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile71, rm as rm13 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join26 } from "path";
+import { join as join28 } from "path";
 var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
 var NO_AUDIO_MARKERS = [
   "Stream map '0:a:0' matches no streams",
@@ -41223,7 +41966,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile68(wavPath);
+  const audio = await readFile71(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -41251,8 +41994,8 @@ var elevenLabsScribe = {
         "ELEVENLABS_API_KEY is not set. Export it (e.g. `export ELEVENLABS_API_KEY=\u2026`) and re-run. A config-file slot will land later."
       );
     }
-    const tmp = await mkdtemp5(join26(tmpdir6(), "syntaur-transcribe-"));
-    const wav = join26(tmp, "audio.wav");
+    const tmp = await mkdtemp5(join28(tmpdir6(), "syntaur-transcribe-"));
+    const wav = join28(tmp, "audio.wav");
     try {
       await extractAudio(videoAbsPath, wav);
       return await callScribe(wav, apiKey, opts);
@@ -41538,7 +42281,7 @@ async function captureCommand(target, options = {}) {
     criterionIndex = sidecar.criterionIndex;
     stopNote = sidecar.note;
     resolvedSource = mp4Path;
-    const mp4TmpDir = dirname26(mp4Path);
+    const mp4TmpDir = dirname27(mp4Path);
     shelloutCleanup = async () => {
       await rm14(mp4TmpDir, { recursive: true, force: true }).catch(() => {
       });
@@ -41559,7 +42302,7 @@ async function captureCommand(target, options = {}) {
         `--file is unreadable: ${options.file} (${e instanceof Error ? e.message : String(e)})`
       );
     }
-    const st = await stat14(real);
+    const st = await stat15(real);
     if (!st.isFile()) {
       throw new Error(`--file is not a regular file: ${options.file}`);
     }
@@ -41589,7 +42332,7 @@ async function captureCommand(target, options = {}) {
     initProofDb();
     const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
     const destDir = resolve97(proofDir(resolved.assignmentDir), subdir);
-    if (resolvedSource) await mkdir12(destDir, { recursive: true });
+    if (resolvedSource) await mkdir13(destDir, { recursive: true });
     const ext = resolvedSource ? extensionForKind(kind) : null;
     let id = null;
     let relativeFilePath = null;
@@ -41650,7 +42393,7 @@ async function captureCommand(target, options = {}) {
         try {
           const json = await getTranscriber().transcribe(absPath);
           const md = renderMarkdown(groupIntoPhrases(json.words ?? []));
-          await writeFile15(sidecarPath2, md, "utf8");
+          await writeFile16(sidecarPath2, md, "utf8");
           console.log(`transcript: ${sidecarPath2}`);
         } catch (err2) {
           if (err2 instanceof TranscribeFfmpegMissingError) {
@@ -41696,8 +42439,8 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile69, writeFile as writeFile16, rename as rename10, stat as stat15 } from "fs/promises";
-import { resolve as resolve98, relative as relative5, isAbsolute as isAbsolute12, dirname as dirname27 } from "path";
+import { readFile as readFile72, writeFile as writeFile17, rename as rename10, stat as stat16 } from "fs/promises";
+import { resolve as resolve98, relative as relative5, isAbsolute as isAbsolute13, dirname as dirname28 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -41941,7 +42684,7 @@ async function readAssignmentMeta(assignmentDir) {
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile69(path, "utf-8");
+  const content = await readFile72(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -41955,12 +42698,12 @@ async function readAssignmentMeta(assignmentDir) {
 }
 async function atomicWrite(destPath, content) {
   const tmp = `${destPath}.${randomBytes4(4).toString("hex")}.tmp`;
-  await writeFile16(tmp, content, "utf-8");
+  await writeFile17(tmp, content, "utf-8");
   await rename10(tmp, destPath);
 }
 function isWithin(root, target) {
   const rel = relative5(root, target);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute12(rel);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute13(rel);
 }
 function groupArtifacts(rows, criterionCount) {
   const artifactsByCriterion = /* @__PURE__ */ new Map();
@@ -41997,13 +42740,13 @@ async function loadInlineFiles(rows, assignmentDir) {
       out.set(r.file_path, null);
       continue;
     }
-    const st = await stat15(abs);
+    const st = await stat16(abs);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) {
       out.set(r.file_path, null);
       continue;
     }
     try {
-      out.set(r.file_path, await readFile69(abs, "utf-8"));
+      out.set(r.file_path, await readFile72(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -42016,13 +42759,13 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
   for (const r of rows) {
     if (r.kind !== "video" || !r.file_path) continue;
     const videoAbs = resolve98(assignmentDir, r.file_path);
-    const sidecar = resolve98(dirname27(videoAbs), `${r.id}.transcript.md`);
+    const sidecar = resolve98(dirname28(videoAbs), `${r.id}.transcript.md`);
     if (!isWithin(proofRoot, sidecar)) continue;
     if (!await fileExists(sidecar)) continue;
-    const st = await stat15(sidecar);
+    const st = await stat16(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile69(sidecar, "utf-8"));
+      out.set(r.id, await readFile72(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -42918,7 +43661,7 @@ init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
 import { resolve as resolve100 } from "path";
-import { readFile as readFile70 } from "fs/promises";
+import { readFile as readFile73 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -42949,7 +43692,7 @@ async function requestCommand(target, text, options = {}) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile70(assignmentMdPath2, "utf-8");
+  let content = await readFile73(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -42964,7 +43707,7 @@ init_paths();
 init_config2();
 init_recompute();
 import { Command as Command10 } from "commander";
-import { readFile as readFile71, readdir as readdir35 } from "fs/promises";
+import { readFile as readFile74, readdir as readdir36 } from "fs/promises";
 import { resolve as resolve101 } from "path";
 init_session_id();
 async function resolveAssignmentDir(opts) {
@@ -42991,7 +43734,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir35(assignmentDir, { withFileTypes: true });
+  const entries = await readdir36(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -43186,7 +43929,7 @@ async function runPlanCreate(options) {
       "plan.md already exists. Use --force to overwrite, or `syntaur plan version` to create the next version."
     );
   }
-  const assignmentMd = await readFile71(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile74(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
   await writeFileForce(planPath, buildInitialPlanStub(slug));
@@ -43223,11 +43966,11 @@ async function runPlanVersion(options) {
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
-  const assignmentMd = await readFile71(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile74(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
   const oldPlanPath = resolve101(assignmentDir, current.fileName);
-  const oldPlanContent = await readFile71(oldPlanPath, "utf-8");
+  const oldPlanContent = await readFile74(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -43298,7 +44041,7 @@ init_cwd();
 init_session_db();
 init_agent_sessions();
 import { Command as Command11 } from "commander";
-import { readFile as readFile72, readdir as readdir36, stat as stat16 } from "fs/promises";
+import { readFile as readFile75, readdir as readdir37, stat as stat17 } from "fs/promises";
 import { resolve as resolve102 } from "path";
 init_engagement_db();
 init_parser();
@@ -43306,7 +44049,7 @@ async function readContext(cwd) {
   const path = resolve102(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile72(path, "utf-8");
+    const raw2 = await readFile75(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -43315,13 +44058,13 @@ async function readContext(cwd) {
 async function findLatestSessionSummary(assignmentDir) {
   const sessionsRoot = resolve102(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir36(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir37(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const summaryPath = resolve102(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
-    const st = await stat16(summaryPath);
+    const st = await stat17(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
       best = { sessionId: entry.name, path: summaryPath, mtime: st.mtime };
     }
@@ -43331,7 +44074,7 @@ async function findLatestSessionSummary(assignmentDir) {
 async function findOpenHandoff(assignmentDir) {
   const handoffPath = resolve102(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile72(handoffPath, "utf-8");
+  const content = await readFile75(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
   if (body.length === 0) return null;
   if (/^<!--[\s\S]*-->$/.test(body)) return null;
@@ -43341,7 +44084,7 @@ async function readAssignmentTitle(assignmentDir) {
   const path = resolve102(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile72(path, "utf-8");
+    const content = await readFile75(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "title");
   } catch {
@@ -43558,13 +44301,13 @@ async function runSessionSave(options, cwd = process.cwd(), body) {
   const now = nowTimestamp();
   let created = now;
   if (await fileExists(summaryPath)) {
-    const existing = await readFile72(summaryPath, "utf-8");
+    const existing = await readFile75(summaryPath, "utf-8");
     created = extractCreated(existing) ?? now;
   }
   let sectionBody2 = body;
   if (sectionBody2 === void 0) {
     if (options.fromFile) {
-      sectionBody2 = await readFile72(resolve102(cwd, options.fromFile), "utf-8");
+      sectionBody2 = await readFile75(resolve102(cwd, options.fromFile), "utf-8");
     } else {
       sectionBody2 = await readStdin();
     }
@@ -43792,7 +44535,7 @@ sessionCommand.command("boundary").description(
 // src/commands/worktree.ts
 init_git_worktree();
 import { Command as Command12 } from "commander";
-import { readFile as readFile73 } from "fs/promises";
+import { readFile as readFile76 } from "fs/promises";
 import { resolve as resolve103 } from "path";
 init_fs();
 init_paths();
@@ -43882,7 +44625,7 @@ async function runWorktreeRemove(options, cwd = process.cwd()) {
   if (!await fileExists(assignmentPath)) {
     throw new Error(`Assignment file not found: ${assignmentPath}`);
   }
-  const original = await readFile73(assignmentPath, "utf-8");
+  const original = await readFile76(assignmentPath, "utf-8");
   const fm = parseAssignmentFrontmatter(original);
   const repository = options.repository ?? fm.workspace.repository ?? void 0;
   const worktreePath = fm.workspace.worktreePath ?? void 0;
@@ -43948,7 +44691,7 @@ async function runWorktreeGc(options, cwd = process.cwd()) {
   const owners = /* @__PURE__ */ new Map();
   for (const entry of walk.withAssignmentMd) {
     try {
-      const content = await readFile73(resolve103(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile76(resolve103(entry.assignmentDir, "assignment.md"), "utf-8");
       const fm = parseAssignmentFrontmatter(content);
       const wp = fm.workspace?.worktreePath;
       if (!wp) continue;
@@ -44189,7 +44932,7 @@ worktreeCommand.command("gc").description(
 // src/commands/open.ts
 init_fs();
 import { Command as Command13 } from "commander";
-import { readFile as readFile74 } from "fs/promises";
+import { readFile as readFile77 } from "fs/promises";
 import { resolve as resolve104 } from "path";
 init_frontmatter();
 init_config2();
@@ -44255,7 +44998,7 @@ async function runOpen(assignmentArg, options) {
       remediation: "check the assignment slug or --id"
     });
   }
-  const fm = parseAssignmentFrontmatter(await readFile74(assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile77(assignmentPath, "utf-8"));
   const worktreePath = fm.workspace?.worktreePath;
   if (!worktreePath) {
     throw new SyntaurError("No worktree recorded for this assignment.", {
@@ -44321,12 +45064,12 @@ init_fs();
 init_slug();
 import { Command as Command14 } from "commander";
 import { resolve as resolve106 } from "path";
-import { readFile as readFile76, readdir as readdir38, rm as rm15 } from "fs/promises";
+import { readFile as readFile79, readdir as readdir39, rm as rm15 } from "fs/promises";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir37, readFile as readFile75 } from "fs/promises";
+import { readdir as readdir38, readFile as readFile78 } from "fs/promises";
 import { resolve as resolve105 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -44336,7 +45079,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir37(dir, { withFileTypes: true });
+  const entries = await readdir38(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -44362,7 +45105,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile75(resolve105(dir, fileName), "utf-8");
+    const content = await readFile78(resolve105(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -44393,7 +45136,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile75(resolve105(dir, fileName), "utf-8");
+    const content = await readFile78(resolve105(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -44500,7 +45243,7 @@ async function runResourceAdd(options) {
 async function listResourceSlugs(projectDir) {
   const dir = resolve106(projectDir, "resources");
   if (!await fileExists(dir)) return [];
-  const entries = await readdir38(dir, { withFileTypes: true });
+  const entries = await readdir39(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md").map((e) => e.name.slice(0, -3)).sort();
 }
 async function runResourceList(project) {
@@ -44508,7 +45251,7 @@ async function runResourceList(project) {
   const slugs = await listResourceSlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseResource(await readFile76(resolve106(projectDir, "resources", `${slug}.md`), "utf-8"));
+    const parsed = parseResource(await readFile79(resolve106(projectDir, "resources", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, category: parsed.category, source: parsed.source, updated: parsed.updated });
   }
   return out;
@@ -44517,7 +45260,7 @@ async function runResourceShow(project, slug) {
   const projectDir = await resolveProjectDir(project);
   const filePath = resolve106(projectDir, "resources", `${slug}.md`);
   if (!await fileExists(filePath)) throw new Error(`Resource "${slug}" not found in project "${project}".`);
-  const parsed = parseResource(await readFile76(filePath, "utf-8"));
+  const parsed = parseResource(await readFile79(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -44538,7 +45281,7 @@ async function runResourceUpdate(slug, options) {
   if (options.name === void 0 && options.source === void 0 && options.category === void 0 && options.relatedAssignments === void 0) {
     throw new Error("Provide at least one of --name, --source, --category, --related-assignments.");
   }
-  const original = await readFile76(filePath, "utf-8");
+  const original = await readFile79(filePath, "utf-8");
   const content = editResourceFrontmatter(original, {
     name: options.name,
     category: options.category,
@@ -44635,7 +45378,7 @@ init_fs();
 init_slug();
 import { Command as Command15 } from "commander";
 import { resolve as resolve107 } from "path";
-import { readFile as readFile77, readdir as readdir39, rm as rm16 } from "fs/promises";
+import { readFile as readFile80, readdir as readdir40, rm as rm16 } from "fs/promises";
 init_parser();
 function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -44733,7 +45476,7 @@ async function runMemoryAdd(options) {
 async function listMemorySlugs(projectDir) {
   const dir = resolve107(projectDir, "memories");
   if (!await fileExists(dir)) return [];
-  const entries = await readdir39(dir, { withFileTypes: true });
+  const entries = await readdir40(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md").map((e) => e.name.slice(0, -3)).sort();
 }
 async function runMemoryList(project) {
@@ -44741,7 +45484,7 @@ async function runMemoryList(project) {
   const slugs = await listMemorySlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseMemory(await readFile77(resolve107(projectDir, "memories", `${slug}.md`), "utf-8"));
+    const parsed = parseMemory(await readFile80(resolve107(projectDir, "memories", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, scope: parsed.scope, source: parsed.source, updated: parsed.updated });
   }
   return out;
@@ -44750,7 +45493,7 @@ async function runMemoryShow(project, slug) {
   const projectDir = await resolveProjectDir2(project);
   const filePath = resolve107(projectDir, "memories", `${slug}.md`);
   if (!await fileExists(filePath)) throw new Error(`Memory "${slug}" not found in project "${project}".`);
-  const parsed = parseMemory(await readFile77(filePath, "utf-8"));
+  const parsed = parseMemory(await readFile80(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -44774,7 +45517,7 @@ async function runMemoryUpdate(slug, options) {
       "Provide at least one of --name, --source, --scope, --source-assignment, --related-assignments."
     );
   }
-  const original = await readFile77(filePath, "utf-8");
+  const original = await readFile80(filePath, "utf-8");
   const content = editMemoryFrontmatter(original, {
     name: options.name,
     source: options.source,
@@ -44877,8 +45620,8 @@ init_derive();
 init_recompute();
 init_query();
 import { Command as Command16 } from "commander";
-import { readFile as readFile78 } from "fs/promises";
-import { dirname as dirname29, resolve as resolve108 } from "path";
+import { readFile as readFile81 } from "fs/promises";
+import { dirname as dirname30, resolve as resolve108 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -44911,7 +45654,7 @@ async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile78(path, "utf-8");
+    const content = await readFile81(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -44975,10 +45718,10 @@ async function loadQueryItem(item, terminalStatuses3, now, declarations) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile78(path, "utf-8");
+    const content = await readFile81(path, "utf-8");
     const fm = parseAssignmentFrontmatter(content);
     const body = content.replace(/^---\n[\s\S]*?\n---/, "");
-    const assignmentDir = dirname29(path);
+    const assignmentDir = dirname30(path);
     const projectDir = item.projectSlug ? resolve108(defaultProjectDir(), item.projectSlug) : null;
     const facts = await computeFacts({ assignmentDir, frontmatter: fm, body, projectDir, terminalStatuses: terminalStatuses3, declarations });
     const history = fm.statusHistory;
@@ -45754,7 +46497,7 @@ init_fs();
 init_timestamp();
 init_frontmatter();
 import { Command as Command21 } from "commander";
-import { readFile as readFile79 } from "fs/promises";
+import { readFile as readFile82 } from "fs/promises";
 import { resolve as resolve109 } from "path";
 function renameAssignmentStatusRefs(content, id, newId, now) {
   const fm = parseAssignmentFrontmatter(content);
@@ -45781,7 +46524,7 @@ function configPath() {
 async function readStatusBlock() {
   const p = configPath();
   if (!await fileExists(p)) return null;
-  const content = await readFile79(p, "utf-8");
+  const content = await readFile82(p, "utf-8");
   return parseStatusConfig(content);
 }
 async function requireStatusBlock() {
@@ -46065,7 +46808,7 @@ async function runStatusRename(id, opts) {
     printBlockDiff(before, after);
     const now2 = nowTimestamp();
     for (const a of affected) {
-      const original = await readFile79(a.path, "utf-8");
+      const original = await readFile82(a.path, "utf-8");
       const rewritten = renameAssignmentStatusRefs(original, id, newId, now2);
       console.log(`
 --- ${a.display}/assignment.md`);
@@ -46076,9 +46819,9 @@ async function runStatusRename(id, opts) {
   }
   const cfgPath = configPath();
   const buffers = /* @__PURE__ */ new Map();
-  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile79(cfgPath, "utf-8") : "");
+  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile82(cfgPath, "utf-8") : "");
   for (const a of affected) {
-    buffers.set(a.path, await readFile79(a.path, "utf-8"));
+    buffers.set(a.path, await readFile82(a.path, "utf-8"));
   }
   const now = nowTimestamp();
   try {
@@ -46280,7 +47023,7 @@ init_config2();
 init_timestamp();
 init_frontmatter();
 import { Command as Command22 } from "commander";
-import { readFile as readFile80 } from "fs/promises";
+import { readFile as readFile83 } from "fs/promises";
 import { resolve as resolve110 } from "path";
 init_session_id();
 async function resolveAssignmentPath3(opts) {
@@ -46336,7 +47079,7 @@ async function runWorkspaceSet(options, cwd = process.cwd()) {
 ${pre.errors.map((e) => `  - ${e}`).join("\n")}`
     );
   }
-  const original = await readFile80(path, "utf-8");
+  const original = await readFile83(path, "utf-8");
   let next = updateAssignmentWorkspace(original, partial);
   next = updateAssignmentFile(next, { updated: nowTimestamp() });
   await writeFileForce(path, next);
@@ -46373,7 +47116,7 @@ init_config2();
 init_timestamp();
 init_templates();
 import { Command as Command23 } from "commander";
-import { readFile as readFile81 } from "fs/promises";
+import { readFile as readFile84 } from "fs/promises";
 import { resolve as resolve111 } from "path";
 init_session_id();
 async function resolveAssignmentDir2(opts) {
@@ -46457,7 +47200,7 @@ async function runProgressLog(text, options, cwd = process.cwd()) {
   }
   const path = resolve111(dir, "progress.md");
   const now = nowTimestamp();
-  const content = await fileExists(path) ? await readFile81(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
+  const content = await fileExists(path) ? await readFile84(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
   const next = appendProgressEntry(content, text, now);
   await writeFileForce(path, next);
   return path;
@@ -46477,10 +47220,10 @@ progressCommand.command("log").description("Append a timestamped entry to the as
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir40 } from "fs/promises";
+import { readdir as readdir41 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir40(projectsDir2, { withFileTypes: true });
+    const entries = await readdir41(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;