syntaur 0.18.0 → 0.20.0

package/dist/index.js

@@ -311,6 +311,9 @@ function parseAssignmentFull(fileContent) {
     },
     externalIds: parseExternalIds(fm),
     tags: parseListField(fm, "tags"),
+    archived: getField(fm, "archived") === "true",
+    archivedAt: getField(fm, "archivedAt"),
+    archivedReason: getField(fm, "archivedReason"),
     created: getField(fm, "created") ?? "",
     updated: getField(fm, "updated") ?? "",
     body
@@ -506,6 +509,53 @@ async function migrateLegacyProjectFiles(projectsDir2) {
   }
   return result;
 }
+function setFrontmatterField(content, key, value) {
+  const formatted = value === null ? "null" : typeof value === "boolean" ? String(value) : value;
+  const fieldRegex = new RegExp(`^(${key}:)\\s*.*$`, "m");
+  if (fieldRegex.test(content)) {
+    return content.replace(fieldRegex, `$1 ${formatted}`);
+  }
+  const closingIdx = content.indexOf("\n---", 4);
+  if (closingIdx === -1) return content;
+  return `${content.slice(0, closingIdx)}
+${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;
+}
+async function migrateLegacyArchivedProjects(projectsDir2) {
+  const result = { reconciled: [] };
+  if (!await fileExists(projectsDir2)) return result;
+  let entries;
+  try {
+    entries = await readdir(projectsDir2, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const projectMd = resolve2(projectsDir2, entry.name, "project.md");
+    try {
+      if (!await fileExists(projectMd)) continue;
+      const content = await readFile(projectMd, "utf-8");
+      if (readFrontmatterField(content, "statusOverride") !== "archived") continue;
+      let next = setFrontmatterField(content, "archived", true);
+      if (readFrontmatterField(content, "archivedAt") === null) {
+        next = setFrontmatterField(next, "archivedAt", nowTimestamp());
+      }
+      next = setFrontmatterField(next, "statusOverride", null);
+      next = setFrontmatterField(next, "updated", nowTimestamp());
+      await writeFile2(projectMd, next, "utf-8");
+      result.reconciled.push(entry.name);
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
 async function migrateLegacyConfig(configPath) {
   const result = {
     renamedField: false,
@@ -599,6 +649,7 @@ var init_fs_migration = __esm({
   "src/utils/fs-migration.ts"() {
     "use strict";
     init_fs();
+    init_timestamp();
   }
 });
 
@@ -2047,7 +2098,7 @@ import { readdir as readdir2, readFile as readFile3, unlink } from "fs/promises"
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function setFrontmatterField(content, key, value) {
+function setFrontmatterField2(content, key, value) {
   const regex = new RegExp(`^(${escapeRegExp(key)}:)\\s*.*$`, "m");
   if (regex.test(content)) {
     return content.replace(regex, `$1 ${value}`);
@@ -2196,8 +2247,8 @@ async function renamePlaybook(playbooksDir3, oldSlug, newSlug) {
     }
   }
   const raw = await readFile3(oldPath, "utf-8");
-  let next = setFrontmatterField(raw, "slug", newSlug);
-  next = setFrontmatterField(next, "updated", `"${nowTimestamp()}"`);
+  let next = setFrontmatterField2(raw, "slug", newSlug);
+  next = setFrontmatterField2(next, "updated", `"${nowTimestamp()}"`);
   await writeFileForce(newPath, next);
   if (!renamedInPlace) {
     await unlink(oldPath);
@@ -2375,6 +2426,9 @@ workspace:
   branch: null
   parentBranch: null
 tags: []
+archived: false
+archivedAt: null
+archivedReason: null
 ---
 
 # ${params2.title}
@@ -3568,10 +3622,14 @@ function parseAssignmentFrontmatter(fileContent) {
     links: parseLinks(frontmatter),
     blockedReason: getField2("blockedReason"),
     workspace: parseWorkspace(frontmatter),
-    tags: parseTags(frontmatter)
+    tags: parseTags(frontmatter),
+    archived: getField2("archived") === "true",
+    archivedAt: getField2("archivedAt"),
+    archivedReason: getField2("archivedReason")
   };
 }
 function formatYamlValue(value) {
+  if (typeof value === "boolean") return value ? "true" : "false";
   if (value === null) return "null";
   if (/^\d{4}-\d{2}-\d{2}T/.test(value)) {
     return `"${value}"`;
@@ -3590,6 +3648,12 @@ function updateAssignmentFile(fileContent, updates) {
     const fieldRegex = new RegExp(`^(${key}:)\\s*.*$`, "m");
     if (fieldRegex.test(result)) {
       result = result.replace(fieldRegex, `$1 ${formatted}`);
+    } else {
+      const closeIdx = result.indexOf("\n---", 4);
+      if (closeIdx !== -1) {
+        result = `${result.slice(0, closeIdx)}
+${key}: ${formatted}${result.slice(closeIdx)}`;
+      }
     }
   }
   return result;
@@ -5042,8 +5106,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile53 } = await import("fs/promises");
-  const raw = await readFile53(filePath, "utf-8");
+  const { readFile: readFile54 } = await import("fs/promises");
+  const raw = await readFile54(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -5475,8 +5539,8 @@ function scanKey(serversDir2, projectsDir2, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir2}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve78) => {
-    const timer2 = setTimeout(resolve78, ms);
+  return new Promise((resolve79) => {
+    const timer2 = setTimeout(resolve79, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -5935,6 +5999,12 @@ function setUpdatedField(content, value) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function isProjectArchived(p) {
+  return p.archived === true;
+}
+function activeAssignments(items) {
+  return items.filter((item) => item.archived !== true);
+}
 function createTraces() {
   return { entries: [], subPhases: /* @__PURE__ */ new Map() };
 }
@@ -6072,7 +6142,7 @@ function clearStatusConfigCache() {
 }
 async function listProjects(projectsDir2) {
   const projectRecords = await listProjectRecords(projectsDir2);
-  return projectRecords.map((record) => record.summary);
+  return projectRecords.filter((record) => !isProjectArchived(record.summary)).map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir2) {
   const registryPath = resolve16(dirname3(projectsDir2), "workspaces.json");
@@ -6204,7 +6274,9 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
     "list-standalone-records",
     () => listStandaloneRecords(assignmentsDir2)
   );
-  const recentActivity = buildRecentActivity(projectRecords, standaloneRecords);
+  const activeProjectRecords = projectRecords.filter((record) => !isProjectArchived(record.summary));
+  const activeStandaloneRecords = standaloneRecords.filter((sr) => sr.record.archived !== true);
+  const recentActivity = buildRecentActivity(activeProjectRecords, activeStandaloneRecords);
   const staleLimit = clamp(
     Number.isFinite(options.staleLimit) ? Number(options.staleLimit) : STALE_LIMIT_DEFAULT,
     1,
@@ -6263,56 +6335,111 @@ async function getOverview(projectsDir2, serversDir2, assignmentsDir2, options =
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     firstRun: projectRecords.length === 0 && standaloneRecords.length === 0,
     stats: {
-      activeProjects: projectRecords.filter((record) => record.summary.status === "active").length,
-      inProgressAssignments: projectRecords.reduce(
+      activeProjects: activeProjectRecords.filter((record) => record.summary.status === "active").length,
+      inProgressAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["in_progress"] ?? 0),
         0
       ),
-      blockedAssignments: projectRecords.reduce(
+      blockedAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["blocked"] ?? 0),
         0
       ),
-      reviewAssignments: projectRecords.reduce(
+      reviewAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["review"] ?? 0),
         0
       ),
-      failedAssignments: projectRecords.reduce(
+      failedAssignments: activeProjectRecords.reduce(
         (total, record) => total + (record.summary.progress["failed"] ?? 0),
         0
       ),
-      staleAssignments: projectRecords.reduce(
-        (total, record) => total + record.assignments.filter((assignment) => isStale(assignment.updated)).length,
+      staleAssignments: activeProjectRecords.reduce(
+        (total, record) => total + activeAssignments(record.assignments).filter((assignment) => isStale(assignment.updated)).length,
         0
-      ) + standaloneRecords.filter((sr) => isStale(sr.record.updated)).length
+      ) + activeStandaloneRecords.filter((sr) => isStale(sr.record.updated)).length
     },
     hero,
     segments,
     recentSessions,
-    recentProjects: projectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
+    recentProjects: activeProjectRecords.map((record) => record.summary).sort((left, right) => compareTimestamps(right.updated, left.updated)).slice(0, RECENT_PROJECTS_LIMIT),
     recentActivity: recentActivity.slice(0, RECENT_ACTIVITY_LIMIT),
     serverStats
   };
 }
-async function listAssignmentsBoard(projectsDir2, assignmentsDir2) {
+async function listAssignmentsBoard(projectsDir2, assignmentsDir2, options = {}) {
+  const mode = options.archived ?? "exclude";
   const projectRecords = await listProjectRecords(projectsDir2);
   const projectItems = await Promise.all(
-    projectRecords.flatMap(
-      async (record) => Promise.all(
-        record.assignments.map(
+    projectRecords.flatMap(async (record) => {
+      if (mode === "only") {
+        return Promise.all(
+          record.assignments.filter((assignment) => assignment.archived === true).map(async (assignment) => toAssignmentBoardItem(projectsDir2, record, assignment))
+        );
+      }
+      if (isProjectArchived(record.summary)) return [];
+      return Promise.all(
+        activeAssignments(record.assignments).map(
           async (assignment) => toAssignmentBoardItem(projectsDir2, record, assignment)
         )
-      )
-    )
+      );
+    })
   );
   const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const filteredStandalone = mode === "only" ? standaloneRecords.filter((sr) => sr.record.archived === true) : standaloneRecords.filter((sr) => sr.record.archived !== true);
   const standaloneItems = await Promise.all(
-    standaloneRecords.map(async (sr) => toStandaloneBoardItem(sr))
+    filteredStandalone.map(async (sr) => toStandaloneBoardItem(sr))
   );
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     assignments: [...projectItems.flat(), ...standaloneItems].sort((left, right) => compareTimestamps(right.updated, left.updated))
   };
 }
+function toArchivedAssignmentItem(assignment, projectSlug, projectTitle) {
+  return {
+    id: assignment.id,
+    slug: assignment.slug,
+    title: assignment.title,
+    status: assignment.status,
+    type: assignment.type,
+    priority: assignment.priority,
+    projectSlug,
+    projectTitle,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
+    updated: assignment.updated
+  };
+}
+async function listArchived(projectsDir2, assignmentsDir2) {
+  const projectRecords = await listProjectRecords(projectsDir2);
+  const standaloneRecords = await listStandaloneRecords(assignmentsDir2);
+  const projects = projectRecords.filter((record) => isProjectArchived(record.summary)).map((record) => ({
+    slug: record.summary.slug,
+    title: record.summary.title,
+    archivedAt: record.summary.archivedAt,
+    archivedReason: record.summary.archivedReason,
+    assignments: record.assignments.map(
+      (assignment) => toArchivedAssignmentItem(assignment, record.summary.slug, record.summary.title)
+    ).sort((left, right) => compareTimestamps(right.updated, left.updated))
+  })).sort((left, right) => compareTimestamps(right.archivedAt ?? "", left.archivedAt ?? ""));
+  const individuallyArchived = [];
+  for (const record of projectRecords) {
+    if (isProjectArchived(record.summary)) continue;
+    for (const assignment of record.assignments) {
+      if (assignment.archived === true) {
+        individuallyArchived.push(
+          toArchivedAssignmentItem(assignment, record.summary.slug, record.summary.title)
+        );
+      }
+    }
+  }
+  for (const sr of standaloneRecords) {
+    if (sr.record.archived === true) {
+      individuallyArchived.push(toArchivedAssignmentItem(sr.record, null, null));
+    }
+  }
+  individuallyArchived.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return { projects, assignments: individuallyArchived };
+}
 async function toStandaloneBoardItem(sr) {
   return {
     ...toAssignmentSummary(sr.record),
@@ -6407,7 +6534,7 @@ async function getProjectDetail(projectsDir2, slug) {
   const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
   const resources = await listResources(projectPath);
   const memories = await listMemories(projectPath);
-  const updated = getProjectActivityTimestamp(project.updated, assignments);
+  const updated = getProjectActivityTimestamp(project.updated, activeAssignments(assignments));
   return {
     slug: project.slug || slug,
     title: project.title,
@@ -6528,6 +6655,9 @@ async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
     projectWorkspace,
     externalIds: assignment.externalIds,
     tags: assignment.tags,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -6778,6 +6908,9 @@ async function buildStandaloneAssignmentDetail(resolved) {
     projectWorkspace: assignment.workspaceGroup,
     externalIds: assignment.externalIds,
     tags: assignment.tags,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason,
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -6807,6 +6940,7 @@ async function computeProjectRecords(projectsDir2, traces) {
   if (!migratedProjectsDirs.has(projectsDir2)) {
     migratedProjectsDirs.add(projectsDir2);
     await migrateLegacyProjectFiles(projectsDir2);
+    await migrateLegacyArchivedProjects(projectsDir2);
   }
   const entries = await readdir8(projectsDir2, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
@@ -6827,7 +6961,7 @@ async function computeProjectRecords(projectsDir2, traces) {
       const t2 = traces ? performance.now() : 0;
       const rollup = await buildProjectRollup(projectPath, project, assignments, traces);
       if (traces) accumulatePhase(traces, "build-rollup", performance.now() - t2);
-      const updated = getProjectActivityTimestamp(project.updated, assignments);
+      const updated = getProjectActivityTimestamp(project.updated, activeAssignments(assignments));
       const t3 = traces ? performance.now() : 0;
       const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
       if (traces) accumulatePhase(traces, "load-dep-graph", performance.now() - t3);
@@ -7037,9 +7171,10 @@ async function loadDependencyGraph(projectPath, assignments) {
   return buildDependencyGraph(assignments);
 }
 async function buildProjectRollup(projectPath, project, assignments, traces) {
-  const progress = { total: assignments.length };
+  const active = activeAssignments(assignments);
+  const progress = { total: active.length };
   const perAssignment = await Promise.all(
-    assignments.map(async (assignment) => {
+    active.map(async (assignment) => {
       const t0 = traces ? performance.now() : 0;
       const openQuestions2 = await countOpenQuestions(projectPath, assignment.slug);
       if (traces) accumulatePhase(traces, "count-open-questions", performance.now() - t0);
@@ -7087,7 +7222,12 @@ function toAssignmentSummary(assignment) {
     assignee: assignment.assignee,
     dependsOn: assignment.dependsOn,
     links: assignment.links,
-    updated: assignment.updated
+    tags: assignment.tags,
+    created: assignment.created,
+    updated: assignment.updated,
+    archived: assignment.archived,
+    archivedAt: assignment.archivedAt,
+    archivedReason: assignment.archivedReason
   };
 }
 async function toAssignmentBoardItem(projectsDir2, projectRecord, assignment) {
@@ -7225,12 +7365,14 @@ async function buildOverviewSegmentBuckets(projectsDir2, projectRecords, standal
   const buckets = emptyBuckets();
   const newestPool = [];
   for (const record of projectRecords) {
+    if (isProjectArchived(record.summary)) continue;
     const depMap = /* @__PURE__ */ new Map();
     for (const a of record.assignments) {
       depMap.set(a.slug, a.status);
     }
+    const visibleAssignments = activeAssignments(record.assignments);
     const resolvedTransitions = await Promise.all(
-      record.assignments.map(async (assignment) => {
+      visibleAssignments.map(async (assignment) => {
         const t0 = traces ? performance.now() : 0;
         const availableTransitions = await getAvailableTransitions(
           projectsDir2,
@@ -7299,7 +7441,7 @@ async function buildOverviewSegmentBuckets(projectsDir2, projectRecords, standal
     }
   }
   const resolvedStandaloneTransitions = await Promise.all(
-    standaloneRecords.map(async (sr) => {
+    standaloneRecords.filter((sr) => sr.record.archived !== true).map(async (sr) => {
       const t0 = traces ? performance.now() : 0;
       const availableTransitions = await getStandaloneAvailableTransitions(sr.record);
       if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
@@ -7425,7 +7567,7 @@ function buildRecentActivity(projectRecords, standaloneRecords = []) {
       assignmentSlug: null,
       summary: `Project status is ${record.summary.status}.`
     });
-    for (const assignment of record.assignments) {
+    for (const assignment of activeAssignments(record.assignments)) {
       activity.push({
         id: `assignment:${record.summary.slug}:${assignment.slug}`,
         type: "assignment",
@@ -8128,8 +8270,8 @@ __export(launch_exports, {
   shellQuote: () => shellQuote
 });
 import { spawn as spawn3 } from "child_process";
-import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
-import { isAbsolute as isAbsolute5, resolve as resolve43 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile11 } from "fs/promises";
+import { isAbsolute as isAbsolute5, resolve as resolve44 } from "path";
 function shellQuote(arg) {
   if (arg === "") return "''";
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -8165,8 +8307,8 @@ async function launchAgent(options) {
     console.error(`Assignment not found: ${projectSlug}/${assignmentSlug}`);
     process.exit(1);
   }
-  const projectDir = resolve43(projectsDir2, projectSlug);
-  const assignmentDir = resolve43(projectDir, "assignments", assignmentSlug);
+  const projectDir = resolve44(projectsDir2, projectSlug);
+  const assignmentDir = resolve44(projectDir, "assignments", assignmentSlug);
   let workspaceDir;
   if (cwdOverride) {
     if (!isExistingDir(cwdOverride)) {
@@ -8198,7 +8340,7 @@ async function launchAgent(options) {
     });
     if (warning) console.warn(warning);
   }
-  const contextDir = resolve43(workspaceDir, ".syntaur");
+  const contextDir = resolve44(workspaceDir, ".syntaur");
   await mkdir6(contextDir, { recursive: true });
   const context = {
     projectSlug,
@@ -8210,8 +8352,8 @@ async function launchAgent(options) {
     branch: detail.workspace.branch ?? null,
     grabbedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile10(
-    resolve43(contextDir, "context.json"),
+  await writeFile11(
+    resolve44(contextDir, "context.json"),
     JSON.stringify(context, null, 2) + "\n"
   );
   const { argv, shellFallbackWarning } = buildAgentArgv(
@@ -8286,7 +8428,7 @@ import {
   unlinkSync
 } from "fs";
 import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
-import { dirname as dirname14, resolve as resolve45, join as join6 } from "path";
+import { dirname as dirname14, resolve as resolve46, join as join6 } from "path";
 import { homedir as homedir7, tmpdir as tmpdir2 } from "os";
 import { spawnSync as spawnSync6 } from "child_process";
 function syntaurRootMjs() {
@@ -8308,7 +8450,7 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
   }
   const stateRoot = syntaurRootMjs();
   mkdirSync2(stateRoot, { recursive: true });
-  const lockPath = resolve45(stateRoot, "install-url-handler.lock");
+  const lockPath = resolve46(stateRoot, "install-url-handler.lock");
   let lockFd;
   try {
     lockFd = openSync(lockPath, "wx");
@@ -8324,8 +8466,8 @@ async function registerMacosUrlHandler(options = { throwOnFailure: false }) {
     throw err2;
   }
   try {
-    const pkgRoot = resolve45(dirname14(fileURLToPath6(import.meta.url)), "..");
-    const cliBin = realpathSync2(resolve45(pkgRoot, "bin/syntaur.js"));
+    const pkgRoot = resolve46(dirname14(fileURLToPath6(import.meta.url)), "..");
+    const cliBin = realpathSync2(resolve46(pkgRoot, "bin/syntaur.js"));
     const nodeBin = process.execPath;
     const bundleParent = join6(
       homedir7(),
@@ -8675,7 +8817,7 @@ function useProjects(projectsDir2) {
         if (cancelled) return;
         const tree = projects.map((m, i) => {
           const detail = details[i];
-          const children = (detail?.assignments ?? []).map((a) => ({
+          const children = (detail?.assignments ?? []).filter((a) => !a.archived).map((a) => ({
             id: `a:${m.slug}:${a.slug}`,
             kind: "assignment",
             label: a.title,
@@ -9653,6 +9795,7 @@ var SORT_FIELDS = [
   "priority",
   "assignee",
   "dependencies",
+  "created",
   "updated"
 ];
 var SORT_DIRECTIONS = ["asc", "desc"];
@@ -9666,6 +9809,37 @@ var GROUPINGS = [
   "project"
 ];
 var ACTIVITIES = ["all", "stale", "fresh"];
+var DATE_RANGE_FIELDS = ["created", "updated"];
+var DATE_RANGE_PRESETS = [
+  "last_24h",
+  "last_7d",
+  "last_30d",
+  "last_90d",
+  "older_7d",
+  "older_30d"
+];
+var YMD_RE = /^\d{4}-\d{2}-\d{2}$/;
+function isDateRangeField(v) {
+  return typeof v === "string" && DATE_RANGE_FIELDS.includes(v);
+}
+function isDateRangePreset(v) {
+  return typeof v === "string" && DATE_RANGE_PRESETS.includes(v);
+}
+function isDateRange(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const r = v;
+  if (!isDateRangeField(r.field)) return false;
+  for (const key of Object.keys(r)) {
+    if (key !== "field" && key !== "preset" && key !== "from" && key !== "to") return false;
+  }
+  const hasPreset = r.preset !== void 0;
+  const hasAbsolute = r.from !== void 0 || r.to !== void 0;
+  if (hasPreset && hasAbsolute) return false;
+  if (hasPreset && !isDateRangePreset(r.preset)) return false;
+  if (r.from !== void 0 && (typeof r.from !== "string" || !YMD_RE.test(r.from))) return false;
+  if (r.to !== void 0 && (typeof r.to !== "string" || !YMD_RE.test(r.to))) return false;
+  return true;
+}
 function toFilterValues(v) {
   const arr = v === void 0 ? [] : Array.isArray(v) ? v : [v];
   const out = [];
@@ -9841,7 +10015,7 @@ function isViewPrefsDefaults(file) {
   if (g.density !== d.density) return false;
   if (g.grouping !== d.grouping) return false;
   const gf = g.filters;
-  for (const key of ["status", "type", "priority", "assignee", "project"]) {
+  for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
     if (toFilterValues(gf[key]).length > 0) return false;
   }
   if (gf.activity !== void 0 && gf.activity !== "all") return false;
@@ -9858,6 +10032,7 @@ var TABLE_COLUMN_IDS = [
   "priority",
   "assignee",
   "dependencies",
+  "created",
   "updated"
 ];
 function isTableColumnId(value) {
@@ -9933,10 +10108,12 @@ function isTableColumnVisibility(value) {
 function isViewFilters(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const obj = value;
-  for (const key of ["status", "type", "priority", "assignee", "project"]) {
+  for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
     if (obj[key] !== void 0 && !isFilterValue(obj[key])) return false;
   }
   if (obj.activity !== void 0 && !isActivity(obj.activity)) return false;
+  if (obj.dateRange !== void 0 && !isDateRange(obj.dateRange)) return false;
+  if (obj.search !== void 0 && typeof obj.search !== "string") return false;
   return true;
 }
 function isSavedViewConfig(value) {
@@ -10614,6 +10791,13 @@ ${key}: ${formatted}${content.slice(closingIdx)}`;
 function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function applyArchiveFields(content, archived, reason) {
+  let next = setTopLevelField(content, "archived", archived);
+  next = setTopLevelField(next, "archivedAt", archived ? nowTimestamp() : null);
+  next = setTopLevelField(next, "archivedReason", archived ? reason : null);
+  next = setTopLevelField(next, "updated", nowTimestamp());
+  return next;
+}
 function appendLogEntry2(existingContent, countField, nextCount, heading, body, emptyPlaceholder) {
   const timestamp = nowTimestamp();
   let next = setTopLevelField(existingContent, "updated", timestamp);
@@ -11907,7 +12091,7 @@ ${entry}`;
       }
       const { status } = req.body || {};
       const config = await getStatusConfig();
-      const validStatuses = ["active", "archived", ...config.statuses.map((s) => s.id)];
+      const validStatuses = ["active", ...config.statuses.map((s) => s.id)];
       if (status !== null && (typeof status !== "string" || !validStatuses.includes(status))) {
         res.status(400).json({ error: `Invalid status. Must be one of: ${validStatuses.join(", ")}, or null to clear.` });
         return;
@@ -11959,6 +12143,106 @@ ${entry}`;
       res.status(500).json({ error: `Failed to override status: ${error.message}` });
     }
   });
+  function archiveReason(body) {
+    const reason = body?.reason;
+    return typeof reason === "string" && reason.trim() ? reason : null;
+  }
+  router.post("/api/projects/:slug/archive", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve21(projectsDir2, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const content = await readFile15(projectPath, "utf-8");
+      await writeFileForce(projectPath, applyArchiveFields(content, true, archiveReason(req.body)));
+      const project = await getProjectDetail(projectsDir2, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error archiving project:", error);
+      res.status(500).json({ error: `Failed to archive project: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/unarchive", async (req, res) => {
+    try {
+      const projectSlug = getParam(req.params.slug);
+      const projectPath = resolve21(projectsDir2, projectSlug, "project.md");
+      if (!await fileExists(projectPath)) {
+        res.status(404).json({ error: `Project "${projectSlug}" not found` });
+        return;
+      }
+      const content = await readFile15(projectPath, "utf-8");
+      await writeFileForce(projectPath, applyArchiveFields(content, false, null));
+      const project = await getProjectDetail(projectsDir2, projectSlug);
+      res.json({ project });
+    } catch (error) {
+      console.error("Error restoring project:", error);
+      res.status(500).json({ error: `Failed to restore project: ${error.message}` });
+    }
+  });
+  async function handleAssignmentArchive(req, res, archived) {
+    const projectSlug = getParam(req.params.slug);
+    const assignmentSlug = getParam(req.params.aslug);
+    const assignmentPath = resolve21(projectsDir2, projectSlug, "assignments", assignmentSlug, "assignment.md");
+    if (!await fileExists(assignmentPath)) {
+      res.status(404).json({ error: "Assignment not found" });
+      return;
+    }
+    const content = await readFile15(assignmentPath, "utf-8");
+    await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
+    const assignment = await getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug);
+    res.json({ assignment });
+  }
+  router.post("/api/projects/:slug/assignments/:aslug/archive", async (req, res) => {
+    try {
+      await handleAssignmentArchive(req, res, true);
+    } catch (error) {
+      console.error("Error archiving assignment:", error);
+      res.status(500).json({ error: `Failed to archive assignment: ${error.message}` });
+    }
+  });
+  router.post("/api/projects/:slug/assignments/:aslug/unarchive", async (req, res) => {
+    try {
+      await handleAssignmentArchive(req, res, false);
+    } catch (error) {
+      console.error("Error restoring assignment:", error);
+      res.status(500).json({ error: `Failed to restore assignment: ${error.message}` });
+    }
+  });
+  async function handleStandaloneArchive(req, res, archived) {
+    if (!assignmentsDir2) {
+      res.status(501).json({ error: "Standalone assignments not configured on this server" });
+      return;
+    }
+    const id = getParam(req.params.id);
+    const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, id);
+    if (!resolved) {
+      res.status(404).json({ error: `Assignment "${id}" not found` });
+      return;
+    }
+    const assignmentPath = resolve21(resolved.assignmentDir, "assignment.md");
+    const content = await readFile15(assignmentPath, "utf-8");
+    await writeFileForce(assignmentPath, applyArchiveFields(content, archived, archived ? archiveReason(req.body) : null));
+    const assignment = await getAssignmentDetailById(projectsDir2, assignmentsDir2, id);
+    res.json({ assignment });
+  }
+  router.post("/api/assignments/:id/archive", async (req, res) => {
+    try {
+      await handleStandaloneArchive(req, res, true);
+    } catch (error) {
+      console.error("Error archiving assignment:", error);
+      res.status(500).json({ error: `Failed to archive assignment: ${error.message}` });
+    }
+  });
+  router.post("/api/assignments/:id/unarchive", async (req, res) => {
+    try {
+      await handleStandaloneArchive(req, res, false);
+    } catch (error) {
+      console.error("Error restoring assignment:", error);
+      res.status(500).json({ error: `Failed to restore assignment: ${error.message}` });
+    }
+  });
   router.patch("/api/projects/:slug/assignments/:aslug/assignee", async (req, res) => {
     try {
       const projectSlug = getParam(req.params.slug);
@@ -12608,84 +12892,6 @@ ${entry}`;
       res.status(500).json({ error: `Failed to update title: ${error.message}` });
     }
   });
-  router.post("/api/assignments/bulk-status-override", async (req, res) => {
-    try {
-      const body = req.body;
-      if (!body || typeof body !== "object" || !Array.isArray(body.items)) {
-        res.status(400).json({ error: "Request body must include `items` (array)." });
-        return;
-      }
-      const items = body.items;
-      if (items.length === 0) {
-        res.status(400).json({ error: "`items` must contain at least one entry." });
-        return;
-      }
-      if (items.length > 200) {
-        res.status(400).json({ error: "`items` is capped at 200 entries per call." });
-        return;
-      }
-      const config = await getStatusConfig();
-      const validStatuses = new Set(config.statuses.map((s) => s.id));
-      const timestamp = nowTimestamp();
-      const results = [];
-      let succeeded = 0;
-      let failed = 0;
-      for (let index = 0; index < items.length; index += 1) {
-        const raw = items[index];
-        const itemKey = buildBulkItemKey(raw, index);
-        try {
-          if (!raw || typeof raw !== "object") {
-            throw new Error("item must be an object");
-          }
-          const item = raw;
-          const status = typeof item.status === "string" ? item.status : null;
-          if (!status || !validStatuses.has(status)) {
-            throw new Error(`invalid status "${status ?? ""}"`);
-          }
-          let assignmentPath = null;
-          if (typeof item.id === "string" && item.id.trim()) {
-            if (!assignmentsDir2) {
-              throw new Error("standalone assignments are not configured on this server");
-            }
-            const resolved = await resolveAssignmentById(projectsDir2, assignmentsDir2, item.id);
-            if (!resolved) {
-              throw new Error(`assignment "${item.id}" not found`);
-            }
-            assignmentPath = resolve21(resolved.assignmentDir, "assignment.md");
-          } else if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string" && item.projectSlug && item.assignmentSlug) {
-            assignmentPath = resolve21(
-              projectsDir2,
-              item.projectSlug,
-              "assignments",
-              item.assignmentSlug,
-              "assignment.md"
-            );
-          } else {
-            throw new Error("must supply either `id` or both `projectSlug` and `assignmentSlug`");
-          }
-          if (!await fileExists(assignmentPath)) {
-            throw new Error("assignment file not found");
-          }
-          let content = await readFile15(assignmentPath, "utf-8");
-          content = setTopLevelField(content, "status", status);
-          content = setTopLevelField(content, "updated", timestamp);
-          if (status !== "blocked") {
-            content = setTopLevelField(content, "blockedReason", null);
-          }
-          await writeFileForce(assignmentPath, content);
-          results.push({ key: itemKey, ok: true });
-          succeeded += 1;
-        } catch (error) {
-          results.push({ key: itemKey, ok: false, error: error.message });
-          failed += 1;
-        }
-      }
-      res.json({ results, succeeded, failed });
-    } catch (error) {
-      console.error("Error in bulk-status-override:", error);
-      res.status(500).json({ error: `Bulk status override failed: ${error.message}` });
-    }
-  });
   router.patch("/api/assignments/:id/acceptance-criteria/:index", async (req, res) => {
     try {
       if (!assignmentsDir2) {
@@ -12799,16 +13005,6 @@ function validateTitleBody(body) {
   }
   return { ok: true, value: trimmed };
 }
-function buildBulkItemKey(raw, index) {
-  if (raw && typeof raw === "object") {
-    const item = raw;
-    if (typeof item.id === "string" && item.id.trim()) return item.id;
-    if (typeof item.projectSlug === "string" && typeof item.assignmentSlug === "string") {
-      return `${item.projectSlug}/${item.assignmentSlug}`;
-    }
-  }
-  return `#${index}`;
-}
 async function appendCommentTo(assignmentDir, assignmentRef, req, res, reloadDetail) {
   const commentsPath = resolve21(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req.body || {};
@@ -15693,8 +15889,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve78 } = await import("path");
-      const { readFile: readFile53 } = await import("fs/promises");
+      const { resolve: resolve79 } = await import("path");
+      const { readFile: readFile54 } = 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);
@@ -15710,10 +15906,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve78(todosDir2, "archive"));
+      await ensureDir(resolve79(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile53(archFile, "utf-8");
+        archContent = await readFile54(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -15995,7 +16191,7 @@ workspace: ${workspace}
         const { readConfig: readConfig3 } = await Promise.resolve().then(() => (init_config2(), config_exports));
         const { assignmentsDir: assignmentsDirFn } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const { fileExists: fileExists2, writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const { readFile: readFile53 } = await import("fs/promises");
+        const { readFile: readFile54 } = await import("fs/promises");
         const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
         const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
         let assignmentRef;
@@ -16016,7 +16212,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
-        let content = await readFile53(assignmentMdPath2, "utf-8");
+        let content = await readFile54(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -18181,7 +18377,7 @@ function createDashboardServer(options) {
     }
   });
   const VIEW_PREFS_LOCK = "vp:global";
-  const FILTER_KEYS = /* @__PURE__ */ new Set(["status", "type", "priority", "assignee", "project", "activity"]);
+  const FILTER_KEYS = /* @__PURE__ */ new Set(["status", "type", "priority", "assignee", "project", "tags", "activity"]);
   const GLOBAL_KEYS = /* @__PURE__ */ new Set(["defaultView", "sortField", "sortDirection", "density", "grouping", "filters"]);
   const SCOPE_KEYS = /* @__PURE__ */ new Set(["defaultView", "sortField", "sortDirection", "grouping", "filters"]);
   const ROOT_KEYS = /* @__PURE__ */ new Set(["global", "projects"]);
@@ -18200,7 +18396,7 @@ function createDashboardServer(options) {
     const unknown = unknownKey(obj, FILTER_KEYS, "filters");
     if (unknown) return { ok: false, error: unknown };
     const out = {};
-    for (const key of ["status", "type", "priority", "assignee", "project"]) {
+    for (const key of ["status", "type", "priority", "assignee", "project", "tags"]) {
       if (obj[key] !== void 0) {
         if (!isFilterValue(obj[key])) {
           return { ok: false, error: `filters.${key} must be a non-empty string or array of non-empty strings` };
@@ -18425,6 +18621,15 @@ function createDashboardServer(options) {
       res.status(500).json({ error: "Failed to list assignments" });
     }
   });
+  app.get("/api/archived", async (_req, res) => {
+    try {
+      const result = await listArchived(projectsDir2, assignmentsDir2);
+      res.json(result);
+    } catch (error) {
+      console.error("Error listing archived content:", error);
+      res.status(500).json({ error: "Failed to list archived content" });
+    }
+  });
   app.get("/api/projects/:slug", async (req, res) => {
     try {
       const detail = await getProjectDetail(projectsDir2, req.params.slug);
@@ -18852,6 +19057,91 @@ async function startCommand(assignment, options) {
   reportResult(result);
 }
 
+// src/commands/_archive-helper.ts
+init_paths();
+init_fs();
+init_config2();
+init_slug();
+init_frontmatter();
+init_timestamp();
+init_assignment_resolver();
+import { resolve as resolve33 } from "path";
+import { readFile as readFile21, writeFile as writeFile7 } from "fs/promises";
+async function resolveTarget(target, options) {
+  const config = await readConfig();
+  const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
+  if (options.project) {
+    if (!isValidSlug(options.project)) {
+      throw new Error(`Invalid project slug "${options.project}".`);
+    }
+    if (!isValidSlug(target)) {
+      throw new Error(`Invalid assignment slug "${target}".`);
+    }
+    const assignmentMd = resolve33(baseDir, options.project, "assignments", target, "assignment.md");
+    if (!await fileExists(assignmentMd)) {
+      throw new Error(`Assignment "${target}" not found in project "${options.project}".`);
+    }
+    return { kind: "assignment", filePath: assignmentMd, label: `assignment "${options.project}/${target}"` };
+  }
+  const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
+  if (resolved) {
+    return {
+      kind: "assignment",
+      filePath: resolve33(resolved.assignmentDir, "assignment.md"),
+      label: resolved.projectSlug ? `assignment "${resolved.projectSlug}/${resolved.assignmentSlug}"` : `assignment "${target}"`
+    };
+  }
+  const projectMd = resolve33(baseDir, target, "project.md");
+  if (await fileExists(projectMd)) {
+    return { kind: "project", filePath: projectMd, label: `project "${target}"` };
+  }
+  return null;
+}
+async function writeArchiveState(filePath, archived, reason) {
+  const content = await readFile21(filePath, "utf-8");
+  const updated = updateAssignmentFile(content, {
+    archived,
+    archivedAt: archived ? nowTimestamp() : null,
+    archivedReason: archived ? reason : null,
+    updated: nowTimestamp()
+  });
+  await writeFile7(filePath, updated, "utf-8");
+}
+async function runArchive(target, options = {}) {
+  const resolved = await resolveTarget(target, options);
+  if (!resolved) {
+    return { success: false, message: `No assignment or project matched "${target}".` };
+  }
+  await writeArchiveState(resolved.filePath, true, options.reason ?? null);
+  return { success: true, message: `Archived ${resolved.label}.` };
+}
+async function runRestore(target, options = {}) {
+  const resolved = await resolveTarget(target, options);
+  if (!resolved) {
+    return { success: false, message: `No assignment or project matched "${target}".` };
+  }
+  await writeArchiveState(resolved.filePath, false, null);
+  return { success: true, message: `Restored ${resolved.label}.` };
+}
+function reportArchiveResult(result) {
+  if (!result.success) {
+    throw new Error(result.message);
+  }
+  console.log(result.message);
+}
+
+// src/commands/archive.ts
+async function archiveCommand(target, options) {
+  const result = await runArchive(target, options);
+  reportArchiveResult(result);
+}
+
+// src/commands/restore.ts
+async function restoreCommand(target, options) {
+  const result = await runRestore(target, options);
+  reportArchiveResult(result);
+}
+
 // src/commands/shape.ts
 async function shapeCommand(assignment, options) {
   const result = await runTransition(assignment, "shape", options);
@@ -18876,8 +19166,8 @@ init_fs();
 init_config2();
 init_frontmatter();
 init_timestamp();
-import { resolve as resolve33 } from "path";
-import { readdir as readdir13, readFile as readFile21 } from "fs/promises";
+import { resolve as resolve34 } from "path";
+import { readdir as readdir13, readFile as readFile22 } 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+|$)/);
@@ -18899,11 +19189,11 @@ async function collectCandidates(baseDirs) {
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const directAssignmentMd = resolve33(baseDir, m.name, "assignment.md");
+      const directAssignmentMd = resolve34(baseDir, m.name, "assignment.md");
       if (await fileExists(directAssignmentMd)) {
         const fm = await parseSafe(directAssignmentMd);
         if (fm && PROMOTABLE_STATUSES.has(fm.status)) {
-          const content = await readFile21(directAssignmentMd, "utf-8");
+          const content = await readFile22(directAssignmentMd, "utf-8");
           if (objectiveIsFleshedOut(content) && hasAcceptanceCriteria(content)) {
             candidates.push({
               projectSlug: null,
@@ -18916,17 +19206,17 @@ async function collectCandidates(baseDirs) {
         }
         continue;
       }
-      const assignmentsDir2 = resolve33(baseDir, m.name, "assignments");
+      const assignmentsDir2 = resolve34(baseDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
       const entries = await readdir13(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentMd = resolve33(assignmentsDir2, a.name, "assignment.md");
+        const assignmentMd = resolve34(assignmentsDir2, a.name, "assignment.md");
         if (!await fileExists(assignmentMd)) continue;
         const fm = await parseSafe(assignmentMd);
         if (!fm || !PROMOTABLE_STATUSES.has(fm.status)) continue;
-        const content = await readFile21(assignmentMd, "utf-8");
+        const content = await readFile22(assignmentMd, "utf-8");
         if (!objectiveIsFleshedOut(content)) continue;
         if (!hasAcceptanceCriteria(content)) continue;
         candidates.push({
@@ -18943,7 +19233,7 @@ async function collectCandidates(baseDirs) {
 }
 async function parseSafe(path) {
   try {
-    const content = await readFile21(path, "utf-8");
+    const content = await readFile22(path, "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -18972,7 +19262,7 @@ async function migrateStatusesCommand(options) {
   const now = nowTimestamp();
   let migrated = 0;
   for (const c2 of candidates) {
-    const content = await readFile21(c2.assignmentMd, "utf-8");
+    const content = await readFile22(c2.assignmentMd, "utf-8");
     const updated = updateAssignmentFile(content, {
       status: c2.toStatus,
       updated: now
@@ -19030,29 +19320,29 @@ import {
   readdir as readdir14,
   symlink,
   lstat,
-  readFile as readFile22,
+  readFile as readFile23,
   readlink,
   rename as rename8,
   rm as rm4,
   unlink as unlink7,
-  writeFile as writeFile7
+  writeFile as writeFile8
 } 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 resolve35 } from "path";
+import { basename as basename4, dirname as dirname10, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve36 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
-import { dirname as dirname9, resolve as resolve34 } from "path";
+import { dirname as dirname9, resolve as resolve35 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function findPackageRoot(expectedRelativePath) {
   let currentDir = dirname9(fileURLToPath3(import.meta.url));
   while (true) {
-    const candidate = resolve34(currentDir, expectedRelativePath);
+    const candidate = resolve35(currentDir, expectedRelativePath);
     if (await fileExists(candidate)) {
       return currentDir;
     }
-    const parentDir = resolve34(currentDir, "..");
+    const parentDir = resolve35(currentDir, "..");
     if (parentDir === currentDir) {
       throw new Error(
         `Could not locate package root containing ${expectedRelativePath}.`
@@ -19073,25 +19363,25 @@ function getPluginManifestRelativePath(pluginKind) {
 }
 function getDefaultPluginTargetDir(pluginKind) {
   const home = homedir3();
-  return pluginKind === "claude" ? resolve35(home, ".claude", "plugins", "syntaur") : resolve35(home, "plugins", "syntaur");
+  return pluginKind === "claude" ? resolve36(home, ".claude", "plugins", "syntaur") : resolve36(home, "plugins", "syntaur");
 }
 function getDefaultMarketplacePath() {
-  return resolve35(homedir3(), ".agents", "plugins", "marketplace.json");
+  return resolve36(homedir3(), ".agents", "plugins", "marketplace.json");
 }
 function getClaudeMarketplacesRoot() {
-  return resolve35(homedir3(), ".claude", "plugins", "marketplaces");
+  return resolve36(homedir3(), ".claude", "plugins", "marketplaces");
 }
 function getClaudeKnownMarketplacesPath() {
-  return resolve35(homedir3(), ".claude", "plugins", "known_marketplaces.json");
+  return resolve36(homedir3(), ".claude", "plugins", "known_marketplaces.json");
 }
 function getClaudeInstalledPluginsPath() {
-  return resolve35(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  return resolve36(homedir3(), ".claude", "plugins", "installed_plugins.json");
 }
 function getInstallMarkerPath(targetDir) {
-  return resolve35(targetDir, INSTALL_MARKER_FILENAME);
+  return resolve36(targetDir, INSTALL_MARKER_FILENAME);
 }
 async function readPackageManifest(packageRoot) {
-  const raw = await readFile22(resolve35(packageRoot, "package.json"), "utf-8");
+  const raw = await readFile23(resolve36(packageRoot, "package.json"), "utf-8");
   return JSON.parse(raw);
 }
 async function readJsonFileIfExists(pathValue) {
@@ -19099,7 +19389,7 @@ async function readJsonFileIfExists(pathValue) {
     return null;
   }
   try {
-    const raw = await readFile22(pathValue, "utf-8");
+    const raw = await readFile23(pathValue, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -19107,15 +19397,15 @@ async function readJsonFileIfExists(pathValue) {
 }
 async function readClaudePluginManifest(pluginDir) {
   return await readJsonFileIfExists(
-    resolve35(pluginDir, ".claude-plugin", "plugin.json")
+    resolve36(pluginDir, ".claude-plugin", "plugin.json")
   ) ?? {};
 }
 async function readPluginManifestName(targetDir, pluginKind) {
-  const manifestPath = resolve35(targetDir, getPluginManifestRelativePath(pluginKind));
+  const manifestPath = resolve36(targetDir, getPluginManifestRelativePath(pluginKind));
   if (!await fileExists(manifestPath)) {
     return void 0;
   }
-  const raw = await readFile22(manifestPath, "utf-8");
+  const raw = await readFile23(manifestPath, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.name;
 }
@@ -19125,7 +19415,7 @@ async function readInstallMetadata(targetDir) {
     return null;
   }
   try {
-    const raw = await readFile22(markerPath, "utf-8");
+    const raw = await readFile23(markerPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -19138,7 +19428,7 @@ async function getInstallStatus(targetDir, pluginKind) {
   const info = await lstat(targetDir);
   if (info.isSymbolicLink()) {
     const symlinkTarget = await readlink(targetDir);
-    const resolvedTarget = resolve35(dirname10(targetDir), symlinkTarget);
+    const resolvedTarget = resolve36(dirname10(targetDir), symlinkTarget);
     const manifestName2 = await readPluginManifestName(resolvedTarget, pluginKind);
     return {
       exists: true,
@@ -19167,7 +19457,7 @@ async function writeInstallMetadata(targetDir, pluginKind, installMode, packageM
     installMode,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile7(
+  await writeFile8(
     getInstallMarkerPath(targetDir),
     `${JSON.stringify(metadata, null, 2)}
 `,
@@ -19184,7 +19474,7 @@ async function installLink(paths) {
   await ensureDir(dirname10(paths.targetDir));
   await rm4(paths.targetDir, { recursive: true, force: true });
   await ensureDir(dirname10(paths.targetDir));
-  await symlink(resolve35(paths.sourceDir), paths.targetDir, "dir");
+  await symlink(resolve36(paths.sourceDir), paths.targetDir, "dir");
 }
 async function removeInstallMarker(targetDir) {
   const markerPath = getInstallMarkerPath(targetDir);
@@ -19198,13 +19488,13 @@ function normalizeAbsoluteInstallPath(pathValue, label) {
   if (!isAbsolute4(expanded)) {
     throw new Error(`${label} must be an absolute path.`);
   }
-  return resolve35(expanded);
+  return resolve36(expanded);
 }
 async function resolvePluginPaths(pluginKind, targetDir) {
   const packageRoot = await findPackageRoot(getPluginRelativePath(pluginKind));
   return {
     packageRoot,
-    sourceDir: resolve35(packageRoot, getPluginRelativePath(pluginKind)),
+    sourceDir: resolve36(packageRoot, getPluginRelativePath(pluginKind)),
     targetDir: targetDir ?? getDefaultPluginTargetDir(pluginKind)
   };
 }
@@ -19248,10 +19538,10 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
   }
   if (await fileExists(manifestPath)) {
     try {
-      const prev = await readFile22(manifestPath, "utf-8");
+      const prev = await readFile23(manifestPath, "utf-8");
       JSON.parse(prev);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      await writeFile7(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+      await writeFile8(`${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.`
@@ -19259,7 +19549,7 @@ async function writeClaudeMarketplaceFile(manifestPath, marketplace) {
     }
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile7(tmpPath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile8(tmpPath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
   await rename8(tmpPath, manifestPath);
 }
@@ -19329,8 +19619,8 @@ async function listClaudeMarketplaceCandidates() {
     if (!entry.isDirectory()) {
       continue;
     }
-    const candidateRoot = resolve35(rootDir, entry.name);
-    const manifestPath = resolve35(candidateRoot, ".claude-plugin", "marketplace.json");
+    const candidateRoot = resolve36(rootDir, entry.name);
+    const manifestPath = resolve36(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -19357,11 +19647,11 @@ async function listClaudeMarketplaceCandidates() {
     if (!installLocation) {
       continue;
     }
-    const candidateRoot = resolve35(expandHome(installLocation));
+    const candidateRoot = resolve36(expandHome(installLocation));
     if (seen.has(candidateRoot)) {
       continue;
     }
-    const manifestPath = resolve35(candidateRoot, ".claude-plugin", "marketplace.json");
+    const manifestPath = resolve36(candidateRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(manifestPath)) {
       continue;
     }
@@ -19389,14 +19679,14 @@ async function getPreferredClaudeMarketplace() {
     name: candidate.name,
     rootDir: candidate.rootDir,
     manifestPath: candidate.manifestPath,
-    targetDir: resolve35(candidate.rootDir, "plugins", "syntaur")
+    targetDir: resolve36(candidate.rootDir, "plugins", "syntaur")
   };
 }
 async function registerKnownClaudeMarketplace(name, rootDir) {
   const manifestPath = getClaudeKnownMarketplacesPath();
   let existing = {};
   if (await fileExists(manifestPath)) {
-    const raw = await readFile22(manifestPath, "utf-8");
+    const raw = await readFile23(manifestPath, "utf-8");
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -19423,12 +19713,12 @@ async function registerKnownClaudeMarketplace(name, rootDir) {
   existing[name].autoUpdate = true;
   await ensureDir(dirname10(manifestPath));
   if (await fileExists(manifestPath)) {
-    const prev = await readFile22(manifestPath, "utf-8");
+    const prev = await readFile23(manifestPath, "utf-8");
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    await writeFile7(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
+    await writeFile8(`${manifestPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${manifestPath}.tmp`;
-  await writeFile7(tmpPath, `${JSON.stringify(existing, null, 2)}
+  await writeFile8(tmpPath, `${JSON.stringify(existing, null, 2)}
 `, "utf-8");
   await rename8(tmpPath, manifestPath);
   return { added: !had, updated: had };
@@ -19437,11 +19727,11 @@ async function ensureKnownClaudeMarketplaceForRoot(options) {
   return registerKnownClaudeMarketplace(options.name, options.rootDir);
 }
 async function setSyntaurPluginEnabled(options) {
-  const settingsPath = resolve35(homedir3(), ".claude", "settings.json");
+  const settingsPath = resolve36(homedir3(), ".claude", "settings.json");
   const key = `syntaur@${options.marketplaceName}`;
   let parsed = {};
   if (await fileExists(settingsPath)) {
-    const raw = await readFile22(settingsPath, "utf-8");
+    const raw = await readFile23(settingsPath, "utf-8");
     try {
       parsed = JSON.parse(raw);
     } catch {
@@ -19460,11 +19750,11 @@ async function setSyntaurPluginEnabled(options) {
   await ensureDir(dirname10(settingsPath));
   if (await fileExists(settingsPath)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const prev = await readFile22(settingsPath, "utf-8");
-    await writeFile7(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
+    const prev = await readFile23(settingsPath, "utf-8");
+    await writeFile8(`${settingsPath}.bak-${stamp}`, prev, "utf-8");
   }
   const tmpPath = `${settingsPath}.tmp`;
-  await writeFile7(tmpPath, `${JSON.stringify(parsed, null, 2)}
+  await writeFile8(tmpPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
   await rename8(tmpPath, settingsPath);
   return { key, previous, current: options.enabled, changed: true };
@@ -19474,9 +19764,9 @@ async function ensureClaudeUserMarketplace() {
   if (existing) {
     return existing;
   }
-  const rootDir = resolve35(getClaudeMarketplacesRoot(), "user-plugins");
-  const manifestPath = resolve35(rootDir, ".claude-plugin", "marketplace.json");
-  await ensureDir(resolve35(rootDir, "plugins"));
+  const rootDir = resolve36(getClaudeMarketplacesRoot(), "user-plugins");
+  const manifestPath = resolve36(rootDir, ".claude-plugin", "marketplace.json");
+  await ensureDir(resolve36(rootDir, "plugins"));
   if (!await fileExists(manifestPath)) {
     const scaffold = {
       plugins: []
@@ -19495,7 +19785,7 @@ async function ensureClaudeUserMarketplace() {
     name: "user-plugins",
     rootDir,
     manifestPath,
-    targetDir: resolve35(rootDir, "plugins", "syntaur")
+    targetDir: resolve36(rootDir, "plugins", "syntaur")
   };
 }
 async function detectClaudeMarketplaceForTarget(targetDir) {
@@ -19505,7 +19795,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const rootDir = dirname10(pluginsDir);
-  const manifestPath = resolve35(rootDir, ".claude-plugin", "marketplace.json");
+  const manifestPath = resolve36(rootDir, ".claude-plugin", "marketplace.json");
   if (!await fileExists(manifestPath)) {
     return null;
   }
@@ -19521,7 +19811,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
 async function findManagedClaudeMarketplacePluginDir() {
   const marketplaces = await listClaudeMarketplaceCandidates();
   for (const marketplace of marketplaces) {
-    const targetDir = resolve35(marketplace.rootDir, "plugins", "syntaur");
+    const targetDir = resolve36(marketplace.rootDir, "plugins", "syntaur");
     const status = await getInstallStatus(targetDir, "claude");
     if (status.exists && status.managed) {
       return targetDir;
@@ -19646,7 +19936,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 === resolve35(paths.sourceDir) && !force) {
+  if (desiredMode === "link" && existing.exists && existing.installMode === "link" && existing.symlinkTarget === resolve36(paths.sourceDir) && !force) {
     return {
       targetDir: paths.targetDir,
       sourceDir: paths.sourceDir,
@@ -19698,7 +19988,7 @@ async function readMarketplaceFile(marketplacePath) {
       plugins: []
     };
   }
-  const raw = await readFile22(marketplacePath, "utf-8");
+  const raw = await readFile23(marketplacePath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "local",
@@ -19708,7 +19998,7 @@ async function readMarketplaceFile(marketplacePath) {
 }
 async function writeMarketplaceFile(marketplacePath, marketplace) {
   await ensureDir(dirname10(marketplacePath));
-  await writeFile7(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+  await writeFile8(marketplacePath, `${JSON.stringify(marketplace, null, 2)}
 `, "utf-8");
 }
 async function hasAnySyntaurMarketplaceEntry(marketplacePath) {
@@ -19859,13 +20149,13 @@ async function recommendMarketplacePath() {
   return configuredOrManaged ?? getDefaultMarketplacePath();
 }
 async function isSyntaurDataInstalled() {
-  return fileExists(resolve35(syntaurRoot(), "config.md"));
+  return fileExists(resolve36(syntaurRoot(), "config.md"));
 }
 async function removeSyntaurData() {
   await rm4(syntaurRoot(), { recursive: true, force: true });
 }
 async function getConfiguredProjectDir() {
-  if (!await fileExists(resolve35(syntaurRoot(), "config.md"))) {
+  if (!await fileExists(resolve36(syntaurRoot(), "config.md"))) {
     return null;
   }
   return (await readConfig()).defaultProjectDir;
@@ -19934,24 +20224,24 @@ async function textPrompt(question, defaultValue) {
 
 // src/utils/install-skills.ts
 init_fs();
-import { readFile as readFile24, readdir as readdir15, mkdir as mkdir4, copyFile, rm as rm5, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve37, relative as relative3, join as join4 } from "path";
+import { readFile as readFile25, 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 { homedir as homedir5 } from "os";
 
 // src/utils/plugin-state.ts
 init_fs();
-import { readFile as readFile23 } from "fs/promises";
-import { resolve as resolve36 } from "path";
+import { readFile as readFile24 } from "fs/promises";
+import { resolve as resolve37 } from "path";
 import { homedir as homedir4 } from "os";
 function settingsPathFor(agent) {
-  if (agent === "claude") return resolve36(homedir4(), ".claude", "settings.json");
+  if (agent === "claude") return resolve37(homedir4(), ".claude", "settings.json");
   return null;
 }
 async function readJsonOrNull(path) {
   if (!path) return null;
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile23(path, "utf-8");
+    const raw = await readFile24(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -20000,11 +20290,11 @@ var KNOWN_SKILL_NAMES = [
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
   const packageRoot = await findPackageRoot("skills");
-  return resolve37(packageRoot, "skills");
+  return resolve38(packageRoot, "skills");
 }
 function defaultSkillTargetDir(target) {
-  if (target === "claude") return resolve37(homedir5(), ".claude", "skills");
-  return resolve37(homedir5(), ".codex", "skills");
+  if (target === "claude") return resolve38(homedir5(), ".claude", "skills");
+  return resolve38(homedir5(), ".codex", "skills");
 }
 async function walkFiles(root) {
   const out = [];
@@ -20024,7 +20314,7 @@ async function walkFiles(root) {
 }
 async function filesEqual(a, b) {
   try {
-    const [ba, bb] = await Promise.all([readFile24(a), readFile24(b)]);
+    const [ba, bb] = await Promise.all([readFile25(a), readFile25(b)]);
     if (ba.length !== bb.length) return false;
     return ba.equals(bb);
   } catch {
@@ -20146,7 +20436,7 @@ async function uninstallSkills(options) {
     if (await isSymlink(destDir)) continue;
     const skillMd = join4(destDir, "SKILL.md");
     if (!await fileExists(skillMd)) continue;
-    const content = await readFile24(skillMd, "utf-8").catch(() => "");
+    const content = await readFile25(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 });
@@ -20335,16 +20625,16 @@ async function installPluginCommand(options) {
 // src/commands/install-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile26, writeFile as writeFile9, copyFile as copyFile2, rm as rm6, stat as stat2, symlink as symlink2, unlink as unlink8, lstat as lstat3 } from "fs/promises";
-import { resolve as resolve39, dirname as dirname12 } from "path";
+import { readFile as readFile27, writeFile as writeFile10, copyFile as copyFile2, rm as rm6, stat as stat2, symlink as symlink2, unlink as unlink8, lstat as lstat3 } from "fs/promises";
+import { resolve as resolve40, dirname as dirname12 } from "path";
 import { homedir as homedir6 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/commands/configure-statusline.ts
 init_paths();
 init_fs();
-import { readFile as readFile25, writeFile as writeFile8 } from "fs/promises";
-import { resolve as resolve38, dirname as dirname11 } from "path";
+import { readFile as readFile26, writeFile as writeFile9 } from "fs/promises";
+import { resolve as resolve39, dirname as dirname11 } from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { checkbox, input as input2, confirm } from "@inquirer/prompts";
 var AVAILABLE_SEGMENTS = [
@@ -20365,12 +20655,12 @@ var PRESETS = {
   tracker: { segments: ["git", "assignment", "external", "session"], separator: " \xB7 " }
 };
 function getConfigPath(installRoot) {
-  return resolve38(installRoot, "statusline.config.json");
+  return resolve39(installRoot, "statusline.config.json");
 }
 async function readConfig2(path) {
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile25(path, "utf-8");
+    const raw = await readFile26(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
     const segments = Array.isArray(parsed.segments) ? parsed.segments.filter(isSegmentName) : [];
@@ -20517,13 +20807,13 @@ async function configureStatuslineCommand(options = {}) {
     return;
   }
   await ensureDir(dirname11(configPath));
-  await writeFile8(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await writeFile9(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 ?? resolve38(installRoot, "statusline.sh");
+  const script = options.statuslineScript ?? resolve39(installRoot, "statusline.sh");
   if (await fileExists(script)) {
     console.log("");
     console.log("Live preview:");
@@ -20548,17 +20838,17 @@ async function writeDefaultConfigIfMissing(installRoot) {
     segments: ["git", "assignment", "session"],
     separator: " \xB7 "
   };
-  await writeFile8(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  await writeFile9(path, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/install-statusline.ts
 function getPackageStatuslineSource() {
   const here = dirname12(fileURLToPath4(import.meta.url));
-  return resolve39(here, "..", "statusline", "statusline.sh");
+  return resolve40(here, "..", "statusline", "statusline.sh");
 }
 async function readSettingsJson(settingsPath) {
   if (!await fileExists(settingsPath)) return {};
-  const raw = await readFile26(settingsPath, "utf-8");
+  const raw = await readFile27(settingsPath, "utf-8");
   if (raw.trim() === "") return {};
   try {
     const parsed = JSON.parse(raw);
@@ -20571,7 +20861,7 @@ async function readSettingsJson(settingsPath) {
 }
 async function writeSettingsJson(settingsPath, data) {
   await ensureDir(dirname12(settingsPath));
-  await writeFile9(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await writeFile10(settingsPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 async function resolveMode(mode, existingCommand, ourCommand) {
   if (mode !== "ask") return mode;
@@ -20606,7 +20896,7 @@ function extractExistingCommand(settings) {
 }
 async function backupSettings(settingsSnapshot, backupPath) {
   await ensureDir(dirname12(backupPath));
-  await writeFile9(
+  await writeFile10(
     backupPath,
     JSON.stringify(
       {
@@ -20638,12 +20928,12 @@ async function installScript(sourceScript, destScript, link) {
 }
 async function installStatuslineCommand(options = {}) {
   const mode = options.mode ?? "ask";
-  const settingsPath = options.settingsPath ?? resolve39(homedir6(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve40(homedir6(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
   const sourceScript = options.sourceScript ?? getPackageStatuslineSource();
-  const destScript = resolve39(installRoot, "statusline.sh");
-  const confPath = resolve39(installRoot, "statusline.conf");
-  const backupPath = resolve39(installRoot, "statusline.backup.json");
+  const destScript = resolve40(installRoot, "statusline.sh");
+  const confPath = resolve40(installRoot, "statusline.conf");
+  const backupPath = resolve40(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.`
@@ -20679,19 +20969,19 @@ async function installStatuslineCommand(options = {}) {
     if (parsed) {
       wrapTarget = parsed;
     } else {
-      const wrapperPath = resolve39(installRoot, "statusline-wrapped.sh");
+      const wrapperPath = resolve40(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 writeFile9(wrapperPath, wrapperBody, "utf-8");
+      await writeFile10(wrapperPath, wrapperBody, "utf-8");
       await chmodExec(wrapperPath);
       wrapTarget = wrapperPath;
     }
   }
   await ensureDir(dirname12(confPath));
-  await writeFile9(
+  await writeFile10(
     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
@@ -20734,19 +21024,19 @@ async function chmodExec(path) {
   }
 }
 async function uninstallStatuslineCommand(options = {}) {
-  const settingsPath = options.settingsPath ?? resolve39(homedir6(), ".claude", "settings.json");
+  const settingsPath = options.settingsPath ?? resolve40(homedir6(), ".claude", "settings.json");
   const installRoot = options.installRoot ?? syntaurRoot();
-  const destScript = resolve39(installRoot, "statusline.sh");
-  const confPath = resolve39(installRoot, "statusline.conf");
-  const backupPath = resolve39(installRoot, "statusline.backup.json");
-  const wrapperPath = resolve39(installRoot, "statusline-wrapped.sh");
+  const destScript = resolve40(installRoot, "statusline.sh");
+  const confPath = resolve40(installRoot, "statusline.conf");
+  const backupPath = resolve40(installRoot, "statusline.backup.json");
+  const wrapperPath = resolve40(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 readFile26(backupPath, "utf-8");
+      const raw = await readFile27(backupPath, "utf-8");
       const parsed = JSON.parse(raw);
       const prev = parsed?.previousStatusLine;
       if (prev && typeof prev === "object" && typeof prev.command === "string") {
@@ -20767,7 +21057,7 @@ async function uninstallStatuslineCommand(options = {}) {
     await writeSettingsJson(settingsPath, settings);
   }
   if (!options.keepScript) {
-    const configPath = resolve39(installRoot, "statusline.config.json");
+    const configPath = resolve40(installRoot, "statusline.config.json");
     for (const path of [destScript, confPath, backupPath, wrapperPath, configPath]) {
       try {
         await rm6(path, { force: true });
@@ -21024,7 +21314,7 @@ async function setupCommand(options) {
 }
 
 // src/commands/uninstall.ts
-import { resolve as resolve40 } from "path";
+import { resolve as resolve41 } from "path";
 init_paths();
 function expandTargets(options) {
   if (options.all) {
@@ -21104,7 +21394,7 @@ async function uninstallCommand(options) {
     const configuredProjectDir = await getConfiguredProjectDir();
     await removeSyntaurData();
     console.log(`Removed ${syntaurRoot()}`);
-    if (configuredProjectDir && resolve40(configuredProjectDir) !== resolve40(syntaurRoot(), "projects")) {
+    if (configuredProjectDir && resolve41(configuredProjectDir) !== resolve41(syntaurRoot(), "projects")) {
       console.warn(
         `Warning: config.md pointed to an external project directory (${configuredProjectDir}). That directory was not removed automatically.`
       );
@@ -21123,7 +21413,7 @@ init_slug();
 init_cursor_rules();
 init_codex_agents();
 init_opencode_config();
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 var SUPPORTED_FRAMEWORKS = ["cursor", "codex", "opencode"];
 async function setupAdapterCommand(framework, options) {
   if (!SUPPORTED_FRAMEWORKS.includes(framework)) {
@@ -21149,19 +21439,19 @@ async function setupAdapterCommand(framework, options) {
   }
   const config = await readConfig();
   const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  const projectDir = resolve41(baseDir, options.project);
-  const assignmentDir = resolve41(
+  const projectDir = resolve42(baseDir, options.project);
+  const assignmentDir = resolve42(
     projectDir,
     "assignments",
     options.assignment
   );
-  const projectMdPath = resolve41(projectDir, "project.md");
+  const projectMdPath = resolve42(projectDir, "project.md");
   if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
     throw new Error(
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath2 = resolve41(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve42(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
@@ -21189,15 +21479,15 @@ async function setupAdapterCommand(framework, options) {
     }
   }
   if (framework === "cursor") {
-    const protocolPath = resolve41(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
-    const assignmentPath = resolve41(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
+    const protocolPath = resolve42(cwd, ".cursor", "rules", "syntaur-protocol.mdc");
+    const assignmentPath = resolve42(cwd, ".cursor", "rules", "syntaur-assignment.mdc");
     await writeAdapterFile(protocolPath, renderCursorProtocol());
     await writeAdapterFile(assignmentPath, renderCursorAssignment(rendererParams));
   } else if (framework === "codex" || framework === "opencode") {
-    const agentsPath = resolve41(cwd, "AGENTS.md");
+    const agentsPath = resolve42(cwd, "AGENTS.md");
     await writeAdapterFile(agentsPath, renderCodexAgents(rendererParams));
     if (framework === "opencode") {
-      const configPath = resolve41(cwd, "opencode.json");
+      const configPath = resolve42(cwd, "opencode.json");
       await writeAdapterFile(configPath, renderOpenCodeConfig({ projectDir }));
     }
   }
@@ -21222,7 +21512,7 @@ async function setupAdapterCommand(framework, options) {
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve42 } from "path";
+import { resolve as resolve43 } from "path";
 init_session_db();
 init_agent_sessions();
 async function trackSessionCommand(options) {
@@ -21237,7 +21527,7 @@ async function trackSessionCommand(options) {
   if (options.project) {
     const config = await readConfig();
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-    const projectDir = resolve42(baseDir, options.project);
+    const projectDir = resolve43(baseDir, options.project);
     if (!await fileExists(projectDir)) {
       throw new Error(
         `Project "${options.project}" not found at ${projectDir}.`
@@ -21613,7 +21903,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve78, reject) => {
+  await new Promise((resolve79, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -21623,7 +21913,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve78();
+      resolve79();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -21752,7 +22042,7 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname13, resolve as resolve44, join as join5 } from "path";
+import { dirname as dirname13, resolve as resolve45, join as join5 } from "path";
 import { realpathSync, readFileSync, mkdirSync } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -21778,7 +22068,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath3 = opts.realpath ?? realpathSync.native;
-  const readFile53 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile54 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath3);
   if (resolved === null) {
@@ -21799,7 +22089,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
     const pkgJsonPath = join5(dir, "package.json");
     let raw;
     try {
-      raw = readFile53(pkgJsonPath);
+      raw = readFile54(pkgJsonPath);
     } catch {
       const parent2 = dirname13(dir);
       if (parent2 === dir) break;
@@ -21831,7 +22121,7 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve44(syntaurRoot(), "npx-handler-nudge");
+  return resolve45(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
@@ -21975,8 +22265,8 @@ function formatInstallUrlHandlerError(err2) {
 init_config2();
 init_paths();
 init_fs();
-import { resolve as resolve46, isAbsolute as isAbsolute7 } from "path";
-import { readFile as readFile27 } from "fs/promises";
+import { resolve as resolve47, isAbsolute as isAbsolute7 } from "path";
+import { readFile as readFile28 } from "fs/promises";
 import { select, confirm as confirm2, input as input3 } from "@inquirer/prompts";
 async function browseCommand(options) {
   const config = await readConfig();
@@ -22045,7 +22335,7 @@ async function pickAgent2(agents) {
   return picked;
 }
 async function ensureWorktree(opts) {
-  const assignmentPath = resolve46(
+  const assignmentPath = resolve47(
     opts.projectsDir,
     opts.projectSlug,
     "assignments",
@@ -22055,7 +22345,7 @@ async function ensureWorktree(opts) {
   if (!await fileExists(assignmentPath)) {
     return void 0;
   }
-  const content = await readFile27(assignmentPath, "utf-8");
+  const content = await readFile28(assignmentPath, "utf-8");
   const { parseAssignmentFrontmatter: parseAssignmentFrontmatter2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
   const fm = parseAssignmentFrontmatter2(content);
   const { workspace } = fm;
@@ -22125,7 +22415,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 : resolve46(expandedWorktree);
+  const absWorktree = isAbsolute7(expandedWorktree) ? expandedWorktree : resolve47(expandedWorktree);
   try {
     await createWorktreeAndRecord2({
       assignmentPath: opts.assignmentPath,
@@ -22154,7 +22444,7 @@ init_paths();
 init_fs();
 init_playbook();
 init_playbooks();
-import { resolve as resolve47 } from "path";
+import { resolve as resolve48 } from "path";
 async function createPlaybookCommand(name, options) {
   if (!name.trim()) {
     throw new Error("Playbook name cannot be empty.");
@@ -22167,7 +22457,7 @@ async function createPlaybookCommand(name, options) {
   }
   const dir = playbooksDir();
   await ensureDir(dir);
-  const filePath = resolve47(dir, `${slug}.md`);
+  const filePath = resolve48(dir, `${slug}.md`);
   if (await fileExists(filePath)) {
     throw new Error(
       `Playbook "${slug}" already exists at ${filePath}
@@ -22189,8 +22479,8 @@ init_paths();
 init_fs();
 init_parser();
 init_config2();
-import { readdir as readdir16, readFile as readFile28 } from "fs/promises";
-import { resolve as resolve48 } from "path";
+import { readdir as readdir16, readFile as readFile29 } from "fs/promises";
+import { resolve as resolve49 } from "path";
 async function listPlaybooksCommand(options = {}) {
   const dir = playbooksDir();
   if (!await fileExists(dir)) {
@@ -22205,8 +22495,8 @@ async function listPlaybooksCommand(options = {}) {
   );
   const rows = [];
   for (const entry of mdFiles) {
-    const filePath = resolve48(dir, entry.name);
-    const raw = await readFile28(filePath, "utf-8");
+    const filePath = resolve49(dir, entry.name);
+    const raw = await readFile29(filePath, "utf-8");
     const parsed = parsePlaybook(raw);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
     const disabled = disabledSet.has(slug);
@@ -22329,14 +22619,14 @@ init_fs();
 init_config2();
 init_slug();
 import { Command as Command2 } from "commander";
-import { readFile as readFile30 } from "fs/promises";
-import { resolve as resolve50 } from "path";
+import { readFile as readFile31 } from "fs/promises";
+import { resolve as resolve51 } from "path";
 
 // src/commands/bundle.ts
 init_paths();
 import { Command } from "commander";
-import { mkdir as mkdir7, readFile as readFile29, readdir as readdir17, rm as rm7, writeFile as writeFile11 } from "fs/promises";
-import { resolve as resolve49 } from "path";
+import { mkdir as mkdir7, readFile as readFile30, readdir as readdir17, rm as rm7, writeFile as writeFile12 } from "fs/promises";
+import { resolve as resolve50 } from "path";
 init_parser2();
 init_fs();
 init_config2();
@@ -22354,7 +22644,7 @@ async function resolveBundleScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve49(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve50(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -22424,10 +22714,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: resolve49(planDir, "plan.md"), version: 1 };
+  if (versions.size === 0) return { target: resolve50(planDir, "plan.md"), version: 1 };
   let n = 2;
   while (versions.has(n)) n++;
-  return { target: resolve49(planDir, `plan-v${n}.md`), version: n };
+  return { target: resolve50(planDir, `plan-v${n}.md`), version: n };
 }
 function dedupePreserveOrder(ids) {
   const out = [];
@@ -22511,7 +22801,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 = resolve49(planDir, "plan.md");
+      const target = resolve50(planDir, "plan.md");
       const memberLines = items.map((it) => `- ${it.description} [t:${it.id}]`).join("\n");
       const stub = [
         "---",
@@ -22687,7 +22977,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 ?? resolve49(repository, ".worktrees", options.branch);
+    const worktreePath = options.worktreePath ?? resolve50(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);
@@ -22697,8 +22987,8 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
     }
     const bundlesFilePath = bundlesPath(sc.todosPath);
     const checklistFilePath = checklistPath(sc.todosPath, sc.checklistKey);
-    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile29(bundlesFilePath, "utf-8") : null;
-    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile29(checklistFilePath, "utf-8") : null;
+    const bundlesSnapshot = await fileExists(bundlesFilePath) ? await readFile30(bundlesFilePath, "utf-8") : null;
+    const checklistSnapshot = await fileExists(checklistFilePath) ? await readFile30(checklistFilePath, "utf-8") : null;
     const record = async () => {
       bundle.branch = options.branch;
       bundle.worktreePath = worktreePath;
@@ -22714,7 +23004,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
       try {
         await writeBundles(sc.todosPath, bundles);
         await writeChecklist(sc.todosPath, checklist);
-        const ctxDir = resolve49(worktreePath, ".syntaur");
+        const ctxDir = resolve50(worktreePath, ".syntaur");
         await mkdir7(ctxDir, { recursive: true });
         const payload = {
           bundleId: bundle.id,
@@ -22728,7 +23018,7 @@ bundleCommand.command("worktree").description("Create a git worktree for the bun
           repository,
           boundAt: nowISO()
         };
-        await writeFile11(resolve49(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
+        await writeFile12(resolve50(ctxDir, "context.json"), JSON.stringify(payload, null, 2) + "\n");
       } catch (err2) {
         try {
           if (bundlesSnapshot === null) {
@@ -22918,7 +23208,7 @@ async function resolveScope(options) {
       throw new Error(`Invalid project slug: "${options.project}".`);
     }
     const config = await readConfig();
-    const projectMd = resolve50(config.defaultProjectDir, options.project, "project.md");
+    const projectMd = resolve51(config.defaultProjectDir, options.project, "project.md");
     if (!await fileExists(projectMd)) {
       throw new Error(`Project "${options.project}" not found.`);
     }
@@ -23241,10 +23531,10 @@ todoCommand.command("archive").description("Archive completed todos and their lo
       (e) => e.itemIds.every((id) => completedIds.has(id))
     );
     const archFile = archivePath(todosPath, workspace, checklist.archiveInterval);
-    await ensureDir(resolve50(todosPath, "archive"));
+    await ensureDir(resolve51(todosPath, "archive"));
     let archContent = "";
     if (await fileExists(archFile)) {
-      archContent = await readFile30(archFile, "utf-8");
+      archContent = await readFile31(archFile, "utf-8");
       archContent = archContent.trimEnd() + "\n\n";
     } else {
       archContent = `---
@@ -23421,12 +23711,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile53 } = await import("fs/promises");
+  const { readFile: readFile54 } = await import("fs/promises");
   const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { appendTodosToAssignmentBody: appendTodosToAssignmentBody2, touchAssignmentUpdated: touchAssignmentUpdated2 } = await Promise.resolve().then(() => (init_assignment_todos(), assignment_todos_exports));
   const { nowTimestamp: nowTimestamp3 } = await Promise.resolve().then(() => (init_timestamp(), timestamp_exports));
   const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
-  let content = await readFile53(assignmentMdPath2, "utf-8");
+  let content = await readFile54(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -23477,7 +23767,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     );
     let target;
     if (existingFiles.length === 0) {
-      target = resolve50(planDir, "plan.md");
+      target = resolve51(planDir, "plan.md");
     } else {
       const versions = /* @__PURE__ */ new Set();
       for (const f of existingFiles) {
@@ -23487,7 +23777,7 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
       }
       let n = 2;
       while (versions.has(n)) n++;
-      target = resolve50(planDir, `plan-v${n}.md`);
+      target = resolve51(planDir, `plan-v${n}.md`);
     }
     if (!await fileExists(target)) {
       const stub = `---
@@ -23676,12 +23966,12 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command4 } from "commander";
-import { readFile as readFile38 } from "fs/promises";
-import { isAbsolute as isAbsolute10, resolve as resolve62 } from "path";
+import { readFile as readFile39 } from "fs/promises";
+import { isAbsolute as isAbsolute10, resolve as resolve63 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { readFile as readFile37 } from "fs/promises";
+import { readFile as readFile38 } from "fs/promises";
 import { dirname as dirname17, join as join9 } from "path";
 
 // src/utils/doctor/context.ts
@@ -23689,11 +23979,11 @@ init_config2();
 init_paths();
 init_fs();
 import Database4 from "better-sqlite3";
-import { resolve as resolve51 } from "path";
+import { resolve as resolve52 } from "path";
 async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
-  const dbPath = resolve51(root, "syntaur.db");
+  const dbPath = resolve52(root, "syntaur.db");
   let db5 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
@@ -23727,8 +24017,8 @@ function closeCheckContext(ctx) {
 // src/utils/doctor/checks/env.ts
 init_fs();
 init_paths();
-import { resolve as resolve52, isAbsolute as isAbsolute8 } from "path";
-import { readFile as readFile31, stat as stat3 } from "fs/promises";
+import { resolve as resolve53, isAbsolute as isAbsolute8 } from "path";
+import { readFile as readFile32, stat as stat3 } from "fs/promises";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { dirname as dirname15, join as join7 } from "path";
 var CATEGORY = "env";
@@ -23768,7 +24058,7 @@ var configValid = {
   category: CATEGORY,
   title: "~/.syntaur/config.md is valid",
   async run(ctx) {
-    const configPath = resolve52(ctx.syntaurRoot, "config.md");
+    const configPath = resolve53(ctx.syntaurRoot, "config.md");
     if (!await fileExists(configPath)) {
       return {
         id: this.id,
@@ -23785,7 +24075,7 @@ var configValid = {
         autoFixable: false
       };
     }
-    const content = await readFile31(configPath, "utf-8");
+    const content = await readFile32(configPath, "utf-8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fmMatch || fmMatch[1].trim() === "") {
       return {
@@ -24065,7 +24355,7 @@ async function readLocalPkg() {
     for (let i = 0; i < 6; i++) {
       const candidate = join7(dir, "package.json");
       try {
-        const text = await readFile31(candidate, "utf-8");
+        const text = await readFile32(candidate, "utf-8");
         return JSON.parse(text);
       } catch {
         dir = dirname15(dir);
@@ -24117,7 +24407,7 @@ function versionGte(a, b) {
 
 // src/utils/doctor/checks/structure.ts
 init_fs();
-import { resolve as resolve53 } from "path";
+import { resolve as resolve54 } from "path";
 import { readdir as readdir18, stat as stat4 } from "fs/promises";
 var CATEGORY2 = "structure";
 var KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
@@ -24137,7 +24427,7 @@ var projectsDir = {
   category: CATEGORY2,
   title: "projects/ directory exists",
   async run(ctx) {
-    const p = resolve53(ctx.syntaurRoot, "projects");
+    const p = resolve54(ctx.syntaurRoot, "projects");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -24162,7 +24452,7 @@ var playbooksDir2 = {
   category: CATEGORY2,
   title: "playbooks/ directory exists",
   async run(ctx) {
-    const p = resolve53(ctx.syntaurRoot, "playbooks");
+    const p = resolve54(ctx.syntaurRoot, "playbooks");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -24187,7 +24477,7 @@ var todosDirValid = {
   category: CATEGORY2,
   title: "todos/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve53(ctx.syntaurRoot, "todos");
+    const p = resolve54(ctx.syntaurRoot, "todos");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -24218,7 +24508,7 @@ var serversDirValid = {
   category: CATEGORY2,
   title: "servers/ directory is readable (if present)",
   async run(ctx) {
-    const p = resolve53(ctx.syntaurRoot, "servers");
+    const p = resolve54(ctx.syntaurRoot, "servers");
     if (!await fileExists(p)) {
       return {
         id: this.id,
@@ -24263,7 +24553,7 @@ var knownFilesRecognized = {
       title: this.title,
       status: "warn",
       detail: `unexpected top-level entries: ${unexpected.join(", ")}`,
-      affected: unexpected.map((n) => resolve53(ctx.syntaurRoot, n)),
+      affected: unexpected.map((n) => resolve54(ctx.syntaurRoot, n)),
       remediation: {
         kind: "manual",
         suggestion: "Review these entries \u2014 they may be leftover state from older versions",
@@ -24292,7 +24582,7 @@ function pass2(check) {
 
 // src/utils/doctor/checks/project.ts
 init_fs();
-import { resolve as resolve54 } from "path";
+import { resolve as resolve55 } from "path";
 import { readdir as readdir19, stat as stat5 } from "fs/promises";
 var CATEGORY3 = "project";
 var REQUIRED_PROJECT_FILES = [
@@ -24322,10 +24612,10 @@ async function listProjects2(ctx) {
   for (const e of entries) {
     if (!e.isDirectory()) continue;
     if (e.name.startsWith(".") || e.name.startsWith("_")) continue;
-    const projectDir = resolve54(dir, e.name);
+    const projectDir = resolve55(dir, e.name);
     let looksLikeProject = false;
     for (const marker of PROJECT_MARKERS) {
-      if (await fileExists(resolve54(projectDir, marker))) {
+      if (await fileExists(resolve55(projectDir, marker))) {
         looksLikeProject = true;
         break;
       }
@@ -24344,7 +24634,7 @@ var requiredFiles = {
     for (const projectDir of projects) {
       const missing = [];
       for (const rel of REQUIRED_PROJECT_FILES) {
-        const p = resolve54(projectDir, rel);
+        const p = resolve55(projectDir, rel);
         if (!await fileExists(p)) missing.push(rel);
       }
       if (missing.length === 0) continue;
@@ -24354,7 +24644,7 @@ var requiredFiles = {
         title: this.title,
         status: "error",
         detail: `project at ${projectDir} is missing: ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve54(projectDir, m)),
+        affected: missing.map((m) => resolve55(projectDir, m)),
         remediation: {
           kind: "manual",
           suggestion: "Recreate the missing scaffold files from templates",
@@ -24377,7 +24667,7 @@ var manifestStale = {
     const projects = await listProjects2(ctx);
     const results = [];
     for (const projectDir of projects) {
-      const manifestPath = resolve54(projectDir, "manifest.md");
+      const manifestPath = resolve55(projectDir, "manifest.md");
       if (!await fileExists(manifestPath)) continue;
       const manifestMtime = (await stat5(manifestPath)).mtimeMs;
       const newestAssignment = await newestAssignmentMtime(projectDir);
@@ -24426,7 +24716,7 @@ var orphanFiles = {
         title: this.title,
         status: "warn",
         detail: `project at ${projectDir} has unexpected entries: ${orphans.join(", ")}`,
-        affected: orphans.map((o) => resolve54(projectDir, o)),
+        affected: orphans.map((o) => resolve55(projectDir, o)),
         autoFixable: false
       });
     }
@@ -24436,7 +24726,7 @@ var orphanFiles = {
 };
 var projectChecks = [requiredFiles, manifestStale, orphanFiles];
 async function newestAssignmentMtime(projectDir) {
-  const assignmentsRoot = resolve54(projectDir, "assignments");
+  const assignmentsRoot = resolve55(projectDir, "assignments");
   if (!await fileExists(assignmentsRoot)) return 0;
   let newest = 0;
   let entries;
@@ -24447,7 +24737,7 @@ async function newestAssignmentMtime(projectDir) {
   }
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const assignmentMd = resolve54(assignmentsRoot, e.name, "assignment.md");
+    const assignmentMd = resolve55(assignmentsRoot, e.name, "assignment.md");
     try {
       const s = await stat5(assignmentMd);
       if (s.mtimeMs > newest) newest = s.mtimeMs;
@@ -24471,8 +24761,8 @@ init_fs();
 init_parser();
 init_types();
 init_paths();
-import { resolve as resolve55 } from "path";
-import { readFile as readFile32, readdir as readdir20 } from "fs/promises";
+import { resolve as resolve56 } from "path";
+import { readFile as readFile33, readdir as readdir20 } from "fs/promises";
 var CATEGORY4 = "assignment";
 var STATUSES_REQUIRING_HANDOFF = /* @__PURE__ */ new Set(["review", "completed"]);
 var PRE_WORKSPACE_STATUSES = /* @__PURE__ */ new Set([
@@ -24566,7 +24856,7 @@ var invalidStatus = {
     const allowed = configuredStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!allowed.has(parsed.status)) {
@@ -24599,7 +24889,7 @@ var workspaceMissing = {
     const terminal = terminalStatuses(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (terminal.has(parsed.status)) continue;
@@ -24646,12 +24936,12 @@ var requiredFilesByStatus = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const assignmentPath = resolve55(a.assignmentDir, "assignment.md");
+      const assignmentPath = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(assignmentPath);
       if (!parsed) continue;
       const missing = [];
       if (STATUSES_REQUIRING_HANDOFF.has(parsed.status)) {
-        const handoffPath = resolve55(a.assignmentDir, "handoff.md");
+        const handoffPath = resolve56(a.assignmentDir, "handoff.md");
         if (!await fileExists(handoffPath)) missing.push("handoff.md");
       }
       if (missing.length === 0) continue;
@@ -24661,7 +24951,7 @@ var requiredFilesByStatus = {
         title: this.title,
         status: "warn",
         detail: `${a.projectSlug}/${a.assignmentSlug} (status: ${parsed.status}) is missing ${missing.join(", ")}`,
-        affected: missing.map((m) => resolve55(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve56(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create the missing ${missing.join(" and ")} files for this assignment`,
@@ -24684,7 +24974,7 @@ var companionFilesScaffolded = {
     for (const a of withAssignmentMd) {
       const missing = [];
       for (const filename of ["progress.md", "comments.md"]) {
-        if (!await fileExists(resolve55(a.assignmentDir, filename))) {
+        if (!await fileExists(resolve56(a.assignmentDir, filename))) {
           missing.push(filename);
         }
       }
@@ -24696,7 +24986,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) => resolve55(a.assignmentDir, m)),
+        affected: missing.map((m) => resolve56(a.assignmentDir, m)),
         remediation: {
           kind: "manual",
           suggestion: `Create ${missing.join(" and ")} with the renderProgress/renderComments templates, or re-scaffold via the CLI`,
@@ -24729,7 +25019,7 @@ var typeDefinition = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (!parsed.type) continue;
@@ -24763,7 +25053,7 @@ var projectFrontmatterMatchesContainer = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (a.standalone) {
@@ -24814,13 +25104,13 @@ var draftMissingObjective = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "draft") continue;
       let raw;
       try {
-        raw = await readFile32(path, "utf-8");
+        raw = await readFile33(path, "utf-8");
       } catch {
         continue;
       }
@@ -24853,7 +25143,7 @@ var readyToImplementMissingPlan = {
     const { withAssignmentMd } = await listAssignments(ctx);
     const results = [];
     for (const a of withAssignmentMd) {
-      const path = resolve55(a.assignmentDir, "assignment.md");
+      const path = resolve56(a.assignmentDir, "assignment.md");
       const parsed = await parseSafe2(path);
       if (!parsed) continue;
       if (parsed.status !== "ready_to_implement") continue;
@@ -24862,7 +25152,7 @@ var readyToImplementMissingPlan = {
       let hasPlanContent = false;
       for (const f of planFiles) {
         try {
-          const c2 = await readFile32(resolve55(a.assignmentDir, f), "utf-8");
+          const c2 = await readFile33(resolve56(a.assignmentDir, f), "utf-8");
           if (c2.trim().length > 0) {
             hasPlanContent = true;
             break;
@@ -24878,7 +25168,7 @@ var readyToImplementMissingPlan = {
         title: this.title,
         status: "warn",
         detail: `${label} (status: ready_to_implement) has no plan.md or plan-v<N>.md`,
-        affected: [resolve55(a.assignmentDir, "plan.md")],
+        affected: [resolve56(a.assignmentDir, "plan.md")],
         remediation: {
           kind: "manual",
           suggestion: `Write a plan with '/plan-assignment' (or 'syntaur plan'), then re-mark ready_to_implement`,
@@ -24905,7 +25195,7 @@ var assignmentChecks = [
 ];
 async function parseSafe2(path) {
   try {
-    const content = await readFile32(path, "utf-8");
+    const content = await readFile33(path, "utf-8");
     return parseAssignmentFull(content);
   } catch {
     return null;
@@ -24924,7 +25214,7 @@ function pass4(check, detail) {
 
 // src/utils/doctor/checks/dashboard.ts
 init_fs();
-import { resolve as resolve56 } from "path";
+import { resolve as resolve57 } from "path";
 var CATEGORY5 = "dashboard";
 var dbReachable = {
   id: "dashboard.db-reachable",
@@ -24938,7 +25228,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `could not open syntaur.db: ${ctx.dbError ?? "unknown error"}`,
-        affected: [resolve56(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve57(ctx.syntaurRoot, "syntaur.db")],
         remediation: {
           kind: "manual",
           suggestion: "Start the dashboard once (`syntaur dashboard`) to initialize the DB, or restore it from backup",
@@ -24956,7 +25246,7 @@ var dbReachable = {
           title: this.title,
           status: "error",
           detail: 'syntaur.db is missing the expected "sessions" table',
-          affected: [resolve56(ctx.syntaurRoot, "syntaur.db")],
+          affected: [resolve57(ctx.syntaurRoot, "syntaur.db")],
           autoFixable: false
         };
       }
@@ -24968,7 +25258,7 @@ var dbReachable = {
         title: this.title,
         status: "error",
         detail: `syntaur.db query failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
-        affected: [resolve56(ctx.syntaurRoot, "syntaur.db")],
+        affected: [resolve57(ctx.syntaurRoot, "syntaur.db")],
         autoFixable: false
       };
     }
@@ -24994,7 +25284,7 @@ var ghostSessions = {
     const results = [];
     for (const row of rows) {
       if (!row.project_slug) continue;
-      const projectPath = resolve56(projectsDir2, row.project_slug, "project.md");
+      const projectPath = resolve57(projectsDir2, row.project_slug, "project.md");
       if (!await fileExists(projectPath)) {
         results.push({
           id: this.id,
@@ -25013,7 +25303,7 @@ var ghostSessions = {
         continue;
       }
       if (row.assignment_slug) {
-        const assignmentPath = resolve56(
+        const assignmentPath = resolve57(
           projectsDir2,
           row.project_slug,
           "assignments",
@@ -25065,8 +25355,8 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve57, dirname as dirname16, basename as basename5 } from "path";
-import { readdir as readdir21, readFile as readFile33 } from "fs/promises";
+import { resolve as resolve58, dirname as dirname16, basename as basename5 } from "path";
+import { readdir as readdir21, readFile as readFile34 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 var CATEGORY6 = "integrations";
 var claudePluginLinked = {
@@ -25148,10 +25438,10 @@ var backupConfigured = {
   }
 };
 async function readKnownMarketplaces() {
-  const path = resolve57(homedir8(), ".claude", "plugins", "known_marketplaces.json");
+  const path = resolve58(homedir8(), ".claude", "plugins", "known_marketplaces.json");
   if (!await fileExists(path)) return {};
   try {
-    const raw = await readFile33(path, "utf-8");
+    const raw = await readFile34(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -25185,7 +25475,7 @@ var claudeMarketplaceRegistered = {
       };
     }
     const marketplaceRoot = dirname16(pluginsParent);
-    const marketplaceManifest = resolve57(marketplaceRoot, ".claude-plugin", "marketplace.json");
+    const marketplaceManifest = resolve58(marketplaceRoot, ".claude-plugin", "marketplace.json");
     if (!await fileExists(marketplaceManifest)) {
       return {
         id: this.id,
@@ -25204,7 +25494,7 @@ var claudeMarketplaceRegistered = {
     }
     let parsed = {};
     try {
-      parsed = JSON.parse(await readFile33(marketplaceManifest, "utf-8"));
+      parsed = JSON.parse(await readFile34(marketplaceManifest, "utf-8"));
     } catch {
       return {
         id: this.id,
@@ -25236,7 +25526,7 @@ var claudeMarketplaceRegistered = {
       title: this.title,
       status: "error",
       detail: issues.join("; "),
-      affected: [marketplaceManifest, resolve57(homedir8(), ".claude", "plugins", "known_marketplaces.json")],
+      affected: [marketplaceManifest, resolve58(homedir8(), ".claude", "plugins", "known_marketplaces.json")],
       remediation: {
         kind: "manual",
         suggestion: "Re-run install-plugin to ensure both files are in sync.",
@@ -25276,8 +25566,8 @@ function skipped2(check, reason) {
 init_fs();
 init_parser();
 init_types();
-import { resolve as resolve58 } from "path";
-import { readFile as readFile34 } from "fs/promises";
+import { resolve as resolve59 } from "path";
+import { readFile as readFile35 } from "fs/promises";
 var CATEGORY7 = "workspace";
 var ASSIGNMENT_FIELDS = ["projectSlug", "assignmentSlug", "projectDir", "assignmentDir"];
 var BUNDLE_FIELDS = ["bundleId", "bundleScope", "bundleScopeId"];
@@ -25298,12 +25588,12 @@ function isStandaloneSession(ctx) {
   return !hasAnyAssignmentField(ctx) && !hasAnyBundleField(ctx) && typeof ctx.sessionId === "string" && ctx.sessionId.length > 0;
 }
 async function loadContext(ctx) {
-  const path = resolve58(ctx.cwd, ".syntaur", "context.json");
+  const path = resolve59(ctx.cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) {
     return { data: null, path, exists: false, parseError: null };
   }
   try {
-    const raw = await readFile34(path, "utf-8");
+    const raw = await readFile35(path, "utf-8");
     return { data: JSON.parse(raw), path, exists: true, parseError: null };
   } catch (err2) {
     return {
@@ -25397,7 +25687,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 = resolve58(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve59(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) {
       return {
         id: this.id,
@@ -25427,10 +25717,10 @@ var contextTerminal = {
     if (isStandaloneSession(data)) return skipped3(this, "standalone session context \u2014 no assignment to check");
     if (isBundleContext(data)) return skipped3(this, "bundle context \u2014 no assignment to check");
     if (!data?.assignmentDir) return skipped3(this, "context has no assignmentDir");
-    const assignmentMd = resolve58(data.assignmentDir, "assignment.md");
+    const assignmentMd = resolve59(data.assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMd)) return skipped3(this, "assignment file missing");
     try {
-      const content = await readFile34(assignmentMd, "utf-8");
+      const content = await readFile35(assignmentMd, "utf-8");
       const parsed = parseAssignmentFull(content);
       const terminal = terminalStatuses2(ctx);
       if (terminal.has(parsed.status)) {
@@ -25576,15 +25866,15 @@ var agentChecks = [agentsResolvable];
 // src/utils/doctor/checks/terminal.ts
 init_config2();
 import { spawnSync as spawnSync8 } from "child_process";
-import { readFile as readFile35 } from "fs/promises";
-import { resolve as resolve59 } from "path";
+import { readFile as readFile36 } from "fs/promises";
+import { resolve as resolve60 } from "path";
 init_paths();
 init_fs();
 var CATEGORY9 = "terminal";
 async function readRawTerminalKey() {
-  const configPath = resolve59(syntaurRoot(), "config.md");
+  const configPath = resolve60(syntaurRoot(), "config.md");
   if (!await fileExists(configPath)) return null;
-  const content = await readFile35(configPath, "utf-8");
+  const content = await readFile36(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));
@@ -25734,13 +26024,13 @@ var terminalChecks = [
 
 // src/utils/doctor/checks/skills.ts
 init_fs();
-import { resolve as resolve60, join as join8 } from "path";
-import { readdir as readdir22, readFile as readFile36, lstat as lstat4 } from "fs/promises";
+import { resolve as resolve61, join as join8 } from "path";
+import { readdir as readdir22, readFile as readFile37, lstat as lstat4 } from "fs/promises";
 import { homedir as homedir9 } from "os";
 var CATEGORY10 = "skills";
 var skillTargets = [
-  { agent: "claude", dir: resolve60(homedir9(), ".claude", "skills"), label: "~/.claude/skills" },
-  { agent: "codex", dir: resolve60(homedir9(), ".codex", "skills"), label: "~/.codex/skills" }
+  { agent: "claude", dir: resolve61(homedir9(), ".claude", "skills"), label: "~/.claude/skills" },
+  { agent: "codex", dir: resolve61(homedir9(), ".codex", "skills"), label: "~/.codex/skills" }
 ];
 var skillsDedupCheck = {
   id: "skills.dedup",
@@ -25764,7 +26054,7 @@ var skillsDedupCheck = {
         if (!KNOWN_SKILLS.includes(entry.name)) continue;
         const skillMd = join8(dir, entry.name, "SKILL.md");
         if (!await fileExists(skillMd)) continue;
-        const content = await readFile36(skillMd, "utf-8").catch(() => "");
+        const content = await readFile37(skillMd, "utf-8").catch(() => "");
         const match = content.match(/^name:\s*(\S+)\s*$/m);
         if (!match || match[1] !== entry.name) continue;
         let isSymlink2 = false;
@@ -25815,7 +26105,7 @@ var skillsChecks = [skillsDedupCheck];
 // src/utils/doctor/checks/bundles.ts
 init_fs();
 init_paths();
-import { resolve as resolve61 } from "path";
+import { resolve as resolve62 } from "path";
 import { readdir as readdir23 } from "fs/promises";
 import { spawnSync as spawnSync9 } from "child_process";
 init_parser2();
@@ -25845,7 +26135,7 @@ async function listScopes(ctx) {
       if (!e.isDirectory()) continue;
       const slug = e.name;
       if (typeof slug !== "string" || slug.startsWith(".")) continue;
-      const projectMd = resolve61(ctx.config.defaultProjectDir, slug, "project.md");
+      const projectMd = resolve62(ctx.config.defaultProjectDir, slug, "project.md");
       if (!await fileExists(projectMd)) continue;
       out.push({
         scopeLabel: `project:${slug}`,
@@ -26136,7 +26426,7 @@ async function readVersion() {
     let dir = dirname17(here);
     for (let i = 0; i < 6; i++) {
       try {
-        const raw = await readFile37(join9(dir, "package.json"), "utf-8");
+        const raw = await readFile38(join9(dir, "package.json"), "utf-8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : null;
       } catch {
@@ -26233,7 +26523,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 : resolve62(cwd, inputPath);
+  const absolute = isAbsolute10(inputPath) ? inputPath : resolve63(cwd, inputPath);
   const errors = [];
   const warnings = [];
   if (!await fileExists(absolute)) {
@@ -26246,7 +26536,7 @@ async function validateAssignmentFile(inputPath, cwd = process.cwd()) {
   }
   let content;
   try {
-    content = await readFile38(absolute, "utf-8");
+    content = await readFile39(absolute, "utf-8");
   } catch (err2) {
     return {
       ok: false,
@@ -26570,8 +26860,8 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve63 } from "path";
-import { readFile as readFile39 } from "fs/promises";
+import { resolve as resolve64 } from "path";
+import { readFile as readFile40 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -26601,7 +26891,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve63(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve64(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -26611,13 +26901,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve63(assignmentDir, "comments.md");
+  const commentsPath = resolve64(assignmentDir, "comments.md");
   const timestamp = nowTimestamp();
   const author = options.author ?? process.env.USER ?? "unknown";
   let currentContent;
   let currentCount = 0;
   if (await fileExists(commentsPath)) {
-    currentContent = await readFile39(commentsPath, "utf-8");
+    currentContent = await readFile40(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -26651,8 +26941,8 @@ ${entry}`;
 }
 
 // src/commands/capture.ts
-import { resolve as resolve67, relative as relative4, dirname as dirname18 } from "path";
-import { copyFile as copyFile3, mkdir as mkdir9, realpath as realpath2, rm as rm12, stat as stat8, writeFile as writeFile13 } from "fs/promises";
+import { resolve as resolve68, relative as relative4, dirname as dirname18 } 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 { existsSync as existsSync5 } from "fs";
 
 // src/utils/assignment-target.ts
@@ -26662,8 +26952,8 @@ init_config2();
 init_slug();
 init_assignment_resolver();
 init_parser();
-import { resolve as resolve64 } from "path";
-import { readFile as readFile40 } from "fs/promises";
+import { resolve as resolve65 } from "path";
+import { readFile as readFile41 } from "fs/promises";
 var AssignmentTargetError = class extends Error {
 };
 function classifyContext(ctx) {
@@ -26675,10 +26965,10 @@ function classifyContext(ctx) {
   return "empty";
 }
 async function readAssignmentFrontmatterId(assignmentDir) {
-  const path = resolve64(assignmentDir, "assignment.md");
+  const path = resolve65(assignmentDir, "assignment.md");
   if (!await fileExists(path)) return null;
   try {
-    const content = await readFile40(path, "utf-8");
+    const content = await readFile41(path, "utf-8");
     const [fm] = extractFrontmatter(content);
     return getField(fm, "id");
   } catch {
@@ -26686,10 +26976,10 @@ async function readAssignmentFrontmatterId(assignmentDir) {
   }
 }
 async function readContextJson(cwd) {
-  const path = resolve64(cwd, ".syntaur", "context.json");
+  const path = resolve65(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile40(path, "utf-8");
+    const raw = await readFile41(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -26710,15 +27000,15 @@ async function resolveAssignmentTarget(input4, opts = {}) {
     if (!isValidSlug(input4)) {
       throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
     }
-    const projectDir = resolve64(baseDir, opts.project);
-    const projectMdPath = resolve64(projectDir, "project.md");
+    const projectDir = resolve65(baseDir, opts.project);
+    const projectMdPath = resolve65(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new AssignmentTargetError(
         `Project "${opts.project}" not found at ${projectDir}.`
       );
     }
-    const assignmentDir = resolve64(projectDir, "assignments", input4);
-    const assignmentMdPath2 = resolve64(assignmentDir, "assignment.md");
+    const assignmentDir = resolve65(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve65(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `Assignment "${input4}" not found in project "${opts.project}".`
@@ -26757,7 +27047,7 @@ async function resolveAssignmentTarget(input4, opts = {}) {
   }
   if (ctx.assignmentDir) {
     const dir = expandHome(ctx.assignmentDir);
-    const assignmentMdPath2 = resolve64(dir, "assignment.md");
+    const assignmentMdPath2 = resolve65(dir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment dir: ${dir}.`
@@ -26786,8 +27076,8 @@ async function resolveAssignmentTarget(input4, opts = {}) {
         `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
       );
     }
-    const assignmentDir = resolve64(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
-    const assignmentMdPath2 = resolve64(assignmentDir, "assignment.md");
+    const assignmentDir = resolve65(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve65(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath2)) {
       throw new AssignmentTargetError(
         `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
@@ -26922,7 +27212,7 @@ async function captureScreenshot(mode) {
 
 // src/utils/asciinema.ts
 import { spawn as spawn6 } from "child_process";
-import { mkdtemp as mkdtemp3, readFile as readFile41, rm as rm9 } from "fs/promises";
+import { mkdtemp as mkdtemp3, readFile as readFile42, rm as rm9 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join11 } from "path";
 var SAFE_RE = /^[A-Za-z0-9_@%+=:,./-]+$/;
@@ -26985,7 +27275,7 @@ async function captureAsciinema(opts) {
       }
       throw err2;
     }
-    const text = await readFile41(castPath, "utf8").catch(() => null);
+    const text = await readFile42(castPath, "utf8").catch(() => null);
     if (text === null) {
       throw new Error(
         `asciinema produced no cast file at ${castPath} (exit ${exitCode}). Try running 'asciinema rec ${castPath}' directly to diagnose.`
@@ -27013,9 +27303,9 @@ async function captureAsciinema(opts) {
 // src/utils/recording.ts
 init_paths();
 import { spawn as spawn7 } from "child_process";
-import { mkdir as mkdir8, mkdtemp as mkdtemp4, open as open3, readFile as readFile42, rm as rm10, stat as stat7, unlink as unlink9, writeFile as writeFile12 } from "fs/promises";
+import { mkdir as mkdir8, mkdtemp as mkdtemp4, open as open3, readFile as readFile43, rm as rm10, stat as stat7, unlink as unlink9, writeFile as writeFile13 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join12, resolve as resolve65 } from "path";
+import { join as join12, resolve as resolve66 } from "path";
 import { setTimeout as sleep } from "timers/promises";
 function sigintPollIntervalMs() {
   const raw = process.env.SYNTAUR_RECORDING_POLL_INTERVAL_MS;
@@ -27036,13 +27326,13 @@ function sigtermWaitMs() {
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1e3;
 }
 function pidfilePath() {
-  return resolve65(syntaurRoot(), "recording.pid");
+  return resolve66(syntaurRoot(), "recording.pid");
 }
 function logPath2() {
-  return resolve65(syntaurRoot(), "recording.log");
+  return resolve66(syntaurRoot(), "recording.log");
 }
 function sidecarPath() {
-  return resolve65(syntaurRoot(), "recording.json");
+  return resolve66(syntaurRoot(), "recording.json");
 }
 function ffmpegArgs(device, fps, mp4Path) {
   return [
@@ -27087,7 +27377,7 @@ async function acquirePidfile(pidfile) {
     } catch (err2) {
       if (err2.code !== "EEXIST") throw err2;
       if (attempt === 1) throw err2;
-      const existing = (await readFile42(pidfile, "utf-8").catch(() => "")).trim();
+      const existing = (await readFile43(pidfile, "utf-8").catch(() => "")).trim();
       if (existing.startsWith(STARTING_SENTINEL_PREFIX)) {
         const parentPidRaw = existing.slice(STARTING_SENTINEL_PREFIX.length);
         const parentPid = Number.parseInt(parentPidRaw, 10);
@@ -27184,12 +27474,12 @@ async function startRecording(input4) {
     const pid = await pidReady;
     acquiredPid = pid;
     child.unref();
-    await writeFile12(pidfile, String(pid));
+    await writeFile13(pidfile, String(pid));
     await logHandle.close();
     logHandle = null;
     if (warmupMs > 0) await sleep(warmupMs);
     if (!await isProcessAlive(pid)) {
-      const tail = await readFile42(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
+      const tail = await readFile43(log, "utf-8").then((s) => s.split("\n").slice(-20).join("\n")).catch(() => "");
       acquiredPid = null;
       throw new Error(
         `ffmpeg exited during startup \u2014 likely macOS Screen Recording permission missing. Grant access to your terminal in System Settings \u2192 Privacy & Security \u2192 Screen Recording, then retry. Log: ${log}
@@ -27212,7 +27502,7 @@ ${tail}`
       device: input4.device,
       fps: input4.fps
     };
-    await writeFile12(sidecar, JSON.stringify(sidecarData, null, 2));
+    await writeFile13(sidecar, JSON.stringify(sidecarData, null, 2));
     return {
       pid,
       logPath: log,
@@ -27246,7 +27536,7 @@ ${tail}`
 async function stopRecording() {
   const pidfile = pidfilePath();
   const sidecar = sidecarPath();
-  const pidRaw = await readFile42(pidfile, "utf-8").catch(() => null);
+  const pidRaw = await readFile43(pidfile, "utf-8").catch(() => null);
   if (pidRaw === null) {
     throw new Error(
       `No active recording found (no pidfile at ${pidfile}). Did you run --start?`
@@ -27256,7 +27546,7 @@ async function stopRecording() {
   if (!Number.isInteger(pid) || pid <= 0) {
     throw new Error(`Pidfile at ${pidfile} is corrupt (got "${pidRaw}").`);
   }
-  const sidecarRaw = await readFile42(sidecar, "utf-8").catch(() => null);
+  const sidecarRaw = await readFile43(sidecar, "utf-8").catch(() => null);
   if (sidecarRaw === null) {
     throw new Error(
       `No recording sidecar at ${sidecar}. The recording state is inconsistent \u2014 delete ${pidfile} and re-run --start.`
@@ -27321,7 +27611,7 @@ async function stopRecording() {
 // src/db/proof-db.ts
 init_paths();
 import Database5 from "better-sqlite3";
-import { resolve as resolve66 } from "path";
+import { resolve as resolve67 } from "path";
 var db4 = null;
 var PROOF_SCHEMA_VERSION = "1";
 var SCHEMA_SQL4 = `
@@ -27341,7 +27631,7 @@ CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
 `;
 function initProofDb(dbPath) {
   if (db4) return db4;
-  const finalPath = dbPath ?? resolve66(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve67(syntaurRoot(), "syntaur.db");
   db4 = new Database5(finalPath);
   db4.pragma("journal_mode = WAL");
   db4.exec(SCHEMA_SQL4);
@@ -27389,7 +27679,7 @@ function listArtifactsByAssignment(assignmentId) {
 
 // src/utils/transcribers/elevenlabs.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdtemp as mkdtemp5, readFile as readFile43, rm as rm11 } from "fs/promises";
+import { mkdtemp as mkdtemp5, readFile as readFile44, rm as rm11 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join13 } from "path";
 var SCRIBE_URL = "https://api.elevenlabs.io/v1/speech-to-text";
@@ -27453,7 +27743,7 @@ async function extractAudio(videoAbsPath, wavOut) {
   throw new TranscribeFfmpegError(`ffmpeg failed (exit ${result.code}): ${tail}`);
 }
 async function callScribe(wavPath, apiKey, opts) {
-  const audio = await readFile43(wavPath);
+  const audio = await readFile44(wavPath);
   const form = new FormData();
   form.set("file", new Blob([new Uint8Array(audio)], { type: "audio/wav" }), "audio.wav");
   form.set("model_id", "scribe_v1");
@@ -27769,7 +28059,7 @@ async function captureCommand(target, options = {}) {
     });
   }
   if (options.file) {
-    const expanded = options.file.startsWith("~/") ? resolve67(process.env.HOME ?? "", options.file.slice(2)) : resolve67(options.file);
+    const expanded = options.file.startsWith("~/") ? resolve68(process.env.HOME ?? "", options.file.slice(2)) : resolve68(options.file);
     if (!await fileExists(expanded)) {
       throw new Error(`--file does not exist: ${options.file}`);
     }
@@ -27810,7 +28100,7 @@ async function captureCommand(target, options = {}) {
     }
     initProofDb();
     const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
-    const destDir = resolve67(proofDir(resolved.assignmentDir), subdir);
+    const destDir = resolve68(proofDir(resolved.assignmentDir), subdir);
     if (resolvedSource) await mkdir9(destDir, { recursive: true });
     const ext = resolvedSource ? extensionForKind(kind) : null;
     let id = null;
@@ -27819,7 +28109,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 ? resolve67(destDir, `${candidate}.${ext}`) : null;
+      const candidateAbsPath = resolvedSource && ext ? resolve68(destDir, `${candidate}.${ext}`) : null;
       const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
       try {
         insertArtifact({
@@ -27863,7 +28153,7 @@ async function captureCommand(target, options = {}) {
       }
     }
     if (options.transcribe && kind === "video" && absPath && id) {
-      const sidecarPath2 = resolve67(destDir, `${id}.transcript.md`);
+      const sidecarPath2 = resolve68(destDir, `${id}.transcript.md`);
       if (existsSync5(sidecarPath2)) {
         console.warn(
           `transcript: ${sidecarPath2} already exists, skipping (delete to re-transcribe)`
@@ -27872,7 +28162,7 @@ async function captureCommand(target, options = {}) {
         try {
           const json = await getTranscriber().transcribe(absPath);
           const md = renderMarkdown(groupIntoPhrases(json.words ?? []));
-          await writeFile13(sidecarPath2, md, "utf8");
+          await writeFile14(sidecarPath2, md, "utf8");
           console.log(`transcript: ${sidecarPath2}`);
         } catch (err2) {
           if (err2 instanceof TranscribeFfmpegMissingError) {
@@ -27895,7 +28185,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: ${resolve67(resolved.assignmentDir, relativeFilePath)}`);
+      console.log(`  file: ${resolve68(resolved.assignmentDir, relativeFilePath)}`);
     }
   } catch (err2) {
     if (options.stop && kind === "video" && shelloutCleanup && resolvedSource) {
@@ -27918,8 +28208,8 @@ async function captureCommand(target, options = {}) {
 
 // src/commands/proof.ts
 import { Command as Command6 } from "commander";
-import { readFile as readFile44, writeFile as writeFile14, rename as rename9, stat as stat9 } from "fs/promises";
-import { resolve as resolve68, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname19 } from "path";
+import { readFile as readFile45, writeFile as writeFile15, rename as rename9, stat as stat9 } from "fs/promises";
+import { resolve as resolve69, relative as relative5, isAbsolute as isAbsolute11, dirname as dirname19 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 
 // src/utils/acceptance-criteria-parse.ts
@@ -28159,11 +28449,11 @@ function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map(), trans
 
 // src/commands/proof.ts
 async function readAssignmentMeta(assignmentDir) {
-  const path = resolve68(assignmentDir, "assignment.md");
+  const path = resolve69(assignmentDir, "assignment.md");
   if (!await fileExists(path)) {
     return { title: "", body: "" };
   }
-  const content = await readFile44(path, "utf-8");
+  const content = await readFile45(path, "utf-8");
   const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
   let title = "";
   if (fmMatch) {
@@ -28177,7 +28467,7 @@ async function readAssignmentMeta(assignmentDir) {
 }
 async function atomicWrite(destPath, content) {
   const tmp = `${destPath}.${randomBytes4(4).toString("hex")}.tmp`;
-  await writeFile14(tmp, content, "utf-8");
+  await writeFile15(tmp, content, "utf-8");
   await rename9(tmp, destPath);
 }
 function isWithin(root, target) {
@@ -28210,7 +28500,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 = resolve68(assignmentDir, r.file_path);
+    const abs = resolve69(assignmentDir, r.file_path);
     if (!isWithin(proofRoot, abs)) {
       out.set(r.file_path, null);
       continue;
@@ -28225,7 +28515,7 @@ async function loadInlineFiles(rows, assignmentDir) {
       continue;
     }
     try {
-      out.set(r.file_path, await readFile44(abs, "utf-8"));
+      out.set(r.file_path, await readFile45(abs, "utf-8"));
     } catch {
       out.set(r.file_path, null);
     }
@@ -28237,14 +28527,14 @@ async function loadTranscriptSidecars(rows, assignmentDir) {
   const proofRoot = proofDir(assignmentDir);
   for (const r of rows) {
     if (r.kind !== "video" || !r.file_path) continue;
-    const videoAbs = resolve68(assignmentDir, r.file_path);
-    const sidecar = resolve68(dirname19(videoAbs), `${r.id}.transcript.md`);
+    const videoAbs = resolve69(assignmentDir, r.file_path);
+    const sidecar = resolve69(dirname19(videoAbs), `${r.id}.transcript.md`);
     if (!isWithin(proofRoot, sidecar)) continue;
     if (!await fileExists(sidecar)) continue;
     const st = await stat9(sidecar);
     if (st.size > INLINE_TEXT_LIMIT_BYTES) continue;
     try {
-      out.set(r.id, await readFile44(sidecar, "utf-8"));
+      out.set(r.id, await readFile45(sidecar, "utf-8"));
     } catch {
     }
   }
@@ -28278,8 +28568,8 @@ async function proofBuildCommand(target, options = {}) {
   };
   const md = renderProofMarkdown(renderParams);
   const html = renderProofHtml(renderParams, inlineFiles, transcriptSidecars);
-  const mdPath = resolve68(resolved.assignmentDir, "proof.md");
-  const htmlPath = resolve68(resolved.assignmentDir, "proof.html");
+  const mdPath = resolve69(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve69(resolved.assignmentDir, "proof.html");
   await atomicWrite(mdPath, md);
   await atomicWrite(htmlPath, html);
   console.log(`Wrote ${htmlPath}`);
@@ -28944,7 +29234,7 @@ async function runCcusage(opts = {}) {
   };
 }
 function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
-  return new Promise((resolve78) => {
+  return new Promise((resolve79) => {
     const child = spawn9(binary, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -28958,7 +29248,7 @@ function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
       if (settled) return;
       settled = true;
       clearTimeout(timer2);
-      resolve78(result);
+      resolve79(result);
     };
     const timer2 = setTimeout(() => {
       timedOut = true;
@@ -29480,8 +29770,8 @@ init_slug();
 init_timestamp();
 init_assignment_resolver();
 init_assignment_todos();
-import { resolve as resolve69 } from "path";
-import { readFile as readFile45 } from "fs/promises";
+import { resolve as resolve70 } from "path";
+import { readFile as readFile46 } from "fs/promises";
 async function requestCommand(target, text, options = {}) {
   if (!text || !text.trim()) {
     throw new Error("Request text cannot be empty.");
@@ -29497,7 +29787,7 @@ async function requestCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve69(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve70(baseDir, options.project, "assignments", target);
     targetRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -29507,12 +29797,12 @@ async function requestCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const assignmentMdPath2 = resolve69(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`assignment.md not found at ${assignmentMdPath2}`);
   }
   const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile45(assignmentMdPath2, "utf-8");
+  let content = await readFile46(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody(content, [
     { description: `${text.trim()} (from: ${source})` }
   ]);
@@ -29525,13 +29815,13 @@ async function requestCommand(target, text, options = {}) {
 init_fs();
 init_paths();
 import { Command as Command9 } from "commander";
-import { readFile as readFile46, readdir as readdir25 } from "fs/promises";
-import { resolve as resolve70 } from "path";
+import { readFile as readFile47, readdir as readdir25 } from "fs/promises";
+import { resolve as resolve71 } from "path";
 async function readContextAssignmentDir(cwd) {
-  const path = resolve70(cwd, ".syntaur", "context.json");
+  const path = resolve71(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile46(path, "utf-8");
+    const raw = await readFile47(path, "utf-8");
     const ctx = JSON.parse(raw);
     if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
       return ctx.assignmentDir;
@@ -29545,9 +29835,9 @@ async function resolveAssignmentDir(opts) {
   const cwd = opts.cwd ?? process.cwd();
   if (opts.assignment) {
     if (opts.project) {
-      return resolve70(defaultProjectDir(), opts.project, "assignments", opts.assignment);
+      return resolve71(defaultProjectDir(), opts.project, "assignments", opts.assignment);
     }
-    return resolve70(assignmentsDir(), opts.assignment);
+    return resolve71(assignmentsDir(), opts.assignment);
   }
   const fromCtx = await readContextAssignmentDir(cwd);
   if (fromCtx) return fromCtx;
@@ -29690,7 +29980,7 @@ async function runPlanVersion(options) {
   if (!await fileExists(assignmentDir)) {
     throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
   }
-  const assignmentMdPath2 = resolve70(assignmentDir, "assignment.md");
+  const assignmentMdPath2 = resolve71(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath2)) {
     throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
   }
@@ -29702,15 +29992,15 @@ async function runPlanVersion(options) {
   }
   const current = planFiles[planFiles.length - 1];
   const next = nextPlanFileName(current.version);
-  const newPath = resolve70(assignmentDir, next.fileName);
+  const newPath = resolve71(assignmentDir, next.fileName);
   if (await fileExists(newPath) && !options.force) {
     throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
   }
-  const assignmentMd = await readFile46(assignmentMdPath2, "utf-8");
+  const assignmentMd = await readFile47(assignmentMdPath2, "utf-8");
   const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
   const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
-  const oldPlanPath = resolve70(assignmentDir, current.fileName);
-  const oldPlanContent = await readFile46(oldPlanPath, "utf-8");
+  const oldPlanPath = resolve71(assignmentDir, current.fileName);
+  const oldPlanContent = await readFile47(oldPlanPath, "utf-8");
   const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
   const carriedTodos = extractUncheckedTodos(oldBody);
   const stub = buildNewPlanStub({
@@ -29747,26 +30037,26 @@ planCommand.command("version").description(
 // src/commands/session.ts
 init_fs();
 import { Command as Command10 } from "commander";
-import { readFile as readFile47, readdir as readdir26, stat as stat11 } from "fs/promises";
-import { resolve as resolve71 } from "path";
+import { readFile as readFile48, readdir as readdir26, stat as stat11 } from "fs/promises";
+import { resolve as resolve72 } from "path";
 async function readContext(cwd) {
-  const path = resolve71(cwd, ".syntaur", "context.json");
+  const path = resolve72(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    const raw = await readFile47(path, "utf-8");
+    const raw = await readFile48(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function findLatestSessionSummary(assignmentDir) {
-  const sessionsRoot = resolve71(assignmentDir, "sessions");
+  const sessionsRoot = resolve72(assignmentDir, "sessions");
   if (!await fileExists(sessionsRoot)) return null;
   const entries = await readdir26(sessionsRoot, { withFileTypes: true });
   let best = null;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const summaryPath = resolve71(sessionsRoot, entry.name, "summary.md");
+    const summaryPath = resolve72(sessionsRoot, entry.name, "summary.md");
     if (!await fileExists(summaryPath)) continue;
     const st = await stat11(summaryPath);
     if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
@@ -29776,9 +30066,9 @@ async function findLatestSessionSummary(assignmentDir) {
   return best;
 }
 async function findOpenHandoff(assignmentDir) {
-  const handoffPath = resolve71(assignmentDir, "handoff.md");
+  const handoffPath = resolve72(assignmentDir, "handoff.md");
   if (!await fileExists(handoffPath)) return null;
-  const content = await readFile47(handoffPath, "utf-8");
+  const content = await readFile48(handoffPath, "utf-8");
   const body = content.replace(/^---[\s\S]*?\n---\n?/, "").trim();
   if (body.length === 0) return null;
   if (/^<!--[\s\S]*-->$/.test(body)) return null;
@@ -29886,13 +30176,13 @@ init_git_worktree();
 init_fs();
 init_paths();
 import { Command as Command11 } from "commander";
-import { readFile as readFile48 } from "fs/promises";
-import { resolve as resolve72 } from "path";
+import { readFile as readFile49 } from "fs/promises";
+import { resolve as resolve73 } from "path";
 async function readContext2(cwd) {
-  const path = resolve72(cwd, ".syntaur", "context.json");
+  const path = resolve73(cwd, ".syntaur", "context.json");
   if (!await fileExists(path)) return null;
   try {
-    return JSON.parse(await readFile48(path, "utf-8"));
+    return JSON.parse(await readFile49(path, "utf-8"));
   } catch {
     return null;
   }
@@ -29900,7 +30190,7 @@ async function readContext2(cwd) {
 async function resolveAssignmentPath2(opts) {
   if (opts.assignment) {
     if (opts.project) {
-      return resolve72(
+      return resolve73(
         defaultProjectDir(),
         opts.project,
         "assignments",
@@ -29908,10 +30198,10 @@ async function resolveAssignmentPath2(opts) {
         "assignment.md"
       );
     }
-    return resolve72(assignmentsDir(), opts.assignment, "assignment.md");
+    return resolve73(assignmentsDir(), opts.assignment, "assignment.md");
   }
   const ctx = await readContext2(opts.cwd);
-  if (ctx?.assignmentDir) return resolve72(ctx.assignmentDir, "assignment.md");
+  if (ctx?.assignmentDir) return resolve73(ctx.assignmentDir, "assignment.md");
   throw new Error(
     "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
   );
@@ -29922,7 +30212,7 @@ async function runWorktreeCreate(options, cwd = process.cwd()) {
   }
   const repository = options.repository ?? cwd;
   const parentBranch = options.parentBranch ?? "main";
-  const worktreePath = options.worktreePath ?? resolve72(repository, ".worktrees", options.branch);
+  const worktreePath = options.worktreePath ?? resolve73(repository, ".worktrees", options.branch);
   const assignmentPath = await resolveAssignmentPath2({
     assignment: options.assignment,
     project: options.project,
@@ -29959,13 +30249,13 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command12 } from "commander";
-import { resolve as resolve74 } from "path";
+import { resolve as resolve75 } from "path";
 
 // src/utils/project-indexes.ts
 init_parser();
 init_fs();
-import { readdir as readdir27, readFile as readFile49 } from "fs/promises";
-import { resolve as resolve73 } from "path";
+import { readdir as readdir27, readFile as readFile50 } from "fs/promises";
+import { resolve as resolve74 } from "path";
 function nowIso3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -29984,7 +30274,7 @@ function joinList(items) {
   return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
 }
 async function rebuildResourcesIndex(projectDir) {
-  const dir = resolve73(projectDir, "resources");
+  const dir = resolve74(projectDir, "resources");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -30000,7 +30290,7 @@ async function rebuildResourcesIndex(projectDir) {
   lines.push("| Name | Category | Source | Related Assignments | Updated |");
   lines.push("|------|----------|--------|---------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile49(resolve73(dir, fileName), "utf-8");
+    const content = await readFile50(resolve74(dir, fileName), "utf-8");
     const parsed = parseResource(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -30010,12 +30300,12 @@ async function rebuildResourcesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve73(dir, "_index.md");
+  const indexPath = resolve74(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
 async function rebuildMemoriesIndex(projectDir) {
-  const dir = resolve73(projectDir, "memories");
+  const dir = resolve74(projectDir, "memories");
   await ensureDir(dir);
   const files = await listSlugFiles(dir);
   const slug = readProjectSlug(projectDir);
@@ -30031,7 +30321,7 @@ async function rebuildMemoriesIndex(projectDir) {
   lines.push("| Name | Source | Scope | Source Assignment | Updated |");
   lines.push("|------|--------|-------|-------------------|---------|");
   for (const fileName of files) {
-    const content = await readFile49(resolve73(dir, fileName), "utf-8");
+    const content = await readFile50(resolve74(dir, fileName), "utf-8");
     const parsed = parseMemory(content);
     const slugBase = fileName.replace(/\.md$/, "");
     const name = parsed.name || slugBase;
@@ -30041,7 +30331,7 @@ async function rebuildMemoriesIndex(projectDir) {
     );
   }
   lines.push("");
-  const indexPath = resolve73(dir, "_index.md");
+  const indexPath = resolve74(dir, "_index.md");
   await writeFileForce(indexPath, lines.join("\n"));
   return { total: files.length, path: indexPath };
 }
@@ -30079,8 +30369,8 @@ async function runResourceAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve74(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve74(projectDir, "project.md"))) {
+  const projectDir = resolve75(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve75(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -30089,7 +30379,7 @@ async function runResourceAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid resource slug: "${slug}".`);
   }
-  const filePath = resolve74(projectDir, "resources", `${slug}.md`);
+  const filePath = resolve75(projectDir, "resources", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -30124,7 +30414,7 @@ init_paths();
 init_fs();
 init_slug();
 import { Command as Command13 } from "commander";
-import { resolve as resolve75 } from "path";
+import { resolve as resolve76 } from "path";
 function nowIso5() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
@@ -30159,8 +30449,8 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(options.project)) {
     throw new Error(`Invalid project slug: "${options.project}".`);
   }
-  const projectDir = resolve75(defaultProjectDir(), options.project);
-  if (!await fileExists(resolve75(projectDir, "project.md"))) {
+  const projectDir = resolve76(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve76(projectDir, "project.md"))) {
     throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
   }
   if (!options.name) throw new Error("--name is required.");
@@ -30169,7 +30459,7 @@ async function runMemoryAdd(options) {
   if (!isValidSlug(slug)) {
     throw new Error(`Invalid memory slug: "${slug}".`);
   }
-  const filePath = resolve75(projectDir, "memories", `${slug}.md`);
+  const filePath = resolve76(projectDir, "memories", `${slug}.md`);
   if (await fileExists(filePath) && !options.force) {
     throw new Error(
       `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
@@ -30206,8 +30496,8 @@ init_paths();
 init_fs();
 init_frontmatter();
 import { Command as Command14 } from "commander";
-import { readFile as readFile50 } from "fs/promises";
-import { resolve as resolve76 } from "path";
+import { readFile as readFile51 } from "fs/promises";
+import { resolve as resolve77 } from "path";
 var AGE_PATTERN = /^(\d+)([dhwm])$/i;
 function parseAgeToCutoff(age) {
   const match = age.match(AGE_PATTERN);
@@ -30226,7 +30516,7 @@ function parseAgeToCutoff(age) {
 }
 function assignmentMdPath(item) {
   if (item.projectSlug) {
-    return resolve76(
+    return resolve77(
       defaultProjectDir(),
       item.projectSlug,
       "assignments",
@@ -30234,13 +30524,13 @@ function assignmentMdPath(item) {
       "assignment.md"
     );
   }
-  return resolve76(assignmentsDir(), item.id, "assignment.md");
+  return resolve77(assignmentsDir(), item.id, "assignment.md");
 }
 async function loadTags(item) {
   const path = assignmentMdPath(item);
   if (!await fileExists(path)) return [];
   try {
-    const content = await readFile50(path, "utf-8");
+    const content = await readFile51(path, "utf-8");
     return parseAssignmentFrontmatter(content).tags;
   } catch {
     return [];
@@ -30249,7 +30539,8 @@ async function loadTags(item) {
 async function runLs(options) {
   const board = await listAssignmentsBoard(
     defaultProjectDir(),
-    assignmentsDir()
+    assignmentsDir(),
+    { archived: options.archived ? "only" : "exclude" }
   );
   let items = board.assignments;
   if (options.status) {
@@ -30302,7 +30593,7 @@ function renderTable2(items) {
 }
 var lsCommand = new Command14("ls").description(
   "List assignments across all projects with optional filters by status, project, tag, or age."
-).option("--status <list>", "Comma-separated status filter (e.g. pending,in_progress)").option("--project <slug>", "Filter to one project").option("--tag <list>", "Comma-separated tag filter (assignment must have ALL tags)").option("--age <duration>", "Only include assignments updated within duration (e.g. 7d, 24h, 2w, 1m)").option("--json", "Emit JSON instead of a table").action(async (options) => {
+).option("--status <list>", "Comma-separated status filter (e.g. pending,in_progress)").option("--project <slug>", "Filter to one project").option("--tag <list>", "Comma-separated tag filter (assignment must have ALL tags)").option("--age <duration>", "Only include assignments updated within duration (e.g. 7d, 24h, 2w, 1m)").option("--archived", "List only archived assignments (hidden from the default view)").option("--json", "Emit JSON instead of a table").action(async (options) => {
   try {
     const { items } = await runLs(options);
     if (options.json) {
@@ -30358,20 +30649,20 @@ async function getDefaultCommandName() {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath10 } from "url";
-import { readFile as readFile52 } from "fs/promises";
-import { dirname as dirname21, join as join16, resolve as resolve77 } from "path";
+import { readFile as readFile53 } from "fs/promises";
+import { dirname as dirname21, join as join16, resolve as resolve78 } from "path";
 import { spawn as spawn10 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { readFile as readFile51 } from "fs/promises";
+import { readFile as readFile52 } from "fs/promises";
 import { dirname as dirname20, join as join15 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath9(scriptUrl);
     const pkgRoot = dirname20(dirname20(scriptPath));
-    const raw = await readFile51(join15(pkgRoot, "package.json"), "utf-8");
+    const raw = await readFile52(join15(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -30380,7 +30671,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve77(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve78(syntaurRoot(), "npx-install.json");
 var META_ARGS2 = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -30401,7 +30692,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile52(STATE_FILE, "utf-8");
+    const raw = await readFile53(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -30460,7 +30751,7 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join16(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile52(manifestPath, "utf-8");
+    const raw = await readFile53(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -30703,6 +30994,22 @@ program.command("start").description("Transition an assignment to in_progress").
     process.exit(1);
   }
 });
+program.command("archive").description("Archive an assignment or a project (hidden from normal views; restorable)").argument("<target>", "Assignment slug/UUID, or a project slug").option("--project <slug>", "Resolve <target> as an assignment within this project").option("--reason <text>", "Optional reason recorded with the archive").option("--dir <path>", "Override default project directory").action(async (target, options) => {
+  try {
+    await archiveCommand(target, options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("restore").description("Restore an archived assignment or project (preserves prior status)").argument("<target>", "Assignment slug/UUID, or a project slug").option("--project <slug>", "Resolve <target> as an assignment within this project").option("--dir <path>", "Override default project directory").action(async (target, options) => {
+  try {
+    await restoreCommand(target, options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 program.command("shape").description("Transition an assignment from draft to ready_for_planning").argument("<assignment>", "Assignment slug").option("--project <slug>", "Target project slug").option("--agent <name>", "Agent name (sets assignee if not already set)").option("--dir <path>", "Override default project directory").action(async (assignment, options) => {
   try {
     await shapeCommand(assignment, options);