syntaur 0.32.0 → 0.34.0

package/dist/index.js

@@ -2760,9 +2760,9 @@ function normalizeAgentsFromConfig(agents) {
     validateAgentList(normalized);
     return normalized;
   } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
     console.warn(
-      `Warning: ~/.syntaur/config.md agents block is invalid (${msg}) \u2014 using built-in defaults`
+      `Warning: ~/.syntaur/config.md agents block is invalid (${msg2}) \u2014 using built-in defaults`
     );
     return null;
   }
@@ -3152,8 +3152,8 @@ async function readConfig() {
       try {
         return parseTerminalConfig(fm["terminal"]);
       } catch (err2) {
-        const msg = err2 instanceof TerminalConfigError ? err2.message : String(err2);
-        console.warn(`Warning: ${msg} \u2014 falling back to default`);
+        const msg2 = err2 instanceof TerminalConfigError ? err2.message : String(err2);
+        console.warn(`Warning: ${msg2} \u2014 falling back to default`);
         return null;
       }
     })(),
@@ -5382,8 +5382,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile63 } = await import("fs/promises");
-  const raw2 = await readFile63(filePath, "utf-8");
+  const { readFile: readFile64 } = await import("fs/promises");
+  const raw2 = await readFile64(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -5819,8 +5819,8 @@ function scanKey(serversDir2, projectsDir2, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir2}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve86) => {
-    const timer2 = setTimeout(resolve86, ms);
+  return new Promise((resolve87) => {
+    const timer2 = setTimeout(resolve87, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -8802,7 +8802,7 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath9, pathToFileURL } from "url";
-import { dirname as dirname17, resolve as resolve50, join as join9 } from "path";
+import { dirname as dirname18, resolve as resolve51, join as join10 } from "path";
 import { homedir as homedir9, tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
 function syntaurRootMjs() {
@@ -8810,7 +8810,7 @@ function syntaurRootMjs() {
   if (override && override.length > 0) {
     return override;
   }
-  return join9(homedir9(), ".syntaur");
+  return join10(homedir9(), ".syntaur");
 }
 async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   const { throwOnFailure } = options;
@@ -8824,38 +8824,38 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   }
   const stateRoot = syntaurRootMjs();
   mkdirSync2(stateRoot, { recursive: true });
-  const lockPath = resolve50(stateRoot, "install-url-handler.lock");
+  const lockPath = resolve51(stateRoot, "install-url-handler.lock");
   let lockFd;
   try {
     lockFd = openSync(lockPath, "wx");
   } catch (err2) {
     if (err2 && err2.code === "EEXIST") {
-      const msg = `Another syntaur:// handler registration is in progress (lock at ${lockPath}). Wait for it to finish or remove the stale lock.`;
+      const msg2 = `Another syntaur:// handler registration is in progress (lock at ${lockPath}). Wait for it to finish or remove the stale lock.`;
       if (throwOnFailure) {
-        throw new Error(msg);
+        throw new Error(msg2);
       }
-      console.warn(`syntaur: skipping macOS URL-handler registration (${msg})`);
+      console.warn(`syntaur: skipping macOS URL-handler registration (${msg2})`);
       return { bundlePath: "" };
     }
     throw err2;
   }
   try {
-    const pkgRoot = resolve50(dirname17(fileURLToPath9(import.meta.url)), "..");
-    const cliBin = realpathSync3(resolve50(pkgRoot, "bin/syntaur.js"));
+    const pkgRoot = resolve51(dirname18(fileURLToPath9(import.meta.url)), "..");
+    const cliBin = realpathSync3(resolve51(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
-    const bundleParent = join9(
+    const bundleParent = join10(
       homedir9(),
       "Library",
       "Application Support",
       "Syntaur"
     );
-    const bundlePath = join9(bundleParent, "syntaur-url.app");
+    const bundlePath = join10(bundleParent, "syntaur-url.app");
     mkdirSync2(bundleParent, { recursive: true });
     if (existsSync5(bundlePath)) {
       rmSync(bundlePath, { recursive: true, force: true });
     }
     const installedTerminals = detectInstalledTerminals();
-    const scriptPath = join9(
+    const scriptPath = join10(
       tmpdir2(),
       `syntaur-url-handler-${process.pid}.applescript`
     );
@@ -8874,7 +8874,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
         `osacompile exited with code ${compile.status}: ${compile.stderr || compile.stdout}`
       );
     }
-    const infoPlistPath = join9(bundlePath, "Contents", "Info.plist");
+    const infoPlistPath = join10(bundlePath, "Contents", "Info.plist");
     if (!existsSync5(infoPlistPath)) {
       throw new Error(`osacompile did not produce ${infoPlistPath}`);
     }
@@ -8914,23 +8914,23 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
       { stdio: "pipe", encoding: "utf-8" }
     );
     if (sign.status !== 0) {
-      const msg = `codesign returned ${sign.status} while re-signing ${bundlePath}: ${sign.stderr || sign.stdout || "(no output)"}`;
+      const msg2 = `codesign returned ${sign.status} while re-signing ${bundlePath}: ${sign.stderr || sign.stdout || "(no output)"}`;
       if (throwOnFailure) {
-        throw new Error(msg);
+        throw new Error(msg2);
       }
-      console.warn(`syntaur: ${msg} \u2014 macOS may deny Automation permission.`);
+      console.warn(`syntaur: ${msg2} \u2014 macOS may deny Automation permission.`);
     }
     const ls = spawnSync7(LSREGISTER, ["-f", bundlePath], {
       stdio: "pipe",
       encoding: "utf-8"
     });
     if (ls.status !== 0) {
-      const msg = `lsregister returned ${ls.status} while registering ${bundlePath}: ${ls.stderr || ls.stdout || "(no output)"}`;
+      const msg2 = `lsregister returned ${ls.status} while registering ${bundlePath}: ${ls.stderr || ls.stdout || "(no output)"}`;
       if (throwOnFailure) {
-        throw new Error(msg);
+        throw new Error(msg2);
       }
       console.warn(
-        `syntaur: ${msg} \u2014 \`open syntaur://...\` may not route through the CLI handler until you run \`${LSREGISTER} -f ${bundlePath}\` manually.`
+        `syntaur: ${msg2} \u2014 \`open syntaur://...\` may not route through the CLI handler until you run \`${LSREGISTER} -f ${bundlePath}\` manually.`
       );
     }
     try {
@@ -8953,8 +8953,8 @@ async function main() {
   try {
     await registerMacosUrlHandler({ throwOnFailure: false });
   } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
-    console.warn(`syntaur: skipping macOS URL-handler registration (${msg})`);
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
+    console.warn(`syntaur: skipping macOS URL-handler registration (${msg2})`);
   }
 }
 function detectInstalledTerminals() {
@@ -8969,7 +8969,7 @@ function detectInstalledTerminals() {
     ghostty: "Ghostty.app",
     warp: "Warp.app"
   };
-  const appDirs = ["/Applications", join9(homedir9(), "Applications")];
+  const appDirs = ["/Applications", join10(homedir9(), "Applications")];
   for (const [id, bundleId] of Object.entries(bundleIds)) {
     const r = spawnSync7(
       "mdfind",
@@ -8981,7 +8981,7 @@ function detectInstalledTerminals() {
       continue;
     }
     const name = bundleNames[id];
-    if (name && appDirs.some((dir) => existsSync5(join9(dir, name)))) {
+    if (name && appDirs.some((dir) => existsSync5(join10(dir, name)))) {
       installed.add(id);
     }
   }
@@ -10431,6 +10431,10 @@ var TABLE_COLUMN_IDS = [
 function isTableColumnId(value) {
   return typeof value === "string" && TABLE_COLUMN_IDS.includes(value);
 }
+var WIDGET_SIZES = ["small", "wide", "tall", "large"];
+function isWidgetSize(value) {
+  return typeof value === "string" && WIDGET_SIZES.includes(value);
+}
 var DEFAULT_FILTERS = {
   status: "all",
   priority: "all",
@@ -10523,6 +10527,7 @@ function isDashboardSlot(value) {
   if (!value || typeof value !== "object") return false;
   const obj = value;
   if (typeof obj.id !== "string" || obj.id.length === 0) return false;
+  if (obj.size !== void 0 && !isWidgetSize(obj.size)) return false;
   if (obj.widget === null) return true;
   return isWidgetConfig(obj.widget);
 }
@@ -10753,7 +10758,10 @@ function validateDashboardBody(body) {
     return { ok: false, error: "slots must be an array" };
   }
   if (!obj.slots.every(isDashboardSlot)) {
-    return { ok: false, error: "every slot must be { id: string, widget: WidgetConfig | null }" };
+    return {
+      ok: false,
+      error: "every slot must be { id: string, widget: WidgetConfig | null, size?: WidgetSize }"
+    };
   }
   return { ok: true, value: obj.slots };
 }
@@ -16160,12 +16168,12 @@ function createPlaybooksRouter(playbooksDir3) {
       const result = await setPlaybookEnabled(playbooksDir3, req.params.slug, true);
       res.json({ slug: result.slug, enabled: result.enabled, changed: result.changed });
     } catch (error) {
-      const msg = error instanceof Error ? error.message : "Failed to enable playbook";
-      if (msg.startsWith("Playbook ")) {
-        res.status(404).json({ error: msg });
+      const msg2 = error instanceof Error ? error.message : "Failed to enable playbook";
+      if (msg2.startsWith("Playbook ")) {
+        res.status(404).json({ error: msg2 });
         return;
       }
-      res.status(500).json({ error: msg });
+      res.status(500).json({ error: msg2 });
     }
   });
   router.post("/:slug/disable", async (req, res) => {
@@ -16173,12 +16181,12 @@ function createPlaybooksRouter(playbooksDir3) {
       const result = await setPlaybookEnabled(playbooksDir3, req.params.slug, false);
       res.json({ slug: result.slug, enabled: result.enabled, changed: result.changed });
     } catch (error) {
-      const msg = error instanceof Error ? error.message : "Failed to disable playbook";
-      if (msg.startsWith("Playbook ")) {
-        res.status(404).json({ error: msg });
+      const msg2 = error instanceof Error ? error.message : "Failed to disable playbook";
+      if (msg2.startsWith("Playbook ")) {
+        res.status(404).json({ error: msg2 });
         return;
       }
-      res.status(500).json({ error: msg });
+      res.status(500).json({ error: msg2 });
     }
   });
   router.get("/:slug", async (req, res) => {
@@ -16916,8 +16924,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve86 } = await import("path");
-      const { readFile: readFile63 } = await import("fs/promises");
+      const { resolve: resolve87 } = await import("path");
+      const { readFile: readFile64 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const outcome = await wsLock(workspace, async () => {
@@ -16933,10 +16941,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
           (e) => e.itemIds.every((id) => completedIds.has(id))
         );
         const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-        await ensureDir(resolve86(todosDir2, "archive"));
+        await ensureDir(resolve87(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile63(archFile, "utf-8");
+          archContent = await readFile64(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -17225,7 +17233,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: readFile63 } = await import("fs/promises");
+        const { readFile: readFile64 } = 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;
@@ -17246,7 +17254,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile63(assignmentMdPath2, "utf-8");
+        let content = await readFile64(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -18920,8 +18928,8 @@ async function restoreFromGithub(overrides) {
         await safeRestoreCategory(localPath, repoSrcPath, isFile);
         restored.push(category);
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        console.error(`Failed to restore "${category}": ${msg}`);
+        const msg2 = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to restore "${category}": ${msg2}`);
         failed.push(category);
       }
     }
@@ -22083,13 +22091,13 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       env: plan.env
     });
   } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
     throw new TerminalNotFoundError(
       plan.terminal,
-      `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
+      `Spawn failed: ${msg2}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve86, reject) => {
+  await new Promise((resolve87, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -22099,7 +22107,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve86();
+      resolve87();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -22270,7 +22278,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile63 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile64 = opts.readFile ?? ((p) => readFileSync(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) {
@@ -22291,7 +22299,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
     const pkgJsonPath = join5(dir, "package.json");
     let raw2;
     try {
-      raw2 = readFile63(pkgJsonPath);
+      raw2 = readFile64(pkgJsonPath);
     } catch {
       const parent2 = dirname12(dir);
       if (parent2 === dir) break;
@@ -23428,36 +23436,267 @@ init_config2();
 // src/commands/cross-agent-install.ts
 init_fs();
 import { spawnSync as spawnSync6 } from "child_process";
-import { resolve as resolve47 } from "path";
-import { readFile as readFile31 } from "fs/promises";
+import { dirname as dirname17, join as join9, resolve as resolve48 } from "path";
+import { cp as cp4, mkdir as mkdir8, readFile as readFile32 } from "fs/promises";
 
 // src/commands/setup-adapter.ts
 init_paths();
 init_fs();
 init_config2();
 init_slug();
-import { resolve as resolve46 } from "path";
+import { resolve as resolve47 } from "path";
 
 // src/targets/registry.ts
 init_fs();
 import { homedir as homedir8 } from "os";
+import { resolve as resolve46 } from "path";
+
+// src/targets/user-descriptors.ts
+init_fs();
+init_paths();
 import { resolve as resolve45 } from "path";
+import { readFile as readFile31, readdir as readdir17 } from "fs/promises";
+
+// src/targets/renderers.ts
+init_cursor_rules();
+init_codex_agents();
+init_opencode_config();
+init_hermes_soul();
+var 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
+function userTargetsDir() {
+  return resolve45(syntaurRoot(), "targets");
+}
+var ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
+var VALID_RENDERER_KEYS = new Set(Object.keys(RENDERERS));
+var ALLOWED_TOP_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "displayName",
+  "skillsShAgentId",
+  "detect",
+  "skillsDir",
+  "instructions"
+]);
+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 resolve45(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 readdir17(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 = resolve45(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 };
+}
+
+// src/targets/registry.ts
 function home(...segments) {
-  return resolve45(homedir8(), ...segments);
+  return resolve46(homedir8(), ...segments);
 }
 function hermesHome() {
   const env = process.env.HERMES_HOME;
-  return env && env.length > 0 ? resolve45(env) : home(".hermes");
+  return env && env.length > 0 ? resolve46(env) : home(".hermes");
 }
 function hermesSkillsDir() {
-  return resolve45(hermesHome(), "skills");
+  return resolve46(hermesHome(), "skills");
 }
 function isHermesHomeCustom() {
   return hermesHome() !== home(".hermes");
 }
 function codexHome() {
   const env = process.env.CODEX_HOME;
-  return env && env.length > 0 ? resolve45(env) : home(".codex");
+  return env && env.length > 0 ? resolve46(env) : home(".codex");
 }
 var detectDir = (dir) => () => fileExists(dir);
 var AGENT_TARGETS = [
@@ -23481,7 +23720,7 @@ var AGENT_TARGETS = [
     skillsShAgentId: "codex",
     nativePlugin: "codex",
     detect: detectDir(codexHome()),
-    skillsDir: { global: resolve45(codexHome(), "skills") },
+    skillsDir: { global: resolve46(codexHome(), "skills") },
     instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] }
   },
   {
@@ -23513,7 +23752,13 @@ var AGENT_TARGETS = [
     skillsShAgentId: "pi",
     detect: detectDir(home(".pi")),
     skillsDir: { global: home(".pi", "agent", "skills") },
-    instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] }
+    instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+    tier3: {
+      kind: "pi-extension",
+      source: "platforms/pi/extensions/syntaur",
+      installDir: () => home(".pi", "agent", "extensions", "syntaur"),
+      entry: "index.ts"
+    }
   },
   {
     id: "openclaw",
@@ -23521,7 +23766,15 @@ var AGENT_TARGETS = [
     skillsShAgentId: "openclaw",
     detect: detectDir(home(".openclaw")),
     skillsDir: { global: home(".openclaw", "skills") },
-    instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] }
+    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",
@@ -23529,42 +23782,34 @@ var AGENT_TARGETS = [
     skillsShAgentId: "hermes-agent",
     detect: () => fileExists(hermesHome()),
     skillsDir: { global: hermesSkillsDir() },
-    instructions: { files: [{ path: "SOUL.md", renderer: "hermesSoul" }] }
+    instructions: { files: [{ path: "SOUL.md", renderer: "hermesSoul" }] },
+    tier3: {
+      kind: "hermes-plugin",
+      source: "platforms/hermes/plugins/syntaur",
+      installDir: () => resolve46(hermesHome(), "plugins", "syntaur"),
+      entry: "plugin.yaml"
+    }
   }
 ];
 var AGENT_TARGETS_BY_ID = Object.fromEntries(
   AGENT_TARGETS.map((t) => [t.id, t])
 );
-function getAgentTarget(id) {
-  return AGENT_TARGETS_BY_ID[id];
-}
-function agentTargetIds() {
-  return AGENT_TARGETS.map((t) => t.id);
-}
-function adapterTargets() {
-  return AGENT_TARGETS.filter((t) => t.instructions !== void 0);
+async function resolveAgentTargets() {
+  const { targets: user, warnings } = await loadUserDescriptors({
+    builtinIds: new Set(AGENT_TARGETS.map((t) => t.id))
+  });
+  return { targets: [...AGENT_TARGETS, ...user], warnings };
 }
 
-// src/targets/renderers.ts
-init_cursor_rules();
-init_codex_agents();
-init_opencode_config();
-init_hermes_soul();
-var RENDERERS = {
-  codexAgents: (ctx) => renderCodexAgents(ctx),
-  cursorProtocol: () => renderCursorProtocol(),
-  cursorAssignment: (ctx) => renderCursorAssignment(ctx),
-  openCodeConfig: (ctx) => renderOpenCodeConfig({ projectDir: ctx.projectDir }),
-  hermesSoul: (ctx) => renderHermesSoul(ctx)
-};
-
 // src/commands/setup-adapter.ts
 async function setupAdapterCommand(framework, options) {
-  const target = getAgentTarget(framework);
+  const { targets: known, warnings } = await resolveAgentTargets();
+  const target = known.find((t) => t.id === framework);
   if (!target || !target.instructions) {
-    const supported = adapterTargets().map((t) => t.id).join(", ");
+    const supported = known.filter((t) => t.instructions !== void 0).map((t) => t.id).join(", ");
+    const warn2 = warnings.length ? ` (descriptor warnings: ${warnings.join("; ")})` : "";
     throw new Error(
-      `Unsupported framework "${framework}". Supported: ${supported}`
+      `Unsupported framework "${framework}". Supported: ${supported}.${warn2}`
     );
   }
   if (!options.project) {
@@ -23585,13 +23830,13 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve46(baseDir, options.project);
-  const assignmentDir = resolve46(projectDir, "assignments", options.assignment);
-  const projectMdPath = resolve46(projectDir, "project.md");
+  const projectDir = resolve47(baseDir, options.project);
+  const assignmentDir = resolve47(projectDir, "assignments", options.assignment);
+  const projectMdPath = resolve47(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
-  const assignmentMdPath2 = resolve46(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve47(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -23608,7 +23853,7 @@ async function setupAdapterCommand(framework, options) {
   const upToDateFiles = [];
   const skippedFiles = [];
   for (const file of target.instructions.files) {
-    const filePath = resolve46(cwd, file.path);
+    const filePath = resolve47(cwd, file.path);
     const content = RENDERERS[file.renderer](rendererParams);
     const status = await writeFileReport(filePath, content, {
       force: options.force
@@ -23647,6 +23892,33 @@ async function setupAdapterCommand(framework, options) {
 // src/commands/cross-agent-install.ts
 init_config2();
 var DEFAULT_SKILLS_SOURCE = "prong-horn/syntaur";
+async function installTier3Plugin(t, opts = {}) {
+  if (!t.tier3) return "none";
+  const plugin = t.tier3;
+  const installDir = plugin.installDir();
+  const prefix = opts.prefix ?? "";
+  if (opts.dryRun) {
+    console.log(`${prefix}Tier 3 (${t.id}): ${plugin.source} -> ${installDir}`);
+    return "dry-run";
+  }
+  if (await fileExists(join9(installDir, plugin.entry)) && !opts.force) {
+    console.log(
+      `Tier 3 (${t.id}): already installed at ${installDir} (use --force to overwrite).`
+    );
+    return "already-present";
+  }
+  try {
+    const sourceDir = resolve48(await findPackageRoot(plugin.source), plugin.source);
+    await mkdir8(dirname17(installDir), { recursive: true });
+    await cp4(sourceDir, installDir, { recursive: true, force: true });
+    console.log(`Tier 3 (${t.id}): installed ${plugin.kind} -> ${installDir}`);
+    return "installed";
+  } catch (err2) {
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
+    console.log(`Tier 3 for ${t.id} FAILED: ${msg2}`);
+    return "failed";
+  }
+}
 function parseTargetIds(options) {
   const raw2 = [options.target, options.agent].filter(Boolean).join(",");
   const ids = raw2.split(",").map((s) => s.trim()).filter(Boolean);
@@ -23661,10 +23933,10 @@ function isNpxAvailable() {
   }
 }
 async function readAssignmentContext() {
-  const p = resolve47(process.cwd(), ".syntaur", "context.json");
+  const p = resolve48(process.cwd(), ".syntaur", "context.json");
   if (!await fileExists(p)) return null;
   try {
-    return JSON.parse(await readFile31(p, "utf-8"));
+    return JSON.parse(await readFile32(p, "utf-8"));
   } catch {
     return null;
   }
@@ -23674,12 +23946,15 @@ async function crossAgentInstallCommand(options) {
   if (ids.length === 0) {
     throw new Error("No agents specified. Use --target <id> or --agent <id>.");
   }
+  const { targets: known, warnings } = await resolveAgentTargets();
+  for (const w of warnings) console.log(`Warning (user target): ${w}`);
+  const byId = new Map(known.map((t) => [t.id, t]));
   const targets = [];
   for (const id of ids) {
-    const t = getAgentTarget(id);
+    const t = byId.get(id);
     if (!t) {
       throw new Error(
-        `Unknown agent "${id}". Known agents: ${agentTargetIds().join(", ")}`
+        `Unknown agent "${id}". Known agents: ${known.map((k) => k.id).join(", ")}`
       );
     }
     if (t.nativePlugin) {
@@ -23713,8 +23988,15 @@ async function crossAgentInstallCommand(options) {
   }
   for (const t of targets) {
     const globalDir = t.id === "hermes" ? hermesSkillsDir() : t.skillsDir?.global;
-    if (!globalDir) continue;
     const offlineNeeded = !tier1Done;
+    if (!globalDir) {
+      if (offlineNeeded && !dryRun) {
+        console.log(
+          `Warning: skills NOT installed for ${t.displayName} \u2014 Tier-1 (npx skills add) was unavailable/failed and the descriptor has no skillsDir.global for an offline copy.`
+        );
+      }
+      continue;
+    }
     const hermesCustom = t.id === "hermes" && isHermesHomeCustom();
     if (!offlineNeeded && !hermesCustom) continue;
     if (dryRun) {
@@ -23726,15 +24008,15 @@ async function crossAgentInstallCommand(options) {
     await installSkillsToDir({ targetDir: globalDir, force });
     console.log(`Copied skills -> ${globalDir}${reason}`);
   }
-  const adapterTargets2 = targets.filter((t) => t.instructions);
-  if (adapterTargets2.length > 0) {
+  const adapterTargets = targets.filter((t) => t.instructions);
+  if (adapterTargets.length > 0) {
     const ctx = await readAssignmentContext();
     const haveCtx = Boolean(ctx?.projectSlug && ctx?.assignmentSlug);
-    for (const t of adapterTargets2) {
+    for (const t of adapterTargets) {
       if (dryRun) {
         for (const f of t.instructions.files) {
           console.log(
-            `${prefix}Tier 2 (${t.id}): ${resolve47(process.cwd(), f.path)}`
+            `${prefix}Tier 2 (${t.id}): ${resolve48(process.cwd(), f.path)}`
           );
         }
         continue;
@@ -23752,11 +24034,21 @@ async function crossAgentInstallCommand(options) {
           force
         });
       } catch (err2) {
-        const msg = err2 instanceof Error ? err2.message : String(err2);
-        console.log(`Tier 2 for ${t.id} skipped: ${msg}`);
+        const msg2 = err2 instanceof Error ? err2.message : String(err2);
+        console.log(`Tier 2 for ${t.id} skipped: ${msg2}`);
       }
     }
   }
+  const tier3Failures = [];
+  for (const t of targets.filter((x) => x.tier3)) {
+    const result = await installTier3Plugin(t, { dryRun, force, prefix });
+    if (result === "failed") tier3Failures.push(t.displayName);
+  }
+  if (tier3Failures.length > 0) {
+    throw new Error(
+      `Tier-3 enforcement plugin failed to install for: ${tier3Failures.join(", ")}. Enforcement is NOT active for ${tier3Failures.length > 1 ? "those agents" : "that agent"} \u2014 check permissions and re-run \`syntaur setup --target <id> --force\`.`
+    );
+  }
   if (!dryRun) {
     const current = (await readConfig()).integrations.installedAgents ?? {};
     const next = { ...current };
@@ -23881,7 +24173,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve48 } from "path";
+import { resolve as resolve49 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -23961,7 +24253,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve48(configuredProjectDir) !== resolve48(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve49(configuredProjectDir) !== resolve49(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -23976,7 +24268,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve49 } from "path";
+import { resolve as resolve50 } from "path";
 init_git_worktree();
 init_cwd();
 init_session_db();
@@ -23993,7 +24285,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve49(baseDir, options.project);
+    const projectDir = resolve50(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -24127,8 +24419,8 @@ function formatInstallUrlHandlerError(err2) {
 init_config2();
 init_paths();
 init_fs();
-import { resolve as resolve51, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile32 } from "fs/promises";
+import { resolve as resolve52, isAbsolute as isAbsolute8 } from "path";
+import { readFile as readFile33 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -24197,7 +24489,7 @@ async function pickAgent2(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve51(
+  const assignmentPath = resolve52(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -24207,7 +24499,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile32(assignmentPath, "utf-8");
+  const content = await readFile33(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -24277,7 +24569,7 @@ async function ensureWorktree(opts) {
 async function runCreate(opts) {
   const { createWorktreeAndRecord: createWorktreeAndRecord2, GitWorktreeError: GitWorktreeError2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
   const expandedWorktree = expandHome(opts.worktreePath);
-  const absWorktree = isAbsolute8(expandedWorktree) ? expandedWorktree : resolve51(expandedWorktree);
+  const absWorktree = isAbsolute8(expandedWorktree) ? expandedWorktree : resolve52(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -24289,11 +24581,11 @@ async function runCreate(opts) {
     console.log(`syntaur: created worktree at ${absWorktree} on branch ${opts.branch}`);
     return absWorktree;
   } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
     if (err2 instanceof GitWorktreeError2) {
-      console.error(`syntaur: ${msg}`);
+      console.error(`syntaur: ${msg2}`);
     } else {
-      console.error(`syntaur: ${msg}`);
+      console.error(`syntaur: ${msg2}`);
     }
     process.exit(1);
   }
@@ -24306,7 +24598,7 @@ init_paths();
 init_fs();
 init_playbook();
 init_playbooks();
-import { resolve as resolve52 } from "path";
+import { resolve as resolve53 } from "path";
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -24319,7 +24611,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve52(dir, `${slug}.md`);
+  const filePath = resolve53(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -24341,8 +24633,8 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir17, readFile as readFile33 } from "fs/promises";
-import { resolve as resolve53 } from "path";
+import { readdir as readdir18, readFile as readFile34 } from "fs/promises";
+import { resolve as resolve54 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -24351,14 +24643,14 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir17(dir, { withFileTypes: true });
+  const entries = await readdir18(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 = resolve53(dir, entry.name);
-    const raw2 = await readFile33(filePath, "utf-8");
+    const filePath = resolve54(dir, entry.name);
+    const raw2 = await readFile34(filePath, "utf-8");
     const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -24481,14 +24773,14 @@ init_fs();
 init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
-import { readFile as readFile35 } from "fs/promises";
-import { resolve as resolve55 } from "path";
+import { readFile as readFile36 } from "fs/promises";
+import { resolve as resolve56 } from "path";
 
 // src/commands/bundle.ts
 init_paths();
 import { Command } from "commander";
-import { mkdir as mkdir8, readFile as readFile34, readdir as readdir18, rm as rm8, writeFile as writeFile13 } from "fs/promises";
-import { resolve as resolve54 } from "path";
+import { mkdir as mkdir9, readFile as readFile35, readdir as readdir19, rm as rm8, writeFile as writeFile13 } from "fs/promises";
+import { resolve as resolve55 } from "path";
 init_parser2();
 init_fs();
 init_config2();
@@ -24506,7 +24798,7 @@ async function resolveBundleScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve54(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve55(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -24576,10 +24868,10 @@ function pickNextPlanFile(planDir, existingFiles) {
     const m = f.match(/^plan-v(\d+)\.md$/);
     if (m) versions.add(parseInt(m[1], 10));
   }
-  if (versions.size === 0) return { target: resolve54(planDir, "plan.md"), version: 1 };
+  if (versions.size === 0) return { target: resolve55(planDir, "plan.md"), version: 1 };
   let n = 2;
   while (versions.has(n)) n++;
-  return { target: resolve54(planDir, `plan-v${n}.md`), version: n };
+  return { target: resolve55(planDir, `plan-v${n}.md`), version: n };
 }
 function dedupePreserveOrder(ids) {
   const out = [];
@@ -24663,7 +24955,7 @@ bundleCommand.command("new").description("Create a new bundle from 2+ existing t
     if (options.plan) {
       const planDir = bundlePlanDir(sc.todosPath, sc.scopeId, id);
       await ensureDir(planDir);
-      const target = resolve54(planDir, "plan.md");
+      const target = resolve55(planDir, "plan.md");
       const memberLines = items.map((it) => `- ${it.description} [t:${it.id}]`).join("\n");
       const stub = [
         "---",
@@ -24780,7 +25072,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 readdir18(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
+    const existing = (await readdir19(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)) {
@@ -24839,7 +25131,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
     }
     const repository = options.repository ?? process.cwd();
     const parentBranch = options.parentBranch ?? "main";
-    const worktreePath = options.worktreePath ?? resolve54(repository, ".worktrees", options.branch);
+    const worktreePath = options.worktreePath ?? resolve55(repository, ".worktrees", options.branch);
     const checklist = await readChecklist(sc.todosPath, sc.checklistKey);
     for (const memberId of bundle.todoIds) {
       const item = checklist.items.find((i) => i.id === memberId);
@@ -24849,8 +25141,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 readFile34(bundlesFilePath, "utf-8") : null;
-    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile34(checklistFilePath, "utf-8") : null;
+    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile35(bundlesFilePath, "utf-8") : null;
+    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile35(checklistFilePath, "utf-8") : null;
     const record = async () => {
       bundle.branch = options.branch;
       bundle.worktreePath = worktreePath;
@@ -24866,8 +25158,8 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
       try {
         await writeBundles(sc.todosPath, bundles);
         await writeChecklist(sc.todosPath, checklist);
-        const ctxDir = resolve54(worktreePath, ".syntaur");
-        await mkdir8(ctxDir, { recursive: true });
+        const ctxDir = resolve55(worktreePath, ".syntaur");
+        await mkdir9(ctxDir, { recursive: true });
         const payload = {
           bundleId: bundle.id,
           bundleSlug: bundle.slug,
@@ -24880,7 +25172,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
           repository,
           boundAt: nowISO()
         };
-        await writeFile13(resolve54(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
+        await writeFile13(resolve55(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
       } catch (err2) {
         try {
           if (bundlesSnapshot === null) {
@@ -25070,7 +25362,7 @@ async function resolveScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve55(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve56(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -25393,10 +25685,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve55(todosPath, "archive"));
+    await ensureDir(resolve56(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile35(archFile, "utf-8");
+      archContent = await readFile36(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -25573,12 +25865,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile63 } = await import("fs/promises");
+  const { readFile: readFile64 } = 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 readFile63(assignmentMdPath2, "utf-8");
+  let content = await readFile64(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -25623,13 +25915,13 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     }
     const planDir = todoPlanDir(todosPath, workspace, id);
     await ensureDir(planDir);
-    const { readdir: readdir32 } = await import("fs/promises");
-    const existingFiles = (await readdir32(planDir).catch(() => [])).filter(
+    const { readdir: readdir33 } = await import("fs/promises");
+    const existingFiles = (await readdir33(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
     if (existingFiles.length === 0) {
-      target = resolve55(planDir, "plan.md");
+      target = resolve56(planDir, "plan.md");
     } else {
       const versions = /* @__PURE__ */ new Set();
       for (const f of existingFiles) {
@@ -25639,7 +25931,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
       }
       let n = 2;
       while (versions.has(n)) n++;
-      target = resolve55(planDir, `plan-v${n}.md`);
+      target = resolve56(planDir, `plan-v${n}.md`);
     }
     if (!await fileExists(target)) {
       const stub = `---
@@ -25709,9 +26001,9 @@ async function moveTodo(id, options) {
     if (await fileExists(newPlanDir)) {
       throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
     }
-    const { rename: rename11, mkdir: mkdir11 } = await import("fs/promises");
-    const { dirname: dirname23 } = await import("path");
-    await mkdir11(dirname23(newPlanDir), { recursive: true });
+    const { rename: rename11, mkdir: mkdir12 } = await import("fs/promises");
+    const { dirname: dirname24 } = await import("path");
+    await mkdir12(dirname24(newPlanDir), { recursive: true });
     await rename11(item.planDir, newPlanDir);
     item.planDir = newPlanDir;
   }
@@ -25828,24 +26120,24 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
-import { readFile as readFile45 } from "fs/promises";
-import { isAbsolute as isAbsolute11, resolve as resolve68 } from "path";
+import { readFile as readFile46 } from "fs/promises";
+import { isAbsolute as isAbsolute11, resolve as resolve69 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath11 } from "url";
-import { readFile as readFile44 } from "fs/promises";
-import { dirname as dirname20, join as join13 } from "path";
+import { readFile as readFile45 } from "fs/promises";
+import { dirname as dirname21, join as join14 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
 init_paths();
 init_fs();
 import Database4 from "better-sqlite3";
-import { resolve as resolve56 } from "path";
+import { resolve as resolve57 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve56(root, "syntaur.db");
+  const dbPath = resolve57(root, "syntaur.db");
   let db5 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -25879,10 +26171,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve57, isAbsolute as isAbsolute9 } from "path";
-import { readFile as readFile36, stat as stat4 } from "fs/promises";
+import { resolve as resolve58, isAbsolute as isAbsolute9 } from "path";
+import { readFile as readFile37, stat as stat4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { dirname as dirname18, join as join10 } from "path";
+import { dirname as dirname19, join as join11 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -25920,7 +26212,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath2 = resolve57(ctx.syntaurRoot, "config.md");
+    const configPath2 = resolve58(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath2)) {
       return {
         id: this.id,
@@ -25937,7 +26229,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile36(configPath2, "utf-8");
+    const content = await readFile37(configPath2, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -26213,14 +26505,14 @@ async function readLocalVersion() {
 async function readLocalPkg() {
   try {
     const here = fileURLToPath10(import.meta.url);
-    let dir = dirname18(here);
+    let dir = dirname19(here);
     for (let i = 0; i < 6; i++) {
-      const candidate = join10(dir, "package.json");
+      const candidate = join11(dir, "package.json");
       try {
-        const text = await readFile36(candidate, "utf-8");
+        const text = await readFile37(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname18(dir);
+        dir = dirname19(dir);
       }
     }
     return null;
@@ -26269,8 +26561,8 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve58 } from "path";
-import { readdir as readdir19, stat as stat5 } from "fs/promises";
+import { resolve as resolve59 } from "path";
+import { readdir as readdir20, stat as stat5 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -26289,7 +26581,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve58(ctx.syntaurRoot, "projects");
+    const p = resolve59(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -26314,7 +26606,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve58(ctx.syntaurRoot, "playbooks");
+    const p = resolve59(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -26339,7 +26631,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve58(ctx.syntaurRoot, "todos");
+    const p = resolve59(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -26370,7 +26662,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve58(ctx.syntaurRoot, "servers");
+    const p = resolve59(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -26401,7 +26693,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir19(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir20(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -26415,7 +26707,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve58(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve59(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -26444,8 +26736,8 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve59 } from "path";
-import { readdir as readdir20, stat as stat6 } from "fs/promises";
+import { resolve as resolve60 } from "path";
+import { readdir as readdir21, stat as stat6 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -26469,15 +26761,15 @@ 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 readdir20(dir, { withFileTypes: true });
+  const entries = await readdir21(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve59(dir, e.name);
+    const projectDir = resolve60(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve59(projectDir, marker))) {
+      if (await fileExists(resolve60(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -26496,7 +26788,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve59(projectDir, rel);
+        const p = resolve60(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -26506,7 +26798,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve59(projectDir, m)),
+        affected: missing.map((m) => resolve60(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -26529,7 +26821,7 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve59(projectDir, "manifest.md");
+      const manifestPath = resolve60(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
       const manifestMtime = (await stat6(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
@@ -26563,7 +26855,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir20(projectDir, { withFileTypes: true });
+      const entries = await readdir21(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -26578,7 +26870,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve59(projectDir, o)),
+        affected: orphans.map((o) => resolve60(projectDir, o)),
         autoFixable: false
       });
     }
@@ -26588,18 +26880,18 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve59(projectDir, "assignments");
+  const assignmentsRoot = resolve60(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
   try {
-    entries = await readdir20(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir21(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve59(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve60(assignmentsRoot, e.name, "assignment.md");
     try {
       const s = await stat6(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
@@ -26623,8 +26915,8 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve60 } from "path";
-import { readFile as readFile37, readdir as readdir21 } from "fs/promises";
+import { resolve as resolve61 } from "path";
+import { readFile as readFile38, readdir as readdir22 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -26718,7 +27010,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -26751,7 +27043,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -26798,12 +27090,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve60(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve60(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve61(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -26813,7 +27105,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve60(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve61(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -26836,7 +27128,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve60(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve61(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -26848,7 +27140,7 @@ var companionFilesScaffolded = {
         title: this.title,
         status: "warn",
         detail: `${label} is missing ${missing.join(" and ")} (pre-v2.0 assignment \u2014 not required, but scaffolding them keeps the dashboard and CLIs consistent)`,
-        affected: missing.map((m) => resolve60(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve61(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -26881,7 +27173,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -26915,7 +27207,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -26966,13 +27258,13 @@ var draftMissingObjective = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "draft") continue;
       let raw2;
       try {
-        raw2 = await readFile37(path, "utf-8");
+        raw2 = await readFile38(path, "utf-8");
       } catch {
         continue;
       }
@@ -27005,16 +27297,16 @@ var readyToImplementMissingPlan = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve60(a.assignmentDir, "assignment.md");
+      const path = resolve61(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir21(a.assignmentDir).catch(() => []);
+      const entries = await readdir22(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 readFile37(resolve60(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile38(resolve61(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -27030,7 +27322,7 @@ var readyToImplementMissingPlan = {
         title: this.title,
         status: "warn",
         detail: `${label} (status: ready_to_implement) has no plan.md or plan-v<N>.md`,
-        affected: [resolve60(a.assignmentDir, "plan.md")],
+        affected: [resolve61(a.assignmentDir, "plan.md")],
         remediation: {
           kind: "manual",
           suggestion: `Write a plan with '/plan-assignment' (or 'syntaur plan'), then re-mark ready_to_implement`,
@@ -27057,7 +27349,7 @@ var assignmentChecks = [
 ];
 async function parseSafe2(path) {
   try {
-    const content = await readFile37(path, "utf-8");
+    const content = await readFile38(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -27076,7 +27368,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve61 } from "path";
+import { resolve as resolve62 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -27090,7 +27382,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve62(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -27108,7 +27400,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve62(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -27120,7 +27412,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve62(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -27146,7 +27438,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve61(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve62(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -27165,7 +27457,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve61(
+        const assignmentPath = resolve62(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -27217,8 +27509,8 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve62, dirname as dirname19, basename as basename6 } from "path";
-import { readdir as readdir22, readFile as readFile38 } from "fs/promises";
+import { resolve as resolve63, dirname as dirname20, basename as basename6 } from "path";
+import { readdir as readdir23, readFile as readFile39 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -27281,7 +27573,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 readdir22(projectsDir2, { withFileTypes: true });
+    const entries = await readdir23(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 {
@@ -27300,10 +27592,10 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve62(homedir10(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve63(homedir10(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw2 = await readFile38(path, "utf-8");
+    const raw2 = await readFile39(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -27319,7 +27611,7 @@ var claudeMarketplaceRegistered = {
     if (!await fileExists(dir)) {
       return skipped2(this, "claudePluginDir does not exist (run install-plugin)");
     }
-    const pluginsParent = dirname19(dir);
+    const pluginsParent = dirname20(dir);
     if (basename6(pluginsParent) !== "plugins") {
       return {
         id: this.id,
@@ -27336,8 +27628,8 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceRoot = dirname19(pluginsParent);
-    const marketplaceManifest = resolve62(marketplaceRoot, ".claude-plugin", "marketplace.json");
+    const marketplaceRoot = dirname20(pluginsParent);
+    const marketplaceManifest = resolve63(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
         id: this.id,
@@ -27356,7 +27648,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile38(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile39(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -27388,7 +27680,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve62(homedir10(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve63(homedir10(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -27428,8 +27720,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve63 } from "path";
-import { readFile as readFile39 } from "fs/promises";
+import { resolve as resolve64 } from "path";
+import { readFile as readFile40 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 var BUNDLE_FIELDS = ["bundleId", "bundleScope", "bundleScopeId"];
@@ -27450,12 +27742,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && !hasAnyBundleField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve63(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve64(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw2 = await readFile39(path, "utf-8");
+    const raw2 = await readFile40(path, "utf-8");
     return { data: JSON.parse(raw2), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -27549,7 +27841,7 @@ var contextAssignmentResolves = {
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to resolve");
     if (isBundleContext(data)) return skipped3(this, "bundle context \u2014 no assignment to resolve");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve63(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve64(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -27579,10 +27871,10 @@ var contextTerminal = {
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (isBundleContext(data)) return skipped3(this, "bundle context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve63(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve64(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile39(assignmentMd, "utf-8");
+      const content = await readFile40(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -27728,15 +28020,15 @@ var agentChecks = [agentsResolvable];
 // src/utils/doctor/checks/terminal.ts
 init_config2();
 import { spawnSync as spawnSync9 } from "child_process";
-import { readFile as readFile40 } from "fs/promises";
-import { resolve as resolve64 } from "path";
+import { readFile as readFile41 } from "fs/promises";
+import { resolve as resolve65 } from "path";
 init_paths();
 init_fs();
 var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
-  const configPath2 = resolve64(syntaurRoot(), "config.md");
+  const configPath2 = resolve65(syntaurRoot(), "config.md");
   if (!await fileExists(configPath2)) return null;
-  const content = await readFile40(configPath2, "utf-8");
+  const content = await readFile41(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));
@@ -27886,13 +28178,13 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve65, join as join11 } from "path";
-import { readdir as readdir23, readFile as readFile41, lstat as lstat4 } from "fs/promises";
+import { resolve as resolve66, join as join12 } from "path";
+import { readdir as readdir24, readFile as readFile42, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve65(homedir11(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve65(homedir11(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve66(homedir11(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve66(homedir11(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -27907,21 +28199,21 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir23(dir, { withFileTypes: true });
+        entries = await readdir24(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 = join11(dir, entry.name, "SKILL.md");
+        const skillMd = join12(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile41(skillMd, "utf-8").catch(() => "");
+        const content = await readFile42(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(join11(dir, entry.name))).isSymbolicLink();
+          isSymlink2 = (await lstat4(join12(dir, entry.name))).isSymbolicLink();
         } catch {
         }
         present.push({ name: entry.name, isSymlink: isSymlink2 });
@@ -27933,7 +28225,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(join11(dir, p.name));
+          for (const p of nonSymlink) affected.push(join12(dir, p.name));
         }
       }
     }
@@ -27966,12 +28258,12 @@ var skillsChecks = [skillsDedupCheck];
 
 // src/utils/doctor/checks/cross-agent.ts
 init_fs();
-import { join as join12, resolve as resolve66 } from "path";
-import { readFile as readFile43 } from "fs/promises";
+import { join as join13, resolve as resolve67 } from "path";
+import { readFile as readFile44 } from "fs/promises";
 
 // src/utils/skill-frontmatter.ts
 import { createHash } from "crypto";
-import { readFile as readFile42 } from "fs/promises";
+import { readFile as readFile43 } from "fs/promises";
 function stripQuotes(raw2) {
   const t = raw2.trim();
   if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
@@ -28015,7 +28307,7 @@ function readSkillIdentity(skillMdText) {
   return { name, hasDescription };
 }
 async function sha256File(path) {
-  return createHash("sha256").update(await readFile42(path)).digest("hex");
+  return createHash("sha256").update(await readFile43(path)).digest("hex");
 }
 
 // src/utils/doctor/checks/cross-agent.ts
@@ -28024,14 +28316,14 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
   const problems = [];
   let valid = 0;
   for (const skill of knownSkills) {
-    const installedPath = join12(installedDir, skill, "SKILL.md");
+    const installedPath = join13(installedDir, skill, "SKILL.md");
     if (!await fileExists(installedPath)) {
       problems.push({ skill, kind: "missing" });
       continue;
     }
     let text;
     try {
-      text = await readFile43(installedPath, "utf-8");
+      text = await readFile44(installedPath, "utf-8");
     } catch {
       problems.push({ skill, kind: "invalid-frontmatter" });
       continue;
@@ -28042,7 +28334,7 @@ async function checkTargetSkillsIntegrity(installedDir, canonicalSkillsDir, know
       continue;
     }
     valid++;
-    const canonicalPath = join12(canonicalSkillsDir, skill, "SKILL.md");
+    const canonicalPath = join13(canonicalSkillsDir, skill, "SKILL.md");
     if (await fileExists(canonicalPath)) {
       const [installedHash, canonicalHash] = await Promise.all([
         sha256File(installedPath),
@@ -28075,6 +28367,7 @@ var crossAgentSkillsCheck = {
   title: "Cross-agent targets have Syntaur skills + protocol files",
   async run(ctx) {
     const installed = ctx.config.integrations.installedAgents ?? {};
+    const { targets: resolvedTargets, warnings: descriptorWarnings } = await resolveAgentTargets();
     const canonicalSkillsDir = await getSkillsDir();
     let knownSkills;
     try {
@@ -28088,7 +28381,7 @@ var crossAgentSkillsCheck = {
     const problems = [];
     const affected = [];
     let considered = 0;
-    for (const t of AGENT_TARGETS) {
+    for (const t of resolvedTargets) {
       if (t.nativePlugin) continue;
       const dir = t.skillsDir?.global;
       if (!dir) continue;
@@ -28107,15 +28400,41 @@ var crossAgentSkillsCheck = {
       }
       if (recorded && t.instructions) {
         for (const f of t.instructions.files) {
-          const p = resolve66(ctx.cwd, f.path);
+          const p = resolve67(ctx.cwd, f.path);
           if (!await fileExists(p)) {
             problems.push(`${t.displayName}: missing protocol file ${f.path} in cwd`);
             affected.push(p);
           }
         }
       }
+      if (t.tier3) {
+        const installDir = t.tier3.installDir();
+        const installed2 = await fileExists(join13(installDir, t.tier3.entry));
+        lines.push(
+          `${t.displayName}: Tier-3 ${t.tier3.kind} ${installed2 ? "installed" : "absent"} (${installDir})`
+        );
+        if (recorded && !installed2) {
+          problems.push(`${t.displayName}: Tier-3 ${t.tier3.kind} not installed`);
+          affected.push(installDir);
+        }
+      }
     }
     if (considered === 0) {
+      if (descriptorWarnings.length > 0) {
+        return {
+          id: this.id,
+          category: this.category,
+          title: this.title,
+          status: "warn",
+          detail: `User target descriptor issues: ${descriptorWarnings.join("; ")}`,
+          remediation: {
+            kind: "manual",
+            suggestion: `Fix or remove the offending file(s) in ~/.syntaur/targets/ (see references/user-targets.md).`,
+            command: null
+          },
+          autoFixable: false
+        };
+      }
       return {
         id: this.id,
         category: this.category,
@@ -28125,6 +28444,7 @@ var crossAgentSkillsCheck = {
         autoFixable: false
       };
     }
+    for (const w of descriptorWarnings) problems.push(`user target descriptor: ${w}`);
     if (problems.length > 0) {
       return {
         id: this.id,
@@ -28156,8 +28476,8 @@ var crossAgentChecks = [crossAgentSkillsCheck];
 // src/utils/doctor/checks/bundles.ts
 init_fs();
 init_paths();
-import { resolve as resolve67 } from "path";
-import { readdir as readdir24 } from "fs/promises";
+import { resolve as resolve68 } from "path";
+import { readdir as readdir25 } from "fs/promises";
 import { spawnSync as spawnSync10 } from "child_process";
 init_parser2();
 var CATEGORY12 = "bundles";
@@ -28165,7 +28485,7 @@ async function listScopes(ctx) {
   const out = [];
   const td = todosDir();
   if (await fileExists(td)) {
-    const entries = await readdir24(td).catch(() => []);
+    const entries = await readdir25(td).catch(() => []);
     for (const f of entries) {
       if (typeof f !== "string") continue;
       if (!f.endsWith(".md") || f.endsWith("-log.md")) continue;
@@ -28181,12 +28501,12 @@ async function listScopes(ctx) {
     }
   }
   if (await fileExists(ctx.config.defaultProjectDir)) {
-    const projectEntries = await readdir24(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
+    const projectEntries = await readdir25(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
     for (const e of projectEntries) {
       if (!e.isDirectory()) continue;
       const slug = e.name;
       if (typeof slug !== "string" || slug.startsWith(".")) continue;
-      const projectMd = resolve67(ctx.config.defaultProjectDir, slug, "project.md");
+      const projectMd = resolve68(ctx.config.defaultProjectDir, slug, "project.md");
       if (!await fileExists(projectMd)) continue;
       out.push({
         scopeLabel: `project:${slug}`,
@@ -28475,14 +28795,14 @@ async function finalize(checks) {
 async function readVersion() {
   try {
     const here = fileURLToPath11(import.meta.url);
-    let dir = dirname20(here);
+    let dir = dirname21(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw2 = await readFile44(join13(dir, "package.json"), "utf-8");
+        const raw2 = await readFile45(join14(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw2);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname20(dir);
+        dir = dirname21(dir);
       }
     }
     return null;
@@ -28575,7 +28895,7 @@ var REQUIRED_WORKSPACE_FIELDS = [
 ];
 var ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
-  const absolute = isAbsolute11(inputPath) ? inputPath : resolve68(cwd, inputPath);
+  const absolute = isAbsolute11(inputPath) ? inputPath : resolve69(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -28588,7 +28908,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile45(absolute, "utf-8");
+    content = await readFile46(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -28654,20 +28974,20 @@ var doctorCommand = new Command4("doctor").description("Diagnose Syntaur state a
     process.exit(result.ok ? 0 : 1);
   }
   if (!await fileExists(syntaurRoot())) {
-    const msg = "~/.syntaur/ does not exist. Run `syntaur init` first.";
+    const msg2 = "~/.syntaur/ does not exist. Run `syntaur init` first.";
     if (options.json) {
       process.stdout.write(
         JSON.stringify(
           {
             version: "1.0",
-            error: msg
+            error: msg2
           },
           null,
           2
         ) + "\n"
       );
     } else {
-      process.stderr.write(msg + "\n");
+      process.stderr.write(msg2 + "\n");
     }
     process.exit(2);
   }
@@ -28686,11 +29006,11 @@ var doctorCommand = new Command4("doctor").description("Diagnose Syntaur state a
     const hasError = report.summary.error > 0;
     process.exit(hasError ? 1 : 0);
   } catch (err2) {
-    const msg = err2 instanceof Error ? err2.message : String(err2);
+    const msg2 = err2 instanceof Error ? err2.message : String(err2);
     if (options.json) {
-      process.stdout.write(JSON.stringify({ version: "1.0", error: msg }, null, 2) + "\n");
+      process.stdout.write(JSON.stringify({ version: "1.0", error: msg2 }, null, 2) + "\n");
     } else {
-      process.stderr.write(`doctor itself failed: ${msg}
+      process.stderr.write(`doctor itself failed: ${msg2}
 `);
     }
     process.exit(2);
@@ -28912,8 +29232,8 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve69 } from "path";
-import { readFile as readFile46 } from "fs/promises";
+import { resolve as resolve70 } from "path";
+import { readFile as readFile47 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -28943,7 +29263,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve69(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve70(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -28953,13 +29273,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve69(assignmentDir, "comments.md");
+  const commentsPath = resolve70(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile46(commentsPath, "utf-8");
+    currentContent = await readFile47(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -28993,8 +29313,8 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve73, relative as relative4, dirname as dirname21 } from "path";
-import { copyFile as copyFile3, mkdir as mkdir10, realpath as realpath2, rm as rm13, stat as stat9, writeFile as writeFile15 } from "fs/promises";
+import { resolve as resolve74, relative as relative4, dirname as dirname22 } from "path";
+import { copyFile as copyFile3, mkdir as mkdir11, realpath as realpath2, rm as rm13, stat as stat9, writeFile as writeFile15 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 
 // src/utils/assignment-target.ts
@@ -29004,8 +29324,8 @@ init_config2();
 init_slug();
 init_assignment_resolver();
 init_parser();
-import { resolve as resolve70 } from "path";
-import { readFile as readFile47 } from "fs/promises";
+import { resolve as resolve71 } from "path";
+import { readFile as readFile48 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 function classifyContext(ctx) {
@@ -29017,10 +29337,10 @@ function classifyContext(ctx) {
   return "empty";
 }
 async function readAssignmentFrontmatterId(assignmentDir) {
-  const path = resolve70(assignmentDir, "assignment.md");
+  const path = resolve71(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile47(path, "utf-8");
+    const content = await readFile48(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -29028,10 +29348,10 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   }
 }
 async function readContextJson(cwd) {
-  const path = resolve70(cwd, ".syntaur", "context.json");
+  const path = resolve71(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile47(path, "utf-8");
+    const raw2 = await readFile48(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
@@ -29052,15 +29372,15 @@ async function resolveAssignmentTarget(input4, opts = {}) {
     if (!isValidSlug(input4)) {
       throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
     }
-    const projectDir = resolve70(baseDir, opts.project);
-    const projectMdPath = resolve70(projectDir, "project.md");
+    const projectDir = resolve71(baseDir, opts.project);
+    const projectMdPath = resolve71(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new AssignmentTargetError(
         `Project "${opts.project}" not found at ${projectDir}.`
       );
     }
-    const assignmentDir = resolve70(projectDir, "assignments", input4);
-    const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
+    const assignmentDir = resolve71(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve71(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `Assignment "${input4}" not found in project "${opts.project}".`
@@ -29099,7 +29419,7 @@ async function resolveAssignmentTarget(input4, opts = {}) {
   }
   if (ctx.assignmentDir) {
     const dir = expandHome(ctx.assignmentDir);
-    const assignmentMdPath2 = resolve70(dir, "assignment.md");
+    const assignmentMdPath2 = resolve71(dir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment dir: ${dir}.`
@@ -29128,8 +29448,8 @@ async function resolveAssignmentTarget(input4, opts = {}) {
         `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
       );
     }
-    const assignmentDir = resolve70(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
-    const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
+    const assignmentDir = resolve71(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve71(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
@@ -29158,7 +29478,7 @@ init_fs();
 import { spawn as spawn7 } from "child_process";
 import { mkdtemp as mkdtemp2, rm as rm9, stat as stat7 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function argsFor(mode, pngPath) {
   switch (mode) {
     case "interactive":
@@ -29191,8 +29511,8 @@ async function captureScreenshot(mode) {
       "screencapture is only available on macOS. Use --file <path> to attach an existing image."
     );
   }
-  const tmpDir = await mkdtemp2(join14(tmpdir3(), "syntaur-screenshot-"));
-  const pngPath = join14(tmpDir, "shot.png");
+  const tmpDir = await mkdtemp2(join15(tmpdir3(), "syntaur-screenshot-"));
+  const pngPath = join15(tmpDir, "shot.png");
   const cleanup = async () => {
     await rm9(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -29230,9 +29550,9 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile48, rm as rm10 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile49, rm as rm10 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
 function shellQuote2(s) {
   if (s.length === 0) return `''`;
@@ -29269,8 +29589,8 @@ function runAsciinema(args, stdio) {
   });
 }
 async function captureAsciinema(opts) {
-  const tmpDir = await mkdtemp3(join15(tmpdir4(), "syntaur-asciinema-"));
-  const castPath = join15(tmpDir, "session.cast");
+  const tmpDir = await mkdtemp3(join16(tmpdir4(), "syntaur-asciinema-"));
+  const castPath = join16(tmpDir, "session.cast");
   const cleanup = async () => {
     await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -29293,7 +29613,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile48(castPath, "utf8").catch(() => null);
+    const text = await readFile49(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.`
@@ -29321,9 +29641,9 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn9 } from "child_process";
-import { mkdir as mkdir9, mkdtemp as mkdtemp4, open as open3, readFile as readFile49, rm as rm11, stat as stat8, unlink as unlink10, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir10, mkdtemp as mkdtemp4, open as open3, readFile as readFile50, rm as rm11, stat as stat8, unlink as unlink10, writeFile as writeFile14 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join16, resolve as resolve71 } from "path";
+import { join as join17, resolve as resolve72 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
   const raw2 = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
@@ -29344,13 +29664,13 @@ function sigtermWaitMs() {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1e3;
 }
 function pidfilePath() {
-  return resolve71(syntaurRoot(), "recording.pid");
+  return resolve72(syntaurRoot(), "recording.pid");
 }
 function logPath2() {
-  return resolve71(syntaurRoot(), "recording.log");
+  return resolve72(syntaurRoot(), "recording.log");
 }
 function sidecarPath() {
-  return resolve71(syntaurRoot(), "recording.json");
+  return resolve72(syntaurRoot(), "recording.json");
 }
 function ffmpegArgs(device, fps, mp4Path) {
   return [
@@ -29395,7 +29715,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile49(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile50(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);
@@ -29437,7 +29757,7 @@ async function startRecording(input4) {
     );
   }
   const root = syntaurRoot();
-  await mkdir9(root, { recursive: true });
+  await mkdir10(root, { recursive: true });
   const pidfile = pidfilePath();
   const log = logPath2();
   const sidecar = sidecarPath();
@@ -29448,8 +29768,8 @@ async function startRecording(input4) {
   let acquiredPid = null;
   try {
     logHandle = await open3(log, "w");
-    tmpDir = await mkdtemp4(join16(tmpdir5(), "syntaur-recording-"));
-    const mp4Path = join16(tmpDir, "recording.mp4");
+    tmpDir = await mkdtemp4(join17(tmpdir5(), "syntaur-recording-"));
+    const mp4Path = join17(tmpDir, "recording.mp4");
     let child;
     try {
       child = spawn9("ffmpeg", ffmpegArgs(input4.device, input4.fps, mp4Path), {
@@ -29497,7 +29817,7 @@ async function startRecording(input4) {
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile49(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile50(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}
@@ -29554,7 +29874,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile49(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile50(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -29564,7 +29884,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile49(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile50(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.`
@@ -29629,7 +29949,7 @@ async function stopRecording() {
 // src/db/proof-db.ts
 init_paths();
 import Database5 from "better-sqlite3";
-import { resolve as resolve72 } from "path";
+import { resolve as resolve73 } from "path";
 var db4 = null;
 var PROOF_SCHEMA_VERSION = "1";
 var SCHEMA_SQL4 = `
@@ -29649,7 +29969,7 @@ CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
 function initProofDb(dbPath) {
   if (db4) return db4;
-  const finalPath = dbPath ?? resolve72(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve73(syntaurRoot(), "syntaur.db");
   db4 = new Database5(finalPath);
   db4.pragma("journal_mode = WAL");
   db4.exec(SCHEMA_SQL4);
@@ -29697,9 +30017,9 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn10 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile50, rm as rm12 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile51, rm as rm12 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } 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",
@@ -29761,7 +30081,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile50(wavPath);
+  const audio = await readFile51(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -29789,8 +30109,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(join17(tmpdir6(), "syntaur-transcribe-"));
-    const wav = join17(tmp, "audio.wav");
+    const tmp = await mkdtemp5(join18(tmpdir6(), "syntaur-transcribe-"));
+    const wav = join18(tmp, "audio.wav");
     try {
       await extractAudio(videoAbsPath, wav);
       return await callScribe(wav, apiKey, opts);
@@ -30064,7 +30384,7 @@ async function captureCommand(target, options = {}) {
     criterionIndex = sidecar.criterionIndex;
     stopNote = sidecar.note;
     resolvedSource = mp4Path;
-    const mp4TmpDir = dirname21(mp4Path);
+    const mp4TmpDir = dirname22(mp4Path);
     shelloutCleanup = async () => {
       await rm13(mp4TmpDir, { recursive: true, force: true }).catch(() => {
       });
@@ -30077,7 +30397,7 @@ async function captureCommand(target, options = {}) {
     });
   }
   if (options.file) {
-    const expanded = options.file.startsWith("~/") ? resolve73(process.env.HOME ?? "", options.file.slice(2)) : resolve73(options.file);
+    const expanded = options.file.startsWith("~/") ? resolve74(process.env.HOME ?? "", options.file.slice(2)) : resolve74(options.file);
     if (!await fileExists(expanded)) {
       throw new Error(`--file does not exist: ${options.file}`);
     }
@@ -30118,8 +30438,8 @@ async function captureCommand(target, options = {}) {
     }
     initProofDb();
     const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-    const destDir = resolve73(proofDir(resolved.assignmentDir), subdir);
-    if (resolvedSource) await mkdir10(destDir, { recursive: true });
+    const destDir = resolve74(proofDir(resolved.assignmentDir), subdir);
+    if (resolvedSource) await mkdir11(destDir, { recursive: true });
     const ext = resolvedSource ? extensionForKind(kind) : null;
     let id = null;
     let relativeFilePath = null;
@@ -30127,7 +30447,7 @@ async function captureCommand(target, options = {}) {
     let lastErr = null;
     for (let attempt = 0; attempt < MAX_ID_RETRIES; attempt += 1) {
       const candidate = generateArtifactId();
-      const candidateAbsPath = resolvedSource && ext ? resolve73(destDir, `${candidate}.${ext}`) : null;
+      const candidateAbsPath = resolvedSource && ext ? resolve74(destDir, `${candidate}.${ext}`) : null;
       const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
       try {
         insertArtifact({
@@ -30171,7 +30491,7 @@ async function captureCommand(target, options = {}) {
       }
     }
     if (options.transcribe && kind === "video" && absPath && id) {
-      const sidecarPath2 = resolve73(destDir, `${id}.transcript.md`);
+      const sidecarPath2 = resolve74(destDir, `${id}.transcript.md`);
       if (existsSync6(sidecarPath2)) {
         console.warn(
           `transcript: ${sidecarPath2} already exists, skipping (delete to re-transcribe)`
@@ -30203,7 +30523,7 @@ async function captureCommand(target, options = {}) {
     const tagSuffix = criterionIndex === null ? "untagged" : `criterion ${criterionIndex}`;
     console.log(`Captured artifact ${id} (${kind}) for ${ref} \u2014 ${tagSuffix}.`);
     if (relativeFilePath) {
-      console.log(`  file: ${resolve73(resolved.assignmentDir, relativeFilePath)}`);
+      console.log(`  file: ${resolve74(resolved.assignmentDir, relativeFilePath)}`);
     }
   } catch (err2) {
     if (options.stop && kind === "video" && shelloutCleanup && resolvedSource) {
@@ -30226,8 +30546,8 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile51, writeFile as writeFile16, rename as rename10, stat as stat10 } from "fs/promises";
-import { resolve as resolve74, relative as relative5, isAbsolute as isAbsolute12, dirname as dirname22 } from "path";
+import { readFile as readFile52, writeFile as writeFile16, rename as rename10, stat as stat10 } from "fs/promises";
+import { resolve as resolve75, relative as relative5, isAbsolute as isAbsolute12, dirname as dirname23 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -30467,11 +30787,11 @@ function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map(), trans
 
 // src/commands/proof.ts
 async function readAssignmentMeta(assignmentDir) {
-  const path = resolve74(assignmentDir, "assignment.md");
+  const path = resolve75(assignmentDir, "assignment.md");
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile51(path, "utf-8");
+  const content = await readFile52(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -30518,7 +30838,7 @@ async function loadInlineFiles(rows, assignmentDir) {
   for (const r of rows) {
     if (!r.file_path) continue;
     if (r.kind !== "http" && r.kind !== "text") continue;
-    const abs = resolve74(assignmentDir, r.file_path);
+    const abs = resolve75(assignmentDir, r.file_path);
     if (!isWithin(proofRoot, abs)) {
       out.set(r.file_path, null);
       continue;
@@ -30533,7 +30853,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       continue;
     }
     try {
-      out.set(r.file_path, await readFile51(abs, "utf-8"));
+      out.set(r.file_path, await readFile52(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -30545,14 +30865,14 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
   const proofRoot = proofDir(assignmentDir);
   for (const r of rows) {
     if (r.kind !== "video" || !r.file_path) continue;
-    const videoAbs = resolve74(assignmentDir, r.file_path);
-    const sidecar = resolve74(dirname22(videoAbs), `${r.id}.transcript.md`);
+    const videoAbs = resolve75(assignmentDir, r.file_path);
+    const sidecar = resolve75(dirname23(videoAbs), `${r.id}.transcript.md`);
     if (!isWithin(proofRoot, sidecar)) continue;
     if (!await fileExists(sidecar)) continue;
     const st = await stat10(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile51(sidecar, "utf-8"));
+      out.set(r.id, await readFile52(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -30586,8 +30906,8 @@ async function proofBuildCommand(target, options = {}) {
   };
   const md = renderProofMarkdown(renderParams);
   const html = renderProofHtml(renderParams, inlineFiles, transcriptSidecars);
-  const mdPath = resolve74(resolved.assignmentDir, "proof.md");
-  const htmlPath = resolve74(resolved.assignmentDir, "proof.html");
+  const mdPath = resolve75(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve75(resolved.assignmentDir, "proof.html");
   await atomicWrite(mdPath, md);
   await atomicWrite(htmlPath, html);
   console.log(`Wrote ${htmlPath}`);
@@ -31252,7 +31572,7 @@ async function runCcusage(opts = {}) {
   };
 }
 function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
-  return new Promise((resolve86) => {
+  return new Promise((resolve87) => {
     const child = spawn11(binary, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -31266,7 +31586,7 @@ function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
-      resolve86(result);
+      resolve87(result);
     };
     const timer2 = setTimeout(() => {
       timedOut = true;
@@ -31310,8 +31630,8 @@ function isoToCcusageDate(iso) {
 
 // src/usage/cwd-extractor.ts
 init_paths();
-import { open as open4, readdir as readdir25, stat as stat11 } from "fs/promises";
-import { join as join18 } from "path";
+import { open as open4, readdir as readdir26, stat as stat11 } from "fs/promises";
+import { join as join19 } from "path";
 import { homedir as homedir12 } from "os";
 var SCAN_LINE_CAP = 50;
 var TAIL_READ_BYTES = 8 * 1024;
@@ -31386,12 +31706,12 @@ async function* walkClaudeProjects(opts = {}) {
   const dirs = await listDirSafe(root);
   for (const dirent of dirs) {
     if (!dirent.isDirectory) continue;
-    const dirPath = join18(root, dirent.name);
+    const dirPath = join19(root, dirent.name);
     const files = await listDirSafe(dirPath);
     let cachedCwd = null;
     for (const f of files) {
       if (!f.isFile || !f.name.endsWith(".jsonl")) continue;
-      const filePath = join18(dirPath, f.name);
+      const filePath = join19(dirPath, f.name);
       if (opts.sinceMtimeMs !== void 0) {
         const mtime = await mtimeMs(filePath);
         if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -31428,12 +31748,12 @@ function resolveCodexSessionsRoot(override) {
   const fromSessionsEnv = process.env.CODEX_SESSIONS_DIR;
   if (fromSessionsEnv && fromSessionsEnv.length > 0) return expandHome(fromSessionsEnv);
   const fromHomeEnv = process.env.CODEX_HOME;
-  if (fromHomeEnv && fromHomeEnv.length > 0) return join18(expandHome(fromHomeEnv), "sessions");
-  return join18(homedir12(), ".codex", "sessions");
+  if (fromHomeEnv && fromHomeEnv.length > 0) return join19(expandHome(fromHomeEnv), "sessions");
+  return join19(homedir12(), ".codex", "sessions");
 }
 async function listDirSafe(path) {
   try {
-    const entries = await readdir25(path, { withFileTypes: true });
+    const entries = await readdir26(path, { withFileTypes: true });
     return entries.map((e) => ({
       name: e.name,
       isFile: e.isFile(),
@@ -31449,7 +31769,7 @@ async function* walkJsonlRecursive(root) {
     const current = stack.pop();
     const entries = await listDirSafe(current);
     for (const e of entries) {
-      const full = join18(current, e.name);
+      const full = join19(current, e.name);
       if (e.isDirectory) {
         stack.push(full);
       } else if (e.isFile && e.name.endsWith(".jsonl")) {
@@ -31788,8 +32108,8 @@ init_slug();
 init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
-import { resolve as resolve75 } from "path";
-import { readFile as readFile52 } from "fs/promises";
+import { resolve as resolve76 } from "path";
+import { readFile as readFile53 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -31805,7 +32125,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve75(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve76(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -31815,12 +32135,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath2 = resolve75(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve76(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile52(assignmentMdPath2, "utf-8");
+  let content = await readFile53(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -31834,13 +32154,13 @@ init_fs();
 init_paths();
 init_config2();
 import { Command as Command9 } from "commander";
-import { readFile as readFile53, readdir as readdir26 } from "fs/promises";
-import { resolve as resolve76 } from "path";
+import { readFile as readFile54, readdir as readdir27 } from "fs/promises";
+import { resolve as resolve77 } from "path";
 async function readContextAssignmentDir(cwd) {
-  const path = resolve76(cwd, ".syntaur", "context.json");
+  const path = resolve77(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile53(path, "utf-8");
+    const raw2 = await readFile54(path, "utf-8");
     const ctx = JSON.parse(raw2);
     if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
       return ctx.assignmentDir;
@@ -31854,9 +32174,9 @@ async function resolveAssignmentDir(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.assignment) {
     if (opts.project) {
-      return resolve76((await readConfig()).defaultProjectDir, opts.project, "assignments", opts.assignment);
+      return resolve77((await readConfig()).defaultProjectDir, opts.project, "assignments", opts.assignment);
     }
-    return resolve76(assignmentsDir(), opts.assignment);
+    return resolve77(assignmentsDir(), opts.assignment);
   }
   const fromCtx = await readContextAssignmentDir(cwd);
   if (fromCtx) return fromCtx;
@@ -31867,7 +32187,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir26(assignmentDir, { withFileTypes: true });
+  const entries = await readdir27(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -32052,17 +32372,17 @@ async function runPlanCreate(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve76(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve77(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
-  const planPath = resolve76(assignmentDir, "plan.md");
+  const planPath = resolve77(assignmentDir, "plan.md");
   if (await fileExists(planPath) && !options.force) {
     throw new Error(
       "plan.md already exists. Use --force to overwrite, or `syntaur plan version` to create the next version."
     );
   }
-  const assignmentMd = await readFile53(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile54(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));
@@ -32082,7 +32402,7 @@ async function runPlanVersion(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve76(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve77(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
@@ -32094,15 +32414,15 @@ async function runPlanVersion(options) {
   }
   const current = planFiles[planFiles.length - 1];
   const next = nextPlanFileName(current.version);
-  const newPath = resolve76(assignmentDir, next.fileName);
+  const newPath = resolve77(assignmentDir, next.fileName);
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
-  const assignmentMd = await readFile53(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile54(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
-  const oldPlanPath = resolve76(assignmentDir, current.fileName);
-  const oldPlanContent = await readFile53(oldPlanPath, "utf-8");
+  const oldPlanPath = resolve77(assignmentDir, current.fileName);
+  const oldPlanContent = await readFile54(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -32150,26 +32470,26 @@ init_paths();
 init_config2();
 init_timestamp();
 import { Command as Command10 } from "commander";
-import { readFile as readFile54, readdir as readdir27, stat as stat12 } from "fs/promises";
-import { resolve as resolve77 } from "path";
+import { readFile as readFile55, readdir as readdir28, stat as stat12 } from "fs/promises";
+import { resolve as resolve78 } from "path";
 async function readContext(cwd) {
-  const path = resolve77(cwd, ".syntaur", "context.json");
+  const path = resolve78(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw2 = await readFile54(path, "utf-8");
+    const raw2 = await readFile55(path, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return null;
   }
 }
 async function findLatestSessionSummary(assignmentDir) {
-  const sessionsRoot = resolve77(assignmentDir, "sessions");
+  const sessionsRoot = resolve78(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir27(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir28(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const summaryPath = resolve77(sessionsRoot, entry.name, "summary.md");
+    const summaryPath = resolve78(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
     const st = await stat12(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
@@ -32179,9 +32499,9 @@ async function findLatestSessionSummary(assignmentDir) {
   return best;
 }
 async function findOpenHandoff(assignmentDir) {
-  const handoffPath = resolve77(assignmentDir, "handoff.md");
+  const handoffPath = resolve78(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile54(handoffPath, "utf-8");
+  const content = await readFile55(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;
@@ -32276,7 +32596,7 @@ async function resolveSaveTarget(options, cwd) {
   let slug;
   const ctx = await readContext(cwd);
   if (options.assignment) {
-    assignmentDir = options.project ? resolve77((await readConfig()).defaultProjectDir, options.project, "assignments", options.assignment) : resolve77(assignmentsDir(), options.assignment);
+    assignmentDir = options.project ? resolve78((await readConfig()).defaultProjectDir, options.project, "assignments", options.assignment) : resolve78(assignmentsDir(), options.assignment);
     slug = options.assignment;
   } else {
     if (!ctx?.assignmentDir) {
@@ -32329,21 +32649,21 @@ function extractCreated(content) {
 }
 async function runSessionSave(options, cwd = process.cwd(), body) {
   const { assignmentDir, slug, sessionId } = await resolveSaveTarget(options, cwd);
-  if (!await fileExists(resolve77(assignmentDir, "assignment.md"))) {
+  if (!await fileExists(resolve78(assignmentDir, "assignment.md"))) {
     throw new Error(`No assignment found at ${assignmentDir} (missing assignment.md).`);
   }
-  const sessionDir = resolve77(assignmentDir, "sessions", sessionId);
-  const summaryPath = resolve77(sessionDir, "summary.md");
+  const sessionDir = resolve78(assignmentDir, "sessions", sessionId);
+  const summaryPath = resolve78(sessionDir, "summary.md");
   const now = nowTimestamp();
   let created = now;
   if (await fileExists(summaryPath)) {
-    const existing = await readFile54(summaryPath, "utf-8");
+    const existing = await readFile55(summaryPath, "utf-8");
     created = extractCreated(existing) ?? now;
   }
   let sectionBody = body;
   if (sectionBody === void 0) {
     if (options.fromFile) {
-      sectionBody = await readFile54(resolve77(cwd, options.fromFile), "utf-8");
+      sectionBody = await readFile55(resolve78(cwd, options.fromFile), "utf-8");
     } else {
       sectionBody = await readStdin();
     }
@@ -32391,13 +32711,13 @@ init_config2();
 init_timestamp();
 init_frontmatter();
 import { Command as Command11 } from "commander";
-import { readFile as readFile55 } from "fs/promises";
-import { resolve as resolve78 } from "path";
+import { readFile as readFile56 } from "fs/promises";
+import { resolve as resolve79 } from "path";
 async function readContext2(cwd) {
-  const path = resolve78(cwd, ".syntaur", "context.json");
+  const path = resolve79(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile55(path, "utf-8"));
+    return JSON.parse(await readFile56(path, "utf-8"));
   } catch {
     return null;
   }
@@ -32406,12 +32726,12 @@ async function resolveAssignmentPath2(opts) {
   if (opts.assignment) {
     if (opts.project) {
       const projectsDir2 = (await readConfig()).defaultProjectDir;
-      return resolve78(projectsDir2, opts.project, "assignments", opts.assignment, "assignment.md");
+      return resolve79(projectsDir2, opts.project, "assignments", opts.assignment, "assignment.md");
     }
-    return resolve78(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve79(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext2(opts.cwd);
-  if (ctx?.assignmentDir) return resolve78(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve79(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -32422,7 +32742,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   }
   const repository = options.repository ?? cwd;
   const parentBranch = options.parentBranch ?? "main";
-  const worktreePath = options.worktreePath ?? resolve78(repository, ".worktrees", options.branch);
+  const worktreePath = options.worktreePath ?? resolve79(repository, ".worktrees", options.branch);
   const assignmentPath = await resolveAssignmentPath2({
     assignment: options.assignment,
     project: options.project,
@@ -32452,7 +32772,7 @@ async function runWorktreeRemove(options, cwd = process.cwd()) {
   if (!await fileExists(assignmentPath)) {
     throw new Error(`Assignment file not found: ${assignmentPath}`);
   }
-  const original = await readFile55(assignmentPath, "utf-8");
+  const original = await readFile56(assignmentPath, "utf-8");
   const fm = parseAssignmentFrontmatter(original);
   const repository = options.repository ?? fm.workspace.repository ?? void 0;
   const worktreePath = fm.workspace.worktreePath ?? void 0;
@@ -32551,14 +32871,14 @@ init_config2();
 init_fs();
 init_slug();
 import { Command as Command12 } from "commander";
-import { resolve as resolve80 } from "path";
-import { readFile as readFile57, readdir as readdir29, rm as rm14 } from "fs/promises";
+import { resolve as resolve81 } from "path";
+import { readFile as readFile58, readdir as readdir30, rm as rm14 } from "fs/promises";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir28, readFile as readFile56 } from "fs/promises";
-import { resolve as resolve79 } from "path";
+import { readdir as readdir29, readFile as readFile57 } from "fs/promises";
+import { resolve as resolve80 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -32567,7 +32887,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir28(dir, { withFileTypes: true });
+  const entries = await readdir29(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -32577,7 +32897,7 @@ function joinList(items) {
   return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
 }
 async function rebuildResourcesIndex(projectDir) {
-  const dir = resolve79(projectDir, "resources");
+  const dir = resolve80(projectDir, "resources");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -32593,7 +32913,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile56(resolve79(dir, fileName), "utf-8");
+    const content = await readFile57(resolve80(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -32603,12 +32923,12 @@ async function rebuildResourcesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve79(dir, "_index.md");
+  const indexPath = resolve80(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 async function rebuildMemoriesIndex(projectDir) {
-  const dir = resolve79(projectDir, "memories");
+  const dir = resolve80(projectDir, "memories");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -32624,7 +32944,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile56(resolve79(dir, fileName), "utf-8");
+    const content = await readFile57(resolve80(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -32634,7 +32954,7 @@ async function rebuildMemoriesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve79(dir, "_index.md");
+  const indexPath = resolve80(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
@@ -32698,8 +33018,8 @@ ${opts.body ?? "<!-- Add notes about this resource here. -->"}
 }
 async function resolveProjectDir(project) {
   if (!isValidSlug(project)) throw new Error(`Invalid project slug: "${project}".`);
-  const projectDir = resolve80((await readConfig()).defaultProjectDir, project);
-  if (!await fileExists(resolve80(projectDir, "project.md"))) {
+  const projectDir = resolve81((await readConfig()).defaultProjectDir, project);
+  if (!await fileExists(resolve81(projectDir, "project.md"))) {
     throw new Error(`Project "${project}" not found at ${projectDir}.`);
   }
   return projectDir;
@@ -32712,7 +33032,7 @@ async function runResourceAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid resource slug: "${slug}".`);
   }
-  const filePath = resolve80(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve81(projectDir, "resources", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -32729,9 +33049,9 @@ async function runResourceAdd(options) {
   return { filePath, indexPath, total };
 }
 async function listResourceSlugs(projectDir) {
-  const dir = resolve80(projectDir, "resources");
+  const dir = resolve81(projectDir, "resources");
   if (!await fileExists(dir)) return [];
-  const entries = await readdir29(dir, { withFileTypes: true });
+  const entries = await readdir30(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) {
@@ -32739,16 +33059,16 @@ async function runResourceList(project) {
   const slugs = await listResourceSlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseResource(await readFile57(resolve80(projectDir, "resources", `${slug}.md`), "utf-8"));
+    const parsed = parseResource(await readFile58(resolve81(projectDir, "resources", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, category: parsed.category, source: parsed.source, updated: parsed.updated });
   }
   return out;
 }
 async function runResourceShow(project, slug) {
   const projectDir = await resolveProjectDir(project);
-  const filePath = resolve80(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve81(projectDir, "resources", `${slug}.md`);
   if (!await fileExists(filePath)) throw new Error(`Resource "${slug}" not found in project "${project}".`);
-  const parsed = parseResource(await readFile57(filePath, "utf-8"));
+  const parsed = parseResource(await readFile58(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -32762,14 +33082,14 @@ async function runResourceShow(project, slug) {
 }
 async function runResourceUpdate(slug, options) {
   const projectDir = await resolveProjectDir(options.project);
-  const filePath = resolve80(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve81(projectDir, "resources", `${slug}.md`);
   if (!await fileExists(filePath)) {
     throw new Error(`Resource "${slug}" not found in project "${options.project}".`);
   }
   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 readFile57(filePath, "utf-8");
+  const original = await readFile58(filePath, "utf-8");
   const content = editResourceFrontmatter(original, {
     name: options.name,
     category: options.category,
@@ -32782,7 +33102,7 @@ async function runResourceUpdate(slug, options) {
 }
 async function runResourceRemove(slug, options) {
   const projectDir = await resolveProjectDir(options.project);
-  const filePath = resolve80(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve81(projectDir, "resources", `${slug}.md`);
   if (!await fileExists(filePath)) {
     throw new Error(`Resource "${slug}" not found in project "${options.project}".`);
   }
@@ -32865,8 +33185,8 @@ init_config2();
 init_fs();
 init_slug();
 import { Command as Command13 } from "commander";
-import { resolve as resolve81 } from "path";
-import { readFile as readFile58, readdir as readdir30, rm as rm15 } from "fs/promises";
+import { resolve as resolve82 } from "path";
+import { readFile as readFile59, readdir as readdir31, rm as rm15 } from "fs/promises";
 init_parser();
 function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -32930,8 +33250,8 @@ ${opts.body ?? "<!-- Capture the load-bearing context for this memory here. -->"
 }
 async function resolveProjectDir2(project) {
   if (!isValidSlug(project)) throw new Error(`Invalid project slug: "${project}".`);
-  const projectDir = resolve81((await readConfig()).defaultProjectDir, project);
-  if (!await fileExists(resolve81(projectDir, "project.md"))) {
+  const projectDir = resolve82((await readConfig()).defaultProjectDir, project);
+  if (!await fileExists(resolve82(projectDir, "project.md"))) {
     throw new Error(`Project "${project}" not found at ${projectDir}.`);
   }
   return projectDir;
@@ -32944,7 +33264,7 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid memory slug: "${slug}".`);
   }
-  const filePath = resolve81(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve82(projectDir, "memories", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -32962,9 +33282,9 @@ async function runMemoryAdd(options) {
   return { filePath, indexPath, total };
 }
 async function listMemorySlugs(projectDir) {
-  const dir = resolve81(projectDir, "memories");
+  const dir = resolve82(projectDir, "memories");
   if (!await fileExists(dir)) return [];
-  const entries = await readdir30(dir, { withFileTypes: true });
+  const entries = await readdir31(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) {
@@ -32972,16 +33292,16 @@ async function runMemoryList(project) {
   const slugs = await listMemorySlugs(projectDir);
   const out = [];
   for (const slug of slugs) {
-    const parsed = parseMemory(await readFile58(resolve81(projectDir, "memories", `${slug}.md`), "utf-8"));
+    const parsed = parseMemory(await readFile59(resolve82(projectDir, "memories", `${slug}.md`), "utf-8"));
     out.push({ slug, name: parsed.name, scope: parsed.scope, source: parsed.source, updated: parsed.updated });
   }
   return out;
 }
 async function runMemoryShow(project, slug) {
   const projectDir = await resolveProjectDir2(project);
-  const filePath = resolve81(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve82(projectDir, "memories", `${slug}.md`);
   if (!await fileExists(filePath)) throw new Error(`Memory "${slug}" not found in project "${project}".`);
-  const parsed = parseMemory(await readFile58(filePath, "utf-8"));
+  const parsed = parseMemory(await readFile59(filePath, "utf-8"));
   return {
     slug,
     name: parsed.name,
@@ -32996,7 +33316,7 @@ async function runMemoryShow(project, slug) {
 }
 async function runMemoryUpdate(slug, options) {
   const projectDir = await resolveProjectDir2(options.project);
-  const filePath = resolve81(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve82(projectDir, "memories", `${slug}.md`);
   if (!await fileExists(filePath)) {
     throw new Error(`Memory "${slug}" not found in project "${options.project}".`);
   }
@@ -33005,7 +33325,7 @@ async function runMemoryUpdate(slug, options) {
       "Provide at least one of --name, --source, --scope, --source-assignment, --related-assignments."
     );
   }
-  const original = await readFile58(filePath, "utf-8");
+  const original = await readFile59(filePath, "utf-8");
   const content = editMemoryFrontmatter(original, {
     name: options.name,
     source: options.source,
@@ -33019,7 +33339,7 @@ async function runMemoryUpdate(slug, options) {
 }
 async function runMemoryRemove(slug, options) {
   const projectDir = await resolveProjectDir2(options.project);
-  const filePath = resolve81(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve82(projectDir, "memories", `${slug}.md`);
   if (!await fileExists(filePath)) {
     throw new Error(`Memory "${slug}" not found in project "${options.project}".`);
   }
@@ -33104,8 +33424,8 @@ init_paths();
 init_fs();
 init_frontmatter();
 import { Command as Command14 } from "commander";
-import { readFile as readFile59 } from "fs/promises";
-import { resolve as resolve82 } from "path";
+import { readFile as readFile60 } from "fs/promises";
+import { resolve as resolve83 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -33124,7 +33444,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve82(
+    return resolve83(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -33132,13 +33452,13 @@ function assignmentMdPath(item) {
       "assignment.md"
     );
   }
-  return resolve82(assignmentsDir(), item.id, "assignment.md");
+  return resolve83(assignmentsDir(), item.id, "assignment.md");
 }
 async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile59(path, "utf-8");
+    const content = await readFile60(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -33567,8 +33887,8 @@ init_fs();
 init_timestamp();
 init_frontmatter();
 import { Command as Command16 } from "commander";
-import { readFile as readFile60 } from "fs/promises";
-import { resolve as resolve83 } from "path";
+import { readFile as readFile61 } from "fs/promises";
+import { resolve as resolve84 } from "path";
 async function scanDirs() {
   const config = await readConfig();
   return { projectsDir: config.defaultProjectDir, standaloneDir: assignmentsDir() };
@@ -33578,12 +33898,12 @@ function fail3(error) {
   process.exit(1);
 }
 function configPath() {
-  return resolve83(syntaurRoot(), "config.md");
+  return resolve84(syntaurRoot(), "config.md");
 }
 async function readStatusBlock() {
   const p = configPath();
   if (!await fileExists(p)) return null;
-  const content = await readFile60(p, "utf-8");
+  const content = await readFile61(p, "utf-8");
   return parseStatusConfig(content);
 }
 async function requireStatusBlock() {
@@ -33832,7 +34152,7 @@ async function runStatusRename(id, opts) {
     printBlockDiff(before, after);
     const now2 = nowTimestamp();
     for (const a of affected) {
-      const original = await readFile60(a.path, "utf-8");
+      const original = await readFile61(a.path, "utf-8");
       const rewritten = updateAssignmentFile(original, { status: newId, updated: now2 });
       console.log(`
 --- ${a.display}/assignment.md`);
@@ -33843,9 +34163,9 @@ async function runStatusRename(id, opts) {
   }
   const cfgPath = configPath();
   const buffers = /* @__PURE__ */ new Map();
-  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile60(cfgPath, "utf-8") : "");
+  buffers.set(cfgPath, await fileExists(cfgPath) ? await readFile61(cfgPath, "utf-8") : "");
   for (const a of affected) {
-    buffers.set(a.path, await readFile60(a.path, "utf-8"));
+    buffers.set(a.path, await readFile61(a.path, "utf-8"));
   }
   const now = nowTimestamp();
   try {
@@ -34025,13 +34345,13 @@ init_config2();
 init_timestamp();
 init_frontmatter();
 import { Command as Command17 } from "commander";
-import { readFile as readFile61 } from "fs/promises";
-import { resolve as resolve84 } from "path";
+import { readFile as readFile62 } from "fs/promises";
+import { resolve as resolve85 } from "path";
 async function readContext3(cwd) {
-  const path = resolve84(cwd, ".syntaur", "context.json");
+  const path = resolve85(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile61(path, "utf-8"));
+    return JSON.parse(await readFile62(path, "utf-8"));
   } catch {
     return null;
   }
@@ -34040,12 +34360,12 @@ async function resolveAssignmentPath3(opts) {
   if (opts.assignment) {
     if (opts.project) {
       const projectsDir2 = (await readConfig()).defaultProjectDir;
-      return resolve84(projectsDir2, opts.project, "assignments", opts.assignment, "assignment.md");
+      return resolve85(projectsDir2, opts.project, "assignments", opts.assignment, "assignment.md");
     }
-    return resolve84(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve85(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext3(opts.cwd);
-  if (ctx?.assignmentDir) return resolve84(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve85(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -34082,7 +34402,7 @@ async function runWorkspaceSet(options, cwd = process.cwd()) {
 ${pre.errors.map((e) => `  - ${e}`).join("\n")}`
     );
   }
-  const original = await readFile61(path, "utf-8");
+  const original = await readFile62(path, "utf-8");
   let next = updateAssignmentWorkspace(original, partial);
   next = updateAssignmentFile(next, { updated: nowTimestamp() });
   await writeFileForce(path, next);
@@ -34119,13 +34439,13 @@ init_config2();
 init_timestamp();
 init_templates();
 import { Command as Command18 } from "commander";
-import { readFile as readFile62 } from "fs/promises";
-import { resolve as resolve85 } from "path";
+import { readFile as readFile63 } from "fs/promises";
+import { resolve as resolve86 } from "path";
 async function readContext4(cwd) {
-  const path = resolve85(cwd, ".syntaur", "context.json");
+  const path = resolve86(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile62(path, "utf-8"));
+    return JSON.parse(await readFile63(path, "utf-8"));
   } catch {
     return null;
   }
@@ -34135,11 +34455,11 @@ async function resolveAssignmentDir2(opts) {
     if (opts.project) {
       const projectsDir2 = (await readConfig()).defaultProjectDir;
       return {
-        dir: resolve85(projectsDir2, opts.project, "assignments", opts.assignment),
+        dir: resolve86(projectsDir2, opts.project, "assignments", opts.assignment),
         slug: opts.assignment
       };
     }
-    return { dir: resolve85(assignmentsDir(), opts.assignment), slug: opts.assignment };
+    return { dir: resolve86(assignmentsDir(), opts.assignment), slug: opts.assignment };
   }
   const ctx = await readContext4(opts.cwd);
   if (ctx?.assignmentDir) {
@@ -34201,12 +34521,12 @@ async function runProgressLog(text, options, cwd = process.cwd()) {
     project: options.project,
     cwd
   });
-  if (!await fileExists(resolve85(dir, "assignment.md"))) {
+  if (!await fileExists(resolve86(dir, "assignment.md"))) {
     throw new Error(`No assignment found at ${dir} (missing assignment.md).`);
   }
-  const path = resolve85(dir, "progress.md");
+  const path = resolve86(dir, "progress.md");
   const now = nowTimestamp();
-  const content = await fileExists(path) ? await readFile62(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
+  const content = await fileExists(path) ? await readFile63(path, "utf-8") : renderProgress({ assignment: slug, timestamp: now });
   const next = appendProgressEntry(content, text, now);
   await writeFileForce(path, next);
   return path;
@@ -34226,10 +34546,10 @@ progressCommand.command("log").description("Append a timestamped entry to the as
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir31 } from "fs/promises";
+import { readdir as readdir32 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir31(projectsDir2, { withFileTypes: true });
+    const entries = await readdir32(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;
@@ -34531,7 +34851,7 @@ program.command("reopen").description("Reopen a completed or failed assignment")
     process.exit(1);
   }
 });
-program.command("setup").description("Initialize Syntaur and optionally install plugins or launch the dashboard").option("--yes", "Skip interactive prompts and perform only the requested flags").option("--claude", "Install the Claude Code plugin").option("--codex", "Install the Codex plugin").option("--claude-dir <path>", "Install the Claude Code plugin at a specific path").option("--codex-dir <path>", "Install the Codex plugin at a specific path").option("--codex-marketplace-path <path>", "Write the Codex marketplace entry to a specific file").option("--dashboard", "Launch the dashboard after setup").option("--target <id>", "Install Syntaur into a cross-agent target (pi, hermes, openclaw, cursor, opencode); comma-separated for several").option("--agent <id>", "Alias for --target; cross-agent target id(s) to install into").option("--force", "Overwrite existing cross-agent protocol files / skills").option("--dry-run", "Print the cross-agent install actions without writing anything").action(async (options) => {
+program.command("setup").description("Initialize Syntaur and optionally install plugins or launch the dashboard").option("--yes", "Skip interactive prompts and perform only the requested flags").option("--claude", "Install the Claude Code plugin").option("--codex", "Install the Codex plugin").option("--claude-dir <path>", "Install the Claude Code plugin at a specific path").option("--codex-dir <path>", "Install the Codex plugin at a specific path").option("--codex-marketplace-path <path>", "Write the Codex marketplace entry to a specific file").option("--dashboard", "Launch the dashboard after setup").option("--target <id>", "Install Syntaur into a cross-agent target. Built-in ids: pi, hermes, openclaw, cursor, opencode (plus any user descriptors in ~/.syntaur/targets/). Comma-separated for several").option("--agent <id>", "Alias for --target; cross-agent target id(s) to install into").option("--force", "Overwrite existing cross-agent protocol files / skills").option("--dry-run", "Print the cross-agent install actions without writing anything").action(async (options) => {
   try {
     await setupCommand(options);
   } catch (error) {
@@ -34640,7 +34960,7 @@ program.command("uninstall").description("Remove Syntaur integrations and option
     process.exit(1);
   }
 });
-program.command("setup-adapter").description("Generate adapter instruction files for a framework in the current directory").argument("<framework>", "Target framework (cursor, codex, opencode)").option("--project <slug>", "Target project slug (required)").option("--assignment <slug>", "Target assignment slug (required)").option("--force", "Overwrite existing adapter files").option("--dir <path>", "Override default project directory").action(async (framework, options) => {
+program.command("setup-adapter").description("Generate adapter instruction files for a framework in the current directory").argument("<framework>", "Target framework: built-in ids cursor, codex, opencode, pi, openclaw, hermes (plus any user descriptor with an instructions adapter in ~/.syntaur/targets/)").option("--project <slug>", "Target project slug (required)").option("--assignment <slug>", "Target assignment slug (required)").option("--force", "Overwrite existing adapter files").option("--dir <path>", "Override default project directory").action(async (framework, options) => {
   try {
     await setupAdapterCommand(framework, options);
   } catch (error) {