syntaur 0.74.0 → 0.76.0

package/dist/index.js

@@ -2643,6 +2643,10 @@ function modelFlagArgs(agent) {
   const m = agent.model?.trim();
   return m ? ["--model", m] : [];
 }
+function agentNameArgs(agent) {
+  const n = agent.agentName?.trim();
+  return n ? ["--agent", n] : [];
+}
 function stripModelFlags(args) {
   const out = [];
   for (let i = 0; i < args.length; i++) {
@@ -3998,6 +4002,26 @@ function validateAgentList(agents) {
         `agent "${agent.id}" has invalid launchPrompt \u2014 must be a single line (no newlines)`
       );
     }
+    if (agent.agentName !== void 0 && /[\r\n]/.test(agent.agentName)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid agentName \u2014 must be a single line (no newlines)`
+      );
+    }
+    if (agent.workdir !== void 0 && /[\r\n]/.test(agent.workdir)) {
+      throw new AgentConfigError(
+        `agent "${agent.id}" has invalid workdir \u2014 must be a single line (no newlines)`
+      );
+    }
+    if (agent.agentName !== void 0 && agent.agentName.trim() !== "" && agent.workdir !== void 0 && agent.workdir.trim() !== "") {
+      throw new AgentConfigError(
+        `agent "${agent.id}" sets both agentName and workdir \u2014 these are mutually exclusive`
+      );
+    }
+    if (agent.agentName !== void 0 && agent.agentName.trim() !== "" && agent.model !== void 0 && agent.model.trim() !== "") {
+      throw new AgentConfigError(
+        `agent "${agent.id}" sets both agentName and model \u2014 the agent definition's own model is authoritative; remove the profile model`
+      );
+    }
     validateSessionInvocation(agent, "resume", agent.resume);
     validateSessionInvocation(agent, "fork", agent.fork);
     if (agent.default) defaults++;
@@ -4818,6 +4842,8 @@ function parseAgentsConfig(content) {
       ...current.model ? { model: current.model } : {},
       ...current.playbook ? { playbook: current.playbook } : {},
       ...current.launchPrompt ? { launchPrompt: current.launchPrompt } : {},
+      ...current.agentName ? { agentName: current.agentName } : {},
+      ...current.workdir ? { workdir: current.workdir } : {},
       ...current.resume ? { resume: current.resume } : {},
       ...current.fork ? { fork: current.fork } : {}
     });
@@ -5009,6 +5035,12 @@ function assignAgentField(target, key, rawValue) {
     case "launchPrompt":
       target.launchPrompt = value;
       break;
+    case "agentName":
+      target.agentName = value;
+      break;
+    case "workdir":
+      target.workdir = value;
+      break;
   }
 }
 function yamlQuoteScalar(value) {
@@ -5038,6 +5070,12 @@ function serializeAgentsConfig(agents) {
     if (a.launchPrompt) {
       lines.push(`    launchPrompt: ${yamlQuoteScalar(a.launchPrompt)}`);
     }
+    if (a.agentName) {
+      lines.push(`    agentName: ${yamlQuoteScalar(a.agentName)}`);
+    }
+    if (a.workdir) {
+      lines.push(`    workdir: ${yamlQuoteScalar(a.workdir)}`);
+    }
     if (a.args && a.args.length > 0) {
       lines.push(`    args:`);
       for (const arg of a.args) {
@@ -5685,7 +5723,9 @@ var init_config2 = __esm({
       "resolveFromShellAliases",
       "model",
       "playbook",
-      "launchPrompt"
+      "launchPrompt",
+      "agentName",
+      "workdir"
     ]);
     migratedConfigPaths = /* @__PURE__ */ new Set();
     TerminalConfigError = class extends Error {
@@ -7269,6 +7309,21 @@ function resolveWorkspaceCwd(input4) {
     invalidReason: `workspace path invalid for ${assignmentSlug}: tried worktreePath ${shown(worktreePath)} and repository ${shown(repository)} \u2014 neither is an existing directory`
   };
 }
+function resolveLaunchCwd(agent, worktreeCwd) {
+  const wd = agent.workdir?.trim();
+  if (wd) {
+    const expanded = expandHome(wd);
+    if (!isExistingDir(expanded)) {
+      return {
+        spawnCwd: worktreeCwd,
+        worktreePath: worktreeCwd,
+        invalidReason: `agent "${agent.id}" workdir ${agent.workdir} (resolved ${expanded}) is not an existing directory`
+      };
+    }
+    return { spawnCwd: expanded, worktreePath: worktreeCwd, invalidReason: null };
+  }
+  return { spawnCwd: worktreeCwd, worktreePath: worktreeCwd, invalidReason: null };
+}
 function formatFallbackCwdWarning(opts) {
   const missing = [];
   if (!opts.worktreePath) missing.push("worktreePath");
@@ -7280,6 +7335,7 @@ function formatFallbackCwdWarning(opts) {
 var init_cwd = __esm({
   "src/launch/cwd.ts"() {
     "use strict";
+    init_paths();
   }
 });
 
@@ -9220,8 +9276,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile81 } = await import("fs/promises");
-  const raw2 = await readFile81(filePath, "utf-8");
+  const { readFile: readFile82 } = await import("fs/promises");
+  const raw2 = await readFile82(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -13535,6 +13591,425 @@ var init_session_id = __esm({
   }
 });
 
+// src/targets/renderers.ts
+var RENDERERS;
+var init_renderers = __esm({
+  "src/targets/renderers.ts"() {
+    "use strict";
+    init_cursor_rules();
+    init_codex_agents();
+    init_opencode_config();
+    init_hermes_soul();
+    RENDERERS = {
+      codexAgents: (ctx) => renderCodexAgents(ctx),
+      cursorProtocol: () => renderCursorProtocol(),
+      cursorAssignment: (ctx) => renderCursorAssignment(ctx),
+      openCodeConfig: (ctx) => renderOpenCodeConfig({ projectDir: ctx.projectDir }),
+      hermesSoul: (ctx) => renderHermesSoul(ctx)
+    };
+  }
+});
+
+// src/targets/user-descriptors.ts
+import { resolve as resolve29 } from "path";
+import { readFile as readFile20, readdir as readdir15 } from "fs/promises";
+function userTargetsDir() {
+  return resolve29(syntaurRoot(), "targets");
+}
+function msg(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+function expandHomeAndEnv(p) {
+  const envExpanded = p.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g,
+    (_m, braced, bare) => {
+      const name = braced ?? bare ?? "";
+      const v = process.env[name];
+      return v ?? "";
+    }
+  );
+  return resolve29(expandHome(envExpanded));
+}
+function compileDetect(spec) {
+  switch (spec.kind) {
+    case "pathExists": {
+      const p = expandHomeAndEnv(spec.path);
+      return () => fileExists(p);
+    }
+    case "anyPathExists": {
+      const ps = spec.paths.map(expandHomeAndEnv);
+      return async () => {
+        for (const p of ps) {
+          if (await fileExists(p)) return true;
+        }
+        return false;
+      };
+    }
+    case "envSet": {
+      const env = spec.env;
+      return async () => {
+        const v = process.env[env];
+        return typeof v === "string" && v.length > 0;
+      };
+    }
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateDetect(detect, errors) {
+  if (!isPlainObject(detect)) {
+    errors.push("detect must be an object");
+    return;
+  }
+  switch (detect.kind) {
+    case "pathExists":
+      if (typeof detect.path !== "string" || detect.path.length === 0)
+        errors.push('detect.path must be a non-empty string for kind "pathExists"');
+      break;
+    case "anyPathExists":
+      if (!Array.isArray(detect.paths) || detect.paths.length === 0 || !detect.paths.every((p) => typeof p === "string" && p.length > 0))
+        errors.push('detect.paths must be a non-empty string[] for kind "anyPathExists"');
+      break;
+    case "envSet":
+      if (typeof detect.env !== "string" || detect.env.length === 0)
+        errors.push('detect.env must be a non-empty string for kind "envSet"');
+      break;
+    default:
+      errors.push(
+        `detect.kind must be one of pathExists|anyPathExists|envSet (got ${JSON.stringify(detect.kind)})`
+      );
+  }
+}
+function validateInstructions(instructions, errors) {
+  if (!isPlainObject(instructions)) {
+    errors.push("instructions must be an object");
+    return;
+  }
+  if (!Array.isArray(instructions.files) || instructions.files.length === 0) {
+    errors.push("instructions.files must be a non-empty array");
+    return;
+  }
+  instructions.files.forEach((f, i) => {
+    if (!isPlainObject(f)) {
+      errors.push(`instructions.files[${i}] must be an object`);
+      return;
+    }
+    if (typeof f.path !== "string" || f.path.length === 0)
+      errors.push(`instructions.files[${i}].path must be a non-empty string`);
+    if (typeof f.renderer !== "string" || !VALID_RENDERER_KEYS.has(f.renderer))
+      errors.push(
+        `instructions.files[${i}].renderer ${JSON.stringify(f.renderer)} is not a known renderer (valid: ${[...VALID_RENDERER_KEYS].join(", ")})`
+      );
+  });
+}
+function validateUserDescriptor(data, builtinIds) {
+  const errors = [];
+  if (!isPlainObject(data)) {
+    return { ok: false, errors: ["descriptor must be a JSON object"] };
+  }
+  for (const k of Object.keys(data)) {
+    if (!ALLOWED_TOP_KEYS.has(k)) errors.push(`unknown field "${k}"`);
+  }
+  if (typeof data.id !== "string" || data.id.length === 0) {
+    errors.push("id is required and must be a non-empty string");
+  } else if (!ID_RE.test(data.id)) {
+    errors.push(`id "${data.id}" must match ${ID_RE.source}`);
+  } else if (builtinIds.has(data.id)) {
+    errors.push(
+      `id "${data.id}" collides with a built-in agent (built-ins cannot be overridden)`
+    );
+  }
+  if (typeof data.displayName !== "string" || data.displayName.trim().length === 0) {
+    errors.push("displayName is required and must be a non-empty string");
+  }
+  if (data.skillsShAgentId !== void 0 && (typeof data.skillsShAgentId !== "string" || data.skillsShAgentId.length === 0)) {
+    errors.push("skillsShAgentId must be a non-empty string when present");
+  }
+  if (data.detect === void 0) {
+    errors.push("detect is required");
+  } else {
+    validateDetect(data.detect, errors);
+  }
+  if (data.skillsDir !== void 0) {
+    if (!isPlainObject(data.skillsDir)) {
+      errors.push("skillsDir must be an object");
+    } else {
+      for (const k of Object.keys(data.skillsDir)) {
+        if (k !== "project" && k !== "global") errors.push(`skillsDir.${k} is not a valid key`);
+      }
+      if (data.skillsDir.project !== void 0 && typeof data.skillsDir.project !== "string")
+        errors.push("skillsDir.project must be a string");
+      if (data.skillsDir.global !== void 0 && typeof data.skillsDir.global !== "string")
+        errors.push("skillsDir.global must be a string");
+    }
+  }
+  if (data.instructions !== void 0) {
+    validateInstructions(data.instructions, errors);
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, value: data };
+}
+function compileDescriptor(desc) {
+  const target = {
+    id: desc.id,
+    displayName: desc.displayName,
+    detect: compileDetect(desc.detect)
+  };
+  if (desc.skillsShAgentId) target.skillsShAgentId = desc.skillsShAgentId;
+  if (desc.skillsDir) {
+    const skillsDir = {};
+    if (desc.skillsDir.global) skillsDir.global = expandHomeAndEnv(desc.skillsDir.global);
+    if (desc.skillsDir.project) skillsDir.project = desc.skillsDir.project;
+    target.skillsDir = skillsDir;
+  }
+  if (desc.instructions) target.instructions = desc.instructions;
+  return target;
+}
+async function loadUserDescriptors(opts = {}) {
+  const dir = opts.dir ?? userTargetsDir();
+  const builtinIds = opts.builtinIds ?? /* @__PURE__ */ new Set();
+  const warnings = [];
+  if (!await fileExists(dir)) return { targets: [], warnings };
+  let files;
+  try {
+    files = (await readdir15(dir)).filter((f) => f.endsWith(".json")).sort();
+  } catch (err2) {
+    return { targets: [], warnings: [`could not read ${dir}: ${msg(err2)}`] };
+  }
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const full = resolve29(dir, file);
+    let raw2;
+    try {
+      raw2 = await readFile20(full, "utf-8");
+    } catch (err2) {
+      warnings.push(`skipped ${file}: ${msg(err2)}`);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw2);
+    } catch (err2) {
+      warnings.push(`skipped ${file}: invalid JSON: ${msg(err2)}`);
+      continue;
+    }
+    const result = validateUserDescriptor(parsed, builtinIds);
+    if (!result.ok) {
+      warnings.push(`skipped ${file}: ${result.errors.join("; ")}`);
+      continue;
+    }
+    if (seen.has(result.value.id)) {
+      warnings.push(
+        `skipped ${file}: duplicate id "${result.value.id}" (already loaded from an earlier file)`
+      );
+      continue;
+    }
+    seen.add(result.value.id);
+    targets.push(compileDescriptor(result.value));
+  }
+  return { targets, warnings };
+}
+var ID_RE, VALID_RENDERER_KEYS, ALLOWED_TOP_KEYS;
+var init_user_descriptors = __esm({
+  "src/targets/user-descriptors.ts"() {
+    "use strict";
+    init_fs();
+    init_paths();
+    init_renderers();
+    ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
+    VALID_RENDERER_KEYS = new Set(Object.keys(RENDERERS));
+    ALLOWED_TOP_KEYS = /* @__PURE__ */ new Set([
+      "id",
+      "displayName",
+      "skillsShAgentId",
+      "detect",
+      "skillsDir",
+      "instructions"
+    ]);
+  }
+});
+
+// src/targets/registry.ts
+import { homedir as homedir4 } from "os";
+import { join as join5, resolve as resolve30 } from "path";
+function home(...segments) {
+  return resolve30(homedir4(), ...segments);
+}
+function hermesHome() {
+  const env = process.env.HERMES_HOME;
+  return env && env.length > 0 ? resolve30(env) : home(".hermes");
+}
+function hermesSkillsDir() {
+  return resolve30(hermesHome(), "skills");
+}
+function isHermesHomeCustom() {
+  return hermesHome() !== home(".hermes");
+}
+function codexHome() {
+  const env = process.env.CODEX_HOME;
+  return env && env.length > 0 ? resolve30(env) : home(".codex");
+}
+function toDiscovered(meta) {
+  if (!meta) return null;
+  return {
+    sessionId: meta.sessionId,
+    cwd: meta.cwd,
+    startedAt: meta.startTs,
+    endedAt: meta.endTs,
+    transcriptPath: meta.path
+  };
+}
+function getAgentTarget(id) {
+  return AGENT_TARGETS_BY_ID[id];
+}
+async function resolveAgentTargets() {
+  const { targets: user, warnings } = await loadUserDescriptors({
+    builtinIds: new Set(AGENT_TARGETS.map((t) => t.id))
+  });
+  return { targets: [...AGENT_TARGETS, ...user], warnings };
+}
+var detectDir, claudeSessions, codexSessions, piSessions, AGENT_TARGETS, AGENT_TARGETS_BY_ID;
+var init_registry = __esm({
+  "src/targets/registry.ts"() {
+    "use strict";
+    init_fs();
+    init_cwd_extractor();
+    init_user_descriptors();
+    detectDir = (dir) => () => fileExists(dir);
+    claudeSessions = {
+      globs: (root) => [join5(root ?? home(".claude", "projects"), "*", "*.jsonl")],
+      parse: async (file) => toDiscovered(await extractClaudeSessionMeta(file)),
+      walk: async function* (opts = {}) {
+        for await (const meta of walkClaudeProjects({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
+          const d = toDiscovered(meta);
+          if (d) yield d;
+        }
+      }
+    };
+    codexSessions = {
+      globs: (root) => [join5(root ?? resolveCodexSessionsRoot(), "**", "*.jsonl")],
+      parse: async (file) => toDiscovered(await extractCodexSessionMeta(file)),
+      walk: async function* (opts = {}) {
+        for await (const meta of walkCodexSessions({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
+          const d = toDiscovered(meta);
+          if (d) yield d;
+        }
+      }
+    };
+    piSessions = {
+      globs: (root) => [join5(root ?? resolvePiSessionsRoot(), "*", "*.jsonl")],
+      parse: async (file) => toDiscovered(await extractPiSessionMeta(file)),
+      walk: async function* (opts = {}) {
+        for await (const meta of walkPiSessions({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
+          const d = toDiscovered(meta);
+          if (d) yield d;
+        }
+      }
+    };
+    AGENT_TARGETS = [
+      {
+        id: "cursor",
+        displayName: "Cursor",
+        skillsShAgentId: "cursor",
+        detect: detectDir(home(".cursor")),
+        skillsDir: { global: home(".cursor", "skills") },
+        instructions: {
+          files: [
+            { path: ".cursor/rules/syntaur-protocol.mdc", renderer: "cursorProtocol" },
+            { path: ".cursor/rules/syntaur-assignment.mdc", renderer: "cursorAssignment" }
+          ]
+        }
+      },
+      {
+        // codex is BOTH an adapter (writes AGENTS.md) AND a native plugin.
+        id: "codex",
+        displayName: "Codex",
+        skillsShAgentId: "codex",
+        nativePlugin: "codex",
+        detect: detectDir(codexHome()),
+        skillsDir: { global: resolve30(codexHome(), "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        sessions: codexSessions
+      },
+      {
+        id: "opencode",
+        displayName: "OpenCode",
+        skillsShAgentId: "opencode",
+        detect: detectDir(home(".config", "opencode")),
+        skillsDir: { global: home(".config", "opencode", "skills") },
+        instructions: {
+          files: [
+            { path: "AGENTS.md", renderer: "codexAgents" },
+            { path: "opencode.json", renderer: "openCodeConfig" }
+          ]
+        }
+      },
+      {
+        // claude has NO adapter today (not in the old SUPPORTED_FRAMEWORKS) — the
+        // full plugin path owns its skills/hooks/commands. Native-plugin only.
+        id: "claude",
+        displayName: "Claude Code",
+        skillsShAgentId: "claude-code",
+        nativePlugin: "claude",
+        detect: detectDir(home(".claude")),
+        skillsDir: { global: home(".claude", "skills") },
+        sessions: claudeSessions,
+        agentsDir: home(".claude", "agents")
+      },
+      {
+        id: "pi",
+        displayName: "Pi",
+        skillsShAgentId: "pi",
+        detect: detectDir(home(".pi")),
+        skillsDir: { global: home(".pi", "agent", "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        sessions: piSessions,
+        tier3: {
+          kind: "pi-extension",
+          source: "platforms/pi/extensions/syntaur",
+          installDir: () => home(".pi", "agent", "extensions", "syntaur"),
+          entry: "index.ts"
+        }
+      },
+      {
+        id: "openclaw",
+        displayName: "OpenClaw",
+        skillsShAgentId: "openclaw",
+        detect: detectDir(home(".openclaw")),
+        skillsDir: { global: home(".openclaw", "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        // OpenClaw runs on pi-coding-agent (design memo), so it reuses the pi
+        // extension SOURCE; only the install dir differs.
+        tier3: {
+          kind: "pi-extension",
+          source: "platforms/pi/extensions/syntaur",
+          installDir: () => home(".openclaw", "extensions", "syntaur"),
+          entry: "index.ts"
+        }
+      },
+      {
+        id: "hermes",
+        displayName: "Hermes Agent",
+        skillsShAgentId: "hermes-agent",
+        detect: () => fileExists(hermesHome()),
+        skillsDir: { global: hermesSkillsDir() },
+        instructions: { files: [{ path: "SOUL.md", renderer: "hermesSoul" }] },
+        tier3: {
+          kind: "hermes-plugin",
+          source: "platforms/hermes/plugins/syntaur",
+          installDir: () => resolve30(hermesHome(), "plugins", "syntaur"),
+          entry: "plugin.yaml"
+        }
+      }
+    ];
+    AGENT_TARGETS_BY_ID = Object.fromEntries(
+      AGENT_TARGETS.map((t) => [t.id, t])
+    );
+  }
+});
+
 // src/launch/launch-prompt.ts
 function bareGrabSeed(params2) {
   if (params2.projectSlug) {
@@ -13556,8 +14031,19 @@ function resolveTemplate(template, ctx) {
   const warnings = [];
   const prompt = template.replace(TOKEN_RE, (_match, boundary, token) => {
     if (token === "assignment") {
+      if (!ctx.assignmentDir) {
+        warnings.push(`launchPrompt: "@assignment" has no assignment context here \u2014 left as literal text.`);
+        return boundary + "@assignment";
+      }
       return boundary + assignmentPointer(ctx.id, ctx.assignmentDir);
     }
+    if (token === "worktree") {
+      if (!ctx.worktreePath) {
+        warnings.push(`launchPrompt: "@worktree" has no worktree path here \u2014 left as literal text.`);
+        return boundary + "@worktree";
+      }
+      return boundary + ctx.worktreePath;
+    }
     if (!isValidSlug(token)) {
       warnings.push(`launchPrompt: "@${token}" is not a valid playbook token \u2014 left as literal text.`);
       return boundary + "@" + token;
@@ -13571,16 +14057,37 @@ function resolveTemplate(template, ctx) {
   return { prompt, warnings };
 }
 function resolveLaunchPrompt(input4) {
-  const { template, playbook, id, assignmentDir, projectSlug, assignmentSlug, knownPlaybookSlugs } = input4;
+  const {
+    template,
+    playbook,
+    id,
+    assignmentDir,
+    projectSlug,
+    assignmentSlug,
+    worktreePath,
+    spawnCwd,
+    knownPlaybookSlugs
+  } = input4;
   if (template && template.trim()) {
-    return resolveTemplate(template, { id, assignmentDir, knownPlaybookSlugs });
+    return resolveTemplate(template, { id, assignmentDir, worktreePath, knownPlaybookSlugs });
   }
   const pb = playbook?.trim();
   if (pb) {
-    const pointer = assignmentPointer(id, assignmentDir);
-    return { prompt: `${pointer} Run ${runPlaybookClause(pb)} end-to-end.`, warnings: [] };
+    const clause = runPlaybookClause(pb);
+    const prompt = assignmentDir ? `${assignmentPointer(id, assignmentDir)} Run ${clause} end-to-end.` : `Run ${clause} end-to-end.`;
+    return { prompt, warnings: [] };
   }
-  return { prompt: bareGrabSeed({ projectSlug, assignmentSlug, id }), warnings: [] };
+  if (worktreePath && spawnCwd && worktreePath !== spawnCwd) {
+    const grab = bareGrabSeed({ projectSlug, assignmentSlug: assignmentSlug ?? "", id });
+    return {
+      prompt: `The assignment's worktree is at ${worktreePath}. cd there, then grab the assignment with ${grab} and work it end-to-end.`,
+      warnings: []
+    };
+  }
+  if (!assignmentSlug && !id) {
+    return { prompt: "", warnings: [] };
+  }
+  return { prompt: bareGrabSeed({ projectSlug, assignmentSlug: assignmentSlug ?? "", id }), warnings: [] };
 }
 function effectiveLaunchTemplate(input4) {
   if (input4.launchPrompt && input4.launchPrompt.trim()) {
@@ -13590,6 +14097,14 @@ function effectiveLaunchTemplate(input4) {
   if (pb) {
     return `@assignment Run ${runPlaybookClause(pb)} end-to-end.`;
   }
+  if (input4.workdir && input4.workdir.trim()) {
+    const grab = bareGrabSeed({
+      projectSlug: input4.projectSlug,
+      assignmentSlug: input4.assignmentSlug,
+      id: input4.id
+    });
+    return `The assignment's worktree is at @worktree. cd there, then grab the assignment with ${grab} and work it end-to-end.`;
+  }
   return bareGrabSeed({
     projectSlug: input4.projectSlug,
     assignmentSlug: input4.assignmentSlug,
@@ -13616,15 +14131,17 @@ __export(launch_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve29 } from "path";
+import { isAbsolute as isAbsolute5, resolve as resolve31 } from "path";
 function shellQuote(arg) {
   if (arg === "") return "''";
   return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
 function buildAgentArgv(agent, prompt, env = process.env) {
   const position = agent.promptArgPosition ?? "first";
-  const baseArgs = applyModelFlag(agent, [...agent.args ?? []]);
-  const agentArgs = position === "first" ? [prompt, ...baseArgs] : position === "last" ? [...baseArgs, prompt] : baseArgs;
+  const prefix = agentNameArgs(agent);
+  const baseArgs = agent.agentName ? [...agent.args ?? []] : applyModelFlag(agent, [...agent.args ?? []]);
+  const positioned = position === "first" ? [prompt, ...baseArgs] : position === "last" ? [...baseArgs, prompt] : baseArgs;
+  const agentArgs = [...prefix, ...positioned];
   if (agent.resolveFromShellAliases) {
     const requested = env.SHELL;
     let shell = requested;
@@ -13652,9 +14169,9 @@ async function launchAgent(options) {
     console.error(`Assignment not found: ${projectSlug}/${assignmentSlug}`);
     process.exit(1);
   }
-  const projectDir = resolve29(projectsDir2, projectSlug);
-  const assignmentDir = resolve29(projectDir, "assignments", assignmentSlug);
-  let workspaceDir;
+  const projectDir = resolve31(projectsDir2, projectSlug);
+  const assignmentDir = resolve31(projectDir, "assignments", assignmentSlug);
+  let worktreeDir;
   if (cwdOverride) {
     if (!isExistingDir(cwdOverride)) {
       console.error(
@@ -13663,7 +14180,7 @@ async function launchAgent(options) {
       exitWith(1);
       return;
     }
-    workspaceDir = cwdOverride;
+    worktreeDir = cwdOverride;
   } else {
     const picked = resolveWorkspaceCwd({
       worktreePath: detail.workspace.worktreePath,
@@ -13676,26 +14193,34 @@ async function launchAgent(options) {
       exitWith(1);
       return;
     }
-    workspaceDir = picked.cwd;
+    worktreeDir = picked.cwd;
     const warning = picked.fallbackWarning ?? formatFallbackCwdWarning({
       assignmentSlug,
-      workspaceDir,
+      workspaceDir: worktreeDir,
       worktreePath: detail.workspace.worktreePath,
       branch: detail.workspace.branch
     });
     if (warning) console.warn(warning);
   }
-  const contextDir = resolve29(workspaceDir, ".syntaur");
+  const launchCwd = resolveLaunchCwd(agent, worktreeDir);
+  if (launchCwd.invalidReason) {
+    console.error(`syntaur: ${launchCwd.invalidReason} \u2014 refusing to launch.`);
+    exitWith(1);
+    return;
+  }
+  const spawnCwd = launchCwd.spawnCwd;
+  const worktreePath = launchCwd.worktreePath;
+  const contextDir = resolve31(worktreePath, ".syntaur");
   await mkdir2(contextDir, { recursive: true });
   const context = {
     repository: detail.workspace.repository ?? null,
     branch: detail.workspace.branch ?? null,
     worktreePath: detail.workspace.worktreePath ?? null,
-    workspaceRoot: workspaceDir,
+    workspaceRoot: worktreePath,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFile4(
-    resolve29(contextDir, "context.json"),
+    resolve31(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   const knownPlaybookSlugs = await listPlaybookSlugs(playbooksDir());
@@ -13706,6 +14231,8 @@ async function launchAgent(options) {
     assignmentDir,
     projectSlug,
     assignmentSlug,
+    worktreePath,
+    spawnCwd,
     knownPlaybookSlugs
   });
   for (const warning of warnings) console.warn(warning);
@@ -13716,7 +14243,7 @@ async function launchAgent(options) {
   const spawnImpl = options.spawnFn ?? spawn2;
   return new Promise((resolvePromise) => {
     const child = spawnImpl(argv.command, argv.args, {
-      cwd: workspaceDir,
+      cwd: spawnCwd,
       stdio: "inherit"
     });
     child.on("error", (err2) => {
@@ -13951,12 +14478,12 @@ var init_assignment_todos = __esm({
 
 // src/utils/path-canon.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve46 } from "path";
+import { resolve as resolve48 } from "path";
 function canonicalPath(p) {
   try {
-    return realpathSync2(resolve46(p));
+    return realpathSync2(resolve48(p));
   } catch {
-    return resolve46(p).replace(/\/+$/, "");
+    return resolve48(p).replace(/\/+$/, "");
   }
 }
 var init_path_canon = __esm({
@@ -13965,421 +14492,6 @@ var init_path_canon = __esm({
   }
 });
 
-// src/targets/renderers.ts
-var RENDERERS;
-var init_renderers = __esm({
-  "src/targets/renderers.ts"() {
-    "use strict";
-    init_cursor_rules();
-    init_codex_agents();
-    init_opencode_config();
-    init_hermes_soul();
-    RENDERERS = {
-      codexAgents: (ctx) => renderCodexAgents(ctx),
-      cursorProtocol: () => renderCursorProtocol(),
-      cursorAssignment: (ctx) => renderCursorAssignment(ctx),
-      openCodeConfig: (ctx) => renderOpenCodeConfig({ projectDir: ctx.projectDir }),
-      hermesSoul: (ctx) => renderHermesSoul(ctx)
-    };
-  }
-});
-
-// src/targets/user-descriptors.ts
-import { resolve as resolve47 } from "path";
-import { readFile as readFile31, readdir as readdir19 } from "fs/promises";
-function userTargetsDir() {
-  return resolve47(syntaurRoot(), "targets");
-}
-function msg(err2) {
-  return err2 instanceof Error ? err2.message : String(err2);
-}
-function expandHomeAndEnv(p) {
-  const envExpanded = p.replace(
-    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g,
-    (_m, braced, bare) => {
-      const name = braced ?? bare ?? "";
-      const v = process.env[name];
-      return v ?? "";
-    }
-  );
-  return resolve47(expandHome(envExpanded));
-}
-function compileDetect(spec) {
-  switch (spec.kind) {
-    case "pathExists": {
-      const p = expandHomeAndEnv(spec.path);
-      return () => fileExists(p);
-    }
-    case "anyPathExists": {
-      const ps = spec.paths.map(expandHomeAndEnv);
-      return async () => {
-        for (const p of ps) {
-          if (await fileExists(p)) return true;
-        }
-        return false;
-      };
-    }
-    case "envSet": {
-      const env = spec.env;
-      return async () => {
-        const v = process.env[env];
-        return typeof v === "string" && v.length > 0;
-      };
-    }
-  }
-}
-function isPlainObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function validateDetect(detect, errors) {
-  if (!isPlainObject(detect)) {
-    errors.push("detect must be an object");
-    return;
-  }
-  switch (detect.kind) {
-    case "pathExists":
-      if (typeof detect.path !== "string" || detect.path.length === 0)
-        errors.push('detect.path must be a non-empty string for kind "pathExists"');
-      break;
-    case "anyPathExists":
-      if (!Array.isArray(detect.paths) || detect.paths.length === 0 || !detect.paths.every((p) => typeof p === "string" && p.length > 0))
-        errors.push('detect.paths must be a non-empty string[] for kind "anyPathExists"');
-      break;
-    case "envSet":
-      if (typeof detect.env !== "string" || detect.env.length === 0)
-        errors.push('detect.env must be a non-empty string for kind "envSet"');
-      break;
-    default:
-      errors.push(
-        `detect.kind must be one of pathExists|anyPathExists|envSet (got ${JSON.stringify(detect.kind)})`
-      );
-  }
-}
-function validateInstructions(instructions, errors) {
-  if (!isPlainObject(instructions)) {
-    errors.push("instructions must be an object");
-    return;
-  }
-  if (!Array.isArray(instructions.files) || instructions.files.length === 0) {
-    errors.push("instructions.files must be a non-empty array");
-    return;
-  }
-  instructions.files.forEach((f, i) => {
-    if (!isPlainObject(f)) {
-      errors.push(`instructions.files[${i}] must be an object`);
-      return;
-    }
-    if (typeof f.path !== "string" || f.path.length === 0)
-      errors.push(`instructions.files[${i}].path must be a non-empty string`);
-    if (typeof f.renderer !== "string" || !VALID_RENDERER_KEYS.has(f.renderer))
-      errors.push(
-        `instructions.files[${i}].renderer ${JSON.stringify(f.renderer)} is not a known renderer (valid: ${[...VALID_RENDERER_KEYS].join(", ")})`
-      );
-  });
-}
-function validateUserDescriptor(data, builtinIds) {
-  const errors = [];
-  if (!isPlainObject(data)) {
-    return { ok: false, errors: ["descriptor must be a JSON object"] };
-  }
-  for (const k of Object.keys(data)) {
-    if (!ALLOWED_TOP_KEYS.has(k)) errors.push(`unknown field "${k}"`);
-  }
-  if (typeof data.id !== "string" || data.id.length === 0) {
-    errors.push("id is required and must be a non-empty string");
-  } else if (!ID_RE.test(data.id)) {
-    errors.push(`id "${data.id}" must match ${ID_RE.source}`);
-  } else if (builtinIds.has(data.id)) {
-    errors.push(
-      `id "${data.id}" collides with a built-in agent (built-ins cannot be overridden)`
-    );
-  }
-  if (typeof data.displayName !== "string" || data.displayName.trim().length === 0) {
-    errors.push("displayName is required and must be a non-empty string");
-  }
-  if (data.skillsShAgentId !== void 0 && (typeof data.skillsShAgentId !== "string" || data.skillsShAgentId.length === 0)) {
-    errors.push("skillsShAgentId must be a non-empty string when present");
-  }
-  if (data.detect === void 0) {
-    errors.push("detect is required");
-  } else {
-    validateDetect(data.detect, errors);
-  }
-  if (data.skillsDir !== void 0) {
-    if (!isPlainObject(data.skillsDir)) {
-      errors.push("skillsDir must be an object");
-    } else {
-      for (const k of Object.keys(data.skillsDir)) {
-        if (k !== "project" && k !== "global") errors.push(`skillsDir.${k} is not a valid key`);
-      }
-      if (data.skillsDir.project !== void 0 && typeof data.skillsDir.project !== "string")
-        errors.push("skillsDir.project must be a string");
-      if (data.skillsDir.global !== void 0 && typeof data.skillsDir.global !== "string")
-        errors.push("skillsDir.global must be a string");
-    }
-  }
-  if (data.instructions !== void 0) {
-    validateInstructions(data.instructions, errors);
-  }
-  if (errors.length > 0) return { ok: false, errors };
-  return { ok: true, value: data };
-}
-function compileDescriptor(desc) {
-  const target = {
-    id: desc.id,
-    displayName: desc.displayName,
-    detect: compileDetect(desc.detect)
-  };
-  if (desc.skillsShAgentId) target.skillsShAgentId = desc.skillsShAgentId;
-  if (desc.skillsDir) {
-    const skillsDir = {};
-    if (desc.skillsDir.global) skillsDir.global = expandHomeAndEnv(desc.skillsDir.global);
-    if (desc.skillsDir.project) skillsDir.project = desc.skillsDir.project;
-    target.skillsDir = skillsDir;
-  }
-  if (desc.instructions) target.instructions = desc.instructions;
-  return target;
-}
-async function loadUserDescriptors(opts = {}) {
-  const dir = opts.dir ?? userTargetsDir();
-  const builtinIds = opts.builtinIds ?? /* @__PURE__ */ new Set();
-  const warnings = [];
-  if (!await fileExists(dir)) return { targets: [], warnings };
-  let files;
-  try {
-    files = (await readdir19(dir)).filter((f) => f.endsWith(".json")).sort();
-  } catch (err2) {
-    return { targets: [], warnings: [`could not read ${dir}: ${msg(err2)}`] };
-  }
-  const targets = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const full = resolve47(dir, file);
-    let raw2;
-    try {
-      raw2 = await readFile31(full, "utf-8");
-    } catch (err2) {
-      warnings.push(`skipped ${file}: ${msg(err2)}`);
-      continue;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(raw2);
-    } catch (err2) {
-      warnings.push(`skipped ${file}: invalid JSON: ${msg(err2)}`);
-      continue;
-    }
-    const result = validateUserDescriptor(parsed, builtinIds);
-    if (!result.ok) {
-      warnings.push(`skipped ${file}: ${result.errors.join("; ")}`);
-      continue;
-    }
-    if (seen.has(result.value.id)) {
-      warnings.push(
-        `skipped ${file}: duplicate id "${result.value.id}" (already loaded from an earlier file)`
-      );
-      continue;
-    }
-    seen.add(result.value.id);
-    targets.push(compileDescriptor(result.value));
-  }
-  return { targets, warnings };
-}
-var ID_RE, VALID_RENDERER_KEYS, ALLOWED_TOP_KEYS;
-var init_user_descriptors = __esm({
-  "src/targets/user-descriptors.ts"() {
-    "use strict";
-    init_fs();
-    init_paths();
-    init_renderers();
-    ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
-    VALID_RENDERER_KEYS = new Set(Object.keys(RENDERERS));
-    ALLOWED_TOP_KEYS = /* @__PURE__ */ new Set([
-      "id",
-      "displayName",
-      "skillsShAgentId",
-      "detect",
-      "skillsDir",
-      "instructions"
-    ]);
-  }
-});
-
-// src/targets/registry.ts
-import { homedir as homedir7 } from "os";
-import { join as join10, resolve as resolve48 } from "path";
-function home(...segments) {
-  return resolve48(homedir7(), ...segments);
-}
-function hermesHome() {
-  const env = process.env.HERMES_HOME;
-  return env && env.length > 0 ? resolve48(env) : home(".hermes");
-}
-function hermesSkillsDir() {
-  return resolve48(hermesHome(), "skills");
-}
-function isHermesHomeCustom() {
-  return hermesHome() !== home(".hermes");
-}
-function codexHome() {
-  const env = process.env.CODEX_HOME;
-  return env && env.length > 0 ? resolve48(env) : home(".codex");
-}
-function toDiscovered(meta) {
-  if (!meta) return null;
-  return {
-    sessionId: meta.sessionId,
-    cwd: meta.cwd,
-    startedAt: meta.startTs,
-    endedAt: meta.endTs,
-    transcriptPath: meta.path
-  };
-}
-async function resolveAgentTargets() {
-  const { targets: user, warnings } = await loadUserDescriptors({
-    builtinIds: new Set(AGENT_TARGETS.map((t) => t.id))
-  });
-  return { targets: [...AGENT_TARGETS, ...user], warnings };
-}
-var detectDir, claudeSessions, codexSessions, piSessions, AGENT_TARGETS, AGENT_TARGETS_BY_ID;
-var init_registry = __esm({
-  "src/targets/registry.ts"() {
-    "use strict";
-    init_fs();
-    init_cwd_extractor();
-    init_user_descriptors();
-    detectDir = (dir) => () => fileExists(dir);
-    claudeSessions = {
-      globs: (root) => [join10(root ?? home(".claude", "projects"), "*", "*.jsonl")],
-      parse: async (file) => toDiscovered(await extractClaudeSessionMeta(file)),
-      walk: async function* (opts = {}) {
-        for await (const meta of walkClaudeProjects({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
-          const d = toDiscovered(meta);
-          if (d) yield d;
-        }
-      }
-    };
-    codexSessions = {
-      globs: (root) => [join10(root ?? resolveCodexSessionsRoot(), "**", "*.jsonl")],
-      parse: async (file) => toDiscovered(await extractCodexSessionMeta(file)),
-      walk: async function* (opts = {}) {
-        for await (const meta of walkCodexSessions({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
-          const d = toDiscovered(meta);
-          if (d) yield d;
-        }
-      }
-    };
-    piSessions = {
-      globs: (root) => [join10(root ?? resolvePiSessionsRoot(), "*", "*.jsonl")],
-      parse: async (file) => toDiscovered(await extractPiSessionMeta(file)),
-      walk: async function* (opts = {}) {
-        for await (const meta of walkPiSessions({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
-          const d = toDiscovered(meta);
-          if (d) yield d;
-        }
-      }
-    };
-    AGENT_TARGETS = [
-      {
-        id: "cursor",
-        displayName: "Cursor",
-        skillsShAgentId: "cursor",
-        detect: detectDir(home(".cursor")),
-        skillsDir: { global: home(".cursor", "skills") },
-        instructions: {
-          files: [
-            { path: ".cursor/rules/syntaur-protocol.mdc", renderer: "cursorProtocol" },
-            { path: ".cursor/rules/syntaur-assignment.mdc", renderer: "cursorAssignment" }
-          ]
-        }
-      },
-      {
-        // codex is BOTH an adapter (writes AGENTS.md) AND a native plugin.
-        id: "codex",
-        displayName: "Codex",
-        skillsShAgentId: "codex",
-        nativePlugin: "codex",
-        detect: detectDir(codexHome()),
-        skillsDir: { global: resolve48(codexHome(), "skills") },
-        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
-        sessions: codexSessions
-      },
-      {
-        id: "opencode",
-        displayName: "OpenCode",
-        skillsShAgentId: "opencode",
-        detect: detectDir(home(".config", "opencode")),
-        skillsDir: { global: home(".config", "opencode", "skills") },
-        instructions: {
-          files: [
-            { path: "AGENTS.md", renderer: "codexAgents" },
-            { path: "opencode.json", renderer: "openCodeConfig" }
-          ]
-        }
-      },
-      {
-        // claude has NO adapter today (not in the old SUPPORTED_FRAMEWORKS) — the
-        // full plugin path owns its skills/hooks/commands. Native-plugin only.
-        id: "claude",
-        displayName: "Claude Code",
-        skillsShAgentId: "claude-code",
-        nativePlugin: "claude",
-        detect: detectDir(home(".claude")),
-        skillsDir: { global: home(".claude", "skills") },
-        sessions: claudeSessions
-      },
-      {
-        id: "pi",
-        displayName: "Pi",
-        skillsShAgentId: "pi",
-        detect: detectDir(home(".pi")),
-        skillsDir: { global: home(".pi", "agent", "skills") },
-        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
-        sessions: piSessions,
-        tier3: {
-          kind: "pi-extension",
-          source: "platforms/pi/extensions/syntaur",
-          installDir: () => home(".pi", "agent", "extensions", "syntaur"),
-          entry: "index.ts"
-        }
-      },
-      {
-        id: "openclaw",
-        displayName: "OpenClaw",
-        skillsShAgentId: "openclaw",
-        detect: detectDir(home(".openclaw")),
-        skillsDir: { global: home(".openclaw", "skills") },
-        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
-        // OpenClaw runs on pi-coding-agent (design memo), so it reuses the pi
-        // extension SOURCE; only the install dir differs.
-        tier3: {
-          kind: "pi-extension",
-          source: "platforms/pi/extensions/syntaur",
-          installDir: () => home(".openclaw", "extensions", "syntaur"),
-          entry: "index.ts"
-        }
-      },
-      {
-        id: "hermes",
-        displayName: "Hermes Agent",
-        skillsShAgentId: "hermes-agent",
-        detect: () => fileExists(hermesHome()),
-        skillsDir: { global: hermesSkillsDir() },
-        instructions: { files: [{ path: "SOUL.md", renderer: "hermesSoul" }] },
-        tier3: {
-          kind: "hermes-plugin",
-          source: "platforms/hermes/plugins/syntaur",
-          installDir: () => resolve48(hermesHome(), "plugins", "syntaur"),
-          entry: "plugin.yaml"
-        }
-      }
-    ];
-    AGENT_TARGETS_BY_ID = Object.fromEntries(
-      AGENT_TARGETS.map((t) => [t.id, t])
-    );
-  }
-});
-
 // src/sessions/agent-view.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -14740,7 +14852,7 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath9, pathToFileURL } from "url";
-import { dirname as dirname21, resolve as resolve74, join as join16 } from "path";
+import { dirname as dirname21, resolve as resolve74, join as join17 } from "path";
 import { homedir as homedir13, tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
 function syntaurRootMjs() {
@@ -14748,7 +14860,7 @@ function syntaurRootMjs() {
   if (override3 && override3.length > 0) {
     return override3;
   }
-  return join16(homedir13(), ".syntaur");
+  return join17(homedir13(), ".syntaur");
 }
 async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   const { throwOnFailure } = options;
@@ -14781,19 +14893,19 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
     const pkgRoot = resolve74(dirname21(fileURLToPath9(import.meta.url)), "..");
     const cliBin = realpathSync4(resolve74(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
-    const bundleParent = join16(
+    const bundleParent = join17(
       homedir13(),
       "Library",
       "Application Support",
       "Syntaur"
     );
-    const bundlePath = join16(bundleParent, "syntaur-url.app");
+    const bundlePath = join17(bundleParent, "syntaur-url.app");
     mkdirSync3(bundleParent, { recursive: true });
     if (existsSync6(bundlePath)) {
       rmSync(bundlePath, { recursive: true, force: true });
     }
     const installedTerminals = detectInstalledTerminals();
-    const scriptPath = join16(
+    const scriptPath = join17(
       tmpdir2(),
       `syntaur-url-handler-${process.pid}.applescript`
     );
@@ -14812,7 +14924,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
         `osacompile exited with code ${compile.status}: ${compile.stderr || compile.stdout}`
       );
     }
-    const infoPlistPath = join16(bundlePath, "Contents", "Info.plist");
+    const infoPlistPath = join17(bundlePath, "Contents", "Info.plist");
     if (!existsSync6(infoPlistPath)) {
       throw new Error(`osacompile did not produce ${infoPlistPath}`);
     }
@@ -14907,7 +15019,7 @@ function detectInstalledTerminals() {
     ghostty: "Ghostty.app",
     warp: "Warp.app"
   };
-  const appDirs = ["/Applications", join16(homedir13(), "Applications")];
+  const appDirs = ["/Applications", join17(homedir13(), "Applications")];
   for (const [id, bundleId] of Object.entries(bundleIds)) {
     const r = spawnSync7(
       "mdfind",
@@ -14919,7 +15031,7 @@ function detectInstalledTerminals() {
       continue;
     }
     const name = bundleNames[id];
-    if (name && appDirs.some((dir) => existsSync6(join16(dir, name)))) {
+    if (name && appDirs.some((dir) => existsSync6(join17(dir, name)))) {
       installed.add(id);
     }
   }
@@ -15643,7 +15755,7 @@ __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 join26, resolve as resolve99 } from "path";
+import { dirname as dirname28, join as join27, 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");
@@ -15675,7 +15787,7 @@ function escapeXml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function defaultAcquireInstallLock(home2) {
-  const lockPath = join26(home2, ".syntaur", "install-launch-agent.lock");
+  const lockPath = join27(home2, ".syntaur", "install-launch-agent.lock");
   mkdirSync4(dirname28(lockPath), { recursive: true });
   const fd = openSync2(lockPath, "wx");
   return () => {
@@ -15711,10 +15823,10 @@ function resolveSpec(config, deps) {
     nodePath: deps.nodePath ?? process.execPath,
     syntaurBin: absolutize(deps.syntaurBin ?? process.argv[1] ?? "syntaur"),
     intervalSeconds: deps.intervalSeconds ?? config.defaultIntervalSeconds,
-    outLog: join26(home2, ".syntaur", "logs", config.outLogName),
-    errLog: join26(home2, ".syntaur", "logs", config.errLogName)
+    outLog: join27(home2, ".syntaur", "logs", config.outLogName),
+    errLog: join27(home2, ".syntaur", "logs", config.errLogName)
   };
-  const plistPath = join26(home2, "Library", "LaunchAgents", `${spec.label}.plist`);
+  const plistPath = join27(home2, "Library", "LaunchAgents", `${spec.label}.plist`);
   return { spec, plistPath, home: home2, uid };
 }
 function installAgent(config, deps) {
@@ -15724,8 +15836,8 @@ function installAgent(config, deps) {
   const run3 = deps.run ?? defaultRun;
   const releaseLock2 = (deps.acquireInstallLock ?? (() => defaultAcquireInstallLock(home2)))();
   try {
-    mkdirp(join26(home2, ".syntaur", "logs"));
-    mkdirp(join26(home2, "Library", "LaunchAgents"));
+    mkdirp(join27(home2, ".syntaur", "logs"));
+    mkdirp(join27(home2, "Library", "LaunchAgents"));
     writeFile17(plistPath, buildPlist(spec));
     const domain = `gui/${uid}`;
     run3("launchctl", ["bootout", `${domain}/${spec.label}`]);
@@ -20602,6 +20714,55 @@ function createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2) {
 init_config2();
 init_agents_schema();
 import { Router as Router5 } from "express";
+
+// src/targets/agent-definitions.ts
+init_parser();
+init_registry();
+import { readdir as readdir16, readFile as readFile21 } from "fs/promises";
+import { join as join6 } from "path";
+async function collectMarkdown(dir, out) {
+  let entries;
+  try {
+    entries = await readdir16(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectMarkdown(full, out);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+}
+async function discoverClaudeAgents(root) {
+  const dir = root ?? getAgentTarget("claude")?.agentsDir;
+  if (!dir) return [];
+  const files = [];
+  await collectMarkdown(dir, files);
+  files.sort();
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile21(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const [frontmatter] = extractFrontmatter(content);
+    if (!frontmatter) continue;
+    const name = getField(frontmatter, "name")?.trim();
+    if (!name) continue;
+    if (byName.has(name)) continue;
+    const description = getField(frontmatter, "description")?.trim() || void 0;
+    const model = getField(frontmatter, "model")?.trim() || void 0;
+    byName.set(name, { name, description, model, path: file });
+  }
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/dashboard/api-agents.ts
 function mapAgentErrorToFieldErrors(err2) {
   const message = err2.message;
   let match = message.match(/^agent id "([^"]*)" is invalid/);
@@ -20689,6 +20850,38 @@ function mapAgentErrorToFieldErrors(err2) {
       ]
     };
   }
+  match = message.match(/^agent "([^"]+)" has invalid agentName/);
+  if (match) {
+    return {
+      error: message,
+      fieldErrors: [{ id: match[1], field: "agentName", message: "must be a single line" }]
+    };
+  }
+  match = message.match(/^agent "([^"]+)" has invalid workdir/);
+  if (match) {
+    return {
+      error: message,
+      fieldErrors: [{ id: match[1], field: "workdir", message: "must be a single line" }]
+    };
+  }
+  match = message.match(/^agent "([^"]+)" sets both agentName and workdir/);
+  if (match) {
+    return {
+      error: message,
+      fieldErrors: [
+        { id: match[1], field: "workdir", message: "agentName and workdir are mutually exclusive" }
+      ]
+    };
+  }
+  match = message.match(/^agent "([^"]+)" sets both agentName and model/);
+  if (match) {
+    return {
+      error: message,
+      fieldErrors: [
+        { id: match[1], field: "model", message: "remove the profile model; the agent defines its own" }
+      ]
+    };
+  }
   return { error: message };
 }
 function coerceAgentRow(raw2, index) {
@@ -20836,10 +21029,47 @@ function coerceAgentRow(raw2, index) {
     }
     if (entry.launchPrompt.trim()) cleaned.launchPrompt = entry.launchPrompt;
   }
+  if (entry.agentName !== void 0) {
+    if (typeof entry.agentName !== "string") {
+      return {
+        ok: false,
+        status: 400,
+        body: {
+          error: `agents[${index}].agentName must be a string`,
+          fieldErrors: [{ id, field: "agentName", message: "agentName must be a string" }]
+        }
+      };
+    }
+    const agentName = entry.agentName.trim();
+    if (agentName) cleaned.agentName = agentName;
+  }
+  if (entry.workdir !== void 0) {
+    if (typeof entry.workdir !== "string") {
+      return {
+        ok: false,
+        status: 400,
+        body: {
+          error: `agents[${index}].workdir must be a string`,
+          fieldErrors: [{ id, field: "workdir", message: "workdir must be a string" }]
+        }
+      };
+    }
+    const workdir = entry.workdir.trim();
+    if (workdir) cleaned.workdir = workdir;
+  }
   return { ok: true, value: cleaned };
 }
 function createAgentsRouter() {
   const router = Router5();
+  router.get("/claude-discovered", async (_req, res) => {
+    try {
+      const agents = await discoverClaudeAgents();
+      res.json({ agents });
+    } catch (err2) {
+      console.error("Error discovering Claude agents:", err2);
+      res.status(500).json({ error: "Failed to discover Claude agents" });
+    }
+  });
   router.get("/", async (_req, res) => {
     try {
       const config = await readConfig();
@@ -20902,8 +21132,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 homedir4 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
 var APP_BUNDLE_IDS = {
   "terminal-app": "com.apple.Terminal",
   iterm: "com.googlecode.iterm2",
@@ -20920,7 +21150,7 @@ var APP_FIXED_PATHS = {
   "terminal-app": "/System/Applications/Utilities/Terminal.app"
 };
 function defaultApplicationsDirs() {
-  return ["/Applications", join5(homedir4(), "Applications")];
+  return ["/Applications", join7(homedir5(), "Applications")];
 }
 function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const fixed = APP_FIXED_PATHS[terminal];
@@ -20928,7 +21158,7 @@ function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const bundleName = APP_BUNDLE_NAMES[terminal];
   if (bundleName) {
     for (const dir of dirs) {
-      const candidate = join5(dir, bundleName);
+      const candidate = join7(dir, bundleName);
       if (existsSync2(candidate)) return candidate;
     }
   }
@@ -20958,11 +21188,11 @@ var defaultCmuxLsappinfoRunner = () => {
 function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunnerOverride) {
   const bundle = findAppBundle("cmux", applicationsDirsOverride);
   if (bundle) {
-    const cli = join5(bundle, "Contents/Resources/bin/cmux");
+    const cli = join7(bundle, "Contents/Resources/bin/cmux");
     if (existsSync2(cli)) return cli;
   }
   for (const dir of cliDirsOverride ?? CMUX_CLI_DIRS) {
-    const cli = join5(dir, "cmux");
+    const cli = join7(dir, "cmux");
     if (existsSync2(cli)) return cli;
   }
   if (process.platform === "darwin") {
@@ -20971,7 +21201,7 @@ function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunn
     if (stdout) {
       const match = stdout.match(/"LSBundlePath"="([^"]+)"/);
       if (match) {
-        const cli = join5(match[1], "Contents/Resources/bin/cmux");
+        const cli = join7(match[1], "Contents/Resources/bin/cmux");
         if (existsSync2(cli)) return cli;
       }
     }
@@ -21058,6 +21288,7 @@ function parseOpenUrl(input4) {
   }
   const assignmentVals = url.searchParams.getAll("assignment");
   const sessionVals = url.searchParams.getAll("session");
+  const standaloneVals = url.searchParams.getAll("standalone");
   if (assignmentVals.length > 1) {
     throw new OpenUrlError(
       "duplicate-param",
@@ -21070,10 +21301,17 @@ function parseOpenUrl(input4) {
       "URL has more than one `session` query param"
     );
   }
-  if (assignmentVals.length === 1 && sessionVals.length === 1) {
+  if (standaloneVals.length > 1) {
+    throw new OpenUrlError(
+      "duplicate-param",
+      "URL has more than one `standalone` query param"
+    );
+  }
+  const kindsPresent = assignmentVals.length + sessionVals.length + standaloneVals.length;
+  if (kindsPresent > 1) {
     throw new OpenUrlError(
       "both-ids",
-      "URL has both `assignment` and `session` query params \u2014 only one is allowed"
+      "URL has more than one of `assignment`, `session`, `standalone` \u2014 only one is allowed"
     );
   }
   const terminalVals = url.searchParams.getAll("terminal");
@@ -21123,6 +21361,37 @@ function parseOpenUrl(input4) {
     }
     prompt = value;
   }
+  const agentNameVals = url.searchParams.getAll("agentName");
+  if (agentNameVals.length > 1) {
+    throw new OpenUrlError(
+      "duplicate-param",
+      "URL has more than one `agentName` query param"
+    );
+  }
+  let agentName;
+  if (agentNameVals.length === 1 && agentNameVals[0].trim() !== "") {
+    const value = agentNameVals[0];
+    if (value.length > MAX_OPEN_PROMPT_LENGTH) {
+      throw new OpenUrlError(
+        "invalid-prompt",
+        `\`agentName\` query param exceeds ${MAX_OPEN_PROMPT_LENGTH} characters`
+      );
+    }
+    agentName = value;
+  }
+  if (standaloneVals.length === 1) {
+    const id = standaloneVals[0];
+    if (id.trim() === "") {
+      throw new OpenUrlError("missing-id", "`standalone` query param is empty");
+    }
+    return {
+      kind: "standalone",
+      id,
+      ...terminal ? { terminal } : {},
+      // standalone identifies the agent by `id`; keep an optional prompt override.
+      ...prompt !== void 0 ? { prompt } : {}
+    };
+  }
   if (assignmentVals.length === 1) {
     const id = assignmentVals[0];
     if (id.trim() === "") {
@@ -21137,7 +21406,8 @@ function parseOpenUrl(input4) {
       ...terminal ? { terminal } : {},
       ...agent ? { agent } : {},
       // assignment-only; keep '' (presence-significant) — hence !== undefined.
-      ...prompt !== void 0 ? { prompt } : {}
+      ...prompt !== void 0 ? { prompt } : {},
+      ...agentName ? { agentName } : {}
     };
   }
   if (sessionVals.length === 1) {
@@ -21173,7 +21443,7 @@ function parseOpenUrl(input4) {
   }
   throw new OpenUrlError(
     "missing-id",
-    "URL must include either `assignment=<id>` or `session=<id>`"
+    "URL must include one of `assignment=<id>`, `session=<id>`, or `standalone=<agentId>`"
   );
 }
 
@@ -21249,8 +21519,60 @@ async function resolveLaunchPlan(input4) {
   if (input4.kind === "assignment") {
     return resolveAssignmentPlan(input4, terminal);
   }
+  if (input4.kind === "standalone") {
+    return resolveStandalonePlan(input4, terminal);
+  }
   return resolveSessionPlan(input4, terminal);
 }
+async function resolveStandalonePlan(input4, terminal) {
+  const agentId = input4.agentId ?? input4.id;
+  if (!agentId) {
+    throw new LaunchError(
+      "agent-not-configured",
+      "A standalone launch requires an agent id."
+    );
+  }
+  const agent = getAgents(input4.config).find((a) => a.id === agentId);
+  if (!agent) {
+    throw new LaunchError(
+      "agent-not-configured",
+      `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)) {
+    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.`
+    );
+  }
+  const knownPlaybookSlugs = await listPlaybookSlugs(playbooksDir());
+  const template = input4.promptOverride !== void 0 ? input4.promptOverride : agent.launchPrompt;
+  const { prompt, warnings: promptWarnings } = resolveLaunchPrompt({
+    template,
+    playbook: agent.playbook,
+    projectSlug: null,
+    knownPlaybookSlugs
+  });
+  const { argv, shellFallbackWarning } = buildFreshArgv(agent, prompt);
+  return {
+    terminal,
+    cwd: expanded,
+    argv,
+    env: process.env,
+    agentId: agent.id,
+    fallbackWarning: null,
+    shellFallbackWarning,
+    promptWarnings
+  };
+}
 async function resolveAssignmentPlan(input4, terminal) {
   const resolved = await resolveAssignmentById(
     input4.projectsDir,
@@ -21274,17 +21596,6 @@ async function resolveAssignmentPlan(input4, terminal) {
       `Assignment ${input4.id} resolver returned a directory but detail could not be loaded`
     );
   }
-  const picked = resolveWorkspaceCwd({
-    worktreePath: detail.workspace.worktreePath,
-    repository: detail.workspace.repository,
-    branch: detail.workspace.branch,
-    assignmentSlug: resolved.assignmentSlug
-  });
-  if (picked.cwd === null) {
-    throw new LaunchError("workspace-path-invalid", picked.invalidReason);
-  }
-  const cwd = picked.cwd;
-  const fallbackWarning = picked.fallbackWarning;
   let agent;
   if (input4.agentId) {
     const found = getAgents(input4.config).find((a) => a.id === input4.agentId);
@@ -21298,6 +21609,30 @@ async function resolveAssignmentPlan(input4, terminal) {
   } else {
     agent = pickAgent(input4.config);
   }
+  if (input4.agentName !== void 0) {
+    agent = { ...agent, agentName: input4.agentName };
+  }
+  const picked = resolveWorkspaceCwd({
+    worktreePath: detail.workspace.worktreePath,
+    repository: detail.workspace.repository,
+    branch: detail.workspace.branch,
+    assignmentSlug: resolved.assignmentSlug
+  });
+  if (picked.cwd === null) {
+    throw new LaunchError("workspace-path-invalid", picked.invalidReason);
+  }
+  const launchCwd = resolveLaunchCwd(agent, picked.cwd);
+  if (launchCwd.invalidReason) {
+    throw new LaunchError("workspace-path-invalid", launchCwd.invalidReason);
+  }
+  const cwd = launchCwd.spawnCwd;
+  const fallbackWarning = picked.fallbackWarning;
+  const promptWarningsExtra = [];
+  if (input4.agentName !== void 0 && input4.agentName.trim() && agent.model?.trim()) {
+    promptWarningsExtra.push(
+      `profile model "${agent.model.trim()}" suppressed: agent "${input4.agentName.trim()}" defines its own model`
+    );
+  }
   const knownPlaybookSlugs = await listPlaybookSlugs(playbooksDir());
   const template = input4.promptOverride !== void 0 ? input4.promptOverride : agent.launchPrompt;
   const { prompt, warnings: promptWarnings } = resolveLaunchPrompt({
@@ -21307,6 +21642,8 @@ async function resolveAssignmentPlan(input4, terminal) {
     assignmentDir: resolved.assignmentDir,
     projectSlug: resolved.projectSlug,
     assignmentSlug: resolved.assignmentSlug,
+    worktreePath: launchCwd.worktreePath,
+    spawnCwd: launchCwd.spawnCwd,
     knownPlaybookSlugs
   });
   const { argv, shellFallbackWarning } = buildFreshArgv(agent, prompt);
@@ -21318,7 +21655,7 @@ async function resolveAssignmentPlan(input4, terminal) {
     agentId: agent.id,
     fallbackWarning,
     shellFallbackWarning,
-    promptWarnings
+    promptWarnings: [...promptWarningsExtra, ...promptWarnings]
   };
 }
 async function resolveSessionPlan(input4, terminal) {
@@ -21395,8 +21732,8 @@ async function resolveSessionPlan(input4, terminal) {
 // src/launch/execute.ts
 init_launch();
 import { spawn as spawn3 } from "child_process";
-import { homedir as homedir5 } from "os";
-import { basename as basename5, join as join6, resolve as resolve30 } from "path";
+import { homedir as homedir6 } from "os";
+import { basename as basename5, join as join8, resolve as resolve32 } from "path";
 init_fs();
 init_config2();
 init_session_id();
@@ -21502,7 +21839,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 : join6(homedir5(), ".syntaur", "runtime", "sessions");
+    const markerDir = envDir && envDir.length > 0 ? envDir : join8(homedir6(), ".syntaur", "runtime", "sessions");
     writeRuntimeMarker(
       pid,
       {
@@ -21515,7 +21852,7 @@ async function registerLaunchAtBirth(plan, child) {
       markerDir
     );
     if (!sessionId) return;
-    if (autoTrack === "workspaces-only" && !await fileExists(resolve30(plan.cwd, ".syntaur", "context.json"))) {
+    if (autoTrack === "workspaces-only" && !await fileExists(resolve32(plan.cwd, ".syntaur", "context.json"))) {
       return;
     }
     const { initSessionDb: initSessionDb2 } = await Promise.resolve().then(() => (init_session_db(), session_db_exports));
@@ -21694,7 +22031,7 @@ init_launch_prompt();
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, resolve as resolve31, join as join7 } from "path";
+import { dirname as dirname7, resolve as resolve33, join as join9 } from "path";
 import { realpathSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -21720,7 +22057,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile81 = opts.readFile ?? ((p) => readFileSync3(p, "utf-8"));
+  const readFile82 = 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) {
@@ -21738,10 +22075,10 @@ function detectInstallKind(scriptUrl, opts = {}) {
   }
   let dir = dirname7(resolved);
   for (let depth = 0; depth < 8; depth++) {
-    const pkgJsonPath = join7(dir, "package.json");
+    const pkgJsonPath = join9(dir, "package.json");
     let raw2;
     try {
-      raw2 = readFile81(pkgJsonPath);
+      raw2 = readFile82(pkgJsonPath);
     } catch {
       const parent2 = dirname7(dir);
       if (parent2 === dir) break;
@@ -21773,13 +22110,13 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve31(syntaurRoot(), "npx-handler-nudge");
+  return resolve33(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
 }
 function nudgeStampPath(hash) {
-  return join7(nudgeStampDir(), sanitizeHash(hash));
+  return join9(nudgeStampDir(), sanitizeHash(hash));
 }
 async function hasNudgedHash(hash) {
   return fileExists(nudgeStampPath(hash));
@@ -21980,7 +22317,8 @@ function createLaunchPreflightRouter(projectsDir2, assignmentsDir2) {
         playbook: agent.playbook,
         projectSlug: resolved.projectSlug,
         assignmentSlug: resolved.assignmentSlug,
-        id: resolved.id
+        id: resolved.id,
+        workdir: agent.workdir
       });
       res.json({ template, knownPlaybookSlugs });
     } catch (error) {
@@ -22224,7 +22562,7 @@ init_frontmatter();
 init_event_emit();
 init_assignment_walk();
 init_timestamp();
-import { readFile as readFile20, writeFile as writeFile5, rm as rm2 } from "fs/promises";
+import { readFile as readFile22, writeFile as writeFile5, rm as rm2 } from "fs/promises";
 import { dirname as dirname8 } from "path";
 var StatusResolutionError = class extends Error {
   constructor(message, code) {
@@ -22243,7 +22581,7 @@ async function scanAssignmentsByStatus(projectsDir2, standaloneDir, ids) {
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile20(assignmentPath, "utf-8");
+      content = await readFile22(assignmentPath, "utf-8");
     } catch (err2) {
       const code = err2?.code;
       if (code === "ENOENT") {
@@ -22306,7 +22644,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const content = await readFile20(a.path, "utf-8");
+        const content = await readFile22(a.path, "utf-8");
         buffer.set(a.path, content);
       } catch (err2) {
         const code = err2?.code;
@@ -22335,7 +22673,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       for (const a of list) {
         let current;
         try {
-          current = await readFile20(a.path, "utf-8");
+          current = await readFile22(a.path, "utf-8");
         } catch (err2) {
           const code = err2?.code;
           if (code === "ENOENT") {
@@ -22406,7 +22744,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
     const list = affected.get(r.id) ?? [];
     for (const a of list) {
       try {
-        const current = await readFile20(a.path, "utf-8");
+        const current = await readFile22(a.path, "utf-8");
         const fm = parseAssignmentFrontmatter(current);
         if (fm.status !== r.id) {
           console.warn(
@@ -22457,7 +22795,7 @@ async function scanAssignmentsReferencingStatus(projectsDir2, standaloneDir, id)
     const assignmentPath = `${entry.assignmentDir}/assignment.md`;
     let content;
     try {
-      content = await readFile20(assignmentPath, "utf-8");
+      content = await readFile22(assignmentPath, "utf-8");
     } catch (err2) {
       const code = err2?.code;
       if (code === "ENOENT") continue;
@@ -22917,7 +23255,7 @@ import { Router as Router12 } from "express";
 init_paths();
 import Database3 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve32 } from "path";
+import { resolve as resolve34 } from "path";
 var db3 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL3 = `
@@ -23041,7 +23379,7 @@ function isBusyError(err2) {
 }
 function initLeasesDb(dbPath) {
   if (db3) return db3;
-  const finalPath = dbPath ?? resolve32(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve34(syntaurRoot(), "syntaur.db");
   db3 = new Database3(finalPath);
   db3.pragma("journal_mode = WAL");
   db3.pragma("busy_timeout = 5000");
@@ -23607,15 +23945,15 @@ init_fs();
 init_paths();
 init_timestamp();
 import { randomUUID as randomUUID4 } from "crypto";
-import { readFile as readFile21, readdir as readdir15, rm as rm3 } from "fs/promises";
-import { resolve as resolve33 } from "path";
+import { readFile as readFile23, readdir as readdir17, rm as rm3 } from "fs/promises";
+import { resolve as resolve35 } from "path";
 function schedulesDir() {
   const override3 = process.env.SYNTAUR_SCHEDULES_DIR;
-  if (override3 && override3.length > 0) return resolve33(override3);
-  return resolve33(syntaurRoot(), "schedules");
+  if (override3 && override3.length > 0) return resolve35(override3);
+  return resolve35(syntaurRoot(), "schedules");
 }
 function jobPath(id) {
-  return resolve33(schedulesDir(), `${jobFileSafe(id)}.md`);
+  return resolve35(schedulesDir(), `${jobFileSafe(id)}.md`);
 }
 function jobFileSafe(id) {
   if (!/^[A-Za-z0-9_-]+$/.test(id)) {
@@ -23740,7 +24078,7 @@ function validateJob(raw2) {
 async function readJob(id) {
   const path = jobPath(id);
   if (!await fileExists(path)) return null;
-  return parseJobFile(await readFile21(path, "utf-8"));
+  return parseJobFile(await readFile23(path, "utf-8"));
 }
 async function writeJob(job) {
   const next = { ...job, updatedAt: nowTimestamp() };
@@ -23750,7 +24088,7 @@ async function writeJob(job) {
 async function listJobs() {
   let names;
   try {
-    names = await readdir15(schedulesDir());
+    names = await readdir17(schedulesDir());
   } catch {
     return [];
   }
@@ -23758,7 +24096,7 @@ async function listJobs() {
   for (const name of names) {
     if (!name.endsWith(".md")) continue;
     try {
-      jobs.push(parseJobFile(await readFile21(resolve33(schedulesDir(), name), "utf-8")));
+      jobs.push(parseJobFile(await readFile23(resolve35(schedulesDir(), name), "utf-8")));
     } catch {
     }
   }
@@ -23768,13 +24106,13 @@ async function listJobs() {
 
 // src/schedules/event-log.ts
 init_timestamp();
-import { appendFile, readFile as readFile22, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname9, resolve as resolve34 } from "path";
+import { appendFile, readFile as readFile24, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname9, resolve as resolve36 } from "path";
 function eventLogPath(jobId) {
   if (!/^[A-Za-z0-9_-]+$/.test(jobId)) {
     throw new Error(`Unsafe schedule id: ${JSON.stringify(jobId)}`);
   }
-  return resolve34(schedulesDir(), `${jobId}.jsonl`);
+  return resolve36(schedulesDir(), `${jobId}.jsonl`);
 }
 async function appendEvent(jobId, type, data) {
   const event = { type, at: nowTimestamp(), ...data ? { data } : {} };
@@ -23787,7 +24125,7 @@ async function appendEvent(jobId, type, data) {
 async function readEvents(jobId) {
   let content;
   try {
-    content = await readFile22(eventLogPath(jobId), "utf-8");
+    content = await readFile24(eventLogPath(jobId), "utf-8");
   } catch {
     return [];
   }
@@ -23806,8 +24144,8 @@ async function readEvents(jobId) {
 
 // src/schedules/attempt.ts
 import { createHash as createHash3 } from "crypto";
-import { open as open4, readFile as readFile23, stat as stat5, unlink as unlink6 } from "fs/promises";
-import { resolve as resolve35 } from "path";
+import { open as open4, readFile as readFile25, stat as stat5, unlink as unlink6 } from "fs/promises";
+import { resolve as resolve37 } from "path";
 
 // src/schedules/triggers.ts
 import { Cron } from "croner";
@@ -23986,7 +24324,7 @@ var LOCK_WAIT_MS2 = 50;
 var LOCK_MAX_WAITS2 = 100;
 var MAX_CONSUMED_EDGES = 50;
 async function acquireJobLock(id) {
-  const lockPath = resolve35(schedulesDir(), `${id}.lock`);
+  const lockPath = resolve37(schedulesDir(), `${id}.lock`);
   const token = `${process.pid}:${createHash3("sha256").update(`${Math.random()}${Date.now()}`).digest("hex").slice(0, 12)}`;
   for (let attempt = 0; attempt <= LOCK_MAX_WAITS2; attempt++) {
     try {
@@ -23995,7 +24333,7 @@ async function acquireJobLock(id) {
       await handle.close();
       return async () => {
         try {
-          const current = await readFile23(lockPath, "utf-8");
+          const current = await readFile25(lockPath, "utf-8");
           if (current === token) await unlink6(lockPath);
         } catch {
         }
@@ -24301,7 +24639,7 @@ async function reapStale(jobs, deps) {
 
 // src/schedules/unattended.ts
 import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve36 } from "path";
+import { resolve as resolve38 } from "path";
 var UnattendedRefusalError = class extends Error {
   constructor(message) {
     super(message);
@@ -24317,7 +24655,7 @@ function assertUnattendedTerminalSupported(terminal) {
 }
 function isKillSwitchEngaged() {
   if (process.env.SYNTAUR_SCHEDULES_DISABLED === "1") return true;
-  return existsSync3(resolve36(schedulesDir(), "KILL"));
+  return existsSync3(resolve38(schedulesDir(), "KILL"));
 }
 function canFire(job, deps) {
   const killSwitch = deps.killSwitch ?? isKillSwitchEngaged;
@@ -24468,20 +24806,20 @@ init_config2();
 init_paths();
 init_assignment_resolver();
 init_frontmatter();
-import { readFile as readFile24 } from "fs/promises";
-import { resolve as resolve37 } from "path";
+import { readFile as readFile26 } 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 homedir6 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join10 } 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 : join8(homedir6(), ".syntaur", "runtime", "sessions");
+  return override3 && override3.length > 0 ? override3 : join10(homedir7(), ".syntaur", "runtime", "sessions");
 }
 function defaultAckProbe(handle) {
   const dir = runtimeSessionsDir();
@@ -24529,7 +24867,7 @@ async function defaultReadAssignment(assignmentId) {
   const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir(), assignmentId);
   if (!resolved) return null;
   try {
-    const content = await readFile24(resolve37(resolved.assignmentDir, "assignment.md"), "utf-8");
+    const content = await readFile26(resolve39(resolved.assignmentDir, "assignment.md"), "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -24621,7 +24959,7 @@ import { Router as Router14 } from "express";
 // src/db/usage-db.ts
 init_paths();
 import Database4 from "better-sqlite3";
-import { resolve as resolve38 } from "path";
+import { resolve as resolve40 } from "path";
 var db4 = null;
 var USAGE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL4 = `
@@ -24695,7 +25033,7 @@ function nowIso2() {
 }
 function initUsageDb(dbPath) {
   if (db4) return db4;
-  const finalPath = dbPath ?? resolve38(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve40(syntaurRoot(), "syntaur.db");
   db4 = new Database4(finalPath);
   db4.pragma("journal_mode = WAL");
   db4.pragma("busy_timeout = 5000");
@@ -25308,14 +25646,14 @@ init_fs();
 init_parser();
 init_events_db();
 import { Router as Router15 } from "express";
-import { resolve as resolve39 } from "path";
-import { readFile as readFile25 } from "fs/promises";
+import { resolve as resolve41 } from "path";
+import { readFile as readFile27 } from "fs/promises";
 function createEventsRouter(projectsDir2, assignmentsDir2) {
   const router = Router15();
   router.get("/projects/:slug/assignments/:aslug/events", async (req2, res) => {
     try {
       const { slug, aslug } = req2.params;
-      const assignmentMdPath2 = resolve39(
+      const assignmentMdPath2 = resolve41(
         projectsDir2,
         slug,
         "assignments",
@@ -25336,7 +25674,7 @@ function createEventsRouter(projectsDir2, assignmentsDir2) {
   router.get("/standalone/assignments/:id/events", async (req2, res) => {
     try {
       const { id: dirId } = req2.params;
-      const assignmentMdPath2 = resolve39(assignmentsDir2, dirId, "assignment.md");
+      const assignmentMdPath2 = resolve41(assignmentsDir2, dirId, "assignment.md");
       const id = await readAssignmentId2(assignmentMdPath2) ?? dirId;
       res.json({ events: loadEvents(id, req2.query) });
     } catch (error) {
@@ -25348,7 +25686,7 @@ function createEventsRouter(projectsDir2, assignmentsDir2) {
 }
 async function readAssignmentId2(assignmentMdPath2) {
   if (!await fileExists(assignmentMdPath2)) return null;
-  const content = await readFile25(assignmentMdPath2, "utf-8");
+  const content = await readFile27(assignmentMdPath2, "utf-8");
   const [fm] = extractFrontmatter(content);
   const id = getField(fm, "id");
   return id && id.length > 0 ? id : null;
@@ -25393,8 +25731,8 @@ init_assignment_walk();
 init_parser();
 init_facts();
 init_state_machine();
-import { resolve as resolve40 } from "path";
-import { readFile as readFile26 } from "fs/promises";
+import { resolve as resolve42 } from "path";
+import { readFile as readFile28 } from "fs/promises";
 
 // src/inbox/types.ts
 var INBOX_CATEGORIES = [
@@ -25574,7 +25912,7 @@ async function computeInbox(opts) {
     if (opts.project !== void 0 && entry.projectSlug !== opts.project) continue;
     let parsed;
     try {
-      const content = await readFile26(resolve40(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile28(resolve42(entry.assignmentDir, "assignment.md"), "utf-8");
       parsed = parseAssignmentFull(content);
     } catch {
       continue;
@@ -25617,10 +25955,10 @@ async function computeInbox(opts) {
       });
     }
     if (!typeFilter || typeFilter.has("question")) {
-      const commentsPath = resolve40(entry.assignmentDir, "comments.md");
+      const commentsPath = resolve42(entry.assignmentDir, "comments.md");
       if (await fileExists(commentsPath)) {
         try {
-          const content = await readFile26(commentsPath, "utf-8");
+          const content = await readFile28(commentsPath, "utf-8");
           const parsedComments = parseComments(content);
           for (const c2 of unresolvedQuestions(parsedComments.entries)) {
             const since = resolveSince("question", parsed, now, c2);
@@ -25733,8 +26071,8 @@ init_fs();
 init_playbook();
 init_playbooks();
 import { Router as Router17 } from "express";
-import { resolve as resolve41 } from "path";
-import { readFile as readFile27 } from "fs/promises";
+import { resolve as resolve43 } from "path";
+import { readFile as readFile29 } from "fs/promises";
 function statusForPlaybookError(code) {
   switch (code) {
     case "manifest":
@@ -25815,8 +26153,8 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req2.params.slug}" not found` });
         return;
       }
-      const filePath = resolve41(playbooksDir3, resolved.filename);
-      const content = await readFile27(filePath, "utf-8");
+      const filePath = resolve43(playbooksDir3, resolved.filename);
+      const content = await readFile29(filePath, "utf-8");
       res.json({
         documentType: "playbook",
         title: `Edit Playbook: ${resolved.slug}`,
@@ -25841,7 +26179,7 @@ function createPlaybooksRouter(playbooksDir3) {
         return;
       }
       await ensureDir(playbooksDir3);
-      const filePath = resolve41(playbooksDir3, `${slug}.md`);
+      const filePath = resolve43(playbooksDir3, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -25865,7 +26203,7 @@ function createPlaybooksRouter(playbooksDir3) {
         res.status(404).json({ error: `Playbook "${req2.params.slug}" not found` });
         return;
       }
-      const filePath = resolve41(playbooksDir3, resolved.filename);
+      const filePath = resolve43(playbooksDir3, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir3);
       res.json({ slug: resolved.slug, path: filePath });
@@ -25913,7 +26251,7 @@ init_parser2();
 init_fs();
 init_paths();
 import { Router as Router19 } from "express";
-import { readdir as readdir17 } from "fs/promises";
+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";
 init_slug();
@@ -25924,8 +26262,8 @@ init_api();
 import { raw } from "express";
 
 // src/todos/attachments.ts
-import { mkdir as mkdir4, readdir as readdir16, stat as stat6, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve42, basename as basename6, dirname as dirname10, extname } from "path";
+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";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -26036,12 +26374,12 @@ function sanitizeAttachmentName(name) {
   return n;
 }
 function attachmentsRootDir(todosDir2) {
-  return resolve42(todosDir2, "attachments");
+  return resolve44(todosDir2, "attachments");
 }
 function attachmentDirFor(todosDir2, scopeId, todoId) {
   assertScope(scopeId);
   assertTodoId(todoId);
-  return resolve42(attachmentsRootDir(todosDir2), scopeId, todoId);
+  return resolve44(attachmentsRootDir(todosDir2), scopeId, todoId);
 }
 async function dirExists(p) {
   try {
@@ -26055,7 +26393,7 @@ async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes)
   await mkdir4(dir, { recursive: true });
   const id = generateArtifactId();
   const filename = sanitizeAttachmentName(originalName);
-  await writeFile6(resolve42(dir, `${id}__${filename}`), bytes);
+  await writeFile6(resolve44(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -26068,7 +26406,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir16(dir);
+    names = await readdir18(dir);
   } catch {
     return [];
   }
@@ -26080,7 +26418,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
     if (!ATTACHMENT_ID_RE.test(id)) continue;
     const filename = stored.slice(sep2 + 2);
     try {
-      const st = await stat6(resolve42(dir, stored));
+      const st = await stat6(resolve44(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -26091,10 +26429,10 @@ async function listAttachments(todosDir2, scopeId, todoId) {
 }
 async function readScopeAttachments(todosDir2, scopeId) {
   assertScope(scopeId);
-  const scopeDir = resolve42(attachmentsRootDir(todosDir2), scopeId);
+  const scopeDir = resolve44(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
-    todoIds = await readdir16(scopeDir);
+    todoIds = await readdir18(scopeDir);
   } catch {
     return {};
   }
@@ -26111,7 +26449,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir16(dir);
+    names = await readdir18(dir);
   } catch {
     return null;
   }
@@ -26119,7 +26457,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const stored = names.find((n) => n.startsWith(prefix));
   if (!stored) return null;
   const filename = stored.slice(prefix.length);
-  return { path: resolve42(dir, stored), filename, mime: mimeForName(filename) };
+  return { path: resolve44(dir, stored), filename, mime: mimeForName(filename) };
 }
 async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
   const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
@@ -26415,7 +26753,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir17(todosDir2).catch(() => []);
+      const files = await readdir19(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -26536,7 +26874,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: readFile81 } = await import("fs/promises");
+      const { readFile: readFile82 } = 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 () => {
@@ -26555,7 +26893,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         await ensureDir(resolve112(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile81(archFile, "utf-8");
+          archContent = await readFile82(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -26856,7 +27194,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: readFile81 } = await import("fs/promises");
+        const { readFile: readFile82 } = 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;
@@ -26877,7 +27215,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile81(assignmentMdPath2, "utf-8");
+        let content = await readFile82(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -27072,8 +27410,8 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router20 } from "express";
-import { mkdir as mkdir6, readFile as readFile28, rename as rename7 } from "fs/promises";
-import { resolve as resolve43, dirname as dirname12 } from "path";
+import { mkdir as mkdir6, readFile as readFile30, rename as rename7 } from "fs/promises";
+import { resolve as resolve45, dirname as dirname12 } from "path";
 init_promote_todos();
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
@@ -27090,7 +27428,7 @@ function params(req2) {
   return req2.params;
 }
 async function projectExists(projectsDir2, slug) {
-  return fileExists(resolve43(projectsDir2, slug, "project.md"));
+  return fileExists(resolve45(projectsDir2, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
@@ -27107,7 +27445,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir6(resolve43(todosDir2, "archive"), { recursive: false });
+    await mkdir6(resolve45(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -27315,7 +27653,7 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
         const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile28(archFile, "utf-8");
+          archContent = await readFile30(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -27786,17 +28124,17 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve43(projectsDir2, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve45(projectsDir2, parts[0], "assignments", parts[1]);
           assignmentRef = `${parts[0]}/${parts[1]}`;
         } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-          assignmentDir = resolve43(assignmentsDirFn(), tg);
+          assignmentDir = resolve45(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath2 = resolve43(assignmentDir, "assignment.md");
+        const assignmentMdPath2 = resolve45(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile28(assignmentMdPath2, "utf-8");
+        let content = await readFile30(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -27999,7 +28337,7 @@ workspace: ${slug}
 
 // src/dashboard/api-bundles.ts
 import { Router as Router21 } from "express";
-import { readdir as readdir18 } from "fs/promises";
+import { readdir as readdir20 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -28007,7 +28345,7 @@ init_fs();
 init_paths();
 init_parser2();
 import { randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile29 } from "fs/promises";
+import { readFile as readFile31 } 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_-]*$/;
@@ -28110,7 +28448,7 @@ ${lines}
 async function readBundles(todosDir2) {
   const path = bundlesPath(todosDir2);
   if (!await fileExists(path)) return [];
-  const content = await readFile29(path, "utf-8");
+  const content = await readFile31(path, "utf-8");
   return parseBundles(content).bundles;
 }
 async function writeBundles(todosDir2, bundles) {
@@ -28163,7 +28501,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir18(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir20(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -28216,7 +28554,7 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router22 } from "express";
-import { resolve as resolve44 } from "path";
+import { resolve as resolve46 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
   const members = bundle.todoIds.map((id) => items.find((i) => i.id === id)).filter((i) => i !== void 0);
@@ -28258,7 +28596,7 @@ function createProjectBundlesRouter(projectsDir2, broadcast) {
   router.get("/", async (req2, res) => {
     try {
       const slug = getProjectIdParam2(req2.params.projectId);
-      const projectMd = resolve44(projectsDir2, slug, "project.md");
+      const projectMd = resolve46(projectsDir2, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -28287,8 +28625,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 readFile30, writeFile as writeFile7, unlink as unlink8, stat as stat7, open as open5, rename as rename8 } from "fs/promises";
-import { resolve as resolve45, join as join9 } from "path";
+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 { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -28328,7 +28666,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve45(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve47(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -28339,7 +28677,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock2() {
-  const lockPath = resolve45(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve47(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open5(lockPath, "wx");
@@ -28348,7 +28686,7 @@ async function acquireLock2() {
     return lockPath;
   } catch (err2) {
     if (err2.code === "EEXIST") {
-      const pid = await readFile30(lockPath, "utf-8").catch(() => "");
+      const pid = await readFile32(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.`
       );
@@ -28386,7 +28724,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve45(dest, ".."));
+    await ensureDir(resolve47(dest, ".."));
     await cp2(src, dest, { force: true });
   }
 }
@@ -28395,7 +28733,7 @@ function resolveCategoriesStrict(csv) {
   return parseCategoriesStrict(parts);
 }
 async function readSanitizedConfig(configPath2) {
-  const content = await readFile30(configPath2, "utf-8");
+  const content = await readFile32(configPath2, "utf-8");
   return content.replace(/^(\s*lastBackup:\s*).*$/m, "$1null").replace(/^(\s*lastRestore:\s*).*$/m, "$1null");
 }
 async function backupToGithub(overrides) {
@@ -28418,11 +28756,11 @@ async function backupToGithub(overrides) {
   let tmpDir = null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    tmpDir = await mkdtemp(join9(tmpdir(), "syntaur-backup-"));
+    tmpDir = await mkdtemp(join11(tmpdir(), "syntaur-backup-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
-      const destPath = join9(tmpDir, repoPath);
+      const destPath = join11(tmpDir, repoPath);
       if (isFile) {
         await rm5(destPath, { force: true });
       } else {
@@ -28434,7 +28772,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve45(destPath, ".."));
+        await ensureDir(resolve47(destPath, ".."));
         await writeFile7(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -28488,7 +28826,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve45(localPath, ".."));
+    await ensureDir(resolve47(localPath, ".."));
     await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -28550,7 +28888,7 @@ async function restoreFromGithub(overrides) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
     await updateBackupConfig({ lastRestore: timestamp });
-    tmpDir = await mkdtemp(join9(tmpdir(), "syntaur-restore-"));
+    tmpDir = await mkdtemp(join11(tmpdir(), "syntaur-restore-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       if (category === "config") {
@@ -28559,7 +28897,7 @@ async function restoreFromGithub(overrides) {
       }
       try {
         const { sourcePath: localPath, repoPath, isFile } = await resolveCategoryPath(category);
-        const repoSrcPath = join9(tmpDir, repoPath);
+        const repoSrcPath = join11(tmpDir, repoPath);
         if (!await fileExists(repoSrcPath)) {
           console.warn(`Category "${category}" not found in backup repo, skipping.`);
           continue;
@@ -28589,7 +28927,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve45(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve47(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -30545,7 +30883,7 @@ init_git_worktree();
 init_recompute();
 init_event_emit();
 init_transitions();
-import { readFile as readFile34 } from "fs/promises";
+import { readFile as readFile35 } from "fs/promises";
 import { resolve as resolve54, basename as basename7 } from "path";
 
 // src/utils/assignment-target.ts
@@ -30556,7 +30894,7 @@ init_slug();
 init_assignment_resolver();
 init_parser();
 import { resolve as resolve53 } from "path";
-import { readFile as readFile32 } from "fs/promises";
+import { readFile as readFile33 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 function classifyContext(ctx) {
@@ -30569,7 +30907,7 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   const path = resolve53(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile32(path, "utf-8");
+    const content = await readFile33(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -30580,7 +30918,7 @@ async function readContextJson(cwd) {
   const path = resolve53(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile32(path, "utf-8");
+    const raw2 = await readFile33(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -30765,7 +31103,7 @@ init_session_id();
 init_fs();
 init_frontmatter();
 init_recompute();
-import { readFile as readFile33 } from "fs/promises";
+import { readFile as readFile34 } from "fs/promises";
 function computeDelta(stage, prevStage, fm) {
   const writes = {};
   if (stage === "implement") {
@@ -30783,7 +31121,7 @@ async function assertStageFactOnOpen(input4) {
   const pre = computeDelta(
     input4.stage,
     input4.prevStage,
-    parseAssignmentFrontmatter(await readFile33(input4.assignmentPath, "utf-8"))
+    parseAssignmentFrontmatter(await readFile34(input4.assignmentPath, "utf-8"))
   );
   if (Object.keys(pre).length === 0) return;
   const context = await resolveDeriveContext();
@@ -30833,7 +31171,7 @@ async function resolveTarget(assignment, options) {
 async function inferActor(options) {
   if (options.agent) return `agent:${options.agent}`;
   try {
-    const raw2 = await readFile34(resolve54(process.cwd(), ".syntaur", "context.json"), "utf-8");
+    const raw2 = await readFile35(resolve54(process.cwd(), ".syntaur", "context.json"), "utf-8");
     const ctx = JSON.parse(raw2);
     if (ctx.sessionId) return `agent:${ctx.sessionId.slice(0, 8)}`;
   } catch {
@@ -30842,7 +31180,7 @@ async function inferActor(options) {
 }
 async function emitDeriveEvent(target, type, actor, details) {
   try {
-    const fm = parseAssignmentFrontmatter(await readFile34(target.assignmentPath, "utf-8"));
+    const fm = parseAssignmentFrontmatter(await readFile35(target.assignmentPath, "utf-8"));
     emitEvent({
       assignmentId: fm.id,
       projectSlug: target.projectDir ? basename7(target.projectDir) : null,
@@ -30903,7 +31241,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 readFile34(resolve54(target2.assignmentDir, planFile), "utf-8");
+      const planContent = await readFile35(resolve54(target2.assignmentDir, planFile), "utf-8");
       return updatePlanApproval(content, {
         file: planFile,
         digest: planDigest(planContent),
@@ -30976,7 +31314,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 readFile34(resolve54(target2.assignmentDir, planFile), "utf-8");
+        const planContent = await readFile35(resolve54(target2.assignmentDir, planFile), "utf-8");
         record.file = planFile;
         record.digest = planDigest(planContent);
       } else if (binds === "commit") {
@@ -31067,13 +31405,13 @@ async function requestReviewCommand(assignment, options) {
   }
   const target = await resolveTarget(assignment, options);
   const context = await resolveDeriveContext();
-  const fm = parseAssignmentFrontmatter(await readFile34(target.assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile35(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 readFile34(target.assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile35(target.assignmentPath, "utf-8"));
   if (fm.dependsOn.length > 0 && target.projectDir) {
     const dep = await checkDependencies(target.projectDir, fm.dependsOn, context.terminalStatuses);
     if (!dep.satisfied) {
@@ -31204,7 +31542,7 @@ init_timestamp();
 init_assignment_resolver();
 init_event_emit();
 import { resolve as resolve55 } from "path";
-import { readFile as readFile35, writeFile as writeFile9 } from "fs/promises";
+import { readFile as readFile36, writeFile as writeFile9 } from "fs/promises";
 async function resolveTarget2(target, options) {
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
@@ -31236,7 +31574,7 @@ async function resolveTarget2(target, options) {
   return null;
 }
 async function writeArchiveState(filePath, archived, reason) {
-  const content = await readFile35(filePath, "utf-8");
+  const content = await readFile36(filePath, "utf-8");
   const updated = updateAssignmentFile(content, {
     archived,
     archivedAt: archived ? nowTimestamp() : null,
@@ -31248,7 +31586,7 @@ async function writeArchiveState(filePath, archived, reason) {
 async function emitArchiveEvent(resolved, type, reason) {
   if (resolved.kind !== "assignment") return;
   try {
-    const fm = parseAssignmentFrontmatter(await readFile35(resolved.filePath, "utf-8"));
+    const fm = parseAssignmentFrontmatter(await readFile36(resolved.filePath, "utf-8"));
     emitEvent({
       assignmentId: fm.id,
       projectSlug: fm.project,
@@ -31319,7 +31657,7 @@ init_frontmatter();
 init_timestamp();
 init_event_emit();
 import { resolve as resolve56 } from "path";
-import { readdir as readdir20, readFile as readFile36 } from "fs/promises";
+import { readdir as readdir21, readFile as readFile37 } 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+|$)/);
@@ -31337,7 +31675,7 @@ async function collectCandidates(baseDirs) {
   const candidates = [];
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const projects = await readdir20(baseDir, { withFileTypes: true });
+    const projects = await readdir21(baseDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -31345,7 +31683,7 @@ async function collectCandidates(baseDirs) {
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
-          const content = await readFile36(directAssignmentMd, "utf-8");
+          const content = await readFile37(directAssignmentMd, "utf-8");
           if (objectiveIsFleshedOut(content) && hasAcceptanceCriteria(content)) {
             candidates.push({
               projectSlug: null,
@@ -31360,7 +31698,7 @@ async function collectCandidates(baseDirs) {
       }
       const assignmentsDir2 = resolve56(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir20(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir21(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -31368,7 +31706,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 readFile36(assignmentMd, "utf-8");
+        const content = await readFile37(assignmentMd, "utf-8");
         if (!objectiveIsFleshedOut(content)) continue;
         if (!hasAcceptanceCriteria(content)) continue;
         candidates.push({
@@ -31385,7 +31723,7 @@ async function collectCandidates(baseDirs) {
 }
 async function parseSafe(path) {
   try {
-    const content = await readFile36(path, "utf-8");
+    const content = await readFile37(path, "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -31415,7 +31753,7 @@ async function migrateStatusesCommand(options) {
   let migrated = 0;
   await withSuppressedEvents(async () => {
     for (const c2 of candidates) {
-      const content = await readFile36(c2.assignmentMd, "utf-8");
+      const content = await readFile37(c2.assignmentMd, "utf-8");
       const updated = appendStatusHistoryEntry(
         updateAssignmentFile(content, {
           status: c2.toStatus,
@@ -31438,10 +31776,10 @@ init_frontmatter();
 init_event_emit();
 init_types();
 import { resolve as resolve57 } from "path";
-import { readdir as readdir21, readFile as readFile37 } from "fs/promises";
+import { readdir as readdir22, readFile as readFile38 } from "fs/promises";
 async function parseSafe2(path) {
   try {
-    return parseAssignmentFrontmatter(await readFile37(path, "utf-8"));
+    return parseAssignmentFrontmatter(await readFile38(path, "utf-8"));
   } catch {
     return null;
   }
@@ -31464,7 +31802,7 @@ async function collectTargets(baseDirs, terminalStatuses3) {
   const seen = /* @__PURE__ */ new Set();
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const entries = await readdir21(baseDir, { withFileTypes: true });
+    const entries = await readdir22(baseDir, { withFileTypes: true });
     for (const m of entries) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
@@ -31485,7 +31823,7 @@ async function collectTargets(baseDirs, terminalStatuses3) {
       }
       const assignmentsBase = resolve57(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsBase)) continue;
-      const slugs = await readdir21(assignmentsBase, { withFileTypes: true });
+      const slugs = await readdir22(assignmentsBase, { withFileTypes: true });
       for (const a of slugs) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
@@ -31533,7 +31871,7 @@ async function migrateStatusHistoryCommand(options) {
   await withSuppressedEvents(async () => {
     for (const t of targets) {
       try {
-        const content = await readFile37(t.assignmentMd, "utf-8");
+        const content = await readFile38(t.assignmentMd, "utf-8");
         if (parseAssignmentFrontmatter(content).statusHistory.length > 0) continue;
         const seededContent = appendStatusHistoryEntry(content, {
           at: t.seedAt,
@@ -31562,10 +31900,10 @@ init_config2();
 init_parser();
 init_events_db();
 import { resolve as resolve58 } from "path";
-import { readdir as readdir22, readFile as readFile38 } from "fs/promises";
+import { readdir as readdir23, readFile as readFile39 } from "fs/promises";
 async function parseSafe3(path) {
   try {
-    return parseAssignmentFull(await readFile38(path, "utf-8"));
+    return parseAssignmentFull(await readFile39(path, "utf-8"));
   } catch {
     return null;
   }
@@ -31598,7 +31936,7 @@ async function collectTargets2(baseDirs) {
   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;
@@ -31622,7 +31960,7 @@ async function collectTargets2(baseDirs) {
       }
       const assignmentsBase = resolve58(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;
@@ -31707,7 +32045,7 @@ init_frontmatter();
 init_facts();
 init_derive();
 init_recompute();
-import { readdir as readdir23, readFile as readFile39 } from "fs/promises";
+import { readdir as readdir24, readFile as readFile40 } 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"]);
@@ -31715,14 +32053,14 @@ async function listTargets(projectsDir2, standaloneDir) {
   const targets = [];
   let projects = [];
   try {
-    projects = await readdir23(projectsDir2);
+    projects = await readdir24(projectsDir2);
   } catch {
   }
   for (const project of projects) {
     const projectDir = resolve59(projectsDir2, project);
     let slugs = [];
     try {
-      slugs = await readdir23(resolve59(projectDir, "assignments"));
+      slugs = await readdir24(resolve59(projectDir, "assignments"));
     } catch {
       continue;
     }
@@ -31733,7 +32071,7 @@ async function listTargets(projectsDir2, standaloneDir) {
   }
   let ids = [];
   try {
-    ids = await readdir23(standaloneDir);
+    ids = await readdir24(standaloneDir);
   } catch {
   }
   for (const id of ids) {
@@ -31793,7 +32131,7 @@ async function migrateDeriveCommand(options) {
   for (const target of targets) {
     let content;
     try {
-      content = await readFile39(target.path, "utf-8");
+      content = await readFile40(target.path, "utf-8");
     } catch {
       continue;
     }
@@ -32007,10 +32345,10 @@ init_config2();
 init_fs();
 import {
   cp as cp3,
-  readdir as readdir24,
+  readdir as readdir25,
   symlink,
   lstat,
-  readFile as readFile40,
+  readFile as readFile41,
   readlink,
   rename as rename9,
   rm as rm6,
@@ -32071,7 +32409,7 @@ function getInstallMarkerPath(targetDir) {
   return resolve64(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw2 = await readFile40(resolve64(packageRoot, "package.json"), "utf-8");
+  const raw2 = await readFile41(resolve64(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw2);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -32079,7 +32417,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw2 = await readFile40(pathValue, "utf-8");
+    const raw2 = await readFile41(pathValue, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -32095,7 +32433,7 @@ async function readPluginManifestName(targetDir, pluginKind) {
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw2 = await readFile40(manifestPath, "utf-8");
+  const raw2 = await readFile41(manifestPath, "utf-8");
   const parsed = JSON.parse(raw2);
   return parsed.name;
 }
@@ -32105,7 +32443,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw2 = await readFile40(markerPath, "utf-8");
+    const raw2 = await readFile41(markerPath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -32228,7 +32566,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   }
   if (await fileExists(manifestPath)) {
     try {
-      const prev = await readFile40(manifestPath, "utf-8");
+      const prev = await readFile41(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       await writeFile10(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
@@ -32301,7 +32639,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir24(rootDir, { withFileTypes: true })
+    readdir25(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -32376,7 +32714,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw2 = await readFile40(manifestPath, "utf-8");
+    const raw2 = await readFile41(manifestPath, "utf-8");
     try {
       const parsed = JSON.parse(raw2);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -32403,7 +32741,7 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   existing[name].autoUpdate = true;
   await ensureDir(dirname15(manifestPath));
   if (await fileExists(manifestPath)) {
-    const prev = await readFile40(manifestPath, "utf-8");
+    const prev = await readFile41(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     await writeFile10(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
@@ -32421,7 +32759,7 @@ async function setSyntaurPluginEnabled(options) {
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw2 = await readFile40(settingsPath, "utf-8");
+    const raw2 = await readFile41(settingsPath, "utf-8");
     try {
       parsed = JSON.parse(raw2);
     } catch {
@@ -32440,7 +32778,7 @@ async function setSyntaurPluginEnabled(options) {
   await ensureDir(dirname15(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const prev = await readFile40(settingsPath, "utf-8");
+    const prev = await readFile41(settingsPath, "utf-8");
     await writeFile10(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
@@ -32678,7 +33016,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw2 = await readFile40(marketplacePath, "utf-8");
+  const raw2 = await readFile41(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw2);
   return {
     name: parsed.name ?? "local",
@@ -32920,13 +33258,13 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile42, readdir as readdir25, mkdir as mkdir7, copyFile, rm as rm7, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve66, relative as relative3, join as join11 } from "path";
+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";
 
 // src/utils/plugin-state.ts
 init_fs();
-import { readFile as readFile41 } from "fs/promises";
+import { readFile as readFile42 } from "fs/promises";
 import { resolve as resolve65 } from "path";
 import { homedir as homedir9 } from "os";
 function settingsPathFor(agent) {
@@ -32937,7 +33275,7 @@ async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile41(path, "utf-8");
+    const raw2 = await readFile42(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -32996,9 +33334,9 @@ function defaultSkillTargetDir(target) {
 async function walkFiles(root) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir25(dir, { withFileTypes: true });
+    const entries = await readdir26(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join11(dir, entry.name);
+      const full = join12(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
@@ -33011,7 +33349,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile42(a), readFile42(b)]);
+    const [ba, bb] = await Promise.all([readFile43(a), readFile43(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -33020,10 +33358,10 @@ async function filesEqual(a, b) {
 }
 async function copyDir(srcDir, destDir) {
   await mkdir7(destDir, { recursive: true });
-  const entries = await readdir25(srcDir, { withFileTypes: true });
+  const entries = await readdir26(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const src = join11(srcDir, entry.name);
-    const dest = join11(destDir, entry.name);
+    const src = join12(srcDir, entry.name);
+    const dest = join12(destDir, entry.name);
     if (entry.isDirectory()) {
       await copyDir(src, dest);
     } else if (entry.isFile()) {
@@ -33036,7 +33374,7 @@ async function skillMatches(srcDir, destDir) {
   const srcFiles = await walkFiles(srcDir);
   for (const srcFile of srcFiles) {
     const rel = relative3(srcDir, srcFile);
-    const destFile = join11(destDir, rel);
+    const destFile = join12(destDir, rel);
     if (!await filesEqual(srcFile, destFile)) return false;
   }
   const destFiles = await walkFiles(destDir);
@@ -33074,12 +33412,12 @@ async function installSkillDir(srcDir, destDir, skillName, force) {
   return { skill: skillName, status: "differs-preserved", targetPath: destDir };
 }
 async function discoverSkillNames(sourceDir) {
-  const entries = await readdir25(sourceDir, { withFileTypes: true });
+  const entries = await readdir26(sourceDir, { withFileTypes: true });
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    if (await fileExists(join11(sourceDir, entry.name, "SKILL.md"))) {
+    if (await fileExists(join12(sourceDir, entry.name, "SKILL.md"))) {
       names.push(entry.name);
     }
   }
@@ -33106,8 +33444,8 @@ async function installSkillsWithReport(options) {
   const results = [];
   await mkdir7(targetRoot, { recursive: true });
   for (const skill of skillNames) {
-    const srcDir = join11(source, skill);
-    const destDir = join11(targetRoot, skill);
+    const srcDir = join12(source, skill);
+    const destDir = join12(targetRoot, skill);
     results.push(await installSkillDir(srcDir, destDir, skill, force));
   }
   return { results };
@@ -33124,8 +33462,8 @@ async function installSkillsToDir(options) {
   await mkdir7(options.targetDir, { recursive: true });
   const results = [];
   for (const skill of skillNames) {
-    const srcDir = join11(source, skill);
-    const destDir = join11(options.targetDir, skill);
+    const srcDir = join12(source, skill);
+    const destDir = join12(options.targetDir, skill);
     results.push(await installSkillDir(srcDir, destDir, skill, force));
   }
   return results;
@@ -33146,12 +33484,12 @@ async function uninstallSkills(options) {
   }
   const removed = [];
   for (const skill of known) {
-    const destDir = join11(targetRoot, skill);
+    const destDir = join12(targetRoot, skill);
     if (!await fileExists(destDir)) continue;
     if (await isSymlink(destDir)) continue;
-    const skillMd = join11(destDir, "SKILL.md");
+    const skillMd = join12(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile42(skillMd, "utf-8").catch(() => "");
+    const content = await readFile43(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 });
@@ -33346,20 +33684,20 @@ import { realpathSync as realpathSync3 } from "fs";
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { readFile as readFile44 } from "fs/promises";
-import { dirname as dirname17, join as join13, resolve as resolve67 } from "path";
+import { readFile as readFile45 } from "fs/promises";
+import { dirname as dirname17, join as join14, 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 readFile43 } from "fs/promises";
-import { dirname as dirname16, join as join12 } from "path";
+import { readFile as readFile44 } from "fs/promises";
+import { dirname as dirname16, join as join13 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath5(scriptUrl);
     const pkgRoot = dirname16(dirname16(scriptPath));
-    const raw2 = await readFile43(join12(pkgRoot, "package.json"), "utf-8");
+    const raw2 = await readFile44(join13(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -33389,7 +33727,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw2 = await readFile44(STATE_FILE, "utf-8");
+    const raw2 = await readFile45(STATE_FILE, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -33403,7 +33741,7 @@ async function resolveNpmBin() {
   const nodeDir = dirname17(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
-  const nearNode = join13(nodeDir, npmName);
+  const nearNode = join14(nodeDir, npmName);
   if (await fileExists(nearNode)) {
     return { cmd: nearNode, shell: false };
   }
@@ -33446,9 +33784,9 @@ async function readGlobalVersion() {
   });
   if (!rootPath) return null;
   try {
-    const manifestPath = join13(rootPath, "syntaur", "package.json");
+    const manifestPath = join14(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw2 = await readFile44(manifestPath, "utf-8");
+    const raw2 = await readFile45(manifestPath, "utf-8");
     const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -33567,7 +33905,7 @@ async function maybePromptInstall(scriptUrl) {
 
 // src/commands/update.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { homedir as homedir11 } 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.";
@@ -33609,12 +33947,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 ?? join14(env.BUN_INSTALL ?? join14(homedir11(), ".bun"), "install", "global");
-  return join14(globalDir, "node_modules");
+  const globalDir = env.BUN_INSTALL_GLOBAL_DIR ?? join15(env.BUN_INSTALL ?? join15(homedir11(), ".bun"), "install", "global");
+  return join15(globalDir, "node_modules");
 }
 async function defaultResolveFreshBin(pm, runner, env) {
   const binFromPkgRoot = (pkgRoot) => {
-    const entry = join14(pkgRoot, "syntaur", "bin", "syntaur.js");
+    const entry = join15(pkgRoot, "syntaur", "bin", "syntaur.js");
     return existsSync5(entry) ? { cmd: process.execPath, baseArgs: [entry] } : null;
   };
   try {
@@ -33626,7 +33964,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(join14(dir, "node_modules")) : null;
+      return dir ? binFromPkgRoot(join15(dir, "node_modules")) : null;
     }
     return binFromPkgRoot(bunGlobalNodeModulesDir(env));
   } catch {
@@ -33806,7 +34144,7 @@ async function refreshPluginSkills(options, pm, runner, getManagedDir, resolveFr
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile46, 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 { 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 { fileURLToPath as fileURLToPath8 } from "url";
@@ -33814,7 +34152,7 @@ import { fileURLToPath as fileURLToPath8 } from "url";
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile45, writeFile as writeFile11 } from "fs/promises";
+import { readFile as readFile46, writeFile as writeFile11 } from "fs/promises";
 import { resolve as resolve68, dirname as dirname18 } from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
@@ -33841,7 +34179,7 @@ function getConfigPath(installRoot) {
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile45(path, "utf-8");
+    const raw2 = await readFile46(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) : [];
@@ -34029,7 +34367,7 @@ function getPackageStatuslineSource() {
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw2 = await readFile46(settingsPath, "utf-8");
+  const raw2 = await readFile47(settingsPath, "utf-8");
   if (raw2.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw2);
@@ -34217,7 +34555,7 @@ async function uninstallStatuslineCommand(options = {}) {
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw2 = await readFile46(backupPath, "utf-8");
+      const raw2 = await readFile47(backupPath, "utf-8");
       const parsed = JSON.parse(raw2);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -34398,7 +34736,7 @@ init_config2();
 // src/commands/cross-agent-install.ts
 init_fs();
 import { spawnSync as spawnSync6 } from "child_process";
-import { dirname as dirname20, join as join15, resolve as resolve71 } from "path";
+import { dirname as dirname20, join as join16, resolve as resolve71 } from "path";
 import { cp as cp4, mkdir as mkdir9 } from "fs/promises";
 
 // src/commands/setup-adapter.ts
@@ -34509,7 +34847,7 @@ async function installTier3Plugin(t, opts = {}) {
     console.log(`${prefix}Tier 3 (${t.id}): ${plugin.source} -> ${installDir}`);
     return "dry-run";
   }
-  if (await fileExists(join15(installDir, plugin.entry)) && !opts.force) {
+  if (await fileExists(join16(installDir, plugin.entry)) && !opts.force) {
     console.log(
       `Tier 3 (${t.id}): already installed at ${installDir} (use --force to overwrite).`
     );
@@ -34887,7 +35225,7 @@ init_cwd();
 init_session_db();
 init_agent_sessions();
 import { resolve as resolve73 } from "path";
-import { readFile as readFile47 } from "fs/promises";
+import { readFile as readFile48 } from "fs/promises";
 async function trackSessionCommand(options, deps = {}) {
   if (!options.agent) {
     throw new Error("--agent <name> is required.");
@@ -34904,7 +35242,7 @@ async function trackSessionCommand(options, deps = {}) {
     const cwd = process.cwd();
     let legacyHint;
     try {
-      const raw2 = await readFile47(resolve73(cwd, ".syntaur", "context.json"), "utf-8");
+      const raw2 = await readFile48(resolve73(cwd, ".syntaur", "context.json"), "utf-8");
       const parsed = JSON.parse(raw2);
       if (typeof parsed.sessionId === "string") legacyHint = parsed.sessionId;
     } catch {
@@ -34988,8 +35326,10 @@ async function urlCommand(input4, options = {}) {
     projectsDir: projectsDir2,
     assignmentsDir: assignmentsDir(),
     terminalOverride: parsed.terminal,
-    agentId: parsed.kind === "assignment" ? parsed.agent : void 0,
-    promptOverride: parsed.kind === "assignment" ? parsed.prompt : void 0
+    // Standalone identifies its agent by `id`; assignment may pin one via `agent=`.
+    agentId: parsed.kind === "standalone" ? parsed.id : parsed.kind === "assignment" ? parsed.agent : void 0,
+    promptOverride: parsed.kind === "assignment" || parsed.kind === "standalone" ? parsed.prompt : void 0,
+    agentName: parsed.kind === "assignment" ? parsed.agentName : void 0
   });
   emitPlanWarnings(plan);
   if (options.printPlan) {
@@ -35067,7 +35407,7 @@ init_config2();
 init_paths();
 init_fs();
 import { resolve as resolve75, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile48 } from "fs/promises";
+import { readFile as readFile49 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -35146,7 +35486,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile48(assignmentPath, "utf-8");
+  const content = await readFile49(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -35280,7 +35620,7 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir26, readFile as readFile49 } from "fs/promises";
+import { readdir as readdir27, readFile as readFile50 } from "fs/promises";
 import { resolve as resolve77 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
@@ -35290,14 +35630,14 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir26(dir, { withFileTypes: true });
+  const entries = await readdir27(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 readFile49(filePath, "utf-8");
+    const raw2 = await readFile50(filePath, "utf-8");
     const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -35420,13 +35760,13 @@ init_fs();
 init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
-import { readFile as readFile51 } from "fs/promises";
+import { readFile as readFile52 } 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 readFile50, readdir as readdir27, rm as rm9, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile51, readdir as readdir28, rm as rm9, writeFile as writeFile13 } from "fs/promises";
 import { resolve as resolve78 } from "path";
 init_parser2();
 init_fs();
@@ -35719,7 +36059,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 readdir27(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
+    const existing = (await readdir28(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)) {
@@ -35788,8 +36128,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 readFile50(bundlesFilePath, "utf-8") : null;
-    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile50(checklistFilePath, "utf-8") : null;
+    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile51(bundlesFilePath, "utf-8") : null;
+    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile51(checklistFilePath, "utf-8") : null;
     const record = async () => {
       bundle.branch = options.branch;
       bundle.worktreePath = worktreePath;
@@ -36345,7 +36685,7 @@ todoCommand.command("archive").description("Archive completed todos and their lo
     await ensureDir(resolve79(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile51(archFile, "utf-8");
+      archContent = await readFile52(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -36523,12 +36863,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile81 } = await import("fs/promises");
+  const { readFile: readFile82 } = 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 readFile81(assignmentMdPath2, "utf-8");
+  let content = await readFile82(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -36573,8 +36913,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: readdir40 } = await import("fs/promises");
-    const existingFiles = (await readdir40(planDir).catch(() => [])).filter(
+    const { readdir: readdir41 } = await import("fs/promises");
+    const existingFiles = (await readdir41(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
@@ -36783,13 +37123,13 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
-import { readFile as readFile63 } from "fs/promises";
+import { readFile as readFile64 } from "fs/promises";
 import { isAbsolute as isAbsolute11, resolve as resolve93 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath12 } from "url";
-import { readFile as readFile62 } from "fs/promises";
-import { dirname as dirname25, join as join21 } from "path";
+import { readFile as readFile63 } from "fs/promises";
+import { dirname as dirname25, join as join22 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
@@ -36835,9 +37175,9 @@ function closeCheckContext(ctx) {
 init_fs();
 init_paths();
 import { resolve as resolve81, isAbsolute as isAbsolute9 } from "path";
-import { readFile as readFile52, stat as stat9 } from "fs/promises";
+import { readFile as readFile53, stat as stat9 } from "fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { dirname as dirname22, join as join17 } from "path";
+import { dirname as dirname22, join as join18 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -36892,7 +37232,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile52(configPath2, "utf-8");
+    const content = await readFile53(configPath2, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -37170,9 +37510,9 @@ async function readLocalPkg() {
     const here = fileURLToPath10(import.meta.url);
     let dir = dirname22(here);
     for (let i = 0; i < 6; i++) {
-      const candidate = join17(dir, "package.json");
+      const candidate = join18(dir, "package.json");
       try {
-        const text = await readFile52(candidate, "utf-8");
+        const text = await readFile53(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
         dir = dirname22(dir);
@@ -37225,7 +37565,7 @@ function versionGte(a, b) {
 // src/utils/doctor/checks/structure.ts
 init_fs();
 import { resolve as resolve82 } from "path";
-import { readdir as readdir28, stat as stat10 } from "fs/promises";
+import { readdir as readdir29, stat as stat10 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -37356,7 +37696,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir28(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir29(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -37400,7 +37740,7 @@ function pass2(check) {
 // src/utils/doctor/checks/project.ts
 init_fs();
 import { resolve as resolve83 } from "path";
-import { readdir as readdir29, stat as stat11 } from "fs/promises";
+import { readdir as readdir30, stat as stat11 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -37424,7 +37764,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 readdir29(dir, { withFileTypes: true });
+  const entries = await readdir30(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
@@ -37518,7 +37858,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir29(projectDir, { withFileTypes: true });
+      const entries = await readdir30(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -37548,7 +37888,7 @@ async function newestAssignmentMtime(projectDir) {
   let newest = 0;
   let entries;
   try {
-    entries = await readdir29(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir30(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -37580,7 +37920,7 @@ init_types();
 init_paths();
 init_assignment_walk();
 import { resolve as resolve84 } from "path";
-import { readFile as readFile53, readdir as readdir30 } from "fs/promises";
+import { readFile as readFile54, readdir as readdir31 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -37928,7 +38268,7 @@ var draftMissingObjective = {
       if (parsed.status !== "draft") continue;
       let raw2;
       try {
-        raw2 = await readFile53(path, "utf-8");
+        raw2 = await readFile54(path, "utf-8");
       } catch {
         continue;
       }
@@ -37965,12 +38305,12 @@ var readyToImplementMissingPlan = {
       const parsed = await parseSafe4(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir30(a.assignmentDir).catch(() => []);
+      const entries = await readdir31(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 readFile53(resolve84(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile54(resolve84(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -38013,7 +38353,7 @@ var assignmentChecks = [
 ];
 async function parseSafe4(path) {
   try {
-    const content = await readFile53(path, "utf-8");
+    const content = await readFile54(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -38176,7 +38516,7 @@ 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 readdir31, readFile as readFile54 } from "fs/promises";
+import { readdir as readdir32, readFile as readFile55 } from "fs/promises";
 import { homedir as homedir14 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -38239,7 +38579,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 readdir31(projectsDir2, { withFileTypes: true });
+    const entries = await readdir32(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 {
@@ -38261,7 +38601,7 @@ async function readKnownMarketplaces() {
   const path = resolve86(homedir14(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw2 = await readFile54(path, "utf-8");
+    const raw2 = await readFile55(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -38314,7 +38654,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile54(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile55(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -38387,7 +38727,7 @@ init_fs();
 init_parser();
 init_types();
 import { resolve as resolve87 } from "path";
-import { readFile as readFile55 } from "fs/promises";
+import { readFile as readFile56 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS2 = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 var BUNDLE_FIELDS = ["bundleId", "bundleScope", "bundleScopeId"];
@@ -38419,7 +38759,7 @@ async function loadContext(ctx) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw2 = await readFile55(path, "utf-8");
+    const raw2 = await readFile56(path, "utf-8");
     return { data: JSON.parse(raw2), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -38531,7 +38871,7 @@ var contextTerminal = {
     const assignmentMd = resolve87(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile55(assignmentMd, "utf-8");
+      const content = await readFile56(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -38677,7 +39017,7 @@ var agentChecks = [agentsResolvable];
 // src/utils/doctor/checks/terminal.ts
 init_config2();
 import { spawnSync as spawnSync9 } from "child_process";
-import { readFile as readFile56 } from "fs/promises";
+import { readFile as readFile57 } from "fs/promises";
 import { resolve as resolve88 } from "path";
 init_paths();
 init_fs();
@@ -38685,7 +39025,7 @@ var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
   const configPath2 = resolve88(syntaurRoot(), "config.md");
   if (!await fileExists(configPath2)) return null;
-  const content = await readFile56(configPath2, "utf-8");
+  const content = await readFile57(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));
@@ -38835,8 +39175,8 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve89, join as join18 } from "path";
-import { readdir as readdir32, readFile as readFile57, lstat as lstat4 } from "fs/promises";
+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";
 var CATEGORY10 = "skills";
 var skillTargets = [
@@ -38856,21 +39196,21 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir32(dir, { withFileTypes: true });
+        entries = await readdir33(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 = join18(dir, entry.name, "SKILL.md");
+        const skillMd = join19(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile57(skillMd, "utf-8").catch(() => "");
+        const content = await readFile58(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(join18(dir, entry.name))).isSymbolicLink();
+          isSymlink2 = (await lstat4(join19(dir, entry.name))).isSymbolicLink();
         } catch {
         }
         present.push({ name: entry.name, isSymlink: isSymlink2 });
@@ -38882,7 +39222,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(join18(dir, p.name));
+          for (const p of nonSymlink) affected.push(join19(dir, p.name));
         }
       }
     }
@@ -38915,12 +39255,12 @@ var skillsChecks = [skillsDedupCheck];
 
 // src/utils/doctor/checks/cross-agent.ts
 init_fs();
-import { join as join19, resolve as resolve90 } from "path";
-import { readFile as readFile59 } from "fs/promises";
+import { join as join20, resolve as resolve90 } from "path";
+import { readFile as readFile60 } from "fs/promises";
 
 // src/utils/skill-frontmatter.ts
 import { createHash as createHash4 } from "crypto";
-import { readFile as readFile58 } from "fs/promises";
+import { readFile as readFile59 } from "fs/promises";
 function stripQuotes(raw2) {
   const t = raw2.trim();
   if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
@@ -38964,7 +39304,7 @@ function readSkillIdentity(skillMdText) {
   return { name, hasDescription };
 }
 async function sha256File(path) {
-  return createHash4("sha256").update(await readFile58(path)).digest("hex");
+  return createHash4("sha256").update(await readFile59(path)).digest("hex");
 }
 
 // src/utils/doctor/checks/cross-agent.ts
@@ -38974,14 +39314,14 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
   const problems = [];
   let valid = 0;
   for (const skill of knownSkills) {
-    const installedPath = join19(installedDir, skill, "SKILL.md");
+    const installedPath = join20(installedDir, skill, "SKILL.md");
     if (!await fileExists(installedPath)) {
       problems.push({ skill, kind: "missing" });
       continue;
     }
     let text;
     try {
-      text = await readFile59(installedPath, "utf-8");
+      text = await readFile60(installedPath, "utf-8");
     } catch {
       problems.push({ skill, kind: "invalid-frontmatter" });
       continue;
@@ -38992,7 +39332,7 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
       continue;
     }
     valid++;
-    const canonicalPath2 = join19(canonicalSkillsDir, skill, "SKILL.md");
+    const canonicalPath2 = join20(canonicalSkillsDir, skill, "SKILL.md");
     if (await fileExists(canonicalPath2)) {
       const [installedHash, canonicalHash] = await Promise.all([
         sha256File(installedPath),
@@ -39067,7 +39407,7 @@ var crossAgentSkillsCheck = {
       }
       if (t.tier3) {
         const installDir = t.tier3.installDir();
-        const installed2 = await fileExists(join19(installDir, t.tier3.entry));
+        const installed2 = await fileExists(join20(installDir, t.tier3.entry));
         lines.push(
           `${t.displayName}: Tier-3 ${t.tier3.kind} ${installed2 ? "installed" : "absent"} (${installDir})`
         );
@@ -39135,7 +39475,7 @@ var crossAgentChecks = [crossAgentSkillsCheck];
 init_fs();
 init_paths();
 import { resolve as resolve91 } from "path";
-import { readdir as readdir33 } from "fs/promises";
+import { readdir as readdir34 } from "fs/promises";
 import { spawnSync as spawnSync10 } from "child_process";
 init_parser2();
 var CATEGORY12 = "bundles";
@@ -39143,7 +39483,7 @@ async function listScopes(ctx) {
   const out = [];
   const td = todosDir();
   if (await fileExists(td)) {
-    const entries = await readdir33(td).catch(() => []);
+    const entries = await readdir34(td).catch(() => []);
     for (const f of entries) {
       if (typeof f !== "string") continue;
       if (!f.endsWith(".md") || f.endsWith("-log.md")) continue;
@@ -39159,7 +39499,7 @@ async function listScopes(ctx) {
     }
   }
   if (await fileExists(ctx.config.defaultProjectDir)) {
-    const projectEntries = await readdir33(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
+    const projectEntries = await readdir34(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
     for (const e of projectEntries) {
       if (!e.isDirectory()) continue;
       const slug = e.name;
@@ -39357,8 +39697,8 @@ var bundleChecks = [
 ];
 
 // src/utils/doctor/checks/plugin.ts
-import { readFile as readFile60 } from "fs/promises";
-import { dirname as dirname24, join as join20 } from "path";
+import { readFile as readFile61 } from "fs/promises";
+import { dirname as dirname24, join as join21 } from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 var CATEGORY13 = "plugin";
 var PLUGIN_KINDS = ["claude", "codex"];
@@ -39367,7 +39707,7 @@ async function readCliVersion() {
     let dir = dirname24(fileURLToPath11(import.meta.url));
     for (let i = 0; i < 8; i += 1) {
       try {
-        const parsed = JSON.parse(await readFile60(join20(dir, "package.json"), "utf-8"));
+        const parsed = JSON.parse(await readFile61(join21(dir, "package.json"), "utf-8"));
         if (typeof parsed.version === "string" && parsed.version.length > 0) return parsed.version;
       } catch {
       }
@@ -39478,7 +39818,7 @@ var deriveConfigChecks = [deriveConfigValid];
 // src/utils/doctor/checks/staleness.ts
 init_config2();
 import { resolve as resolve92 } from "path";
-import { readFile as readFile61 } from "fs/promises";
+import { readFile as readFile62 } from "fs/promises";
 var CATEGORY15 = "staleness";
 var stalenessConfigValid = {
   id: "staleness.valid",
@@ -39487,7 +39827,7 @@ var stalenessConfigValid = {
   async run(ctx) {
     let content;
     try {
-      content = await readFile61(resolve92(ctx.syntaurRoot, "config.md"), "utf-8");
+      content = await readFile62(resolve92(ctx.syntaurRoot, "config.md"), "utf-8");
     } catch {
       return {
         id: this.id,
@@ -39640,7 +39980,7 @@ async function readVersion() {
     let dir = dirname25(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw2 = await readFile62(join21(dir, "package.json"), "utf-8");
+        const raw2 = await readFile63(join22(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw2);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
@@ -39750,7 +40090,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile63(absolute, "utf-8");
+    content = await readFile64(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -39876,6 +40216,7 @@ note: ${FIX_NOOP_NOTE}
 
 // src/commands/agents.ts
 init_config2();
+init_paths();
 import { Command as Command5 } from "commander";
 var agentsCommand = new Command5("agents").description(
   "Manage configurable agents used by `syntaur browse` and future launch flows"
@@ -39894,6 +40235,8 @@ agentsCommand.command("list").description("List configured agents (or built-in d
       if (agent.model) flags.push(`model=${agent.model}`);
       if (agent.playbook) flags.push(`playbook=${agent.playbook}`);
       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)}`);
       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}`);
@@ -39902,7 +40245,7 @@ agentsCommand.command("list").description("List configured agents (or built-in d
     reportAndExit(error);
   }
 });
-agentsCommand.command("add").description("Add a new agent to ~/.syntaur/config.md").requiredOption("--id <id>", "Agent id (slug)").requiredOption("--label <label>", "Display label").requiredOption("--command <command>", "Absolute path or bare binary name").option("--args <csv>", "Comma-separated default args").option("--prompt-arg-position <position>", "first | last | none").option("--default", "Mark this agent as the default launch target").option("--resolve-from-shell-aliases", "Run via $SHELL -i -c (for shell aliases)").option("--model <model>", "LLM model injected as --model <value> at launch").option("--playbook <slug>", "Playbook slug to run end-to-end on a fresh launch").option("--launch-prompt <text>", "Editable launch prompt with @assignment / @<playbook> tokens").option("--dry-run", "Validate and print the proposed config without writing").action(async (options) => {
+agentsCommand.command("add").description("Add a new agent to ~/.syntaur/config.md").requiredOption("--id <id>", "Agent id (slug)").requiredOption("--label <label>", "Display label").requiredOption("--command <command>", "Absolute path or bare binary name").option("--args <csv>", "Comma-separated default args").option("--prompt-arg-position <position>", "first | last | none").option("--default", "Mark this agent as the default launch target").option("--resolve-from-shell-aliases", "Run via $SHELL -i -c (for shell aliases)").option("--model <model>", "LLM model injected as --model <value> at launch").option("--playbook <slug>", "Playbook slug to run end-to-end on a fresh launch").option("--launch-prompt <text>", "Editable launch prompt with @assignment / @worktree / @<playbook> tokens").option("--agent-name <name>", "Claude agent identity injected as --agent <name> (Claude-compatible runners)").option("--workdir <path>", "Launch cwd override for directory-agents (pi/codex); mutually exclusive with --agent-name").option("--dry-run", "Validate and print the proposed config without writing").action(async (options) => {
   try {
     const agent = buildAgentFromOptions(options, null);
     const mutation = {
@@ -39942,7 +40285,7 @@ agentsCommand.command("remove <id>").description("Remove an agent from ~/.syntau
     reportAndExit(error);
   }
 });
-agentsCommand.command("set <id>").description("Update one or more fields on an existing agent").option("--label <label>", "Display label").option("--command <command>", "Absolute path or bare binary name").option("--args <csv>", "Comma-separated default args").option("--prompt-arg-position <position>", "first | last | none").option("--default", "Mark this agent as the default (clears any prior default)").option("--no-default", "Unset the default flag on this agent").option("--resolve-from-shell-aliases", "Run via $SHELL -i -c (for shell aliases)").option("--no-resolve-from-shell-aliases", "Disable shell-alias resolution for this agent").option("--model <model>", "LLM model injected as --model <value> (empty string clears)").option("--playbook <slug>", "Playbook slug to run on a fresh launch (empty string clears)").option("--launch-prompt <text>", "Editable launch prompt with @-tokens (empty string clears)").option("--dry-run", "Validate and print the proposed config without writing").action(async (id, options) => {
+agentsCommand.command("set <id>").description("Update one or more fields on an existing agent").option("--label <label>", "Display label").option("--command <command>", "Absolute path or bare binary name").option("--args <csv>", "Comma-separated default args").option("--prompt-arg-position <position>", "first | last | none").option("--default", "Mark this agent as the default (clears any prior default)").option("--no-default", "Unset the default flag on this agent").option("--resolve-from-shell-aliases", "Run via $SHELL -i -c (for shell aliases)").option("--no-resolve-from-shell-aliases", "Disable shell-alias resolution for this agent").option("--model <model>", "LLM model injected as --model <value> (empty string clears)").option("--playbook <slug>", "Playbook slug to run on a fresh launch (empty string clears)").option("--launch-prompt <text>", "Editable launch prompt with @-tokens (empty string clears)").option("--agent-name <name>", "Claude agent identity injected as --agent <name> (empty string clears)").option("--workdir <path>", "Launch cwd override for directory-agents (empty string clears)").option("--dry-run", "Validate and print the proposed config without writing").action(async (id, options) => {
   try {
     const mutation = {
       kind: "set",
@@ -40003,6 +40346,36 @@ agentsCommand.command("reorder <ids>").description("Reorder agents (comma-separa
     reportAndExit(error);
   }
 });
+agentsCommand.command("launch <id>").description("Launch a directory-agent standalone (no assignment) from its workdir").option("--prompt <text>", "One-shot launch prompt override for this launch only").option("--cwd <path>", "Override the agent workdir for this launch only").action(async (id, options) => {
+  try {
+    const config = await readConfig();
+    const agents = getAgents(config);
+    const agent = agents.find((a) => a.id === id);
+    if (!agent) {
+      throw new AgentConfigError(`unknown agent id "${id}"`);
+    }
+    let effectiveConfig = config;
+    if (options.cwd !== void 0) {
+      const cloned = { ...agent, workdir: expandHome(options.cwd) };
+      effectiveConfig = { ...config, agents: agents.map((a) => a.id === id ? cloned : a) };
+    }
+    const projectsDir2 = config.defaultProjectDir || defaultProjectDir();
+    const plan = await resolveLaunchPlan({
+      kind: "standalone",
+      id,
+      agentId: id,
+      config: effectiveConfig,
+      projectsDir: projectsDir2,
+      assignmentsDir: assignmentsDir(),
+      promptOverride: options.prompt
+    });
+    if (plan.shellFallbackWarning) console.error(plan.shellFallbackWarning);
+    for (const warning of plan.promptWarnings ?? []) console.error(warning);
+    await executeLaunchPlan(plan);
+  } catch (error) {
+    reportAndExit(error);
+  }
+});
 function buildAgentFromOptions(options, existing) {
   const agent = {
     id: options.id,
@@ -40019,6 +40392,8 @@ function buildAgentFromOptions(options, existing) {
   if (options.model && options.model.trim()) agent.model = options.model.trim();
   if (options.playbook && options.playbook.trim()) agent.playbook = options.playbook.trim();
   if (options.launchPrompt && options.launchPrompt.trim()) agent.launchPrompt = options.launchPrompt;
+  if (options.agentName && options.agentName.trim()) agent.agentName = options.agentName.trim();
+  if (options.workdir && options.workdir.trim()) agent.workdir = options.workdir.trim();
   validateAgentList([...existing ? [] : [], agent]);
   return agent;
 }
@@ -40054,6 +40429,16 @@ function mergeOptionsIntoAgent(existing, options) {
     if (options.launchPrompt.trim()) merged.launchPrompt = options.launchPrompt;
     else delete merged.launchPrompt;
   }
+  if (options.agentName !== void 0) {
+    const agentName = options.agentName.trim();
+    if (agentName) merged.agentName = agentName;
+    else delete merged.agentName;
+  }
+  if (options.workdir !== void 0) {
+    const workdir = options.workdir.trim();
+    if (workdir) merged.workdir = workdir;
+    else delete merged.workdir;
+  }
   return merged;
 }
 function parseArgsCsv(csv) {
@@ -40094,6 +40479,8 @@ function formatAgentLine(a) {
   if (a.model) flags.push(`model=${a.model}`);
   if (a.playbook) flags.push(`playbook=${a.playbook}`);
   if (a.launchPrompt) flags.push(`launchPrompt=${a.launchPrompt}`);
+  if (a.agentName) flags.push(`agentName=${a.agentName}`);
+  if (a.workdir) flags.push(`workdir=${a.workdir}`);
   if (a.args && a.args.length > 0) flags.push(`args=[${a.args.join(", ")}]`);
   const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
   return `${a.id}: ${a.label} \u2192 ${a.command}${suffix}`;
@@ -40118,7 +40505,7 @@ init_frontmatter();
 init_event_emit();
 init_templates();
 import { resolve as resolve94 } from "path";
-import { readFile as readFile64 } from "fs/promises";
+import { readFile as readFile65 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -40167,7 +40554,7 @@ async function commentCommand(target, text, options = {}) {
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile64(commentsPath, "utf-8");
+    currentContent = await readFile65(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -40197,7 +40584,7 @@ ${entry}`;
   try {
     const assignmentMd = resolve94(assignmentDir, "assignment.md");
     if (await fileExists(assignmentMd)) {
-      const fm = parseAssignmentFrontmatter(await readFile64(assignmentMd, "utf-8"));
+      const fm = parseAssignmentFrontmatter(await readFile65(assignmentMd, "utf-8"));
       emitEvent({
         assignmentId: fm.id,
         projectSlug,
@@ -40233,7 +40620,7 @@ init_fs();
 import { spawn as spawn8 } from "child_process";
 import { mkdtemp as mkdtemp2, rm as rm10, stat as stat12 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function argsFor(mode, pngPath) {
   switch (mode) {
     case "interactive":
@@ -40266,8 +40653,8 @@ async function captureScreenshot(mode) {
       "screencapture is only available on macOS. Use --file <path> to attach an existing image."
     );
   }
-  const tmpDir = await mkdtemp2(join22(tmpdir3(), "syntaur-screenshot-"));
-  const pngPath = join22(tmpDir, "shot.png");
+  const tmpDir = await mkdtemp2(join23(tmpdir3(), "syntaur-screenshot-"));
+  const pngPath = join23(tmpDir, "shot.png");
   const cleanup = async () => {
     await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -40305,9 +40692,9 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn9 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile65, rm as rm11 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile66, rm as rm11 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
 function shellQuote2(s) {
   if (s.length === 0) return `''`;
@@ -40344,8 +40731,8 @@ function runAsciinema(args, stdio) {
   });
 }
 async function captureAsciinema(opts) {
-  const tmpDir = await mkdtemp3(join23(tmpdir4(), "syntaur-asciinema-"));
-  const castPath = join23(tmpDir, "session.cast");
+  const tmpDir = await mkdtemp3(join24(tmpdir4(), "syntaur-asciinema-"));
+  const castPath = join24(tmpDir, "session.cast");
   const cleanup = async () => {
     await rm11(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -40368,7 +40755,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile65(castPath, "utf8").catch(() => null);
+    const text = await readFile66(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.`
@@ -40396,9 +40783,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 readFile66, rm as rm12, stat as stat13, unlink as unlink12, writeFile as writeFile14 } from "fs/promises";
+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 { tmpdir as tmpdir5 } from "os";
-import { join as join24, resolve as resolve95 } from "path";
+import { join as join25, resolve as resolve95 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
   const raw2 = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
@@ -40470,7 +40857,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile66(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile67(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);
@@ -40523,8 +40910,8 @@ async function startRecording(input4) {
   let acquiredPid = null;
   try {
     logHandle = await open6(log, "w");
-    tmpDir = await mkdtemp4(join24(tmpdir5(), "syntaur-recording-"));
-    const mp4Path = join24(tmpDir, "recording.mp4");
+    tmpDir = await mkdtemp4(join25(tmpdir5(), "syntaur-recording-"));
+    const mp4Path = join25(tmpDir, "recording.mp4");
     let child;
     try {
       child = spawn10("ffmpeg", ffmpegArgs(input4.device, input4.fps, mp4Path), {
@@ -40572,7 +40959,7 @@ async function startRecording(input4) {
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile66(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile67(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}
@@ -40629,7 +41016,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile66(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile67(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -40639,7 +41026,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile66(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile67(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.`
@@ -40772,9 +41159,9 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn11 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile67, rm as rm13 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile68, rm as rm13 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join25 } from "path";
+import { join as join26 } 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",
@@ -40836,7 +41223,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile67(wavPath);
+  const audio = await readFile68(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -40864,8 +41251,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(join25(tmpdir6(), "syntaur-transcribe-"));
-    const wav = join25(tmp, "audio.wav");
+    const tmp = await mkdtemp5(join26(tmpdir6(), "syntaur-transcribe-"));
+    const wav = join26(tmp, "audio.wav");
     try {
       await extractAudio(videoAbsPath, wav);
       return await callScribe(wav, apiKey, opts);
@@ -41309,7 +41696,7 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile68, writeFile as writeFile16, rename as rename10, stat as stat15 } from "fs/promises";
+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 { randomBytes as randomBytes4 } from "crypto";
 
@@ -41554,7 +41941,7 @@ async function readAssignmentMeta(assignmentDir) {
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile68(path, "utf-8");
+  const content = await readFile69(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -41616,7 +42003,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       continue;
     }
     try {
-      out.set(r.file_path, await readFile68(abs, "utf-8"));
+      out.set(r.file_path, await readFile69(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -41635,7 +42022,7 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
     const st = await stat15(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile68(sidecar, "utf-8"));
+      out.set(r.id, await readFile69(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -42531,7 +42918,7 @@ init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
 import { resolve as resolve100 } from "path";
-import { readFile as readFile69 } from "fs/promises";
+import { readFile as readFile70 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -42562,7 +42949,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 readFile69(assignmentMdPath2, "utf-8");
+  let content = await readFile70(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -42577,7 +42964,7 @@ init_paths();
 init_config2();
 init_recompute();
 import { Command as Command10 } from "commander";
-import { readFile as readFile70, readdir as readdir34 } from "fs/promises";
+import { readFile as readFile71, readdir as readdir35 } from "fs/promises";
 import { resolve as resolve101 } from "path";
 init_session_id();
 async function resolveAssignmentDir(opts) {
@@ -42604,7 +42991,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir34(assignmentDir, { withFileTypes: true });
+  const entries = await readdir35(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -42799,7 +43186,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 readFile70(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile71(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));
@@ -42836,11 +43223,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 readFile70(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile71(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 readFile70(oldPlanPath, "utf-8");
+  const oldPlanContent = await readFile71(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -42911,7 +43298,7 @@ init_cwd();
 init_session_db();
 init_agent_sessions();
 import { Command as Command11 } from "commander";
-import { readFile as readFile71, readdir as readdir35, stat as stat16 } from "fs/promises";
+import { readFile as readFile72, readdir as readdir36, stat as stat16 } from "fs/promises";
 import { resolve as resolve102 } from "path";
 init_engagement_db();
 init_parser();
@@ -42919,7 +43306,7 @@ async function readContext(cwd) {
   const path = resolve102(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile71(path, "utf-8");
+    const raw2 = await readFile72(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -42928,7 +43315,7 @@ async function readContext(cwd) {
 async function findLatestSessionSummary(assignmentDir) {
   const sessionsRoot = resolve102(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir35(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir36(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -42944,7 +43331,7 @@ async function findLatestSessionSummary(assignmentDir) {
 async function findOpenHandoff(assignmentDir) {
   const handoffPath = resolve102(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile71(handoffPath, "utf-8");
+  const content = await readFile72(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;
@@ -42954,7 +43341,7 @@ async function readAssignmentTitle(assignmentDir) {
   const path = resolve102(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile71(path, "utf-8");
+    const content = await readFile72(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "title");
   } catch {
@@ -43171,13 +43558,13 @@ async function runSessionSave(options, cwd = process.cwd(), body) {
   const now = nowTimestamp();
   let created = now;
   if (await fileExists(summaryPath)) {
-    const existing = await readFile71(summaryPath, "utf-8");
+    const existing = await readFile72(summaryPath, "utf-8");
     created = extractCreated(existing) ?? now;
   }
   let sectionBody2 = body;
   if (sectionBody2 === void 0) {
     if (options.fromFile) {
-      sectionBody2 = await readFile71(resolve102(cwd, options.fromFile), "utf-8");
+      sectionBody2 = await readFile72(resolve102(cwd, options.fromFile), "utf-8");
     } else {
       sectionBody2 = await readStdin();
     }
@@ -43405,7 +43792,7 @@ sessionCommand.command("boundary").description(
 // src/commands/worktree.ts
 init_git_worktree();
 import { Command as Command12 } from "commander";
-import { readFile as readFile72 } from "fs/promises";
+import { readFile as readFile73 } from "fs/promises";
 import { resolve as resolve103 } from "path";
 init_fs();
 init_paths();
@@ -43495,7 +43882,7 @@ async function runWorktreeRemove(options, cwd = process.cwd()) {
   if (!await fileExists(assignmentPath)) {
     throw new Error(`Assignment file not found: ${assignmentPath}`);
   }
-  const original = await readFile72(assignmentPath, "utf-8");
+  const original = await readFile73(assignmentPath, "utf-8");
   const fm = parseAssignmentFrontmatter(original);
   const repository = options.repository ?? fm.workspace.repository ?? void 0;
   const worktreePath = fm.workspace.worktreePath ?? void 0;
@@ -43561,7 +43948,7 @@ async function runWorktreeGc(options, cwd = process.cwd()) {
   const owners = /* @__PURE__ */ new Map();
   for (const entry of walk.withAssignmentMd) {
     try {
-      const content = await readFile72(resolve103(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile73(resolve103(entry.assignmentDir, "assignment.md"), "utf-8");
       const fm = parseAssignmentFrontmatter(content);
       const wp = fm.workspace?.worktreePath;
       if (!wp) continue;
@@ -43802,7 +44189,7 @@ worktreeCommand.command("gc").description(
 // src/commands/open.ts
 init_fs();
 import { Command as Command13 } from "commander";
-import { readFile as readFile73 } from "fs/promises";
+import { readFile as readFile74 } from "fs/promises";
 import { resolve as resolve104 } from "path";
 init_frontmatter();
 init_config2();
@@ -43868,7 +44255,7 @@ async function runOpen(assignmentArg, options) {
       remediation: "check the assignment slug or --id"
     });
   }
-  const fm = parseAssignmentFrontmatter(await readFile73(assignmentPath, "utf-8"));
+  const fm = parseAssignmentFrontmatter(await readFile74(assignmentPath, "utf-8"));
   const worktreePath = fm.workspace?.worktreePath;
   if (!worktreePath) {
     throw new SyntaurError("No worktree recorded for this assignment.", {
@@ -43934,12 +44321,12 @@ init_fs();
 init_slug();
 import { Command as Command14 } from "commander";
 import { resolve as resolve106 } from "path";
-import { readFile as readFile75, readdir as readdir37, rm as rm15 } from "fs/promises";
+import { readFile as readFile76, readdir as readdir38, rm as rm15 } from "fs/promises";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir36, readFile as readFile74 } from "fs/promises";
+import { readdir as readdir37, readFile as readFile75 } from "fs/promises";
 import { resolve as resolve105 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -43949,7 +44336,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir36(dir, { withFileTypes: true });
+  const entries = await readdir37(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -43975,7 +44362,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile74(resolve105(dir, fileName), "utf-8");
+    const content = await readFile75(resolve105(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -44006,7 +44393,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile74(resolve105(dir, fileName), "utf-8");
+    const content = await readFile75(resolve105(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -44113,7 +44500,7 @@ async function runResourceAdd(options) {
 async function listResourceSlugs(projectDir) {
   const dir = resolve106(projectDir, "resources");
   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 !== "_index.md").map((e) => e.name.slice(0, -3)).sort();
 }
 async function runResourceList(project) {
@@ -44121,7 +44508,7 @@ async function runResourceList(project) {
   const slugs = await listResourceSlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseResource(await readFile75(resolve106(projectDir, "resources", `${slug}.md`), "utf-8"));
+    const parsed = parseResource(await readFile76(resolve106(projectDir, "resources", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, category: parsed.category, source: parsed.source, updated: parsed.updated });
   }
   return out;
@@ -44130,7 +44517,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 readFile75(filePath, "utf-8"));
+  const parsed = parseResource(await readFile76(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -44151,7 +44538,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 readFile75(filePath, "utf-8");
+  const original = await readFile76(filePath, "utf-8");
   const content = editResourceFrontmatter(original, {
     name: options.name,
     category: options.category,
@@ -44248,7 +44635,7 @@ init_fs();
 init_slug();
 import { Command as Command15 } from "commander";
 import { resolve as resolve107 } from "path";
-import { readFile as readFile76, readdir as readdir38, rm as rm16 } from "fs/promises";
+import { readFile as readFile77, readdir as readdir39, rm as rm16 } from "fs/promises";
 init_parser();
 function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -44346,7 +44733,7 @@ async function runMemoryAdd(options) {
 async function listMemorySlugs(projectDir) {
   const dir = resolve107(projectDir, "memories");
   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 runMemoryList(project) {
@@ -44354,7 +44741,7 @@ async function runMemoryList(project) {
   const slugs = await listMemorySlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseMemory(await readFile76(resolve107(projectDir, "memories", `${slug}.md`), "utf-8"));
+    const parsed = parseMemory(await readFile77(resolve107(projectDir, "memories", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, scope: parsed.scope, source: parsed.source, updated: parsed.updated });
   }
   return out;
@@ -44363,7 +44750,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 readFile76(filePath, "utf-8"));
+  const parsed = parseMemory(await readFile77(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -44387,7 +44774,7 @@ async function runMemoryUpdate(slug, options) {
       "Provide at least one of --name, --source, --scope, --source-assignment, --related-assignments."
     );
   }
-  const original = await readFile76(filePath, "utf-8");
+  const original = await readFile77(filePath, "utf-8");
   const content = editMemoryFrontmatter(original, {
     name: options.name,
     source: options.source,
@@ -44490,7 +44877,7 @@ init_derive();
 init_recompute();
 init_query();
 import { Command as Command16 } from "commander";
-import { readFile as readFile77 } from "fs/promises";
+import { readFile as readFile78 } from "fs/promises";
 import { dirname as dirname29, resolve as resolve108 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
@@ -44524,7 +44911,7 @@ async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile77(path, "utf-8");
+    const content = await readFile78(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -44588,7 +44975,7 @@ async function loadQueryItem(item, terminalStatuses3, now, declarations) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile77(path, "utf-8");
+    const content = await readFile78(path, "utf-8");
     const fm = parseAssignmentFrontmatter(content);
     const body = content.replace(/^---\n[\s\S]*?\n---/, "");
     const assignmentDir = dirname29(path);
@@ -45367,7 +45754,7 @@ init_fs();
 init_timestamp();
 init_frontmatter();
 import { Command as Command21 } from "commander";
-import { readFile as readFile78 } from "fs/promises";
+import { readFile as readFile79 } from "fs/promises";
 import { resolve as resolve109 } from "path";
 function renameAssignmentStatusRefs(content, id, newId, now) {
   const fm = parseAssignmentFrontmatter(content);
@@ -45394,7 +45781,7 @@ function configPath() {
 async function readStatusBlock() {
   const p = configPath();
   if (!await fileExists(p)) return null;
-  const content = await readFile78(p, "utf-8");
+  const content = await readFile79(p, "utf-8");
   return parseStatusConfig(content);
 }
 async function requireStatusBlock() {
@@ -45678,7 +46065,7 @@ async function runStatusRename(id, opts) {
     printBlockDiff(before, after);
     const now2 = nowTimestamp();
     for (const a of affected) {
-      const original = await readFile78(a.path, "utf-8");
+      const original = await readFile79(a.path, "utf-8");
       const rewritten = renameAssignmentStatusRefs(original, id, newId, now2);
       console.log(`
 --- ${a.display}/assignment.md`);
@@ -45689,9 +46076,9 @@ async function runStatusRename(id, opts) {
   }
   const cfgPath = configPath();
   const buffers = /* @__PURE__ */ new Map();
-  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile78(cfgPath, "utf-8") : "");
+  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile79(cfgPath, "utf-8") : "");
   for (const a of affected) {
-    buffers.set(a.path, await readFile78(a.path, "utf-8"));
+    buffers.set(a.path, await readFile79(a.path, "utf-8"));
   }
   const now = nowTimestamp();
   try {
@@ -45893,7 +46280,7 @@ init_config2();
 init_timestamp();
 init_frontmatter();
 import { Command as Command22 } from "commander";
-import { readFile as readFile79 } from "fs/promises";
+import { readFile as readFile80 } from "fs/promises";
 import { resolve as resolve110 } from "path";
 init_session_id();
 async function resolveAssignmentPath3(opts) {
@@ -45949,7 +46336,7 @@ async function runWorkspaceSet(options, cwd = process.cwd()) {
 ${pre.errors.map((e) => `  - ${e}`).join("\n")}`
     );
   }
-  const original = await readFile79(path, "utf-8");
+  const original = await readFile80(path, "utf-8");
   let next = updateAssignmentWorkspace(original, partial);
   next = updateAssignmentFile(next, { updated: nowTimestamp() });
   await writeFileForce(path, next);
@@ -45986,7 +46373,7 @@ init_config2();
 init_timestamp();
 init_templates();
 import { Command as Command23 } from "commander";
-import { readFile as readFile80 } from "fs/promises";
+import { readFile as readFile81 } from "fs/promises";
 import { resolve as resolve111 } from "path";
 init_session_id();
 async function resolveAssignmentDir2(opts) {
@@ -46070,7 +46457,7 @@ async function runProgressLog(text, options, cwd = process.cwd()) {
   }
   const path = resolve111(dir, "progress.md");
   const now = nowTimestamp();
-  const content = await fileExists(path) ? await readFile80(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
+  const content = await fileExists(path) ? await readFile81(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
   const next = appendProgressEntry(content, text, now);
   await writeFileForce(path, next);
   return path;
@@ -46090,10 +46477,10 @@ progressCommand.command("log").description("Append a timestamped entry to the as
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir39 } from "fs/promises";
+import { readdir as readdir40 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir39(projectsDir2, { withFileTypes: true });
+    const entries = await readdir40(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;