syntaur 0.26.0 → 0.27.0

package/dist/index.js

@@ -187,8 +187,8 @@ function extractFrontmatter(fileContent) {
   const body = fileContent.slice(match[0].length).trim();
   return [frontmatterBlock, body];
 }
-function parseSimpleValue(raw) {
-  const trimmed = raw.trim();
+function parseSimpleValue(raw2) {
+  const trimmed = raw2.trim();
   if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
     return trimmed.slice(1, -1);
@@ -540,8 +540,8 @@ ${key}: ${formatted}${content.slice(closingIdx)}`;
 function readFrontmatterField(content, key) {
   const match = content.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
   if (!match) return null;
-  const raw = match[1].trim().replace(/^['"]|['"]$/g, "");
-  return raw === "" || raw === "null" ? null : raw;
+  const raw2 = match[1].trim().replace(/^['"]|['"]$/g, "");
+  return raw2 === "" || raw2 === "null" ? null : raw2;
 }
 async function migrateLegacyArchivedProjects(projectsDir2) {
   const result = { reconciled: [] };
@@ -811,9 +811,9 @@ function normalizeHiddenList(input4) {
   if (!Array.isArray(input4)) return [];
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const raw of input4) {
-    if (typeof raw !== "string") continue;
-    const name = raw.trim();
+  for (const raw2 of input4) {
+    if (typeof raw2 !== "string") continue;
+    const name = raw2.trim();
     if (name.length === 0) continue;
     if (name.length > MAX_WORKSPACE_NAME_LENGTH) continue;
     if (/[\r\n]/.test(name)) continue;
@@ -1192,13 +1192,13 @@ function parsePlaybooksConfig(fmBlock) {
       continue;
     }
     if (currentSection === "disabled" && indent >= 4 && trimmed.startsWith("- ")) {
-      const raw = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
-      if (raw.length === 0) continue;
-      if (/\s/.test(raw)) {
-        console.warn(`Warning: config.md playbooks.disabled entry "${raw}" contains whitespace, ignoring`);
+      const raw2 = trimmed.slice(2).trim().replace(/^["']|["']$/g, "");
+      if (raw2.length === 0) continue;
+      if (/\s/.test(raw2)) {
+        console.warn(`Warning: config.md playbooks.disabled entry "${raw2}" contains whitespace, ignoring`);
         continue;
       }
-      disabled.push(raw);
+      disabled.push(raw2);
       continue;
     }
   }
@@ -1478,9 +1478,9 @@ function serializeHotkeyBindingsConfig(cfg) {
 async function writeHotkeyBindingsConfig(cfg) {
   const cleaned = {};
   for (const kind of BINDABLE_ACTION_KINDS) {
-    const raw = cfg.bindings[kind];
-    if (typeof raw !== "string" || raw.trim() === "") continue;
-    const canonical = canonicalizeCombo(raw);
+    const raw2 = cfg.bindings[kind];
+    if (typeof raw2 !== "string" || raw2.trim() === "") continue;
+    const canonical = canonicalizeCombo(raw2);
     if (!canonical) continue;
     if (isReservedCombo(canonical)) continue;
     cleaned[kind] = canonical;
@@ -2277,8 +2277,8 @@ async function resolvePlaybookSlug(playbooksDir3, slug) {
   for (const entry of entries) {
     if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
     const filePath = resolve4(playbooksDir3, entry.name);
-    const raw = await readFile4(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile4(filePath, "utf-8");
+    const parsed = parsePlaybook(raw2);
     const canonical = parsed.slug || entry.name.replace(/\.md$/, "");
     if (canonical === slug) {
       return { filename: entry.name, slug: canonical, parsed };
@@ -2325,8 +2325,8 @@ async function rebuildPlaybookManifest(playbooksDir3) {
   const rows = [];
   for (const entry of entries) {
     if (!isVisiblePlaybookFile(entry.name, entry.isFile())) continue;
-    const raw = await readFile4(resolve4(playbooksDir3, entry.name), "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile4(resolve4(playbooksDir3, entry.name), "utf-8");
+    const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     if (disabledSet.has(slug)) continue;
     rows.push({
@@ -2403,8 +2403,8 @@ async function renamePlaybook(playbooksDir3, oldSlug, newSlug) {
       );
     }
   }
-  const raw = await readFile4(oldPath, "utf-8");
-  let next = setFrontmatterField2(raw, "slug", newSlug);
+  const raw2 = await readFile4(oldPath, "utf-8");
+  let next = setFrontmatterField2(raw2, "slug", newSlug);
   next = setFrontmatterField2(next, "updated", `"${nowTimestamp()}"`);
   await writeFileForce(newPath, next);
   if (!renamedInPlace) {
@@ -3683,8 +3683,8 @@ function extractFrontmatter2(fileContent) {
   const body = fileContent.slice(match[0].length);
   return [frontmatterBlock, body];
 }
-function parseSimpleValue2(raw) {
-  const trimmed = raw.trim();
+function parseSimpleValue2(raw2) {
+  const trimmed = raw2.trim();
   if (trimmed === "null" || trimmed === "~" || trimmed === "") return null;
   if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
     return trimmed.slice(1, -1);
@@ -5283,9 +5283,9 @@ async function migrateFromMarkdown(projectsDir2) {
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
   const { readFile: readFile56 } = await import("fs/promises");
-  const raw = await readFile56(filePath, "utf-8");
+  const raw2 = await readFile56(filePath, "utf-8");
   const sessions = [];
-  const lines = raw.split("\n");
+  const lines = raw2.split("\n");
   let inTable = false;
   let headerSeen = false;
   for (const line of lines) {
@@ -5441,8 +5441,8 @@ async function deleteSessions(sessionIds) {
 }
 async function readAssignmentStatusFromPath(assignmentMdPath2) {
   if (!await fileExists(assignmentMdPath2)) return null;
-  const raw = await readFile9(assignmentMdPath2, "utf-8");
-  const match = raw.match(/^status:\s*(.+)$/m);
+  const raw2 = await readFile9(assignmentMdPath2, "utf-8");
+  const match = raw2.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
 async function readAssignmentStatus(projectDir, assignmentSlug) {
@@ -5586,8 +5586,8 @@ async function listSessionFiles(dir) {
 async function readSessionFile(dir, name) {
   const filePath = resolve14(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
-  const raw = await readFile10(filePath, "utf-8");
-  const [frontmatter] = extractFrontmatter(raw);
+  const raw2 = await readFile10(filePath, "utf-8");
+  const [frontmatter] = extractFrontmatter(raw2);
   if (!frontmatter) return null;
   const session = getField(frontmatter, "session") ?? name;
   const registered = getField(frontmatter, "registered") ?? "";
@@ -5715,8 +5715,8 @@ function scanKey(serversDir2, projectsDir2, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir2}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve82) => {
-    const timer2 = setTimeout(resolve82, ms);
+  return new Promise((resolve83) => {
+    const timer2 = setTimeout(resolve83, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -6323,8 +6323,8 @@ async function listProjects(projectsDir2) {
 async function readWorkspaceRegistry(projectsDir2) {
   const registryPath = resolve16(dirname3(projectsDir2), "workspaces.json");
   try {
-    const raw = await readFile11(registryPath, "utf-8");
-    const parsed = JSON.parse(raw);
+    const raw2 = await readFile11(registryPath, "utf-8");
+    const parsed = JSON.parse(raw2);
     return Array.isArray(parsed) ? parsed.filter((w) => typeof w === "string") : [];
   } catch {
     return [];
@@ -6412,8 +6412,8 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
       const path = resolve16(projectsDir2, slug, "project.md");
-      const raw = await readFile11(path, "utf-8");
-      let next = clearFrontmatterField(raw, "workspace");
+      const raw2 = await readFile11(path, "utf-8");
+      let next = clearFrontmatterField(raw2, "workspace");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
       rewroteFiles = true;
@@ -6421,8 +6421,8 @@ async function deleteWorkspace(projectsDir2, name, opts = {}) {
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
       const path = resolve16(opts.assignmentsDir, id, "assignment.md");
-      const raw = await readFile11(path, "utf-8");
-      let next = clearFrontmatterField(raw, "workspaceGroup");
+      const raw2 = await readFile11(path, "utf-8");
+      let next = clearFrontmatterField(raw2, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
       await writeFileForce(path, next);
       rewroteFiles = true;
@@ -7872,8 +7872,8 @@ async function listPlaybooks(playbooksDir3) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
     const filePath = resolve16(playbooksDir3, entry.name);
-    const raw = await readFile11(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
+    const raw2 = await readFile11(filePath, "utf-8");
+    const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     playbooks.push({
       slug,
@@ -8446,8 +8446,8 @@ __export(launch_exports, {
   shellQuote: () => shellQuote
 });
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve39 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
+import { isAbsolute as isAbsolute5, resolve as resolve40 } from "path";
 function shellQuote(arg) {
   if (arg === "") return "''";
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -8483,8 +8483,8 @@ async function launchAgent(options) {
     console.error(`Assignment not found: ${projectSlug}/${assignmentSlug}`);
     process.exit(1);
   }
-  const projectDir = resolve39(projectsDir2, projectSlug);
-  const assignmentDir = resolve39(projectDir, "assignments", assignmentSlug);
+  const projectDir = resolve40(projectsDir2, projectSlug);
+  const assignmentDir = resolve40(projectDir, "assignments", assignmentSlug);
   let workspaceDir;
   if (cwdOverride) {
     if (!isExistingDir(cwdOverride)) {
@@ -8516,8 +8516,8 @@ async function launchAgent(options) {
     });
     if (warning) console.warn(warning);
   }
-  const contextDir = resolve39(workspaceDir, ".syntaur");
-  await mkdir5(contextDir, { recursive: true });
+  const contextDir = resolve40(workspaceDir, ".syntaur");
+  await mkdir6(contextDir, { recursive: true });
   const context = {
     projectSlug,
     assignmentSlug,
@@ -8528,8 +8528,8 @@ async function launchAgent(options) {
     branch: detail.workspace.branch ?? null,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile9(
-    resolve39(contextDir, "context.json"),
+  await writeFile10(
+    resolve40(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   const { argv, shellFallbackWarning } = buildAgentArgv(
@@ -8604,7 +8604,7 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath9, pathToFileURL } from "url";
-import { dirname as dirname16, resolve as resolve49, join as join9 } from "path";
+import { dirname as dirname17, resolve as resolve50, join as join9 } from "path";
 import { homedir as homedir9, tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
 function syntaurRootMjs() {
@@ -8626,7 +8626,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   }
   const stateRoot = syntaurRootMjs();
   mkdirSync2(stateRoot, { recursive: true });
-  const lockPath = resolve49(stateRoot, "install-url-handler.lock");
+  const lockPath = resolve50(stateRoot, "install-url-handler.lock");
   let lockFd;
   try {
     lockFd = openSync(lockPath, "wx");
@@ -8642,8 +8642,8 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
     throw err2;
   }
   try {
-    const pkgRoot = resolve49(dirname16(fileURLToPath9(import.meta.url)), "..");
-    const cliBin = realpathSync3(resolve49(pkgRoot, "bin/syntaur.js"));
+    const pkgRoot = resolve50(dirname17(fileURLToPath9(import.meta.url)), "..");
+    const cliBin = realpathSync3(resolve50(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
     const bundleParent = join9(
       homedir9(),
@@ -9651,7 +9651,7 @@ init_create_assignment();
 init_config2();
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
-import { resolve as resolve31, dirname as dirname8 } from "path";
+import { resolve as resolve32, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/dashboard/server.ts
@@ -9661,8 +9661,8 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve30 } from "path";
-import { writeFile as writeFile6, unlink as unlink6 } from "fs/promises";
+import { resolve as resolve31 } from "path";
+import { writeFile as writeFile7, unlink as unlink7 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/session-liveness.ts
@@ -10136,15 +10136,15 @@ async function readViewPrefsFile() {
   if (!await fileExists(path)) {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
-  let raw;
+  let raw2;
   try {
-    raw = await readFile12(path, "utf-8");
+    raw2 = await readFile12(path, "utf-8");
   } catch {
     return { ...DEFAULT_VIEW_PREFS_FILE };
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(raw2);
   } catch {
     await backupCorrupt(path);
     return { ...DEFAULT_VIEW_PREFS_FILE };
@@ -10349,15 +10349,15 @@ async function readSavedViewsFile() {
   if (!await fileExists(path)) {
     return cloneDefault();
   }
-  let raw;
+  let raw2;
   try {
-    raw = await readFile13(path, "utf-8");
+    raw2 = await readFile13(path, "utf-8");
   } catch {
     return cloneDefault();
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(raw2);
   } catch {
     await backupCorrupt2(path);
     return cloneDefault();
@@ -10768,8 +10768,8 @@ async function getProjectRepositoryCandidates(projectsDir2, projectSlug) {
   const projectPath = resolve20(projectsDir2, projectSlug, "project.md");
   if (await fileExists(projectPath)) {
     const project = parseProject(await readFile15(projectPath, "utf-8"));
-    for (const raw of project.repositories) {
-      const path = raw.trim();
+    for (const raw2 of project.repositories) {
+      const path = raw2.trim();
       if (!path) continue;
       const abs = resolve20(path);
       if (seen.has(abs)) continue;
@@ -13678,8 +13678,8 @@ function mapAgentErrorToFieldErrors(err2) {
   }
   return { error: message };
 }
-function coerceAgentRow(raw, index) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+function coerceAgentRow(raw2, index) {
+  if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) {
     return {
       ok: false,
       status: 400,
@@ -13689,7 +13689,7 @@ function coerceAgentRow(raw, index) {
       }
     };
   }
-  const entry = raw;
+  const entry = raw2;
   if (typeof entry.id !== "string" || entry.id.length === 0) {
     return {
       ok: false,
@@ -13798,14 +13798,14 @@ function createAgentsRouter() {
   });
   router.put("/", async (req, res) => {
     try {
-      const raw = req.body && typeof req.body === "object" ? req.body : {};
-      if (!Array.isArray(raw.agents)) {
+      const raw2 = req.body && typeof req.body === "object" ? req.body : {};
+      if (!Array.isArray(raw2.agents)) {
         res.status(400).json({ error: "agents must be an array" });
         return;
       }
       const cleaned = [];
-      for (let i = 0; i < raw.agents.length; i++) {
-        const result = coerceAgentRow(raw.agents[i], i);
+      for (let i = 0; i < raw2.agents.length; i++) {
+        const result = coerceAgentRow(raw2.agents[i], i);
         if (!result.ok) {
           res.status(result.status).json(result.body);
           return;
@@ -14363,18 +14363,18 @@ function buildAffectedResponse(id, list) {
 function isString(x) {
   return typeof x === "string" && x.length > 0;
 }
-function parseResolutions(raw) {
-  if (raw === void 0) {
+function parseResolutions(raw2) {
+  if (raw2 === void 0) {
     return { resolutions: [], malformed: null, duplicateIds: null };
   }
-  if (!Array.isArray(raw)) {
+  if (!Array.isArray(raw2)) {
     return { resolutions: [], malformed: "resolutions must be an array", duplicateIds: null };
   }
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const dups = /* @__PURE__ */ new Set();
-  for (let i = 0; i < raw.length; i++) {
-    const r = raw[i];
+  for (let i = 0; i < raw2.length; i++) {
+    const r = raw2[i];
     if (!r || typeof r !== "object") {
       return { resolutions: [], malformed: `resolutions[${i}] must be an object`, duplicateIds: null };
     }
@@ -15863,13 +15863,362 @@ init_fs_migration();
 init_parser2();
 init_fs();
 init_paths();
-import { Router as Router13 } from "express";
-import { readdir as readdir11 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname6 } from "path";
-import { rename as rename5, mkdir as mkdir2 } from "fs/promises";
+import { Router as Router14 } from "express";
+import { readdir as readdir12 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname7 } from "path";
+import { rename as rename6, mkdir as mkdir3 } from "fs/promises";
 init_slug();
 init_promote_todos();
 init_api();
+
+// src/dashboard/todo-attachments-routes.ts
+import { raw } from "express";
+
+// src/todos/attachments.ts
+import { mkdir as mkdir2, readdir as readdir11, stat, rename as rename5, rm as rm3, unlink as unlink5, writeFile as writeFile5, cp } from "fs/promises";
+import { resolve as resolve27, basename as basename4, dirname as dirname6, extname } from "path";
+
+// src/utils/proof-artifact-id.ts
+import { randomBytes as randomBytes2 } from "crypto";
+function generateArtifactId() {
+  const ts = Date.now().toString(36);
+  const rand = randomBytes2(2).toString("hex");
+  return `${ts}-${rand}`;
+}
+var EXTENSIONS = {
+  screenshot: "png",
+  video: "mp4",
+  asciinema: "cast",
+  http: "txt",
+  text: "txt"
+};
+function extensionForKind(kind) {
+  const ext = EXTENSIONS[kind];
+  if (!ext) {
+    throw new Error(`Unknown artifact kind: ${kind}`);
+  }
+  return ext;
+}
+var ARTIFACT_KINDS = [
+  "screenshot",
+  "video",
+  "asciinema",
+  "http",
+  "text"
+];
+function isArtifactKind(value) {
+  return typeof value === "string" && ARTIFACT_KINDS.includes(value);
+}
+
+// src/todos/attachments.ts
+var SCOPE_RE = /^[a-z0-9_][a-z0-9-]*$/;
+var TODO_ID_RE = /^[a-f0-9]{4}$/;
+var ATTACHMENT_ID_RE = /^[a-z0-9]+-[0-9a-f]{4}$/;
+var AttachmentValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AttachmentValidationError";
+  }
+};
+function assertScope(scopeId) {
+  if (!SCOPE_RE.test(scopeId)) throw new AttachmentValidationError(`Invalid scope id: "${scopeId}"`);
+}
+function assertTodoId(todoId) {
+  if (!TODO_ID_RE.test(todoId)) throw new AttachmentValidationError(`Invalid todo id: "${todoId}"`);
+}
+function assertAttachmentId(attachmentId) {
+  if (!ATTACHMENT_ID_RE.test(attachmentId)) {
+    throw new AttachmentValidationError(`Invalid attachment id: "${attachmentId}"`);
+  }
+}
+var EXT_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  log: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  csv: "text/csv",
+  html: "text/html",
+  htm: "text/html",
+  xml: "application/xml",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  zip: "application/zip"
+};
+function mimeForName(name) {
+  const ext = extname(name).slice(1).toLowerCase();
+  return EXT_MIME[ext] ?? "application/octet-stream";
+}
+var SAFE_INLINE_MIME = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "application/pdf",
+  "text/plain"
+]);
+function isSafeInlineMime(mime) {
+  return SAFE_INLINE_MIME.has(mime);
+}
+function sanitizeAttachmentName(name) {
+  let n = basename4(name || "").replace(/["'\\/]/g, "_");
+  n = Array.from(n, (ch) => {
+    const code = ch.charCodeAt(0);
+    return code < 32 || code === 127 ? "_" : ch;
+  }).join("");
+  n = n.trim();
+  if (!n || n === "." || n === "..") n = "file";
+  if (n.length > 120) {
+    const ext = extname(n);
+    n = n.slice(0, Math.max(1, 120 - ext.length)) + ext;
+  }
+  return n;
+}
+function attachmentsRootDir(todosDir2) {
+  return resolve27(todosDir2, "attachments");
+}
+function attachmentDirFor(todosDir2, scopeId, todoId) {
+  assertScope(scopeId);
+  assertTodoId(todoId);
+  return resolve27(attachmentsRootDir(todosDir2), scopeId, todoId);
+}
+async function dirExists(p) {
+  try {
+    return (await stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes) {
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  await mkdir2(dir, { recursive: true });
+  const id = generateArtifactId();
+  const filename = sanitizeAttachmentName(originalName);
+  await writeFile5(resolve27(dir, `${id}__${filename}`), bytes);
+  return {
+    id,
+    filename,
+    mime: mimeForName(filename),
+    size: bytes.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function listAttachments(todosDir2, scopeId, todoId) {
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  let names;
+  try {
+    names = await readdir11(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const stored of names) {
+    const sep2 = stored.indexOf("__");
+    if (sep2 <= 0) continue;
+    const id = stored.slice(0, sep2);
+    if (!ATTACHMENT_ID_RE.test(id)) continue;
+    const filename = stored.slice(sep2 + 2);
+    try {
+      const st = await stat(resolve27(dir, stored));
+      if (!st.isFile()) continue;
+      out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
+    } catch {
+    }
+  }
+  out.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return out;
+}
+async function readScopeAttachments(todosDir2, scopeId) {
+  assertScope(scopeId);
+  const scopeDir = resolve27(attachmentsRootDir(todosDir2), scopeId);
+  let todoIds;
+  try {
+    todoIds = await readdir11(scopeDir);
+  } catch {
+    return {};
+  }
+  const result = {};
+  for (const todoId of todoIds) {
+    if (!TODO_ID_RE.test(todoId)) continue;
+    const list = await listAttachments(todosDir2, scopeId, todoId);
+    if (list.length) result[todoId] = list;
+  }
+  return result;
+}
+async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
+  assertAttachmentId(attachmentId);
+  const dir = attachmentDirFor(todosDir2, scopeId, todoId);
+  let names;
+  try {
+    names = await readdir11(dir);
+  } catch {
+    return null;
+  }
+  const prefix = `${attachmentId}__`;
+  const stored = names.find((n) => n.startsWith(prefix));
+  if (!stored) return null;
+  const filename = stored.slice(prefix.length);
+  return { path: resolve27(dir, stored), filename, mime: mimeForName(filename) };
+}
+async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
+  const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
+  if (!resolved) return false;
+  await unlink5(resolved.path);
+  return true;
+}
+async function deleteAllAttachments(todosDir2, scopeId, todoId) {
+  await rm3(attachmentDirFor(todosDir2, scopeId, todoId), { recursive: true, force: true });
+}
+async function attachmentMoveConflict(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId, todoId) {
+  const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
+  const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
+  return await dirExists(src) && await dirExists(dst);
+}
+async function moveAttachments(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId, todoId) {
+  const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
+  if (!await dirExists(src)) return;
+  const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
+  await mkdir2(dirname6(dst), { recursive: true });
+  try {
+    await rename5(src, dst);
+  } catch (err2) {
+    if (err2?.code === "EXDEV") {
+      await cp(src, dst, { recursive: true });
+      await rm3(src, { recursive: true, force: true });
+    } else {
+      throw err2;
+    }
+  }
+}
+
+// src/dashboard/todo-attachments-routes.ts
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+function headerValue(req, name) {
+  const v = req.headers[name];
+  return Array.isArray(v) ? v[0] : v;
+}
+function paramStr(v) {
+  return Array.isArray(v) ? v[0] ?? "" : v ?? "";
+}
+function sendError(res, err2) {
+  if (err2 instanceof AttachmentValidationError) {
+    res.status(400).json({ error: err2.message });
+    return;
+  }
+  res.status(500).json({ error: err2 instanceof Error ? err2.message : "Attachment operation failed" });
+}
+function contentDisposition(filename, inline) {
+  const disp = inline ? "inline" : "attachment";
+  const asciiFallback = Array.from(filename, (ch) => {
+    const code = ch.charCodeAt(0);
+    return code >= 32 && code <= 126 && ch !== '"' && ch !== "\\" ? ch : "_";
+  }).join("");
+  return `${disp}; filename="${asciiFallback}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+}
+function installTodoAttachmentRoutes(router, prefix, opts) {
+  router.post(
+    `${prefix}/attachments`,
+    raw({ type: () => true, limit: MAX_UPLOAD_BYTES }),
+    async (req, res) => {
+      try {
+        const rawName = headerValue(req, "x-attachment-filename");
+        let filename = "file";
+        if (rawName) {
+          try {
+            filename = decodeURIComponent(rawName);
+          } catch {
+            res.status(400).json({ error: "Invalid x-attachment-filename header" });
+            return;
+          }
+        }
+        const body = req.body;
+        if (!Buffer.isBuffer(body) || body.length === 0) {
+          res.status(400).json({ error: "Empty upload body" });
+          return;
+        }
+        const scope = opts.resolveScope(req);
+        const result = await opts.withScopeLock(req, async () => {
+          if (!await opts.todoExists(scope)) return null;
+          return writeAttachment(scope.todosDir, scope.scopeId, scope.todoId, filename, body);
+        });
+        if (!result) {
+          res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+          return;
+        }
+        opts.onChange(req);
+        res.status(201).json(result);
+      } catch (err2) {
+        sendError(res, err2);
+      }
+    }
+  );
+  router.get(`${prefix}/attachments/:attachmentId`, async (req, res) => {
+    try {
+      const scope = opts.resolveScope(req);
+      const attachmentId = paramStr(req.params.attachmentId);
+      const resolved = await opts.withScopeLock(req, async () => {
+        if (!await opts.todoExists(scope)) return { notFound: true };
+        return {
+          file: await resolveAttachmentFile(scope.todosDir, scope.scopeId, scope.todoId, attachmentId)
+        };
+      });
+      if ("notFound" in resolved) {
+        res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+        return;
+      }
+      if (!resolved.file) {
+        res.status(404).json({ error: `Attachment "${attachmentId}" not found` });
+        return;
+      }
+      const { path, filename, mime } = resolved.file;
+      const inline = isSafeInlineMime(mime);
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("Content-Type", inline ? mime : "application/octet-stream");
+      res.setHeader("Content-Disposition", contentDisposition(filename, inline));
+      res.sendFile(path, (err2) => {
+        if (err2 && !res.headersSent) res.status(500).end();
+      });
+    } catch (err2) {
+      sendError(res, err2);
+    }
+  });
+  router.delete(`${prefix}/attachments/:attachmentId`, async (req, res) => {
+    try {
+      const scope = opts.resolveScope(req);
+      const attachmentId = paramStr(req.params.attachmentId);
+      const result = await opts.withScopeLock(req, async () => {
+        if (!await opts.todoExists(scope)) return { notFound: true };
+        return { deleted: await deleteAttachment(scope.todosDir, scope.scopeId, scope.todoId, attachmentId) };
+      });
+      if ("notFound" in result) {
+        res.status(404).json({ error: `Todo "${scope.todoId}" not found` });
+        return;
+      }
+      if (!result.deleted) {
+        res.status(404).json({ error: `Attachment "${attachmentId}" not found` });
+        return;
+      }
+      opts.onChange(req);
+      res.json({ deleted: attachmentId });
+    } catch (err2) {
+      sendError(res, err2);
+    }
+  });
+}
+
+// src/dashboard/api-todos.ts
 var WORKSPACE_REGEX = /^[a-z0-9_][a-z0-9-]*$/;
 function getWorkspaceParam(value) {
   if (Array.isArray(value)) {
@@ -15883,7 +16232,7 @@ function touchItem3(item) {
   item.updatedAt = now;
 }
 function createTodosRouter(todosDir2, broadcast, projectsDir2) {
-  const router = Router13();
+  const router = Router14();
   installRecordsInvalidation(router);
   function broadcastUpdate() {
     broadcast({ type: "todos-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -15900,6 +16249,19 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
     next();
   }
   router.param("workspace", validateWorkspace);
+  installTodoAttachmentRoutes(router, "/:workspace/:id", {
+    resolveScope: (req) => ({
+      todosDir: todosDir2,
+      scopeId: getWorkspaceParam(req.params.workspace),
+      todoId: getWorkspaceParam(req.params.id)
+    }),
+    withScopeLock: (req, fn) => wsLock(getWorkspaceParam(req.params.workspace), fn),
+    todoExists: async (scope) => {
+      const checklist = await readChecklist(scope.todosDir, scope.scopeId);
+      return checklist.items.some((i) => i.id === scope.todoId);
+    },
+    onChange: () => broadcastUpdate()
+  });
   router.post("/promote-bulk", async (req, res) => {
     try {
       const { groups, mode, target, title, type, priority, keepSource } = req.body ?? {};
@@ -16004,17 +16366,18 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir11(todosDir2).catch(() => []);
+      const files = await readdir12(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
         if (!file.endsWith(".md") || file.endsWith("-log.md")) continue;
         const workspace = file.replace(".md", "");
         const checklist = await readChecklist(todosDir2, workspace);
+        const attachmentsByTodo = await readScopeAttachments(todosDir2, checklist.workspace);
         workspaces.push({
           workspace: checklist.workspace,
           archiveInterval: checklist.archiveInterval,
-          items: checklist.items,
+          items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
           counts: computeCounts(checklist.items)
         });
       }
@@ -16027,10 +16390,11 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
     try {
       const workspace = getWorkspaceParam(req.params.workspace);
       const checklist = await readChecklist(todosDir2, workspace);
+      const attachmentsByTodo = await readScopeAttachments(todosDir2, workspace);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
-        items: checklist.items,
+        items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
         counts: computeCounts(checklist.items)
       });
     } catch (error) {
@@ -16118,63 +16482,68 @@ 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: resolve82 } = await import("path");
+      const { resolve: resolve83 } = await import("path");
       const { readFile: readFile56 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
-      const checklist = await readChecklist(todosDir2, workspace);
-      const log = await readLog(todosDir2, workspace);
-      const completedIds = new Set(
-        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
-      );
-      if (completedIds.size === 0) {
-        res.json({ archived: 0, message: "No completed items to archive" });
-        return;
-      }
-      const toArchive = log.entries.filter(
-        (e) => e.itemIds.every((id) => completedIds.has(id))
-      );
-      const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve82(todosDir2, "archive"));
-      let archContent = "";
-      if (await fileExists(archFile)) {
-        archContent = await readFile56(archFile, "utf-8");
-        archContent = archContent.trimEnd() + "\n\n";
-      } else {
-        archContent = `---
+      const outcome = await wsLock(workspace, async () => {
+        const checklist = await readChecklist(todosDir2, workspace);
+        const log = await readLog(todosDir2, workspace);
+        const completedIds = new Set(
+          checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+        );
+        if (completedIds.size === 0) {
+          return { archived: 0, message: "No completed items to archive" };
+        }
+        const toArchive = log.entries.filter(
+          (e) => e.itemIds.every((id) => completedIds.has(id))
+        );
+        const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
+        await ensureDir(resolve83(todosDir2, "archive"));
+        let archContent = "";
+        if (await fileExists(archFile)) {
+          archContent = await readFile56(archFile, "utf-8");
+          archContent = archContent.trimEnd() + "\n\n";
+        } else {
+          archContent = `---
 workspace: ${workspace}
 ---
 
 # Archive
 
 `;
-      }
-      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
-      for (const item of completedItems) {
-        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+        }
+        const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+        for (const item of completedItems) {
+          archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
 `;
-      }
-      archContent += "\n";
-      for (const entry of toArchive) {
-        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+        }
+        archContent += "\n";
+        for (const entry of toArchive) {
+          archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
 `;
-        if (entry.items) archContent += `**Items:** ${entry.items}
+          if (entry.items) archContent += `**Items:** ${entry.items}
 `;
-        if (entry.session) archContent += `**Session:** ${entry.session}
+          if (entry.session) archContent += `**Session:** ${entry.session}
 `;
-        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+          if (entry.branch) archContent += `**Branch:** ${entry.branch}
 `;
-        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+          if (entry.summary) archContent += `**Summary:** ${entry.summary}
 `;
-        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+          if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
 `;
-        archContent += "\n";
-      }
-      await writeFileForce2(archFile, archContent);
-      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir2, checklist);
-      broadcastUpdate();
-      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+          archContent += "\n";
+        }
+        await writeFileForce2(archFile, archContent);
+        checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+        await writeChecklist(todosDir2, checklist);
+        for (const id of completedIds) {
+          await deleteAllAttachments(todosDir2, workspace, id);
+        }
+        return { archived: completedIds.size, logEntries: toArchive.length };
+      });
+      if (outcome.archived > 0) broadcastUpdate();
+      res.json(outcome);
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to archive" });
     }
@@ -16199,7 +16568,8 @@ workspace: ${workspace}
       }
       const log = await readLog(todosDir2, workspace);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(req.params.id));
-      res.json({ ...item, log: logEntries });
+      const attachments = await listAttachments(todosDir2, workspace, item.id);
+      res.json({ ...item, attachments, log: logEntries });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
     }
@@ -16236,6 +16606,7 @@ workspace: ${workspace}
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
         await writeChecklist(todosDir2, checklist);
+        await deleteAllAttachments(todosDir2, workspace, req.params.id);
         return true;
       });
       if (!deleted) {
@@ -16547,15 +16918,22 @@ workspace: ${workspace}
           return { status: 409, error: "id already exists in target" };
         }
         const item = sourceChecklist.items[idx];
+        let newPlanDir = null;
         if (item.planDir) {
-          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          newPlanDir = todoPlanDir(target.todosPath, target.id, id);
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir2(dirname6(newPlanDir), { recursive: true });
-          await rename5(item.planDir, newPlanDir);
+        }
+        if (await attachmentMoveConflict(todosDir2, sourceWs, target.todosPath, target.id, id)) {
+          return { status: 409, error: "attachments already exist in target" };
+        }
+        if (item.planDir && newPlanDir) {
+          await mkdir3(dirname7(newPlanDir), { recursive: true });
+          await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
+        await moveAttachments(todosDir2, sourceWs, target.todosPath, target.id, id);
         sourceChecklist.items.splice(idx, 1);
         targetChecklist.items.push(item);
         await writeChecklist(todosDir2, sourceChecklist);
@@ -16628,9 +17006,9 @@ init_parser2();
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router14 } from "express";
-import { mkdir as mkdir3, readFile as readFile19, rename as rename6 } from "fs/promises";
-import { resolve as resolve27, dirname as dirname7 } from "path";
+import { Router as Router15 } from "express";
+import { mkdir as mkdir4, readFile as readFile19, rename as rename7 } from "fs/promises";
+import { resolve as resolve28, dirname as dirname8 } from "path";
 init_promote_todos();
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
@@ -16647,12 +17025,12 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir2, slug) {
-  return fileExists(resolve27(projectsDir2, slug, "project.md"));
+  return fileExists(resolve28(projectsDir2, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir2, slug) {
   const todosDir2 = projectTodosDir(projectsDir2, slug);
   try {
-    await mkdir3(todosDir2, { recursive: false });
+    await mkdir4(todosDir2, { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -16664,7 +17042,7 @@ async function ensureProjectTodosDir(projectsDir2, slug) {
     throw err2;
   }
   try {
-    await mkdir3(resolve27(todosDir2, "archive"), { recursive: false });
+    await mkdir4(resolve28(todosDir2, "archive"), { recursive: false });
   } catch (err2) {
     const code = err2.code;
     if (code === "EEXIST") return;
@@ -16680,7 +17058,7 @@ function notFound(res, slug) {
   res.status(404).json({ error: `Project "${slug}" not found` });
 }
 function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
-  const router = Router14({ mergeParams: true });
+  const router = Router15({ mergeParams: true });
   installRecordsInvalidation(router);
   function broadcastUpdate(projectSlug) {
     broadcast({ type: "todos-updated", projectSlug, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -16697,6 +17075,18 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
     next();
   }
   router.use(validateProjectId);
+  installTodoAttachmentRoutes(router, "/:id", {
+    resolveScope: (req) => {
+      const slug = getProjectIdParam(params(req).projectId);
+      return { todosDir: projectTodosDir(projectsDir2, slug), scopeId: slug, todoId: params(req).id ?? "" };
+    },
+    withScopeLock: (req, fn) => projLock(getProjectIdParam(params(req).projectId), fn),
+    todoExists: async (scope) => {
+      const checklist = await readChecklist(scope.todosDir, scope.scopeId);
+      return checklist.items.some((i) => i.id === scope.todoId);
+    },
+    onChange: (req) => broadcastUpdate(getProjectIdParam(params(req).projectId))
+  });
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam(params(req).projectId);
@@ -16706,10 +17096,11 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
       }
       const todosDir2 = projectTodosDir(projectsDir2, slug);
       const checklist = await readChecklist(todosDir2, slug);
+      const attachmentsByTodo = await readScopeAttachments(todosDir2, slug);
       res.json({
         workspace: checklist.workspace,
         archiveInterval: checklist.archiveInterval,
-        items: checklist.items,
+        items: checklist.items.map((i) => ({ ...i, attachments: attachmentsByTodo[i.id] ?? [] })),
         counts: computeCounts(checklist.items)
       });
     } catch (error) {
@@ -16837,61 +17228,71 @@ function createProjectTodosRouter(projectsDir2, broadcast, workspaceTodosDir) {
         notFound(res, slug);
         return;
       }
-      const todosDir2 = projectTodosDir(projectsDir2, slug);
-      await ensureProjectTodosDir(projectsDir2, slug);
-      const checklist = await readChecklist(todosDir2, slug);
-      const log = await readLog(todosDir2, slug);
-      const completedIds = new Set(
-        checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
-      );
-      if (completedIds.size === 0) {
-        res.json({ archived: 0, message: "No completed items to archive" });
-        return;
-      }
-      const toArchive = log.entries.filter(
-        (e) => e.itemIds.every((id) => completedIds.has(id))
-      );
-      const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
-      let archContent = "";
-      if (await fileExists(archFile)) {
-        archContent = await readFile19(archFile, "utf-8");
-        archContent = archContent.trimEnd() + "\n\n";
-      } else {
-        archContent = `---
+      const outcome = await projLock(slug, async () => {
+        if (!await projectExists(projectsDir2, slug)) return "gone";
+        await ensureProjectTodosDir(projectsDir2, slug);
+        const todosDir2 = projectTodosDir(projectsDir2, slug);
+        const checklist = await readChecklist(todosDir2, slug);
+        const log = await readLog(todosDir2, slug);
+        const completedIds = new Set(
+          checklist.items.filter((i) => i.status === "completed").map((i) => i.id)
+        );
+        if (completedIds.size === 0) {
+          return { archived: 0, message: "No completed items to archive" };
+        }
+        const toArchive = log.entries.filter(
+          (e) => e.itemIds.every((id) => completedIds.has(id))
+        );
+        const archFile = archivePath(todosDir2, slug, checklist.archiveInterval);
+        let archContent = "";
+        if (await fileExists(archFile)) {
+          archContent = await readFile19(archFile, "utf-8");
+          archContent = archContent.trimEnd() + "\n\n";
+        } else {
+          archContent = `---
 workspace: ${slug}
 ---
 
 # Archive
 
 `;
-      }
-      const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
-      for (const item of completedItems) {
-        archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
+        }
+        const completedItems = checklist.items.filter((i) => completedIds.has(i.id));
+        for (const item of completedItems) {
+          archContent += `- [x] ${item.description} ${item.tags.map((t) => `#${t}`).join(" ")} [t:${item.id}]
 `;
-      }
-      archContent += "\n";
-      for (const entry of toArchive) {
-        archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
+        }
+        archContent += "\n";
+        for (const entry of toArchive) {
+          archContent += `### ${entry.timestamp} \u2014 ${entry.itemIds.map((i) => `t:${i}`).join(", ")}
 `;
-        if (entry.items) archContent += `**Items:** ${entry.items}
+          if (entry.items) archContent += `**Items:** ${entry.items}
 `;
-        if (entry.session) archContent += `**Session:** ${entry.session}
+          if (entry.session) archContent += `**Session:** ${entry.session}
 `;
-        if (entry.branch) archContent += `**Branch:** ${entry.branch}
+          if (entry.branch) archContent += `**Branch:** ${entry.branch}
 `;
-        if (entry.summary) archContent += `**Summary:** ${entry.summary}
+          if (entry.summary) archContent += `**Summary:** ${entry.summary}
 `;
-        if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
+          if (entry.blockers) archContent += `**Blockers:** ${entry.blockers}
 `;
-        archContent += "\n";
+          archContent += "\n";
+        }
+        await writeFileForce(archFile, archContent);
+        checklist.workspace = slug;
+        checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
+        await writeChecklist(todosDir2, checklist);
+        for (const id of completedIds) {
+          await deleteAllAttachments(todosDir2, slug, id);
+        }
+        return { archived: completedIds.size, logEntries: toArchive.length };
+      });
+      if (outcome === "gone") {
+        notFound(res, slug);
+        return;
       }
-      await writeFileForce(archFile, archContent);
-      checklist.workspace = slug;
-      checklist.items = checklist.items.filter((i) => !completedIds.has(i.id));
-      await writeChecklist(todosDir2, checklist);
-      broadcastUpdate(slug);
-      res.json({ archived: completedIds.size, logEntries: toArchive.length });
+      if (outcome.archived > 0) broadcastUpdate(slug);
+      res.json(outcome);
     } catch (error) {
       if (error.code === "PROJECT_GONE") {
         notFound(res, getProjectIdParam(params(req).projectId));
@@ -16931,7 +17332,8 @@ workspace: ${slug}
       }
       const log = await readLog(todosDir2, slug);
       const logEntries = log.entries.filter((e) => e.itemIds.includes(params(req).id ?? ""));
-      res.json({ ...item, log: logEntries });
+      const attachments = await listAttachments(todosDir2, slug, item.id);
+      res.json({ ...item, attachments, log: logEntries });
     } catch (error) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Failed to get todo" });
     }
@@ -16987,11 +17389,13 @@ workspace: ${slug}
         await ensureProjectTodosDir(projectsDir2, slug);
         const todosDir2 = projectTodosDir(projectsDir2, slug);
         const checklist = await readChecklist(todosDir2, slug);
-        const idx = checklist.items.findIndex((i) => i.id === (params(req).id ?? ""));
+        const targetId = params(req).id ?? "";
+        const idx = checklist.items.findIndex((i) => i.id === targetId);
         if (idx === -1) return false;
         checklist.items.splice(idx, 1);
         checklist.workspace = slug;
         await writeChecklist(todosDir2, checklist);
+        await deleteAllAttachments(todosDir2, slug, targetId);
         return true;
       });
       if (deleted === "gone") {
@@ -17301,15 +17705,15 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve27(projectsDir2, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve28(projectsDir2, parts[0], "assignments", parts[1]);
           assignmentRef = `${parts[0]}/${parts[1]}`;
         } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-          assignmentDir = resolve27(assignmentsDirFn(), tg);
+          assignmentDir = resolve28(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath2 = resolve27(assignmentDir, "assignment.md");
+        const assignmentMdPath2 = resolve28(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
         let content = await readFile19(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
@@ -17439,15 +17843,22 @@ workspace: ${slug}
           return { status: 409, error: "id already exists in target" };
         }
         const item = sourceChecklist.items[idx];
+        let newPlanDir = null;
         if (item.planDir) {
-          const newPlanDir = todoPlanDir(target.todosPath, target.id, id);
+          newPlanDir = todoPlanDir(target.todosPath, target.id, id);
           if (await fileExists(newPlanDir)) {
             return { status: 409, error: "plan dir already exists in target" };
           }
-          await mkdir3(dirname7(newPlanDir), { recursive: true });
-          await rename6(item.planDir, newPlanDir);
+        }
+        if (await attachmentMoveConflict(sourceTodosDir, sourceSlug, target.todosPath, target.id, id)) {
+          return { status: 409, error: "attachments already exist in target" };
+        }
+        if (item.planDir && newPlanDir) {
+          await mkdir4(dirname8(newPlanDir), { recursive: true });
+          await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
+        await moveAttachments(sourceTodosDir, sourceSlug, target.todosPath, target.id, id);
         sourceChecklist.items.splice(idx, 1);
         targetChecklist.items.push(item);
         sourceChecklist.workspace = sourceSlug;
@@ -17506,22 +17917,22 @@ workspace: ${slug}
 }
 
 // src/dashboard/api-bundles.ts
-import { Router as Router15 } from "express";
-import { readdir as readdir12 } from "fs/promises";
+import { Router as Router16 } from "express";
+import { readdir as readdir13 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
 init_fs();
 init_paths();
 init_parser2();
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 import { readFile as readFile20 } from "fs/promises";
 var BUNDLE_ID_REGEX = /^[a-f0-9]{4}$/;
 var SCOPE_VALUES = /* @__PURE__ */ new Set(["workspace", "project", "global"]);
 var SCOPE_ID_REGEX = /^[a-z0-9_][a-z0-9_-]*$/;
 var BUNDLE_LINE_REGEX = /^- b:([a-f0-9]{4})\s+<([^>]*)>\s*$/;
 function generateShortBundleId() {
-  return randomBytes2(2).toString("hex");
+  return randomBytes3(2).toString("hex");
 }
 function generateUniqueBundleId(existing) {
   let id = generateShortBundleId();
@@ -17532,19 +17943,19 @@ function generateUniqueBundleId(existing) {
   }
   return id;
 }
-function parseScopeToken(raw) {
-  const idx = raw.indexOf(":");
+function parseScopeToken(raw2) {
+  const idx = raw2.indexOf(":");
   if (idx < 0) return null;
-  const scopeRaw = raw.slice(0, idx);
-  const scopeId = raw.slice(idx + 1);
+  const scopeRaw = raw2.slice(0, idx);
+  const scopeId = raw2.slice(idx + 1);
   if (!SCOPE_VALUES.has(scopeRaw)) return null;
   if (!scopeId) return null;
   if (!SCOPE_ID_REGEX.test(scopeId)) return null;
   return { scope: scopeRaw, scopeId };
 }
-function parseTodosToken(raw) {
-  if (!raw) return [];
-  return raw.split(",").map((s) => s.trim()).filter((s) => BUNDLE_ID_REGEX.test(s));
+function parseTodosToken(raw2) {
+  if (!raw2) return [];
+  return raw2.split(",").map((s) => s.trim()).filter((s) => BUNDLE_ID_REGEX.test(s));
 }
 function parseBundleLine(line) {
   const match = line.match(BUNDLE_LINE_REGEX);
@@ -17657,7 +18068,7 @@ function annotate(bundle, items) {
 }
 function createBundlesRouter(todosDir2, broadcast) {
   void broadcast;
-  const router = Router15();
+  const router = Router16();
   function validateWorkspace(req, res, next) {
     const workspace = getWorkspaceParam2(req.params.workspace);
     if (workspace && !WORKSPACE_REGEX3.test(workspace)) {
@@ -17671,7 +18082,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir12(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir13(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -17723,8 +18134,8 @@ function createBundlesRouter(todosDir2, broadcast) {
 init_fs();
 init_paths();
 init_slug();
-import { Router as Router16 } from "express";
-import { resolve as resolve28 } from "path";
+import { Router as Router17 } from "express";
+import { resolve as resolve29 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
   const members = bundle.todoIds.map((id) => items.find((i) => i.id === id)).filter((i) => i !== void 0);
@@ -17753,7 +18164,7 @@ function notFound2(res, slug) {
 }
 function createProjectBundlesRouter(projectsDir2, broadcast) {
   void broadcast;
-  const router = Router16({ mergeParams: true });
+  const router = Router17({ mergeParams: true });
   function validateProjectId(req, res, next) {
     const slug = getProjectIdParam2(req.params.projectId);
     if (!slug || !isValidSlug(slug)) {
@@ -17766,7 +18177,7 @@ function createProjectBundlesRouter(projectsDir2, broadcast) {
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam2(req.params.projectId);
-      const projectMd = resolve28(projectsDir2, slug, "project.md");
+      const projectMd = resolve29(projectsDir2, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -17787,7 +18198,7 @@ function createProjectBundlesRouter(projectsDir2, broadcast) {
 init_config2();
 init_api();
 init_scanner();
-import { Router as Router17 } from "express";
+import { Router as Router18 } from "express";
 
 // src/utils/github-backup.ts
 init_paths();
@@ -17795,8 +18206,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp, mkdtemp, rm as rm3, readFile as readFile21, writeFile as writeFile5, unlink as unlink5, stat, open as open2, rename as rename7 } from "fs/promises";
-import { resolve as resolve29, join as join3 } from "path";
+import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile21, writeFile as writeFile6, unlink as unlink6, stat as stat2, open as open2, rename as rename8 } from "fs/promises";
+import { resolve as resolve30, join as join3 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -17836,7 +18247,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve29(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve30(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -17847,7 +18258,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock() {
-  const lockPath = resolve29(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve30(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open2(lockPath, "wx");
@@ -17866,7 +18277,7 @@ async function acquireLock() {
 }
 async function releaseLock(lockPath) {
   try {
-    await unlink5(lockPath);
+    await unlink6(lockPath);
   } catch {
   }
 }
@@ -17889,13 +18300,13 @@ async function cloneOrInit(repoUrl, destDir) {
 }
 async function copyRecursive(src, dest) {
   if (!await fileExists(src)) return;
-  const s = await stat(src);
+  const s = await stat2(src);
   if (s.isDirectory()) {
     await ensureDir(dest);
-    await cp(src, dest, { recursive: true, force: true });
+    await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve29(dest, ".."));
-    await cp(src, dest, { force: true });
+    await ensureDir(resolve30(dest, ".."));
+    await cp2(src, dest, { force: true });
   }
 }
 function resolveCategoriesStrict(csv) {
@@ -17932,9 +18343,9 @@ async function backupToGithub(overrides) {
       const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
       const destPath = join3(tmpDir, repoPath);
       if (isFile) {
-        await rm3(destPath, { force: true });
+        await rm4(destPath, { force: true });
       } else {
-        await rm3(destPath, { recursive: true, force: true });
+        await rm4(destPath, { recursive: true, force: true });
       }
       if (!await fileExists(sourcePath)) {
         console.warn(`Category "${category}": no local data at ${sourcePath}; backup will reflect deletion.`);
@@ -17942,8 +18353,8 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve29(destPath, ".."));
-        await writeFile5(destPath, sanitized, "utf-8");
+        await ensureDir(resolve30(destPath, ".."));
+        await writeFile6(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
       }
@@ -17988,7 +18399,7 @@ async function backupToGithub(overrides) {
     };
   } finally {
     if (tmpDir) {
-      await rm3(tmpDir, { recursive: true, force: true }).catch(() => {
+      await rm4(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
     await releaseLock(lockPath);
@@ -17996,18 +18407,18 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve29(localPath, ".."));
-    await cp(repoSrcPath, localPath, { force: true });
+    await ensureDir(resolve30(localPath, ".."));
+    await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
   const stagingPath = `${localPath}.syntaur-restore-staging`;
   const backupPath = `${localPath}.syntaur-restore-backup`;
-  await rm3(stagingPath, { recursive: true, force: true });
+  await rm4(stagingPath, { recursive: true, force: true });
   const backupExistsBefore = await fileExists(backupPath);
   const localExistsBefore = await fileExists(localPath);
   if (backupExistsBefore) {
     if (!localExistsBefore) {
-      await rename7(backupPath, localPath);
+      await rename8(backupPath, localPath);
     } else {
       throw new Error(
         `Cannot restore "${localPath}": a stale crash-recovery backup exists at ${backupPath} while the current path also exists. Inspect both and remove the one you don't need, then retry.`
@@ -18016,21 +18427,21 @@ async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   }
   let localMovedAside = false;
   try {
-    await cp(repoSrcPath, stagingPath, { recursive: true, force: true });
+    await cp2(repoSrcPath, stagingPath, { recursive: true, force: true });
     const localExists = await fileExists(localPath);
     if (localExists) {
-      await rename7(localPath, backupPath);
+      await rename8(localPath, backupPath);
       localMovedAside = true;
     }
-    await rename7(stagingPath, localPath);
-    await rm3(backupPath, { recursive: true, force: true }).catch(() => {
+    await rename8(stagingPath, localPath);
+    await rm4(backupPath, { recursive: true, force: true }).catch(() => {
     });
   } catch (err2) {
     if (localMovedAside && await fileExists(backupPath)) {
-      await rename7(backupPath, localPath).catch(() => {
+      await rename8(backupPath, localPath).catch(() => {
       });
     }
-    await rm3(stagingPath, { recursive: true, force: true }).catch(() => {
+    await rm4(stagingPath, { recursive: true, force: true }).catch(() => {
     });
     throw err2;
   }
@@ -18089,7 +18500,7 @@ async function restoreFromGithub(overrides) {
     };
   } finally {
     if (tmpDir) {
-      await rm3(tmpDir, { recursive: true, force: true }).catch(() => {
+      await rm4(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
     await releaseLock(lockPath);
@@ -18097,7 +18508,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve29(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve30(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -18110,7 +18521,7 @@ async function getBackupStatus() {
 
 // src/dashboard/api-backup.ts
 function createBackupRouter() {
-  const router = Router17();
+  const router = Router18();
   router.get("/", async (_req, res) => {
     try {
       const status = await getBackupStatus();
@@ -18445,7 +18856,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve30(syntaurRoot(), "config.md")
+        resolve31(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir2);
       const summary = summarizeMigration(projectResult, configResult);
@@ -18546,8 +18957,8 @@ function createDashboardServer(options) {
   });
   app.put("/api/config/hotkeys", async (req, res) => {
     try {
-      const raw = req.body && typeof req.body === "object" ? req.body : {};
-      const incoming = raw.bindings;
+      const raw2 = req.body && typeof req.body === "object" ? req.body : {};
+      const incoming = raw2.bindings;
       if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) {
         res.status(400).json({ error: "bindings must be an object keyed by action kind" });
         return;
@@ -18963,14 +19374,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve30(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve31(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve30(dashboardDistPath, "index.html");
+      const indexPath = resolve31(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -18994,7 +19405,7 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir3,
         todosDir: todosDir2,
-        dbPath: resolve30(syntaurRoot(), "syntaur.db"),
+        dbPath: resolve31(syntaurRoot(), "syntaur.db"),
         onMessage: broadcast
       });
       startAutodiscovery({ serversDir: serversDir2, projectsDir: projectsDir2, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
@@ -19009,8 +19420,8 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve30(syntaurRoot(), "dashboard-port");
-          writeFile6(portFile, String(port), "utf-8").catch(() => {
+          const portFile = resolve31(syntaurRoot(), "dashboard-port");
+          writeFile7(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
         });
@@ -19028,8 +19439,8 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve30(syntaurRoot(), "dashboard-port");
-      await unlink6(portFile).catch(() => {
+      const portFile = resolve31(syntaurRoot(), "dashboard-port");
+      await unlink7(portFile).catch(() => {
       });
       server.closeAllConnections?.();
       return new Promise((resolvePromise) => {
@@ -19108,8 +19519,8 @@ async function dashboardCommand(options) {
     port = availablePort;
   }
   const thisFile = fileURLToPath2(import.meta.url);
-  const packageRoot = resolve31(dirname8(thisFile), "..");
-  const dashboardDist = resolve31(packageRoot, "dashboard", "dist");
+  const packageRoot = resolve32(dirname9(thisFile), "..");
+  const dashboardDist = resolve32(packageRoot, "dashboard", "dist");
   const server = createDashboardServer({
     port,
     projectsDir: projectsDir2,
@@ -19123,8 +19534,8 @@ async function dashboardCommand(options) {
   await server.start();
   let viteProcess = null;
   if (mode === "dev") {
-    const dashboardDir = resolve31(packageRoot, "dashboard");
-    const viteBin = resolve31(dashboardDir, "node_modules", ".bin", "vite");
+    const dashboardDir = resolve32(packageRoot, "dashboard");
+    const viteBin = resolve32(dashboardDir, "node_modules", ".bin", "vite");
     if (!await fileExists(viteBin)) {
       console.error(
         'Vite not found. Run "npm ci --prefix dashboard" first, or use the default bundled dashboard mode.'
@@ -19199,7 +19610,7 @@ init_config2();
 init_slug();
 init_lifecycle();
 init_assignment_resolver();
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 function resolveLinkedTodosLookup(projectsDir2) {
   return { todosDir: todosDir(), projectsDir: projectsDir2 };
 }
@@ -19213,8 +19624,8 @@ async function runTransition(assignment, command, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve32(baseDir, options.project);
-    const projectMdPath = resolve32(projectDir, "project.md");
+    const projectDir = resolve33(baseDir, options.project);
+    const projectMdPath = resolve33(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -19247,8 +19658,8 @@ async function runAssign(assignment, agent, options = {}) {
     if (!isValidSlug(assignment)) {
       throw new Error(`Invalid assignment slug "${assignment}".`);
     }
-    const projectDir = resolve32(baseDir, options.project);
-    const projectMdPath = resolve32(projectDir, "project.md");
+    const projectDir = resolve33(baseDir, options.project);
+    const projectMdPath = resolve33(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
     }
@@ -19295,8 +19706,8 @@ init_slug();
 init_frontmatter();
 init_timestamp();
 init_assignment_resolver();
-import { resolve as resolve33 } from "path";
-import { readFile as readFile22, writeFile as writeFile7 } from "fs/promises";
+import { resolve as resolve34 } from "path";
+import { readFile as readFile22, writeFile as writeFile8 } from "fs/promises";
 async function resolveTarget(target, options) {
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
@@ -19307,7 +19718,7 @@ async function resolveTarget(target, options) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    const assignmentMd = resolve33(baseDir, options.project, "assignments", target, "assignment.md");
+    const assignmentMd = resolve34(baseDir, options.project, "assignments", target, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       throw new Error(`Assignment "${target}" not found in project "${options.project}".`);
     }
@@ -19317,11 +19728,11 @@ async function resolveTarget(target, options) {
   if (resolved) {
     return {
       kind: "assignment",
-      filePath: resolve33(resolved.assignmentDir, "assignment.md"),
+      filePath: resolve34(resolved.assignmentDir, "assignment.md"),
       label: resolved.projectSlug ? `assignment "${resolved.projectSlug}/${resolved.assignmentSlug}"` : `assignment "${target}"`
     };
   }
-  const projectMd = resolve33(baseDir, target, "project.md");
+  const projectMd = resolve34(baseDir, target, "project.md");
   if (await fileExists(projectMd)) {
     return { kind: "project", filePath: projectMd, label: `project "${target}"` };
   }
@@ -19335,7 +19746,7 @@ async function writeArchiveState(filePath, archived, reason) {
     archivedReason: archived ? reason : null,
     updated: nowTimestamp()
   });
-  await writeFile7(filePath, updated, "utf-8");
+  await writeFile8(filePath, updated, "utf-8");
 }
 async function runArchive(target, options = {}) {
   const resolved = await resolveTarget(target, options);
@@ -19396,8 +19807,8 @@ init_fs();
 init_config2();
 init_frontmatter();
 init_timestamp();
-import { resolve as resolve34 } from "path";
-import { readdir as readdir13, readFile as readFile23 } from "fs/promises";
+import { resolve as resolve35 } from "path";
+import { readdir as readdir14, readFile as readFile23 } from "fs/promises";
 var PROMOTABLE_STATUSES = /* @__PURE__ */ new Set(["pending"]);
 function objectiveIsFleshedOut(content) {
   const match = content.match(/##\s+Objective\s*\n([\s\S]*?)(?=\n##\s+|$)/);
@@ -19415,11 +19826,11 @@ async function collectCandidates(baseDirs) {
   const candidates = [];
   for (const baseDir of baseDirs) {
     if (!await fileExists(baseDir)) continue;
-    const projects = await readdir13(baseDir, { withFileTypes: true });
+    const projects = await readdir14(baseDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const directAssignmentMd = resolve34(baseDir, m.name, "assignment.md");
+      const directAssignmentMd = resolve35(baseDir, m.name, "assignment.md");
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
@@ -19436,13 +19847,13 @@ async function collectCandidates(baseDirs) {
         }
         continue;
       }
-      const assignmentsDir2 = resolve34(baseDir, m.name, "assignments");
+      const assignmentsDir2 = resolve35(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir14(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentMd = resolve34(assignmentsDir2, a.name, "assignment.md");
+        const assignmentMd = resolve35(assignmentsDir2, a.name, "assignment.md");
         if (!await fileExists(assignmentMd)) continue;
         const fm = await parseSafe(assignmentMd);
         if (!fm || !PROMOTABLE_STATUSES.has(fm.status)) continue;
@@ -19546,33 +19957,33 @@ init_config2();
 init_config2();
 init_fs();
 import {
-  cp as cp2,
-  readdir as readdir14,
+  cp as cp3,
+  readdir as readdir15,
   symlink,
   lstat,
   readFile as readFile24,
   readlink,
-  rename as rename8,
-  rm as rm4,
-  unlink as unlink7,
-  writeFile as writeFile8
+  rename as rename9,
+  rm as rm5,
+  unlink as unlink8,
+  writeFile as writeFile9
 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename4, dirname as dirname10, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve36 } from "path";
+import { basename as basename5, dirname as dirname11, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve37 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname9, resolve as resolve35 } from "path";
+import { dirname as dirname10, resolve as resolve36 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
-  let currentDir = dirname9(fileURLToPath3(import.meta.url));
+  let currentDir = dirname10(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve35(currentDir, expectedRelativePath);
+    const candidate = resolve36(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve35(currentDir, "..");
+    const parentDir = resolve36(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -19593,50 +20004,50 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home2 = homedir3();
-  return pluginKind === "claude" ? resolve36(home2, ".claude", "plugins", "syntaur") : resolve36(home2, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve37(home2, ".claude", "plugins", "syntaur") : resolve37(home2, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve36(homedir3(), ".agents", "plugins", "marketplace.json");
+  return resolve37(homedir3(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve36(homedir3(), ".claude", "plugins", "marketplaces");
+  return resolve37(homedir3(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve36(homedir3(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve37(homedir3(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve36(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  return resolve37(homedir3(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve36(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve37(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile24(resolve36(packageRoot, "package.json"), "utf-8");
-  return JSON.parse(raw);
+  const raw2 = await readFile24(resolve37(packageRoot, "package.json"), "utf-8");
+  return JSON.parse(raw2);
 }
 async function readJsonFileIfExists(pathValue) {
   if (!await fileExists(pathValue)) {
     return null;
   }
   try {
-    const raw = await readFile24(pathValue, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile24(pathValue, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve36(pluginDir, ".claude-plugin", "plugin.json")
+    resolve37(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve36(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve37(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile24(manifestPath, "utf-8");
-  const parsed = JSON.parse(raw);
+  const raw2 = await readFile24(manifestPath, "utf-8");
+  const parsed = JSON.parse(raw2);
   return parsed.name;
 }
 async function readInstallMetadata(targetDir) {
@@ -19645,8 +20056,8 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile24(markerPath, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile24(markerPath, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
@@ -19658,7 +20069,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve36(dirname10(targetDir), symlinkTarget);
+    const resolvedTarget = resolve37(dirname11(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -19687,7 +20098,7 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
     installMode,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile8(
+  await writeFile9(
     getInstallMarkerPath(targetDir),
     `${JSON.stringify(metadata, null, 2)}
 `,
@@ -19695,21 +20106,21 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
   );
 }
 async function installCopy(paths, pluginKind) {
-  await ensureDir(dirname10(paths.targetDir));
-  await cp2(paths.sourceDir, paths.targetDir, { recursive: true });
+  await ensureDir(dirname11(paths.targetDir));
+  await cp3(paths.sourceDir, paths.targetDir, { recursive: true });
   const packageManifest = await readPackageManifest(paths.packageRoot);
   await writeInstallMetadata(paths.targetDir, pluginKind, "copy", packageManifest);
 }
 async function installLink(paths) {
-  await ensureDir(dirname10(paths.targetDir));
-  await rm4(paths.targetDir, { recursive: true, force: true });
-  await ensureDir(dirname10(paths.targetDir));
-  await symlink(resolve36(paths.sourceDir), paths.targetDir, "dir");
+  await ensureDir(dirname11(paths.targetDir));
+  await rm5(paths.targetDir, { recursive: true, force: true });
+  await ensureDir(dirname11(paths.targetDir));
+  await symlink(resolve37(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
   if (await fileExists(markerPath)) {
-    await unlink7(markerPath).catch(() => {
+    await unlink8(markerPath).catch(() => {
     });
   }
 }
@@ -19718,13 +20129,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute4(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve36(expanded);
+  return resolve37(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve36(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve37(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -19758,7 +20169,7 @@ async function readClaudeMarketplaceFile(manifestPath) {
   };
 }
 async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
-  await ensureDir(dirname10(manifestPath));
+  await ensureDir(dirname11(manifestPath));
   if (Array.isArray(marketplace.plugins)) {
     marketplace.plugins = [...marketplace.plugins].sort((a, b) => {
       const an = a?.name ?? "";
@@ -19771,7 +20182,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
       const prev = await readFile24(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      await writeFile8(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+      await writeFile9(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
     } catch {
       throw new Error(
         `Refusing to overwrite ${manifestPath}: existing file is not valid JSON. Inspect and remove or repair it manually before re-running.`
@@ -19779,9 +20190,9 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
     }
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile8(tmpPath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile9(tmpPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
-  await rename8(tmpPath, manifestPath);
+  await rename9(tmpPath, manifestPath);
 }
 function buildClaudeMarketplaceSourcePath(pluginTargetDir, marketplaceRootDir) {
   const relPath = relative2(marketplaceRootDir, pluginTargetDir).replaceAll("\\", "/");
@@ -19841,7 +20252,7 @@ async function listClaudeMarketplaceCandidates() {
   const [knownMarketplaces, activeMarketplaceNames, entries] = await Promise.all([
     readKnownClaudeMarketplaceRecords(),
     readInstalledClaudeMarketplaceNames(),
-    readdir14(rootDir, { withFileTypes: true })
+    readdir15(rootDir, { withFileTypes: true })
   ]);
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -19849,8 +20260,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve36(rootDir, entry.name);
-    const manifestPath = resolve36(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve37(rootDir, entry.name);
+    const manifestPath = resolve37(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -19877,11 +20288,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve36(expandHome(installLocation));
+    const candidateRoot = resolve37(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve36(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve37(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -19909,16 +20320,16 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve36(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve37(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw = await readFile24(manifestPath, "utf-8");
+    const raw2 = await readFile24(manifestPath, "utf-8");
     try {
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(raw2);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         existing = parsed;
       } else {
@@ -19941,29 +20352,29 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   };
   existing[name].lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   existing[name].autoUpdate = true;
-  await ensureDir(dirname10(manifestPath));
+  await ensureDir(dirname11(manifestPath));
   if (await fileExists(manifestPath)) {
     const prev = await readFile24(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    await writeFile8(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+    await writeFile9(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile8(tmpPath, `${JSON.stringify(existing, null, 2)}
+  await writeFile9(tmpPath, `${JSON.stringify(existing, null, 2)}
 `, "utf-8");
-  await rename8(tmpPath, manifestPath);
+  await rename9(tmpPath, manifestPath);
   return { added: !had, updated: had };
 }
 async function ensureKnownClaudeMarketplaceForRoot(options) {
   return registerKnownClaudeMarketplace(options.name, options.rootDir);
 }
 async function setSyntaurPluginEnabled(options) {
-  const settingsPath = resolve36(homedir3(), ".claude", "settings.json");
+  const settingsPath = resolve37(homedir3(), ".claude", "settings.json");
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw = await readFile24(settingsPath, "utf-8");
+    const raw2 = await readFile24(settingsPath, "utf-8");
     try {
-      parsed = JSON.parse(raw);
+      parsed = JSON.parse(raw2);
     } catch {
       throw new Error(
         `Cannot toggle plugin: ${settingsPath} is not valid JSON. Inspect and repair it before retrying.`
@@ -19977,16 +20388,16 @@ async function setSyntaurPluginEnabled(options) {
   }
   enabledPlugins[key] = options.enabled;
   parsed.enabledPlugins = enabledPlugins;
-  await ensureDir(dirname10(settingsPath));
+  await ensureDir(dirname11(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const prev = await readFile24(settingsPath, "utf-8");
-    await writeFile8(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
+    await writeFile9(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
-  await writeFile8(tmpPath, `${JSON.stringify(parsed, null, 2)}
+  await writeFile9(tmpPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
-  await rename8(tmpPath, settingsPath);
+  await rename9(tmpPath, settingsPath);
   return { key, previous, current: options.enabled, changed: true };
 }
 async function ensureClaudeUserMarketplace() {
@@ -19994,9 +20405,9 @@ async function ensureClaudeUserMarketplace() {
   if (existing) {
     return existing;
   }
-  const rootDir = resolve36(getClaudeMarketplacesRoot(), "user-plugins");
-  const manifestPath = resolve36(rootDir, ".claude-plugin", "marketplace.json");
-  await ensureDir(resolve36(rootDir, "plugins"));
+  const rootDir = resolve37(getClaudeMarketplacesRoot(), "user-plugins");
+  const manifestPath = resolve37(rootDir, ".claude-plugin", "marketplace.json");
+  await ensureDir(resolve37(rootDir, "plugins"));
   if (!await fileExists(manifestPath)) {
     const scaffold = {
       plugins: []
@@ -20015,22 +20426,22 @@ async function ensureClaudeUserMarketplace() {
     name: "user-plugins",
     rootDir,
     manifestPath,
-    targetDir: resolve36(rootDir, "plugins", "syntaur")
+    targetDir: resolve37(rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
   const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
-  const pluginsDir = dirname10(normalizedTargetDir);
-  if (basename4(pluginsDir) !== "plugins") {
+  const pluginsDir = dirname11(normalizedTargetDir);
+  if (basename5(pluginsDir) !== "plugins") {
     return null;
   }
-  const rootDir = dirname10(pluginsDir);
-  const manifestPath = resolve36(rootDir, ".claude-plugin", "marketplace.json");
+  const rootDir = dirname11(pluginsDir);
+  const manifestPath = resolve37(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
   const marketplace = await readClaudeMarketplaceFile(manifestPath);
-  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename4(rootDir);
+  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename5(rootDir);
   return {
     name,
     rootDir,
@@ -20041,7 +20452,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve36(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve37(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -20166,7 +20577,7 @@ async function installManagedPlugin(options) {
       `${paths.targetDir} already exists and is not a Syntaur-managed install. Remove it manually before installing Syntaur there.`
     );
   }
-  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve36(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve37(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -20175,7 +20586,7 @@ async function installManagedPlugin(options) {
     };
   }
   if (existing.exists) {
-    await rm4(paths.targetDir, { recursive: true, force: true });
+    await rm5(paths.targetDir, { recursive: true, force: true });
   }
   if (desiredMode === "link") {
     await installLink(paths);
@@ -20190,7 +20601,7 @@ async function installManagedPlugin(options) {
   };
 }
 function buildMarketplaceSourcePath(pluginTargetDir, marketplacePath) {
-  const relPath = relative2(dirname10(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
+  const relPath = relative2(dirname11(marketplacePath), pluginTargetDir).replaceAll("\\", "/");
   if (relPath === "") {
     return ".";
   }
@@ -20218,8 +20629,8 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile24(marketplacePath, "utf-8");
-  const parsed = JSON.parse(raw);
+  const raw2 = await readFile24(marketplacePath, "utf-8");
+  const parsed = JSON.parse(raw2);
   return {
     name: parsed.name ?? "local",
     interface: parsed.interface ?? { displayName: "Local Plugins" },
@@ -20227,8 +20638,8 @@ async function readMarketplaceFile(marketplacePath) {
   };
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
-  await ensureDir(dirname10(marketplacePath));
-  await writeFile8(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+  await ensureDir(dirname11(marketplacePath));
+  await writeFile9(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
@@ -20314,7 +20725,7 @@ async function removeMarketplaceEntry(options) {
     return { marketplacePath, removed: false };
   }
   if (marketplace.plugins.length === 0 && isDefaultMarketplaceShell(marketplace)) {
-    await rm4(marketplacePath, { force: true });
+    await rm5(marketplacePath, { force: true });
     return { marketplacePath, removed: true };
   }
   await writeMarketplaceFile(marketplacePath, marketplace);
@@ -20335,7 +20746,7 @@ async function uninstallManagedPlugin(pluginKind, targetDir = getDefaultPluginTa
     );
   }
   await removeInstallMarker(normalizedTarget);
-  await rm4(normalizedTarget, { recursive: true, force: true });
+  await rm5(normalizedTarget, { recursive: true, force: true });
   return { removed: true, targetDir: normalizedTarget };
 }
 async function getConfiguredOrLegacyManagedPluginDir(pluginKind) {
@@ -20379,13 +20790,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve36(syntaurRoot(), "config.md"));
+  return fileExists(resolve37(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
-  await rm4(syntaurRoot(), { recursive: true, force: true });
+  await rm5(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve36(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve37(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -20454,25 +20865,25 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile26, readdir as readdir15, mkdir as mkdir4, copyFile, rm as rm5, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve38, relative as relative3, join as join4 } from "path";
+import { readFile as readFile26, readdir as readdir16, mkdir as mkdir5, copyFile, rm as rm6, lstat as lstat2 } from "fs/promises";
+import { resolve as resolve39, relative as relative3, join as join4 } from "path";
 import { homedir as homedir5 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
 import { readFile as readFile25 } from "fs/promises";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 import { homedir as homedir4 } from "os";
 function settingsPathFor(agent) {
-  if (agent === "claude") return resolve37(homedir4(), ".claude", "settings.json");
+  if (agent === "claude") return resolve38(homedir4(), ".claude", "settings.json");
   return null;
 }
 async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile25(path, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile25(path, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
@@ -20521,16 +20932,16 @@ var KNOWN_SKILL_NAMES = [
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
   const packageRoot = await findPackageRoot("skills");
-  return resolve38(packageRoot, "skills");
+  return resolve39(packageRoot, "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve38(homedir5(), ".claude", "skills");
-  return resolve38(homedir5(), ".codex", "skills");
+  if (target === "claude") return resolve39(homedir5(), ".claude", "skills");
+  return resolve39(homedir5(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
   async function walk(dir) {
-    const entries = await readdir15(dir, { withFileTypes: true });
+    const entries = await readdir16(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = join4(dir, entry.name);
       if (entry.isDirectory()) {
@@ -20553,8 +20964,8 @@ async function filesEqual(a, b) {
   }
 }
 async function copyDir(srcDir, destDir) {
-  await mkdir4(destDir, { recursive: true });
-  const entries = await readdir15(srcDir, { withFileTypes: true });
+  await mkdir5(destDir, { recursive: true });
+  const entries = await readdir16(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const src = join4(srcDir, entry.name);
     const dest = join4(destDir, entry.name);
@@ -20579,8 +20990,8 @@ async function skillMatches(srcDir, destDir) {
 }
 async function isSymlink(path) {
   try {
-    const stat12 = await lstat2(path);
-    return stat12.isSymbolicLink();
+    const stat13 = await lstat2(path);
+    return stat13.isSymbolicLink();
   } catch {
     return false;
   }
@@ -20601,14 +21012,14 @@ async function installSkillDir(srcDir, destDir, skillName, force) {
     return { skill: skillName, status: "already-current", targetPath: destDir };
   }
   if (force) {
-    await rm5(destDir, { recursive: true, force: true });
+    await rm6(destDir, { recursive: true, force: true });
     await copyDir(srcDir, destDir);
     return { skill: skillName, status: "overwritten", targetPath: destDir };
   }
   return { skill: skillName, status: "differs-preserved", targetPath: destDir };
 }
 async function discoverSkillNames(sourceDir) {
-  const entries = await readdir15(sourceDir, { withFileTypes: true });
+  const entries = await readdir16(sourceDir, { withFileTypes: true });
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -20638,7 +21049,7 @@ async function installSkillsWithReport(options) {
   }
   const skillNames = await discoverSkillNames(source);
   const results = [];
-  await mkdir4(targetRoot, { recursive: true });
+  await mkdir5(targetRoot, { recursive: true });
   for (const skill of skillNames) {
     const srcDir = join4(source, skill);
     const destDir = join4(targetRoot, skill);
@@ -20655,7 +21066,7 @@ async function installSkillsToDir(options) {
   }
   const force = options.force ?? false;
   const skillNames = await discoverSkillNames(source);
-  await mkdir4(options.targetDir, { recursive: true });
+  await mkdir5(options.targetDir, { recursive: true });
   const results = [];
   for (const skill of skillNames) {
     const srcDir = join4(source, skill);
@@ -20688,7 +21099,7 @@ async function uninstallSkills(options) {
     const content = await readFile26(skillMd, "utf-8").catch(() => "");
     const match = content.match(/^name:\s*(\S+)\s*$/m);
     if (!match || match[1] !== skill) continue;
-    await rm5(destDir, { recursive: true, force: true });
+    await rm6(destDir, { recursive: true, force: true });
     removed.push(destDir);
   }
   return removed;
@@ -20971,14 +21382,14 @@ function parseOpenUrl(input4) {
     }
     let mode = "resume";
     if (modeVals.length === 1) {
-      const raw = modeVals[0];
-      if (!SESSION_MODES.includes(raw)) {
+      const raw2 = modeVals[0];
+      if (!SESSION_MODES.includes(raw2)) {
         throw new OpenUrlError(
           "bad-mode",
-          `\`mode\` must be one of ${SESSION_MODES.join("|")} (got "${raw}")`
+          `\`mode\` must be one of ${SESSION_MODES.join("|")} (got "${raw2}")`
         );
       }
-      mode = raw;
+      mode = raw2;
     }
     return { kind: "session", id, mode, ...terminal ? { terminal } : {} };
   }
@@ -21213,7 +21624,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve82, reject) => {
+  await new Promise((resolve83, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -21223,7 +21634,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve82();
+      resolve83();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -21368,7 +21779,7 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname11, resolve as resolve40, join as join5 } from "path";
+import { dirname as dirname12, resolve as resolve41, join as join5 } from "path";
 import { realpathSync, readFileSync, mkdirSync } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -21410,26 +21821,26 @@ function detectInstallKind(scriptUrl, opts = {}) {
   if (GLOBAL_PATTERN.test(norm)) {
     return "global";
   }
-  let dir = dirname11(resolved);
+  let dir = dirname12(resolved);
   for (let depth = 0; depth < 8; depth++) {
     const pkgJsonPath = join5(dir, "package.json");
-    let raw;
+    let raw2;
     try {
-      raw = readFile56(pkgJsonPath);
+      raw2 = readFile56(pkgJsonPath);
     } catch {
-      const parent2 = dirname11(dir);
+      const parent2 = dirname12(dir);
       if (parent2 === dir) break;
       dir = parent2;
       continue;
     }
     try {
-      const pkg = JSON.parse(raw);
+      const pkg = JSON.parse(raw2);
       if (typeof pkg.name === "string" && pkg.name === "syntaur" && !normalizeSlashes(dir).includes("/node_modules/")) {
         return "local";
       }
     } catch {
     }
-    const parent = dirname11(dir);
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -21447,7 +21858,7 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve40(syntaurRoot(), "npx-handler-nudge");
+  return resolve41(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
@@ -21469,9 +21880,9 @@ async function recordNudge(hash) {
   }
 }
 function isHandlerNudgeDisabled() {
-  const raw = process.env.SYNTAUR_SKIP_HANDLER_NUDGE;
-  if (raw === void 0) return false;
-  const trimmed = raw.trim();
+  const raw2 = process.env.SYNTAUR_SKIP_HANDLER_NUDGE;
+  if (raw2 === void 0) return false;
+  const trimmed = raw2.trim();
   return /^(1|true|yes)$/i.test(trimmed);
 }
 function nudgeMessage() {
@@ -21501,20 +21912,20 @@ init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { readFile as readFile28 } from "fs/promises";
-import { dirname as dirname13, join as join7, resolve as resolve41 } from "path";
+import { dirname as dirname14, join as join7, resolve as resolve42 } from "path";
 import { spawn as spawn5 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { readFile as readFile27 } from "fs/promises";
-import { dirname as dirname12, join as join6 } from "path";
+import { dirname as dirname13, join as join6 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath5(scriptUrl);
-    const pkgRoot = dirname12(dirname12(scriptPath));
-    const raw = await readFile27(join6(pkgRoot, "package.json"), "utf-8");
-    const parsed = JSON.parse(raw);
+    const pkgRoot = dirname13(dirname13(scriptPath));
+    const raw2 = await readFile27(join6(pkgRoot, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
     return null;
@@ -21522,7 +21933,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve41(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve42(syntaurRoot(), "npx-install.json");
 var META_ARGS2 = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -21543,8 +21954,8 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile28(STATE_FILE, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile28(STATE_FILE, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
@@ -21554,7 +21965,7 @@ async function writeState(state) {
 `);
 }
 async function resolveNpmBin() {
-  const nodeDir = dirname13(process.execPath);
+  const nodeDir = dirname14(process.execPath);
   const isWin = process.platform === "win32";
   const npmName = isWin ? "npm.cmd" : "npm";
   const nearNode = join7(nodeDir, npmName);
@@ -21602,8 +22013,8 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join7(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile28(manifestPath, "utf-8");
-    const parsed = JSON.parse(raw);
+    const raw2 = await readFile28(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw2);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
     return null;
@@ -21632,10 +22043,10 @@ async function askChoice(promptLabel) {
   const onSigint = () => controller.abort();
   process.once("SIGINT", onSigint);
   try {
-    const raw = await rl.question(promptLabel, {
+    const raw2 = await rl.question(promptLabel, {
       signal: controller.signal
     });
-    return raw.trim();
+    return raw2.trim();
   } catch {
     return "";
   } finally {
@@ -21960,16 +22371,16 @@ async function refreshPluginSkills(options, pm, runner, getManagedDir, resolveFr
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile30, writeFile as writeFile11, copyFile as copyFile2, rm as rm6, stat as stat2, symlink as symlink2, unlink as unlink8, lstat as lstat3 } from "fs/promises";
-import { resolve as resolve43, dirname as dirname15 } from "path";
+import { readFile as readFile30, writeFile as writeFile12, copyFile as copyFile2, rm as rm7, stat as stat3, symlink as symlink2, unlink as unlink9, lstat as lstat3 } from "fs/promises";
+import { resolve as resolve44, dirname as dirname16 } from "path";
 import { homedir as homedir7 } from "os";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile29, writeFile as writeFile10 } from "fs/promises";
-import { resolve as resolve42, dirname as dirname14 } from "path";
+import { readFile as readFile29, writeFile as writeFile11 } from "fs/promises";
+import { resolve as resolve43, dirname as dirname15 } from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -21990,13 +22401,13 @@ var PRESETS = {
   tracker: { segments: ["git", "assignment", "external", "session"], separator: " \xB7 " }
 };
 function getConfigPath(installRoot) {
-  return resolve42(installRoot, "statusline.config.json");
+  return resolve43(installRoot, "statusline.config.json");
 }
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile29(path, "utf-8");
-    const parsed = JSON.parse(raw);
+    const raw2 = await readFile29(path, "utf-8");
+    const parsed = JSON.parse(raw2);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
     const separator = typeof parsed.separator === "string" ? parsed.separator : " \xB7 ";
@@ -22045,7 +22456,7 @@ async function promptSegmentsInteractive(current) {
     default: false
   });
   if (wantReorder) {
-    const raw = await input2({
+    const raw2 = await input2({
       message: `Enter the segments in the order you want, comma-separated:`,
       default: defaultReorderHint,
       validate: (value) => {
@@ -22061,7 +22472,7 @@ async function promptSegmentsInteractive(current) {
         return true;
       }
     });
-    orderedSegments = raw.split(",").map((s) => s.trim()).filter(Boolean);
+    orderedSegments = raw2.split(",").map((s) => s.trim()).filter(Boolean);
   }
   const separator = await input2({
     message: "Separator between segments:",
@@ -22090,7 +22501,7 @@ function renderPreview(config, statuslineScript, cwd) {
     env: {
       ...process.env,
       // Force the child to pick up the freshly-written config from install root.
-      HOME: dirname14(dirname14(statuslineScript))
+      HOME: dirname15(dirname15(statuslineScript))
     }
   });
   if (res.status !== 0) return null;
@@ -22141,14 +22552,14 @@ async function configureStatuslineCommand(options = {}) {
     console.log("(preview mode \u2014 config NOT written)");
     return;
   }
-  await ensureDir(dirname14(configPath));
-  await writeFile10(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await ensureDir(dirname15(configPath));
+  await writeFile11(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   console.log("Wrote statusline config:");
   console.log(`  path:      ${configPath}`);
   console.log(`  segments:  ${config.segments.join(", ")}`);
   console.log(`  separator: ${JSON.stringify(config.separator)}`);
   if (config.wrap) console.log(`  wrap:      ${config.wrap}`);
-  const script = options.statuslineScript ?? resolve42(installRoot, "statusline.sh");
+  const script = options.statuslineScript ?? resolve43(installRoot, "statusline.sh");
   if (await fileExists(script)) {
     console.log("");
     console.log("Live preview:");
@@ -22168,25 +22579,25 @@ async function configureStatuslineCommand(options = {}) {
 async function writeDefaultConfigIfMissing(installRoot) {
   const path = getConfigPath(installRoot);
   if (await fileExists(path)) return;
-  await ensureDir(dirname14(path));
+  await ensureDir(dirname15(path));
   const defaultConfig = {
     segments: ["git", "assignment", "session"],
     separator: " \xB7 "
   };
-  await writeFile10(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  await writeFile11(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
-  const here = dirname15(fileURLToPath8(import.meta.url));
-  return resolve43(here, "..", "statusline", "statusline.sh");
+  const here = dirname16(fileURLToPath8(import.meta.url));
+  return resolve44(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw = await readFile30(settingsPath, "utf-8");
-  if (raw.trim() === "") return {};
+  const raw2 = await readFile30(settingsPath, "utf-8");
+  if (raw2.trim() === "") return {};
   try {
-    const parsed = JSON.parse(raw);
+    const parsed = JSON.parse(raw2);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch (error) {
     throw new Error(
@@ -22195,8 +22606,8 @@ async function readSettingsJson(settingsPath) {
   }
 }
 async function writeSettingsJson(settingsPath, data) {
-  await ensureDir(dirname15(settingsPath));
-  await writeFile11(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await ensureDir(dirname16(settingsPath));
+  await writeFile12(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 async function resolveMode(mode, existingCommand, ourCommand) {
   if (mode !== "ask") return mode;
@@ -22230,8 +22641,8 @@ function extractExistingCommand(settings) {
   };
 }
 async function backupSettings(settingsSnapshot, backupPath) {
-  await ensureDir(dirname15(backupPath));
-  await writeFile11(
+  await ensureDir(dirname16(backupPath));
+  await writeFile12(
     backupPath,
     JSON.stringify(
       {
@@ -22247,11 +22658,11 @@ async function backupSettings(settingsSnapshot, backupPath) {
   );
 }
 async function installScript(sourceScript, destScript, link) {
-  await ensureDir(dirname15(destScript));
+  await ensureDir(dirname16(destScript));
   try {
     const s = await lstat3(destScript);
     if (s.isSymbolicLink() || s.isFile()) {
-      await unlink8(destScript);
+      await unlink9(destScript);
     }
   } catch {
   }
@@ -22263,12 +22674,12 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve43(homedir7(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve44(homedir7(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
-  const destScript = resolve43(installRoot, "statusline.sh");
-  const confPath = resolve43(installRoot, "statusline.conf");
-  const backupPath = resolve43(installRoot, "statusline.backup.json");
+  const destScript = resolve44(installRoot, "statusline.sh");
+  const confPath = resolve44(installRoot, "statusline.conf");
+  const backupPath = resolve44(installRoot, "statusline.backup.json");
   if (!await fileExists(sourceScript)) {
     throw new Error(
       `Statusline source script not found at ${sourceScript}. Try re-installing syntaur (npm install -g syntaur) or pass --source-script explicitly.`
@@ -22304,19 +22715,19 @@ async function installStatuslineCommand(options = {}) {
     if (parsed) {
       wrapTarget = parsed;
     } else {
-      const wrapperPath = resolve43(installRoot, "statusline-wrapped.sh");
+      const wrapperPath = resolve44(installRoot, "statusline-wrapped.sh");
       const wrapperBody = `#!/usr/bin/env bash
 # Auto-generated by syntaur install-statusline.
 # Executes the previously configured statusLine command.
 exec ${existingCommand}
 `;
-      await writeFile11(wrapperPath, wrapperBody, "utf-8");
+      await writeFile12(wrapperPath, wrapperBody, "utf-8");
       await chmodExec(wrapperPath);
       wrapTarget = wrapperPath;
     }
   }
-  await ensureDir(dirname15(confPath));
-  await writeFile11(
+  await ensureDir(dirname16(confPath));
+  await writeFile12(
     confPath,
     wrapTarget ? `# Wrap target \u2014 the command below is invoked with the same stdin; its
 # stdout becomes the leading segment of the statusline. Remove this
@@ -22353,26 +22764,26 @@ function parseWrapCommand(command) {
 async function chmodExec(path) {
   const fs = await import("fs/promises");
   try {
-    const s = await stat2(path);
+    const s = await stat3(path);
     await fs.chmod(path, s.mode | 73);
   } catch {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve43(homedir7(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve44(homedir7(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
-  const destScript = resolve43(installRoot, "statusline.sh");
-  const confPath = resolve43(installRoot, "statusline.conf");
-  const backupPath = resolve43(installRoot, "statusline.backup.json");
-  const wrapperPath = resolve43(installRoot, "statusline-wrapped.sh");
+  const destScript = resolve44(installRoot, "statusline.sh");
+  const confPath = resolve44(installRoot, "statusline.conf");
+  const backupPath = resolve44(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve44(installRoot, "statusline-wrapped.sh");
   const settings = await readSettingsJson(settingsPath);
   const existing = extractExistingCommand(settings);
   const ourCommand = `bash ${destScript}`;
   let restored = null;
   if (await fileExists(backupPath)) {
     try {
-      const raw = await readFile30(backupPath, "utf-8");
-      const parsed = JSON.parse(raw);
+      const raw2 = await readFile30(backupPath, "utf-8");
+      const parsed = JSON.parse(raw2);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
         restored = { command: prev.command };
@@ -22392,10 +22803,10 @@ async function uninstallStatuslineCommand(options = {}) {
     await writeSettingsJson(settingsPath, settings);
   }
   if (!options.keepScript) {
-    const configPath = resolve43(installRoot, "statusline.config.json");
+    const configPath = resolve44(installRoot, "statusline.config.json");
     for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
       try {
-        await rm6(path, { force: true });
+        await rm7(path, { force: true });
       } catch {
       }
     }
@@ -22552,7 +22963,7 @@ init_config2();
 // src/commands/cross-agent-install.ts
 init_fs();
 import { spawnSync as spawnSync6 } from "child_process";
-import { resolve as resolve46 } from "path";
+import { resolve as resolve47 } from "path";
 import { readFile as readFile31 } from "fs/promises";
 
 // src/commands/setup-adapter.ts
@@ -22560,28 +22971,28 @@ init_paths();
 init_fs();
 init_config2();
 init_slug();
-import { resolve as resolve45 } from "path";
+import { resolve as resolve46 } from "path";
 
 // src/targets/registry.ts
 init_fs();
 import { homedir as homedir8 } from "os";
-import { resolve as resolve44 } from "path";
+import { resolve as resolve45 } from "path";
 function home(...segments) {
-  return resolve44(homedir8(), ...segments);
+  return resolve45(homedir8(), ...segments);
 }
 function hermesHome() {
   const env = process.env.HERMES_HOME;
-  return env && env.length > 0 ? resolve44(env) : home(".hermes");
+  return env && env.length > 0 ? resolve45(env) : home(".hermes");
 }
 function hermesSkillsDir() {
-  return resolve44(hermesHome(), "skills");
+  return resolve45(hermesHome(), "skills");
 }
 function isHermesHomeCustom() {
   return hermesHome() !== home(".hermes");
 }
 function codexHome() {
   const env = process.env.CODEX_HOME;
-  return env && env.length > 0 ? resolve44(env) : home(".codex");
+  return env && env.length > 0 ? resolve45(env) : home(".codex");
 }
 var detectDir = (dir) => () => fileExists(dir);
 var AGENT_TARGETS = [
@@ -22605,7 +23016,7 @@ var AGENT_TARGETS = [
     skillsShAgentId: "codex",
     nativePlugin: "codex",
     detect: detectDir(codexHome()),
-    skillsDir: { global: resolve44(codexHome(), "skills") },
+    skillsDir: { global: resolve45(codexHome(), "skills") },
     instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] }
   },
   {
@@ -22709,13 +23120,13 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve45(baseDir, options.project);
-  const assignmentDir = resolve45(projectDir, "assignments", options.assignment);
-  const projectMdPath = resolve45(projectDir, "project.md");
+  const projectDir = resolve46(baseDir, options.project);
+  const assignmentDir = resolve46(projectDir, "assignments", options.assignment);
+  const projectMdPath = resolve46(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
-  const assignmentMdPath2 = resolve45(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve46(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -22732,7 +23143,7 @@ async function setupAdapterCommand(framework, options) {
   const upToDateFiles = [];
   const skippedFiles = [];
   for (const file of target.instructions.files) {
-    const filePath = resolve45(cwd, file.path);
+    const filePath = resolve46(cwd, file.path);
     const content = RENDERERS[file.renderer](rendererParams);
     const status = await writeFileReport(filePath, content, {
       force: options.force
@@ -22772,8 +23183,8 @@ async function setupAdapterCommand(framework, options) {
 init_config2();
 var DEFAULT_SKILLS_SOURCE = "prong-horn/syntaur";
 function parseTargetIds(options) {
-  const raw = [options.target, options.agent].filter(Boolean).join(",");
-  const ids = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const raw2 = [options.target, options.agent].filter(Boolean).join(",");
+  const ids = raw2.split(",").map((s) => s.trim()).filter(Boolean);
   return [...new Set(ids)];
 }
 function isNpxAvailable() {
@@ -22785,7 +23196,7 @@ function isNpxAvailable() {
   }
 }
 async function readAssignmentContext() {
-  const p = resolve46(process.cwd(), ".syntaur", "context.json");
+  const p = resolve47(process.cwd(), ".syntaur", "context.json");
   if (!await fileExists(p)) return null;
   try {
     return JSON.parse(await readFile31(p, "utf-8"));
@@ -22858,7 +23269,7 @@ async function crossAgentInstallCommand(options) {
       if (dryRun) {
         for (const f of t.instructions.files) {
           console.log(
-            `${prefix}Tier 2 (${t.id}): ${resolve46(process.cwd(), f.path)}`
+            `${prefix}Tier 2 (${t.id}): ${resolve47(process.cwd(), f.path)}`
           );
         }
         continue;
@@ -23005,7 +23416,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve47 } from "path";
+import { resolve as resolve48 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -23085,7 +23496,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve47(configuredProjectDir) !== resolve47(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve48(configuredProjectDir) !== resolve48(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -23100,7 +23511,7 @@ async function uninstallCommand(options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve48 } from "path";
+import { resolve as resolve49 } from "path";
 init_session_db();
 init_agent_sessions();
 async function trackSessionCommand(options) {
@@ -23115,7 +23526,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve48(baseDir, options.project);
+    const projectDir = resolve49(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -23247,7 +23658,7 @@ function formatInstallUrlHandlerError(err2) {
 init_config2();
 init_paths();
 init_fs();
-import { resolve as resolve50, isAbsolute as isAbsolute7 } from "path";
+import { resolve as resolve51, isAbsolute as isAbsolute7 } from "path";
 import { readFile as readFile32 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
@@ -23317,7 +23728,7 @@ async function pickAgent2(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve50(
+  const assignmentPath = resolve51(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -23397,7 +23808,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 = isAbsolute7(expandedWorktree) ? expandedWorktree : resolve50(expandedWorktree);
+  const absWorktree = isAbsolute7(expandedWorktree) ? expandedWorktree : resolve51(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -23426,7 +23837,7 @@ init_paths();
 init_fs();
 init_playbook();
 init_playbooks();
-import { resolve as resolve51 } from "path";
+import { resolve as resolve52 } from "path";
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -23439,7 +23850,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve51(dir, `${slug}.md`);
+  const filePath = resolve52(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -23461,8 +23872,8 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir16, readFile as readFile33 } from "fs/promises";
-import { resolve as resolve52 } from "path";
+import { readdir as readdir17, readFile as readFile33 } from "fs/promises";
+import { resolve as resolve53 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -23471,15 +23882,15 @@ async function listPlaybooksCommand(options = {}) {
   }
   const config = await readConfig();
   const disabledSet = new Set(config.playbooks.disabled);
-  const entries = await readdir16(dir, { withFileTypes: true });
+  const entries = await readdir17(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 = resolve52(dir, entry.name);
-    const raw = await readFile33(filePath, "utf-8");
-    const parsed = parsePlaybook(raw);
+    const filePath = resolve53(dir, entry.name);
+    const raw2 = await readFile33(filePath, "utf-8");
+    const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
     if (disabled && !options.all) continue;
@@ -23602,13 +24013,13 @@ init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
 import { readFile as readFile35 } from "fs/promises";
-import { resolve as resolve54 } from "path";
+import { resolve as resolve55 } from "path";
 
 // src/commands/bundle.ts
 init_paths();
 import { Command } from "commander";
-import { mkdir as mkdir7, readFile as readFile34, readdir as readdir17, rm as rm7, writeFile as writeFile12 } from "fs/promises";
-import { resolve as resolve53 } from "path";
+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";
 init_parser2();
 init_fs();
 init_config2();
@@ -23626,7 +24037,7 @@ async function resolveBundleScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve53(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve54(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -23696,10 +24107,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: resolve53(planDir, "plan.md"), version: 1 };
+  if (versions.size === 0) return { target: resolve54(planDir, "plan.md"), version: 1 };
   let n = 2;
   while (versions.has(n)) n++;
-  return { target: resolve53(planDir, `plan-v${n}.md`), version: n };
+  return { target: resolve54(planDir, `plan-v${n}.md`), version: n };
 }
 function dedupePreserveOrder(ids) {
   const out = [];
@@ -23783,7 +24194,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 = resolve53(planDir, "plan.md");
+      const target = resolve54(planDir, "plan.md");
       const memberLines = items.map((it) => `- ${it.description} [t:${it.id}]`).join("\n");
       const stub = [
         "---",
@@ -23900,7 +24311,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 readdir17(planDir).catch(() => [])).filter((f) => /^plan(?:-v\d+)?\.md$/.test(f));
+    const existing = (await readdir18(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)) {
@@ -23959,7 +24370,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 ?? resolve53(repository, ".worktrees", options.branch);
+    const worktreePath = options.worktreePath ?? resolve54(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);
@@ -23986,8 +24397,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 = resolve53(worktreePath, ".syntaur");
-        await mkdir7(ctxDir, { recursive: true });
+        const ctxDir = resolve54(worktreePath, ".syntaur");
+        await mkdir8(ctxDir, { recursive: true });
         const payload = {
           bundleId: bundle.id,
           bundleSlug: bundle.slug,
@@ -24000,16 +24411,16 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
           repository,
           boundAt: nowISO()
         };
-        await writeFile12(resolve53(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
+        await writeFile13(resolve54(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
       } catch (err2) {
         try {
           if (bundlesSnapshot === null) {
-            await rm7(bundlesFilePath, { force: true });
+            await rm8(bundlesFilePath, { force: true });
           } else {
             await writeFileForce(bundlesFilePath, bundlesSnapshot);
           }
           if (checklistSnapshot === null) {
-            await rm7(checklistFilePath, { force: true });
+            await rm8(checklistFilePath, { force: true });
           } else {
             await writeFileForce(checklistFilePath, checklistSnapshot);
           }
@@ -24190,7 +24601,7 @@ async function resolveScope(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.`);
     }
@@ -24513,7 +24924,7 @@ 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(resolve54(todosPath, "archive"));
+    await ensureDir(resolve55(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
       archContent = await readFile35(archFile, "utf-8");
@@ -24743,13 +25154,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: readdir29 } = await import("fs/promises");
-    const existingFiles = (await readdir29(planDir).catch(() => [])).filter(
+    const { readdir: readdir30 } = await import("fs/promises");
+    const existingFiles = (await readdir30(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
     if (existingFiles.length === 0) {
-      target = resolve54(planDir, "plan.md");
+      target = resolve55(planDir, "plan.md");
     } else {
       const versions = /* @__PURE__ */ new Set();
       for (const f of existingFiles) {
@@ -24759,7 +25170,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
       }
       let n = 2;
       while (versions.has(n)) n++;
-      target = resolve54(planDir, `plan-v${n}.md`);
+      target = resolve55(planDir, `plan-v${n}.md`);
     }
     if (!await fileExists(target)) {
       const stub = `---
@@ -24829,10 +25240,10 @@ async function moveTodo(id, options) {
     if (await fileExists(newPlanDir)) {
       throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
     }
-    const { rename: rename10, mkdir: mkdir10 } = await import("fs/promises");
-    const { dirname: dirname22 } = await import("path");
-    await mkdir10(dirname22(newPlanDir), { recursive: true });
-    await rename10(item.planDir, newPlanDir);
+    const { rename: rename11, mkdir: mkdir11 } = await import("fs/promises");
+    const { dirname: dirname23 } = await import("path");
+    await mkdir11(dirname23(newPlanDir), { recursive: true });
+    await rename11(item.planDir, newPlanDir);
     item.planDir = newPlanDir;
   }
   sourceChecklist.items.splice(idx, 1);
@@ -24949,23 +25360,23 @@ backupCommand.command("config").description("Show or update backup configuration
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
 import { readFile as readFile43 } from "fs/promises";
-import { isAbsolute as isAbsolute10, resolve as resolve67 } from "path";
+import { isAbsolute as isAbsolute10, resolve as resolve68 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath11 } from "url";
 import { readFile as readFile42 } from "fs/promises";
-import { dirname as dirname19, join as join13 } from "path";
+import { dirname as dirname20, join as join13 } from "path";
 
 // src/utils/doctor/context.ts
 init_config2();
 init_paths();
 init_fs();
 import Database4 from "better-sqlite3";
-import { resolve as resolve55 } from "path";
+import { resolve as resolve56 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve55(root, "syntaur.db");
+  const dbPath = resolve56(root, "syntaur.db");
   let db5 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -24999,10 +25410,10 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve56, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile36, stat as stat3 } from "fs/promises";
+import { resolve as resolve57, isAbsolute as isAbsolute8 } from "path";
+import { readFile as readFile36, stat as stat4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { dirname as dirname17, join as join10 } from "path";
+import { dirname as dirname18, join as join10 } from "path";
 var CATEGORY = "env";
 var syntaurRootExists = {
   id: "env.syntaur-root-exists",
@@ -25010,7 +25421,7 @@ var syntaurRootExists = {
   title: "~/.syntaur/ directory exists",
   async run(ctx) {
     try {
-      const s = await stat3(ctx.syntaurRoot);
+      const s = await stat4(ctx.syntaurRoot);
       if (!s.isDirectory()) {
         return err(this, `${ctx.syntaurRoot} exists but is not a directory`, [
           ctx.syntaurRoot
@@ -25040,7 +25451,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve56(ctx.syntaurRoot, "config.md");
+    const configPath = resolve57(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -25153,8 +25564,8 @@ function detectNestedParseMismatch(fmBlock, config) {
     ["integrations.codexMarketplacePath", config.integrations.codexMarketplacePath]
   ];
   for (const [dotted, parsedValue] of integrationChecks2) {
-    const raw = readNestedField(fmBlock, dotted);
-    if (raw !== null && raw !== "null" && raw !== "" && parsedValue === null) {
+    const raw2 = readNestedField(fmBlock, dotted);
+    if (raw2 !== null && raw2 !== "null" && raw2 !== "" && parsedValue === null) {
       return { field: dotted, parent: "integrations" };
     }
   }
@@ -25164,8 +25575,8 @@ function detectNestedParseMismatch(fmBlock, config) {
     ["backup.lastRestore", config.backup?.lastRestore ?? null]
   ];
   for (const [dotted, parsedValue] of backupFields) {
-    const raw = readNestedField(fmBlock, dotted);
-    if (raw !== null && raw !== "null" && raw !== "" && parsedValue === null) {
+    const raw2 = readNestedField(fmBlock, dotted);
+    if (raw2 !== null && raw2 !== "null" && raw2 !== "" && parsedValue === null) {
       return { field: dotted, parent: "backup" };
     }
   }
@@ -25203,11 +25614,11 @@ function readNestedField(fmBlock, dotted) {
     if (colonIdx < 0) continue;
     const lineKey = stripped.slice(0, colonIdx).trim();
     if (lineKey !== key) continue;
-    const raw = stripped.slice(colonIdx + 1).trim();
-    if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-      return raw.slice(1, -1);
+    const raw2 = stripped.slice(colonIdx + 1).trim();
+    if (raw2.startsWith('"') && raw2.endsWith('"') || raw2.startsWith("'") && raw2.endsWith("'")) {
+      return raw2.slice(1, -1);
     }
-    return raw;
+    return raw2;
   }
   return null;
 }
@@ -25319,28 +25730,28 @@ function err(check, detail, affected) {
   };
 }
 async function readEngineMin() {
-  const raw = await readLocalPkg();
-  if (!raw) return null;
-  const engine = raw.engines?.node;
+  const raw2 = await readLocalPkg();
+  if (!raw2) return null;
+  const engine = raw2.engines?.node;
   if (typeof engine !== "string") return null;
   const match = engine.match(/(\d+(?:\.\d+){0,2})/);
   return match ? match[1] : null;
 }
 async function readLocalVersion() {
-  const raw = await readLocalPkg();
-  return typeof raw?.version === "string" ? raw.version : null;
+  const raw2 = await readLocalPkg();
+  return typeof raw2?.version === "string" ? raw2.version : null;
 }
 async function readLocalPkg() {
   try {
     const here = fileURLToPath10(import.meta.url);
-    let dir = dirname17(here);
+    let dir = dirname18(here);
     for (let i = 0; i < 6; i++) {
       const candidate = join10(dir, "package.json");
       try {
         const text = await readFile36(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
-        dir = dirname17(dir);
+        dir = dirname18(dir);
       }
     }
     return null;
@@ -25367,12 +25778,12 @@ async function fetchLatestNpmVersion2(pkg, timeoutMs) {
 function readTopLevelField(fmBlock, key) {
   const match = fmBlock.match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
   if (!match) return null;
-  const raw = match[1].trim();
-  if (raw === "") return null;
-  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
-    return raw.slice(1, -1);
+  const raw2 = match[1].trim();
+  if (raw2 === "") return null;
+  if (raw2.startsWith('"') && raw2.endsWith('"') || raw2.startsWith("'") && raw2.endsWith("'")) {
+    return raw2.slice(1, -1);
   }
-  return raw;
+  return raw2;
 }
 function versionGte(a, b) {
   const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
@@ -25389,8 +25800,8 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve57 } from "path";
-import { readdir as readdir18, stat as stat4 } from "fs/promises";
+import { resolve as resolve58 } from "path";
+import { readdir as readdir19, stat as stat5 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
   "projects",
@@ -25409,7 +25820,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve57(ctx.syntaurRoot, "projects");
+    const p = resolve58(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -25434,7 +25845,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve57(ctx.syntaurRoot, "playbooks");
+    const p = resolve58(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -25459,7 +25870,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve57(ctx.syntaurRoot, "todos");
+    const p = resolve58(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -25470,7 +25881,7 @@ var todosDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat4(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -25490,7 +25901,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve57(ctx.syntaurRoot, "servers");
+    const p = resolve58(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -25501,7 +25912,7 @@ var serversDirValid = {
         autoFixable: false
       };
     }
-    const s = await stat4(p);
+    const s = await stat5(p);
     if (!s.isDirectory()) {
       return {
         id: this.id,
@@ -25521,7 +25932,7 @@ var knownFilesRecognized = {
   category: CATEGORY2,
   title: "No unexpected top-level entries under ~/.syntaur/",
   async run(ctx) {
-    const entries = await readdir18(ctx.syntaurRoot, { withFileTypes: true });
+    const entries = await readdir19(ctx.syntaurRoot, { withFileTypes: true });
     const unexpected = [];
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
@@ -25535,7 +25946,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve57(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve58(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -25564,8 +25975,8 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.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 stat6 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
   "project.md",
@@ -25589,15 +26000,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 readdir19(dir, { withFileTypes: true });
+  const entries = await readdir20(dir, { withFileTypes: true });
   const result = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve58(dir, e.name);
+    const projectDir = resolve59(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve58(projectDir, marker))) {
+      if (await fileExists(resolve59(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -25616,7 +26027,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve58(projectDir, rel);
+        const p = resolve59(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -25626,7 +26037,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve58(projectDir, m)),
+        affected: missing.map((m) => resolve59(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -25649,9 +26060,9 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve58(projectDir, "manifest.md");
+      const manifestPath = resolve59(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
-      const manifestMtime = (await stat5(manifestPath)).mtimeMs;
+      const manifestMtime = (await stat6(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
       if (newestAssignment === 0) continue;
       if (newestAssignment > manifestMtime) {
@@ -25683,7 +26094,7 @@ var orphanFiles = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const entries = await readdir19(projectDir, { withFileTypes: true });
+      const entries = await readdir20(projectDir, { withFileTypes: true });
       const orphans = [];
       for (const e of entries) {
         if (e.name.startsWith(".")) continue;
@@ -25698,7 +26109,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve58(projectDir, o)),
+        affected: orphans.map((o) => resolve59(projectDir, o)),
         autoFixable: false
       });
     }
@@ -25708,20 +26119,20 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve58(projectDir, "assignments");
+  const assignmentsRoot = resolve59(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
   try {
-    entries = await readdir19(assignmentsRoot, { withFileTypes: true });
+    entries = await readdir20(assignmentsRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve58(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve59(assignmentsRoot, e.name, "assignment.md");
     try {
-      const s = await stat5(assignmentMd);
+      const s = await stat6(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
     } catch {
     }
@@ -25743,8 +26154,8 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve59 } from "path";
-import { readFile as readFile37, readdir as readdir20 } from "fs/promises";
+import { resolve as resolve60 } from "path";
+import { readFile as readFile37, readdir as readdir21 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -25838,7 +26249,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -25871,7 +26282,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -25918,12 +26329,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve59(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve59(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve60(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -25933,7 +26344,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve59(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve60(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -25956,7 +26367,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve59(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve60(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -25968,7 +26379,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) => resolve59(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve60(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -26001,7 +26412,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -26035,7 +26446,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -26086,17 +26497,17 @@ var draftMissingObjective = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "draft") continue;
-      let raw;
+      let raw2;
       try {
-        raw = await readFile37(path, "utf-8");
+        raw2 = await readFile37(path, "utf-8");
       } catch {
         continue;
       }
-      if (!objectiveBodyIsEmpty(raw)) continue;
+      if (!objectiveBodyIsEmpty(raw2)) continue;
       const label = a.standalone ? `standalone/${a.assignmentSlug}` : `${a.projectSlug}/${a.assignmentSlug}`;
       results.push({
         id: this.id,
@@ -26125,16 +26536,16 @@ var readyToImplementMissingPlan = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve59(a.assignmentDir, "assignment.md");
+      const path = resolve60(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
-      const entries = await readdir20(a.assignmentDir).catch(() => []);
+      const entries = await readdir21(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(resolve59(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile37(resolve60(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -26150,7 +26561,7 @@ var readyToImplementMissingPlan = {
         title: this.title,
         status: "warn",
         detail: `${label} (status: ready_to_implement) has no plan.md or plan-v<N>.md`,
-        affected: [resolve59(a.assignmentDir, "plan.md")],
+        affected: [resolve60(a.assignmentDir, "plan.md")],
         remediation: {
           kind: "manual",
           suggestion: `Write a plan with '/plan-assignment' (or 'syntaur plan'), then re-mark ready_to_implement`,
@@ -26196,7 +26607,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve60 } from "path";
+import { resolve as resolve61 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -26210,7 +26621,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve60(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -26228,7 +26639,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve60(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -26240,7 +26651,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve60(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve61(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -26266,7 +26677,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve60(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve61(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -26285,7 +26696,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve60(
+        const assignmentPath = resolve61(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -26337,8 +26748,8 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve61, dirname as dirname18, basename as basename5 } from "path";
-import { readdir as readdir21, readFile as readFile38 } from "fs/promises";
+import { resolve as resolve62, dirname as dirname19, basename as basename6 } from "path";
+import { readdir as readdir22, readFile as readFile38 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -26401,7 +26812,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 readdir21(projectsDir2, { withFileTypes: true });
+    const entries = await readdir22(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 {
@@ -26420,11 +26831,11 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve61(homedir10(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve62(homedir10(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw = await readFile38(path, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile38(path, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return {};
   }
@@ -26439,8 +26850,8 @@ var claudeMarketplaceRegistered = {
     if (!await fileExists(dir)) {
       return skipped2(this, "claudePluginDir does not exist (run install-plugin)");
     }
-    const pluginsParent = dirname18(dir);
-    if (basename5(pluginsParent) !== "plugins") {
+    const pluginsParent = dirname19(dir);
+    if (basename6(pluginsParent) !== "plugins") {
       return {
         id: this.id,
         category: this.category,
@@ -26456,8 +26867,8 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceRoot = dirname18(pluginsParent);
-    const marketplaceManifest = resolve61(marketplaceRoot, ".claude-plugin", "marketplace.json");
+    const marketplaceRoot = dirname19(pluginsParent);
+    const marketplaceManifest = resolve62(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
         id: this.id,
@@ -26488,7 +26899,7 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceName = parsed.name ?? basename5(marketplaceRoot);
+    const marketplaceName = parsed.name ?? basename6(marketplaceRoot);
     const hasSyntaurEntry = (parsed.plugins ?? []).some((p) => p?.name === "syntaur");
     const known = await readKnownMarketplaces();
     const registered = known[marketplaceName]?.installLocation === marketplaceRoot || Object.values(known).some((v) => v.installLocation === marketplaceRoot);
@@ -26508,7 +26919,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve61(homedir10(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve62(homedir10(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -26548,7 +26959,7 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve62 } from "path";
+import { resolve as resolve63 } from "path";
 import { readFile as readFile39 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
@@ -26570,13 +26981,13 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && !hasAnyBundleField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve62(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve63(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile39(path, "utf-8");
-    return { data: JSON.parse(raw), path, exists: true, parseError: null };
+    const raw2 = await readFile39(path, "utf-8");
+    return { data: JSON.parse(raw2), path, exists: true, parseError: null };
   } catch (err2) {
     return {
       data: null,
@@ -26669,7 +27080,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 = resolve62(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve63(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -26699,7 +27110,7 @@ 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 = resolve62(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve63(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
       const content = await readFile39(assignmentMd, "utf-8");
@@ -26849,30 +27260,30 @@ var agentChecks = [agentsResolvable];
 init_config2();
 import { spawnSync as spawnSync9 } from "child_process";
 import { readFile as readFile40 } from "fs/promises";
-import { resolve as resolve63 } from "path";
+import { resolve as resolve64 } from "path";
 init_paths();
 init_fs();
 var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
-  const configPath = resolve63(syntaurRoot(), "config.md");
+  const configPath = resolve64(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return null;
   const content = await readFile40(configPath, "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));
   if (!line) return null;
-  const raw = line.replace(/^terminal:\s*/, "").trim();
-  if (raw.length === 0) return null;
-  const unquoted = /^"(.*)"$|^'(.*)'$/.exec(raw);
-  return unquoted ? unquoted[1] ?? unquoted[2] : raw;
+  const raw2 = line.replace(/^terminal:\s*/, "").trim();
+  if (raw2.length === 0) return null;
+  const unquoted = /^"(.*)"$|^'(.*)'$/.exec(raw2);
+  return unquoted ? unquoted[1] ?? unquoted[2] : raw2;
 }
 var terminalValueValid = {
   id: "terminal.value-valid",
   category: CATEGORY9,
   title: "Configured terminal value is recognized",
   async run(ctx) {
-    const raw = await readRawTerminalKey();
-    if (raw === null) {
+    const raw2 = await readRawTerminalKey();
+    if (raw2 === null) {
       return {
         id: this.id,
         category: this.category,
@@ -26882,13 +27293,13 @@ var terminalValueValid = {
         autoFixable: false
       };
     }
-    if (!TERMINAL_CHOICES.includes(raw)) {
+    if (!TERMINAL_CHOICES.includes(raw2)) {
       return {
         id: this.id,
         category: this.category,
         title: this.title,
         status: "warn",
-        detail: `unknown terminal "${raw}" in ~/.syntaur/config.md`,
+        detail: `unknown terminal "${raw2}" in ~/.syntaur/config.md`,
         remediation: {
           kind: "manual",
           suggestion: `Set \`terminal:\` in ~/.syntaur/config.md to one of: ${TERMINAL_CHOICES.join(", ")}`,
@@ -26902,7 +27313,7 @@ var terminalValueValid = {
       category: this.category,
       title: this.title,
       status: "pass",
-      detail: `terminal: ${raw}`,
+      detail: `terminal: ${raw2}`,
       autoFixable: false
     };
   }
@@ -27006,13 +27417,13 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve64, join as join11 } from "path";
-import { readdir as readdir22, readFile as readFile41, lstat as lstat4 } from "fs/promises";
+import { resolve as resolve65, join as join11 } from "path";
+import { readdir as readdir23, readFile as readFile41, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve64(homedir11(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve64(homedir11(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve65(homedir11(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve65(homedir11(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -27027,7 +27438,7 @@ var skillsDedupCheck = {
       const present = [];
       let entries;
       try {
-        entries = await readdir22(dir, { withFileTypes: true });
+        entries = await readdir23(dir, { withFileTypes: true });
       } catch {
         continue;
       }
@@ -27086,7 +27497,7 @@ var skillsChecks = [skillsDedupCheck];
 
 // src/utils/doctor/checks/cross-agent.ts
 init_fs();
-import { join as join12, resolve as resolve65 } from "path";
+import { join as join12, resolve as resolve66 } from "path";
 var CATEGORY11 = "cross-agent";
 async function countSyntaurSkills(dir) {
   if (!await fileExists(dir)) return 0;
@@ -27125,7 +27536,7 @@ var crossAgentSkillsCheck = {
       }
       if (recorded && t.instructions) {
         for (const f of t.instructions.files) {
-          const p = resolve65(ctx.cwd, f.path);
+          const p = resolve66(ctx.cwd, f.path);
           if (!await fileExists(p)) {
             problems.push(`${t.displayName}: missing protocol file ${f.path} in cwd`);
             affected.push(p);
@@ -27174,8 +27585,8 @@ var crossAgentChecks = [crossAgentSkillsCheck];
 // src/utils/doctor/checks/bundles.ts
 init_fs();
 init_paths();
-import { resolve as resolve66 } from "path";
-import { readdir as readdir23 } from "fs/promises";
+import { resolve as resolve67 } from "path";
+import { readdir as readdir24 } from "fs/promises";
 import { spawnSync as spawnSync10 } from "child_process";
 init_parser2();
 var CATEGORY12 = "bundles";
@@ -27183,7 +27594,7 @@ async function listScopes(ctx) {
   const out = [];
   const td = todosDir();
   if (await fileExists(td)) {
-    const entries = await readdir23(td).catch(() => []);
+    const entries = await readdir24(td).catch(() => []);
     for (const f of entries) {
       if (typeof f !== "string") continue;
       if (!f.endsWith(".md") || f.endsWith("-log.md")) continue;
@@ -27199,12 +27610,12 @@ async function listScopes(ctx) {
     }
   }
   if (await fileExists(ctx.config.defaultProjectDir)) {
-    const projectEntries = await readdir23(ctx.config.defaultProjectDir, { withFileTypes: true }).catch(() => []);
+    const projectEntries = await readdir24(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 = resolve66(ctx.config.defaultProjectDir, slug, "project.md");
+      const projectMd = resolve67(ctx.config.defaultProjectDir, slug, "project.md");
       if (!await fileExists(projectMd)) continue;
       out.push({
         scopeLabel: `project:${slug}`,
@@ -27493,14 +27904,14 @@ async function finalize(checks) {
 async function readVersion() {
   try {
     const here = fileURLToPath11(import.meta.url);
-    let dir = dirname19(here);
+    let dir = dirname20(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile42(join13(dir, "package.json"), "utf-8");
-        const parsed = JSON.parse(raw);
+        const raw2 = await readFile42(join13(dir, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw2);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
-        dir = dirname19(dir);
+        dir = dirname20(dir);
       }
     }
     return null;
@@ -27593,7 +28004,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 = isAbsolute10(inputPath) ? inputPath : resolve67(cwd, inputPath);
+  const absolute = isAbsolute10(inputPath) ? inputPath : resolve68(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -27930,7 +28341,7 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve68 } from "path";
+import { resolve as resolve69 } from "path";
 import { readFile as readFile44 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
@@ -27961,7 +28372,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve68(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve69(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -27971,7 +28382,7 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve68(assignmentDir, "comments.md");
+  const commentsPath = resolve69(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
@@ -28011,8 +28422,8 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve72, relative as relative4, dirname as dirname20 } from "path";
-import { copyFile as copyFile3, mkdir as mkdir9, realpath as realpath2, rm as rm12, stat as stat8, writeFile as writeFile14 } from "fs/promises";
+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 { existsSync as existsSync6 } from "fs";
 
 // src/utils/assignment-target.ts
@@ -28022,7 +28433,7 @@ init_config2();
 init_slug();
 init_assignment_resolver();
 init_parser();
-import { resolve as resolve69 } from "path";
+import { resolve as resolve70 } from "path";
 import { readFile as readFile45 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
@@ -28035,7 +28446,7 @@ function classifyContext(ctx) {
   return "empty";
 }
 async function readAssignmentFrontmatterId(assignmentDir) {
-  const path = resolve69(assignmentDir, "assignment.md");
+  const path = resolve70(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
     const content = await readFile45(path, "utf-8");
@@ -28046,11 +28457,11 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   }
 }
 async function readContextJson(cwd) {
-  const path = resolve69(cwd, ".syntaur", "context.json");
+  const path = resolve70(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile45(path, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile45(path, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
@@ -28070,15 +28481,15 @@ async function resolveAssignmentTarget(input4, opts = {}) {
     if (!isValidSlug(input4)) {
       throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
     }
-    const projectDir = resolve69(baseDir, opts.project);
-    const projectMdPath = resolve69(projectDir, "project.md");
+    const projectDir = resolve70(baseDir, opts.project);
+    const projectMdPath = resolve70(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new AssignmentTargetError(
         `Project "${opts.project}" not found at ${projectDir}.`
       );
     }
-    const assignmentDir = resolve69(projectDir, "assignments", input4);
-    const assignmentMdPath2 = resolve69(assignmentDir, "assignment.md");
+    const assignmentDir = resolve70(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `Assignment "${input4}" not found in project "${opts.project}".`
@@ -28117,7 +28528,7 @@ async function resolveAssignmentTarget(input4, opts = {}) {
   }
   if (ctx.assignmentDir) {
     const dir = expandHome(ctx.assignmentDir);
-    const assignmentMdPath2 = resolve69(dir, "assignment.md");
+    const assignmentMdPath2 = resolve70(dir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment dir: ${dir}.`
@@ -28146,8 +28557,8 @@ async function resolveAssignmentTarget(input4, opts = {}) {
         `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
       );
     }
-    const assignmentDir = resolve69(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
-    const assignmentMdPath2 = resolve69(assignmentDir, "assignment.md");
+    const assignmentDir = resolve70(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
@@ -28170,45 +28581,11 @@ async function resolveAssignmentTarget(input4, opts = {}) {
 
 // src/commands/capture.ts
 init_paths();
-
-// src/utils/proof-artifact-id.ts
-import { randomBytes as randomBytes3 } from "crypto";
-function generateArtifactId() {
-  const ts = Date.now().toString(36);
-  const rand = randomBytes3(2).toString("hex");
-  return `${ts}-${rand}`;
-}
-var EXTENSIONS = {
-  screenshot: "png",
-  video: "mp4",
-  asciinema: "cast",
-  http: "txt",
-  text: "txt"
-};
-function extensionForKind(kind) {
-  const ext = EXTENSIONS[kind];
-  if (!ext) {
-    throw new Error(`Unknown artifact kind: ${kind}`);
-  }
-  return ext;
-}
-var ARTIFACT_KINDS = [
-  "screenshot",
-  "video",
-  "asciinema",
-  "http",
-  "text"
-];
-function isArtifactKind(value) {
-  return typeof value === "string" && ARTIFACT_KINDS.includes(value);
-}
-
-// src/commands/capture.ts
 init_fs();
 
 // src/utils/screencapture.ts
 import { spawn as spawn7 } from "child_process";
-import { mkdtemp as mkdtemp2, rm as rm8, stat as stat6 } from "fs/promises";
+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";
 function argsFor(mode, pngPath) {
@@ -28246,7 +28623,7 @@ async function captureScreenshot(mode) {
   const tmpDir = await mkdtemp2(join14(tmpdir3(), "syntaur-screenshot-"));
   const pngPath = join14(tmpDir, "shot.png");
   const cleanup = async () => {
-    await rm8(tmpDir, { recursive: true, force: true }).catch(() => {
+    await rm9(tmpDir, { recursive: true, force: true }).catch(() => {
     });
   };
   try {
@@ -28266,7 +28643,7 @@ async function captureScreenshot(mode) {
     }
     let size = 0;
     try {
-      size = (await stat6(pngPath)).size;
+      size = (await stat7(pngPath)).size;
     } catch {
       throw new Error("screencapture exited 0 but produced no image.");
     }
@@ -28282,7 +28659,7 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile46, rm as rm9 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile46, rm as rm10 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join15 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
@@ -28297,10 +28674,10 @@ function joinCommandForShell(argv) {
 function hasRecordedData(text) {
   const lines = text.split("\n");
   for (let i = 1; i < lines.length; i++) {
-    const raw = lines[i];
-    if (raw === "") continue;
-    if (raw.startsWith("#")) continue;
-    if (/^\s*\[\s*[\d.eE+-]+\s*,\s*"([oi])"/.test(raw)) return true;
+    const raw2 = lines[i];
+    if (raw2 === "") continue;
+    if (raw2.startsWith("#")) continue;
+    if (/^\s*\[\s*[\d.eE+-]+\s*,\s*"([oi])"/.test(raw2)) return true;
   }
   return false;
 }
@@ -28324,7 +28701,7 @@ async function captureAsciinema(opts) {
   const tmpDir = await mkdtemp3(join15(tmpdir4(), "syntaur-asciinema-"));
   const castPath = join15(tmpDir, "session.cast");
   const cleanup = async () => {
-    await rm9(tmpDir, { recursive: true, force: true }).catch(() => {
+    await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
     });
   };
   const noopSigint = () => {
@@ -28373,36 +28750,36 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn9 } from "child_process";
-import { mkdir as mkdir8, mkdtemp as mkdtemp4, open as open3, readFile as readFile47, rm as rm10, stat as stat7, unlink as unlink9, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir9, mkdtemp as mkdtemp4, open as open3, readFile as readFile47, 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 resolve70 } from "path";
+import { join as join16, resolve as resolve71 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
-  const raw = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
-  if (raw === void 0) return 500;
-  const parsed = Number(raw);
+  const raw2 = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
+  if (raw2 === void 0) return 500;
+  const parsed = Number(raw2);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 500;
 }
 function sigintPollCount() {
-  const raw = process.env.SYNTAUR_RECORDING_POLL_COUNT;
-  if (raw === void 0) return 20;
-  const parsed = Number(raw);
+  const raw2 = process.env.SYNTAUR_RECORDING_POLL_COUNT;
+  if (raw2 === void 0) return 20;
+  const parsed = Number(raw2);
   return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 20;
 }
 function sigtermWaitMs() {
-  const raw = process.env.SYNTAUR_RECORDING_SIGTERM_WAIT_MS;
-  if (raw === void 0) return 1e3;
-  const parsed = Number(raw);
+  const raw2 = process.env.SYNTAUR_RECORDING_SIGTERM_WAIT_MS;
+  if (raw2 === void 0) return 1e3;
+  const parsed = Number(raw2);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1e3;
 }
 function pidfilePath() {
-  return resolve70(syntaurRoot(), "recording.pid");
+  return resolve71(syntaurRoot(), "recording.pid");
 }
 function logPath2() {
-  return resolve70(syntaurRoot(), "recording.log");
+  return resolve71(syntaurRoot(), "recording.log");
 }
 function sidecarPath() {
-  return resolve70(syntaurRoot(), "recording.json");
+  return resolve71(syntaurRoot(), "recording.json");
 }
 function ffmpegArgs(device, fps, mp4Path) {
   return [
@@ -28427,9 +28804,9 @@ function ffmpegArgs(device, fps, mp4Path) {
   ];
 }
 function defaultWarmupMs() {
-  const raw = process.env.SYNTAUR_RECORDING_WARMUP_MS;
-  if (raw === void 0) return 1500;
-  const parsed = Number(raw);
+  const raw2 = process.env.SYNTAUR_RECORDING_WARMUP_MS;
+  if (raw2 === void 0) return 1500;
+  const parsed = Number(raw2);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1500;
 }
 var STARTING_SENTINEL_PREFIX = "STARTING:";
@@ -28456,7 +28833,7 @@ async function acquirePidfile(pidfile) {
             `Recording startup already in progress (parent PID ${parentPid}). Wait a moment and retry, or kill ${parentPid} and remove ${pidfile} manually if it's truly stuck.`
           );
         }
-        await unlink9(pidfile).catch(() => {
+        await unlink10(pidfile).catch(() => {
         });
         continue;
       }
@@ -28472,7 +28849,7 @@ async function acquirePidfile(pidfile) {
             `Recording already in progress (PID ${existingPid}). Stop with: syntaur capture --kind video --stop`
           );
         }
-        await unlink9(pidfile).catch(() => {
+        await unlink10(pidfile).catch(() => {
         });
         continue;
       }
@@ -28489,7 +28866,7 @@ async function startRecording(input4) {
     );
   }
   const root = syntaurRoot();
-  await mkdir8(root, { recursive: true });
+  await mkdir9(root, { recursive: true });
   const pidfile = pidfilePath();
   const log = logPath2();
   const sidecar = sidecarPath();
@@ -28544,7 +28921,7 @@ async function startRecording(input4) {
     const pid = await pidReady;
     acquiredPid = pid;
     child.unref();
-    await writeFile13(pidfile, String(pid));
+    await writeFile14(pidfile, String(pid));
     await logHandle.close();
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
@@ -28572,7 +28949,7 @@ ${tail}`
       device: input4.device,
       fps: input4.fps
     };
-    await writeFile13(sidecar, JSON.stringify(sidecarData, null, 2));
+    await writeFile14(sidecar, JSON.stringify(sidecarData, null, 2));
     return {
       pid,
       logPath: log,
@@ -28596,9 +28973,9 @@ ${tail}`
     }
     if (logHandle) await logHandle.close().catch(() => {
     });
-    if (tmpDir) await rm10(tmpDir, { recursive: true, force: true }).catch(() => {
+    if (tmpDir) await rm11(tmpDir, { recursive: true, force: true }).catch(() => {
     });
-    await unlink9(pidfile).catch(() => {
+    await unlink10(pidfile).catch(() => {
     });
     throw err2;
   }
@@ -28661,19 +29038,19 @@ async function stopRecording() {
   if (alive) {
     throw new Error(`ffmpeg (PID ${pid}) refused to die after SIGKILL`);
   }
-  const st = await stat7(sidecarData.mp4Path).catch(() => null);
+  const st = await stat8(sidecarData.mp4Path).catch(() => null);
   if (st === null || st.size === 0) {
-    await unlink9(pidfile).catch(() => {
+    await unlink10(pidfile).catch(() => {
     });
-    await unlink9(sidecar).catch(() => {
+    await unlink10(sidecar).catch(() => {
     });
     throw new Error(
       `ffmpeg produced no output at ${sidecarData.mp4Path}. Check ${sidecarData.logPath} for errors.`
     );
   }
-  await unlink9(pidfile).catch(() => {
+  await unlink10(pidfile).catch(() => {
   });
-  await unlink9(sidecar).catch(() => {
+  await unlink10(sidecar).catch(() => {
   });
   return { mp4Path: sidecarData.mp4Path, sidecar: sidecarData };
 }
@@ -28681,7 +29058,7 @@ async function stopRecording() {
 // src/db/proof-db.ts
 init_paths();
 import Database5 from "better-sqlite3";
-import { resolve as resolve71 } from "path";
+import { resolve as resolve72 } from "path";
 var db4 = null;
 var PROOF_SCHEMA_VERSION = "1";
 var SCHEMA_SQL4 = `
@@ -28701,7 +29078,7 @@ CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
 function initProofDb(dbPath) {
   if (db4) return db4;
-  const finalPath = dbPath ?? resolve71(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve72(syntaurRoot(), "syntaur.db");
   db4 = new Database5(finalPath);
   db4.pragma("journal_mode = WAL");
   db4.exec(SCHEMA_SQL4);
@@ -28749,7 +29126,7 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn10 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile48, rm as rm11 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile48, rm as rm12 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join17 } from "path";
 var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
@@ -28847,7 +29224,7 @@ var elevenLabsScribe = {
       await extractAudio(videoAbsPath, wav);
       return await callScribe(wav, apiKey, opts);
     } finally {
-      await rm11(tmp, { recursive: true, force: true }).catch(() => {
+      await rm12(tmp, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -28897,10 +29274,10 @@ function groupIntoPhrases(words, silenceThresholdSec = 0.5) {
     const parts = [];
     for (const w of currentWords) {
       const t = w.type ?? "word";
-      let raw = (w.text ?? "").trim();
-      if (!raw) continue;
-      if (t === "audio_event" && !raw.startsWith("(")) raw = `(${raw})`;
-      parts.push(raw);
+      let raw2 = (w.text ?? "").trim();
+      if (!raw2) continue;
+      if (t === "audio_event" && !raw2.startsWith("(")) raw2 = `(${raw2})`;
+      parts.push(raw2);
     }
     if (parts.length === 0) {
       currentWords = [];
@@ -28968,17 +29345,17 @@ function renderMarkdown(phrases) {
 
 // src/commands/capture.ts
 var MAX_ID_RETRIES = 5;
-function normalizeCriterionIndex(raw) {
-  if (raw === void 0 || raw === null || raw === "") return null;
-  if (typeof raw === "number") {
-    if (!Number.isInteger(raw) || raw < 0) {
-      throw new Error(`--criterion must be a non-negative integer (got "${raw}")`);
+function normalizeCriterionIndex(raw2) {
+  if (raw2 === void 0 || raw2 === null || raw2 === "") return null;
+  if (typeof raw2 === "number") {
+    if (!Number.isInteger(raw2) || raw2 < 0) {
+      throw new Error(`--criterion must be a non-negative integer (got "${raw2}")`);
     }
-    return raw;
+    return raw2;
   }
-  const s = String(raw).trim();
+  const s = String(raw2).trim();
   if (!/^\d+$/.test(s)) {
-    throw new Error(`--criterion must be a non-negative integer (got "${raw}")`);
+    throw new Error(`--criterion must be a non-negative integer (got "${raw2}")`);
   }
   return parseInt(s, 10);
 }
@@ -29116,9 +29493,9 @@ async function captureCommand(target, options = {}) {
     criterionIndex = sidecar.criterionIndex;
     stopNote = sidecar.note;
     resolvedSource = mp4Path;
-    const mp4TmpDir = dirname20(mp4Path);
+    const mp4TmpDir = dirname21(mp4Path);
     shelloutCleanup = async () => {
-      await rm12(mp4TmpDir, { recursive: true, force: true }).catch(() => {
+      await rm13(mp4TmpDir, { recursive: true, force: true }).catch(() => {
       });
     };
   } else {
@@ -29129,7 +29506,7 @@ async function captureCommand(target, options = {}) {
     });
   }
   if (options.file) {
-    const expanded = options.file.startsWith("~/") ? resolve72(process.env.HOME ?? "", options.file.slice(2)) : resolve72(options.file);
+    const expanded = options.file.startsWith("~/") ? resolve73(process.env.HOME ?? "", options.file.slice(2)) : resolve73(options.file);
     if (!await fileExists(expanded)) {
       throw new Error(`--file does not exist: ${options.file}`);
     }
@@ -29141,7 +29518,7 @@ async function captureCommand(target, options = {}) {
         `--file is unreadable: ${options.file} (${e instanceof Error ? e.message : String(e)})`
       );
     }
-    const st = await stat8(real);
+    const st = await stat9(real);
     if (!st.isFile()) {
       throw new Error(`--file is not a regular file: ${options.file}`);
     }
@@ -29170,8 +29547,8 @@ async function captureCommand(target, options = {}) {
     }
     initProofDb();
     const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-    const destDir = resolve72(proofDir(resolved.assignmentDir), subdir);
-    if (resolvedSource) await mkdir9(destDir, { recursive: true });
+    const destDir = resolve73(proofDir(resolved.assignmentDir), subdir);
+    if (resolvedSource) await mkdir10(destDir, { recursive: true });
     const ext = resolvedSource ? extensionForKind(kind) : null;
     let id = null;
     let relativeFilePath = null;
@@ -29179,7 +29556,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 ? resolve72(destDir, `${candidate}.${ext}`) : null;
+      const candidateAbsPath = resolvedSource && ext ? resolve73(destDir, `${candidate}.${ext}`) : null;
       const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
       try {
         insertArtifact({
@@ -29223,7 +29600,7 @@ async function captureCommand(target, options = {}) {
       }
     }
     if (options.transcribe && kind === "video" && absPath && id) {
-      const sidecarPath2 = resolve72(destDir, `${id}.transcript.md`);
+      const sidecarPath2 = resolve73(destDir, `${id}.transcript.md`);
       if (existsSync6(sidecarPath2)) {
         console.warn(
           `transcript: ${sidecarPath2} already exists, skipping (delete to re-transcribe)`
@@ -29232,7 +29609,7 @@ async function captureCommand(target, options = {}) {
         try {
           const json = await getTranscriber().transcribe(absPath);
           const md = renderMarkdown(groupIntoPhrases(json.words ?? []));
-          await writeFile14(sidecarPath2, md, "utf8");
+          await writeFile15(sidecarPath2, md, "utf8");
           console.log(`transcript: ${sidecarPath2}`);
         } catch (err2) {
           if (err2 instanceof TranscribeFfmpegMissingError) {
@@ -29255,7 +29632,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: ${resolve72(resolved.assignmentDir, relativeFilePath)}`);
+      console.log(`  file: ${resolve73(resolved.assignmentDir, relativeFilePath)}`);
     }
   } catch (err2) {
     if (options.stop && kind === "video" && shelloutCleanup && resolvedSource) {
@@ -29278,8 +29655,8 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile49, writeFile as writeFile15, rename as rename9, stat as stat9 } from "fs/promises";
-import { resolve as resolve73, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname21 } from "path";
+import { readFile as readFile49, writeFile as writeFile16, rename as rename10, stat as stat10 } from "fs/promises";
+import { resolve as resolve74, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname22 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -29519,7 +29896,7 @@ function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map(), trans
 
 // src/commands/proof.ts
 async function readAssignmentMeta(assignmentDir) {
-  const path = resolve73(assignmentDir, "assignment.md");
+  const path = resolve74(assignmentDir, "assignment.md");
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
@@ -29529,16 +29906,16 @@ async function readAssignmentMeta(assignmentDir) {
   if (fmMatch) {
     const titleLine = fmMatch[1].split("\n").find((l) => /^title:\s/i.test(l));
     if (titleLine) {
-      const raw = titleLine.replace(/^title:\s*/i, "").trim();
-      title = raw.replace(/^["']|["']$/g, "");
+      const raw2 = titleLine.replace(/^title:\s*/i, "").trim();
+      title = raw2.replace(/^["']|["']$/g, "");
     }
   }
   return { title, body: content };
 }
 async function atomicWrite(destPath, content) {
   const tmp = `${destPath}.${randomBytes4(4).toString("hex")}.tmp`;
-  await writeFile15(tmp, content, "utf-8");
-  await rename9(tmp, destPath);
+  await writeFile16(tmp, content, "utf-8");
+  await rename10(tmp, destPath);
 }
 function isWithin(root, target) {
   const rel = relative5(root, target);
@@ -29570,7 +29947,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 = resolve73(assignmentDir, r.file_path);
+    const abs = resolve74(assignmentDir, r.file_path);
     if (!isWithin(proofRoot, abs)) {
       out.set(r.file_path, null);
       continue;
@@ -29579,7 +29956,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       out.set(r.file_path, null);
       continue;
     }
-    const st = await stat9(abs);
+    const st = await stat10(abs);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) {
       out.set(r.file_path, null);
       continue;
@@ -29597,11 +29974,11 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
   const proofRoot = proofDir(assignmentDir);
   for (const r of rows) {
     if (r.kind !== "video" || !r.file_path) continue;
-    const videoAbs = resolve73(assignmentDir, r.file_path);
-    const sidecar = resolve73(dirname21(videoAbs), `${r.id}.transcript.md`);
+    const videoAbs = resolve74(assignmentDir, r.file_path);
+    const sidecar = resolve74(dirname22(videoAbs), `${r.id}.transcript.md`);
     if (!isWithin(proofRoot, sidecar)) continue;
     if (!await fileExists(sidecar)) continue;
-    const st = await stat9(sidecar);
+    const st = await stat10(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
       out.set(r.id, await readFile49(sidecar, "utf-8"));
@@ -29638,8 +30015,8 @@ async function proofBuildCommand(target, options = {}) {
   };
   const md = renderProofMarkdown(renderParams);
   const html = renderProofHtml(renderParams, inlineFiles, transcriptSidecars);
-  const mdPath = resolve73(resolved.assignmentDir, "proof.md");
-  const htmlPath = resolve73(resolved.assignmentDir, "proof.html");
+  const mdPath = resolve74(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve74(resolved.assignmentDir, "proof.html");
   await atomicWrite(mdPath, md);
   await atomicWrite(htmlPath, html);
   console.log(`Wrote ${htmlPath}`);
@@ -29675,12 +30052,12 @@ function parseDuration(input4, fallbackSeconds) {
 function parseMetadataFlags(values) {
   if (!values || values.length === 0) return void 0;
   const out = {};
-  for (const raw of values) {
-    const eq = raw.indexOf("=");
+  for (const raw2 of values) {
+    const eq = raw2.indexOf("=");
     if (eq < 0) {
-      throw new Error(`invalid -m flag "${raw}" \u2014 use key=value`);
+      throw new Error(`invalid -m flag "${raw2}" \u2014 use key=value`);
     }
-    out[raw.slice(0, eq)] = raw.slice(eq + 1);
+    out[raw2.slice(0, eq)] = raw2.slice(eq + 1);
   }
   return out;
 }
@@ -30149,41 +30526,41 @@ function parseCcusageSession(payload, nowIso6 = () => (/* @__PURE__ */ new Date(
   }
   const rows = [];
   let highWaterIso = null;
-  for (const raw of sessions) {
-    if (!raw || typeof raw !== "object") {
+  for (const raw2 of sessions) {
+    if (!raw2 || typeof raw2 !== "object") {
       warnings.push("skipped non-object session row");
       continue;
     }
-    const tool = typeof raw.agent === "string" ? raw.agent : null;
-    const period = typeof raw.period === "string" ? raw.period : null;
+    const tool = typeof raw2.agent === "string" ? raw2.agent : null;
+    const period = typeof raw2.period === "string" ? raw2.period : null;
     if (!tool || !period) {
       warnings.push("skipped session row missing agent or period");
       continue;
     }
     const sessionId = extractSessionId(tool, period);
-    const breakdowns = Array.isArray(raw.modelBreakdowns) ? raw.modelBreakdowns : [];
+    const breakdowns = Array.isArray(raw2.modelBreakdowns) ? raw2.modelBreakdowns : [];
     const eventTs = normalizeLastActivity(
-      raw.metadata?.lastActivity,
+      raw2.metadata?.lastActivity,
       nowIso6
     );
     if (eventTs && (!highWaterIso || eventTs > highWaterIso)) {
       highWaterIso = eventTs;
     }
     if (breakdowns.length === 0) {
-      const modelsUsed = Array.isArray(raw.modelsUsed) ? raw.modelsUsed : [];
+      const modelsUsed = Array.isArray(raw2.modelsUsed) ? raw2.modelsUsed : [];
       const fallbackModel = typeof modelsUsed[0] === "string" ? modelsUsed[0] : "unknown";
       rows.push({
         sessionId,
         model: fallbackModel,
         tool,
         eventTs,
-        inputTokens: toInt(raw.inputTokens),
-        outputTokens: toInt(raw.outputTokens),
-        cacheCreationTokens: toInt(raw.cacheCreationTokens),
-        cacheReadTokens: toInt(raw.cacheReadTokens),
-        totalTokens: toInt(raw.totalTokens),
-        totalCost: toNumber(raw.totalCost),
-        rawJson: JSON.stringify(raw)
+        inputTokens: toInt(raw2.inputTokens),
+        outputTokens: toInt(raw2.outputTokens),
+        cacheCreationTokens: toInt(raw2.cacheCreationTokens),
+        cacheReadTokens: toInt(raw2.cacheReadTokens),
+        totalTokens: toInt(raw2.totalTokens),
+        totalCost: toNumber(raw2.totalCost),
+        rawJson: JSON.stringify(raw2)
       });
       continue;
     }
@@ -30213,7 +30590,7 @@ function parseCcusageSession(payload, nowIso6 = () => (/* @__PURE__ */ new Date(
         cacheReadTokens,
         totalTokens,
         totalCost: toNumber(b.cost),
-        rawJson: JSON.stringify(raw)
+        rawJson: JSON.stringify(raw2)
       });
     }
   }
@@ -30304,7 +30681,7 @@ async function runCcusage(opts = {}) {
   };
 }
 function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
-  return new Promise((resolve82) => {
+  return new Promise((resolve83) => {
     const child = spawn11(binary, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -30318,7 +30695,7 @@ function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
-      resolve82(result);
+      resolve83(result);
     };
     const timer2 = setTimeout(() => {
       timedOut = true;
@@ -30362,7 +30739,7 @@ function isoToCcusageDate(iso) {
 
 // src/usage/cwd-extractor.ts
 init_paths();
-import { open as open4, readdir as readdir24, stat as stat10 } from "fs/promises";
+import { open as open4, readdir as readdir25, stat as stat11 } from "fs/promises";
 import { join as join18 } from "path";
 import { homedir as homedir12 } from "os";
 var SCAN_LINE_CAP = 50;
@@ -30371,8 +30748,8 @@ var TAIL_READ_BYTES_MAX = 64 * 1024;
 async function extractClaudeSessionMeta(jsonlPath) {
   const cwd = await derivePathFromTranscript(jsonlPath);
   if (!cwd) return null;
-  const basename6 = jsonlPath.split("/").pop() ?? "";
-  const sessionId = basename6.replace(/\.jsonl$/, "");
+  const basename7 = jsonlPath.split("/").pop() ?? "";
+  const sessionId = basename7.replace(/\.jsonl$/, "");
   if (!sessionId) return null;
   const startTs = await readFirstTimestamp(jsonlPath);
   const endTs = await readLastTimestamp(jsonlPath);
@@ -30465,8 +30842,8 @@ async function* walkClaudeProjects(opts = {}) {
 async function* walkCodexSessions(opts = {}) {
   const root = resolveCodexSessionsRoot(opts.root);
   for await (const filePath of walkJsonlRecursive(root)) {
-    const basename6 = filePath.split("/").pop() ?? "";
-    if (!basename6.endsWith(".jsonl")) continue;
+    const basename7 = filePath.split("/").pop() ?? "";
+    if (!basename7.endsWith(".jsonl")) continue;
     if (opts.sinceMtimeMs !== void 0) {
       const mtime = await mtimeMs(filePath);
       if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -30485,7 +30862,7 @@ function resolveCodexSessionsRoot(override) {
 }
 async function listDirSafe(path) {
   try {
-    const entries = await readdir24(path, { withFileTypes: true });
+    const entries = await readdir25(path, { withFileTypes: true });
     return entries.map((e) => ({
       name: e.name,
       isFile: e.isFile(),
@@ -30512,7 +30889,7 @@ async function* walkJsonlRecursive(root) {
 }
 async function mtimeMs(path) {
   try {
-    const s = await stat10(path);
+    const s = await stat11(path);
     return s.mtimeMs;
   } catch {
     return null;
@@ -30840,7 +31217,7 @@ init_slug();
 init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
-import { resolve as resolve74 } from "path";
+import { resolve as resolve75 } from "path";
 import { readFile as readFile50 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
@@ -30857,7 +31234,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve74(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve75(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -30867,7 +31244,7 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath2 = resolve74(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve75(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
@@ -30885,14 +31262,14 @@ async function requestCommand(target, text, options = {}) {
 init_fs();
 init_paths();
 import { Command as Command9 } from "commander";
-import { readFile as readFile51, readdir as readdir25 } from "fs/promises";
-import { resolve as resolve75 } from "path";
+import { readFile as readFile51, readdir as readdir26 } from "fs/promises";
+import { resolve as resolve76 } from "path";
 async function readContextAssignmentDir(cwd) {
-  const path = resolve75(cwd, ".syntaur", "context.json");
+  const path = resolve76(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile51(path, "utf-8");
-    const ctx = JSON.parse(raw);
+    const raw2 = await readFile51(path, "utf-8");
+    const ctx = JSON.parse(raw2);
     if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
       return ctx.assignmentDir;
     }
@@ -30905,9 +31282,9 @@ async function resolveAssignmentDir(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.assignment) {
     if (opts.project) {
-      return resolve75(defaultProjectDir(), opts.project, "assignments", opts.assignment);
+      return resolve76(defaultProjectDir(), opts.project, "assignments", opts.assignment);
     }
-    return resolve75(assignmentsDir(), opts.assignment);
+    return resolve76(assignmentsDir(), opts.assignment);
   }
   const fromCtx = await readContextAssignmentDir(cwd);
   if (fromCtx) return fromCtx;
@@ -30918,7 +31295,7 @@ async function resolveAssignmentDir(opts) {
 var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
 async function listPlanFiles(assignmentDir) {
   if (!await fileExists(assignmentDir)) return [];
-  const entries = await readdir25(assignmentDir, { withFileTypes: true });
+  const entries = await readdir26(assignmentDir, { withFileTypes: true });
   const out = [];
   for (const e of entries) {
     if (!e.isFile()) continue;
@@ -31050,7 +31427,7 @@ async function runPlanVersion(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve75(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve76(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
@@ -31062,14 +31439,14 @@ async function runPlanVersion(options) {
   }
   const current = planFiles[planFiles.length - 1];
   const next = nextPlanFileName(current.version);
-  const newPath = resolve75(assignmentDir, next.fileName);
+  const newPath = resolve76(assignmentDir, next.fileName);
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
   const assignmentMd = await readFile51(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
-  const oldPlanPath = resolve75(assignmentDir, current.fileName);
+  const oldPlanPath = resolve76(assignmentDir, current.fileName);
   const oldPlanContent = await readFile51(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
@@ -31107,28 +31484,28 @@ planCommand.command("version").description(
 // src/commands/session.ts
 init_fs();
 import { Command as Command10 } from "commander";
-import { readFile as readFile52, readdir as readdir26, stat as stat11 } from "fs/promises";
-import { resolve as resolve76 } from "path";
+import { readFile as readFile52, readdir as readdir27, stat as stat12 } from "fs/promises";
+import { resolve as resolve77 } from "path";
 async function readContext(cwd) {
-  const path = resolve76(cwd, ".syntaur", "context.json");
+  const path = resolve77(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile52(path, "utf-8");
-    return JSON.parse(raw);
+    const raw2 = await readFile52(path, "utf-8");
+    return JSON.parse(raw2);
   } catch {
     return null;
   }
 }
 async function findLatestSessionSummary(assignmentDir) {
-  const sessionsRoot = resolve76(assignmentDir, "sessions");
+  const sessionsRoot = resolve77(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
-  const entries = await readdir26(sessionsRoot, { withFileTypes: true });
+  const entries = await readdir27(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const summaryPath = resolve76(sessionsRoot, entry.name, "summary.md");
+    const summaryPath = resolve77(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
-    const st = await stat11(summaryPath);
+    const st = await stat12(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
       best = { sessionId: entry.name, path: summaryPath, mtime: st.mtime };
     }
@@ -31136,7 +31513,7 @@ async function findLatestSessionSummary(assignmentDir) {
   return best;
 }
 async function findOpenHandoff(assignmentDir) {
-  const handoffPath = resolve76(assignmentDir, "handoff.md");
+  const handoffPath = resolve77(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
   const content = await readFile52(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
@@ -31247,9 +31624,9 @@ init_fs();
 init_paths();
 import { Command as Command11 } from "commander";
 import { readFile as readFile53 } from "fs/promises";
-import { resolve as resolve77 } from "path";
+import { resolve as resolve78 } from "path";
 async function readContext2(cwd) {
-  const path = resolve77(cwd, ".syntaur", "context.json");
+  const path = resolve78(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
     return JSON.parse(await readFile53(path, "utf-8"));
@@ -31260,7 +31637,7 @@ async function readContext2(cwd) {
 async function resolveAssignmentPath2(opts) {
   if (opts.assignment) {
     if (opts.project) {
-      return resolve77(
+      return resolve78(
         defaultProjectDir(),
         opts.project,
         "assignments",
@@ -31268,10 +31645,10 @@ async function resolveAssignmentPath2(opts) {
         "assignment.md"
       );
     }
-    return resolve77(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve78(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext2(opts.cwd);
-  if (ctx?.assignmentDir) return resolve77(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve78(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -31282,7 +31659,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   }
   const repository = options.repository ?? cwd;
   const parentBranch = options.parentBranch ?? "main";
-  const worktreePath = options.worktreePath ?? resolve77(repository, ".worktrees", options.branch);
+  const worktreePath = options.worktreePath ?? resolve78(repository, ".worktrees", options.branch);
   const assignmentPath = await resolveAssignmentPath2({
     assignment: options.assignment,
     project: options.project,
@@ -31319,13 +31696,13 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command12 } from "commander";
-import { resolve as resolve79 } from "path";
+import { resolve as resolve80 } from "path";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir27, readFile as readFile54 } from "fs/promises";
-import { resolve as resolve78 } from "path";
+import { readdir as readdir28, readFile as readFile54 } from "fs/promises";
+import { resolve as resolve79 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -31334,7 +31711,7 @@ function readProjectSlug(projectDir) {
 }
 async function listSlugFiles(dir) {
   if (!await fileExists(dir)) return [];
-  const entries = await readdir27(dir, { withFileTypes: true });
+  const entries = await readdir28(dir, { withFileTypes: true });
   return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
 }
 function escapeCell(value) {
@@ -31344,7 +31721,7 @@ function joinList(items) {
   return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
 }
 async function rebuildResourcesIndex(projectDir) {
-  const dir = resolve78(projectDir, "resources");
+  const dir = resolve79(projectDir, "resources");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -31360,7 +31737,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile54(resolve78(dir, fileName), "utf-8");
+    const content = await readFile54(resolve79(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -31370,12 +31747,12 @@ async function rebuildResourcesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve78(dir, "_index.md");
+  const indexPath = resolve79(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 async function rebuildMemoriesIndex(projectDir) {
-  const dir = resolve78(projectDir, "memories");
+  const dir = resolve79(projectDir, "memories");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -31391,7 +31768,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile54(resolve78(dir, fileName), "utf-8");
+    const content = await readFile54(resolve79(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -31401,7 +31778,7 @@ async function rebuildMemoriesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve78(dir, "_index.md");
+  const indexPath = resolve79(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
@@ -31439,8 +31816,8 @@ async function runResourceAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve79(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve79(projectDir, "project.md"))) {
+  const projectDir = resolve80(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve80(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -31449,7 +31826,7 @@ async function runResourceAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid resource slug: "${slug}".`);
   }
-  const filePath = resolve79(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve80(projectDir, "resources", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -31484,7 +31861,7 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command13 } from "commander";
-import { resolve as resolve80 } from "path";
+import { resolve as resolve81 } from "path";
 function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -31519,8 +31896,8 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve80(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve80(projectDir, "project.md"))) {
+  const projectDir = resolve81(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve81(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -31529,7 +31906,7 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid memory slug: "${slug}".`);
   }
-  const filePath = resolve80(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve81(projectDir, "memories", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -31567,7 +31944,7 @@ init_fs();
 init_frontmatter();
 import { Command as Command14 } from "commander";
 import { readFile as readFile55 } from "fs/promises";
-import { resolve as resolve81 } from "path";
+import { resolve as resolve82 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -31586,7 +31963,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve81(
+    return resolve82(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -31594,7 +31971,7 @@ function assignmentMdPath(item) {
       "assignment.md"
     );
   }
-  return resolve81(assignmentsDir(), item.id, "assignment.md");
+  return resolve82(assignmentsDir(), item.id, "assignment.md");
 }
 async function loadTags(item) {
   const path = assignmentMdPath(item);
@@ -32024,10 +32401,10 @@ viewsCommand.command("delete").description("Delete a saved view by id").argument
 
 // src/cli-default-command.ts
 init_config2();
-import { readdir as readdir28 } from "fs/promises";
+import { readdir as readdir29 } from "fs/promises";
 async function hasAnyProjectContent(projectsDir2) {
   try {
-    const entries = await readdir28(projectsDir2, { withFileTypes: true });
+    const entries = await readdir29(projectsDir2, { withFileTypes: true });
     return entries.some((entry) => entry.isDirectory());
   } catch {
     return false;