syntaur 0.8.0 → 0.12.0

package/dist/index.js

@@ -16,6 +16,7 @@ __export(paths_exports, {
   expandHome: () => expandHome,
   playbooksDir: () => playbooksDir,
   projectTodosDir: () => projectTodosDir,
+  proofDir: () => proofDir,
   serversDir: () => serversDir,
   syntaurRoot: () => syntaurRoot,
   todoPlanDir: () => todoPlanDir,
@@ -57,6 +58,9 @@ function projectTodosDir(projectsDir2, projectSlug) {
 function todoPlanDir(todosDir2, workspaceOrProject, todoId) {
   return resolve(todosDir2, "plans", workspaceOrProject, todoId);
 }
+function proofDir(assignmentDir) {
+  return resolve(assignmentDir, "proof");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -393,6 +397,7 @@ function parseMemory(fileContent) {
     scope: getField(fm, "scope") ?? "",
     sourceAssignment: getField(fm, "sourceAssignment"),
     relatedAssignments: parseListField(fm, "relatedAssignments"),
+    tags: parseListField(fm, "tags"),
     created: getField(fm, "created") ?? "",
     updated: getField(fm, "updated") ?? "",
     body
@@ -2157,6 +2162,40 @@ var init_decision_record = __esm({
 });
 
 // src/templates/index-stubs.ts
+function renderMemoryStub(params2) {
+  return `---
+type: memory
+name: ${escapeYamlString(params2.name)}
+source: claude
+sourceAssignment: null
+relatedAssignments: []
+scope: project
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
+tags: []
+---
+
+# ${params2.name}
+
+`;
+}
+function renderResourceStub(params2) {
+  return `---
+type: resource
+name: ${escapeYamlString(params2.name)}
+source: claude
+category: documentation
+sourceUrl: null
+sourceAssignment: null
+relatedAssignments: []
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
+---
+
+# ${params2.name}
+
+`;
+}
 function renderIndexAssignments(params2) {
   return `---
 project: ${params2.slug}
@@ -2269,6 +2308,7 @@ total: 0
 var init_index_stubs = __esm({
   "src/templates/index-stubs.ts"() {
     "use strict";
+    init_yaml();
   }
 });
 
@@ -2511,6 +2551,15 @@ If the global Syntaur Codex plugin is installed, prefer these workflows instead
 - \`plan-assignment\` -- write a versioned plan file (\`plan.md\`, \`plan-v2.md\`, ...) and link it from the \`## Todos\` section of \`assignment.md\`
 - \`complete-assignment\` -- write the cross-ticket \`handoff.md\` entry, append a final entry to \`progress.md\`, close the session, and transition state
 - \`save-session-summary\` -- write per-session continuity at \`<assignmentDir>/sessions/<sessionId>/summary.md\` for resume across sessions of the same agent. Codex has no \`PreCompact\` hook event \u2014 invoke this manually before compaction or session end.
+- \`capture-artifacts\` -- capture typed proof artifacts (screenshot/video/asciinema/http/text) for the active assignment. Criterion linkage is optional. Run \`syntaur proof build\` to render \`proof.html\`.
+- \`resume-session\` -- counterpart to \`save-session-summary\`; loads the latest summary, \`.syntaur/context.json\`, and any open handoff so a fresh session re-orients without re-reading the transcript
+- \`replan\` -- bump the active assignment to a new \`plan-v<N>.md\` per the Plan Versioning playbook (CLI does file ops, skill writes the body)
+- \`syntaur-worktree\` -- atomic worktree creation under \`<repository>/.worktrees/<branch>\` plus assign + start + context binding in one move
+- \`add-resource\` -- register a project-level resource (link to dashboard / doc / ticket); CLI regenerates \`_index.md\` server-side
+- \`add-memory\` -- capture a project-level Syntaur memory; CLI regenerates \`_index.md\` server-side (distinct from user-global Claude Code auto-memory)
+- \`list-assignments\` -- cross-project listing with filters by status, project, tag, age (scriptable; not the interactive \`browse\` TUI)
+- \`log-progress\` -- append a timestamped entry to the active \`progress.md\` and bump frontmatter (Keep Records Updated playbook)
+- \`set-workspace\` -- populate the four \`workspace.*\` fields in \`assignment.md\`; validates via \`syntaur doctor --assignment --json\` before writing
 - \`track-session\` -- manage tracked tmux sessions for the dashboard
 
 If the plugin is unavailable, follow the same workflow manually with the \`syntaur\` CLI and keep the protocol files current yourself.
@@ -2639,6 +2688,8 @@ Use the \`syntaur\` CLI for state transitions and coordination:
 - \`syntaur fail ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- mark as failed
 - \`syntaur comment ${params2.assignmentSlug} "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (use for all Q&A; questions support resolve toggle)
 - \`syntaur request ${params2.assignmentSlug} <target-slug-or-uuid> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: ${params2.assignmentSlug})\`
+- \`syntaur capture --kind <screenshot|video|asciinema|http|text> [--file <path>] [--criterion <index>] [--note <text>] ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- record a proof artifact. \`--kind=text\` requires \`--note\` and forbids \`--file\`. Criterion linkage is optional.
+- \`syntaur proof build ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- render \`proof.html\` and \`proof.md\` at the assignment dir. Atomic overwrite \u2014 safe to re-run.
 
 ## Troubleshooting
 
@@ -4456,7 +4507,7 @@ var init_scanner = __esm({
 
 // src/dashboard/api.ts
 import { readdir as readdir7, readFile as readFile9, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve12, dirname as dirname3 } from "path";
+import { resolve as resolve12, dirname as dirname3, basename } from "path";
 async function listStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
@@ -4465,10 +4516,10 @@ async function listStandaloneRecords(assignmentsDir2) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
     const assignmentDir = resolve12(assignmentsDir2, entry.name);
-    const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
-    if (!await fileExists(assignmentMdPath)) continue;
+    const assignmentMdPath2 = resolve12(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath2)) continue;
     try {
-      const content = await readFile9(assignmentMdPath, "utf-8");
+      const content = await readFile9(assignmentMdPath2, "utf-8");
       const record = parseAssignmentFull(content);
       records.push({ assignmentDir, id: entry.name, record });
     } catch {
@@ -4832,11 +4883,11 @@ async function getProjectDetail(projectsDir2, slug) {
 }
 async function getAssignmentDetail(projectsDir2, projectSlug, assignmentSlug) {
   const assignmentDir = resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
-  if (!await fileExists(assignmentMdPath)) {
+  const assignmentMdPath2 = resolve12(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath2)) {
     return null;
   }
-  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
+  const assignmentContent = await readFile9(assignmentMdPath2, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planPath = resolve12(assignmentDir, "plan.md");
@@ -5110,9 +5161,9 @@ async function getAssignmentDetailById(projectsDir2, assignmentsDir2, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve12(assignmentDir, "assignment.md");
-  if (!await fileExists(assignmentMdPath)) return null;
-  const assignmentContent = await readFile9(assignmentMdPath, "utf-8");
+  const assignmentMdPath2 = resolve12(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath2)) return null;
+  const assignmentContent = await readFile9(assignmentMdPath2, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planPath = resolve12(assignmentDir, "plan.md");
@@ -5295,12 +5346,102 @@ async function listMemories(projectPath) {
       source: parsed.source,
       scope: parsed.scope,
       sourceAssignment: parsed.sourceAssignment,
+      relatedAssignments: parsed.relatedAssignments,
       updated: parsed.updated
     });
   }
   results.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return results;
 }
+async function listAllMemories(projectsDir2) {
+  const projectRecords = await listProjectRecords(projectsDir2);
+  const all = [];
+  for (const record of projectRecords) {
+    const memories = await listMemories(record.projectPath);
+    for (const memory of memories) {
+      all.push({
+        ...memory,
+        projectSlug: basename(record.projectPath),
+        projectTitle: record.summary.title
+      });
+    }
+  }
+  all.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return all;
+}
+async function listAllResources(projectsDir2) {
+  const projectRecords = await listProjectRecords(projectsDir2);
+  const all = [];
+  for (const record of projectRecords) {
+    const resources = await listResources(record.projectPath);
+    for (const resource of resources) {
+      all.push({
+        ...resource,
+        projectSlug: basename(record.projectPath),
+        projectTitle: record.summary.title
+      });
+    }
+  }
+  all.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return all;
+}
+async function resolveProjectPath(projectsDir2, projectSlug) {
+  const direct = resolve12(projectsDir2, projectSlug);
+  if (await fileExists(resolve12(direct, "project.md"))) return direct;
+  const records = await listProjectRecords(projectsDir2);
+  const match = records.find((r) => r.summary.slug === projectSlug);
+  return match ? match.projectPath : null;
+}
+async function getMemoryDetail(projectsDir2, projectSlug, itemSlug) {
+  if (itemSlug.startsWith("_")) return null;
+  const projectRecords = await listProjectRecords(projectsDir2);
+  const projectRecord = projectRecords.find(
+    (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
+  );
+  if (!projectRecord) return null;
+  const filePath = resolve12(projectRecord.projectPath, "memories", `${itemSlug}.md`);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile9(filePath, "utf-8");
+  const parsed = parseMemory(content);
+  return {
+    name: parsed.name,
+    slug: itemSlug,
+    source: parsed.source,
+    scope: parsed.scope,
+    sourceAssignment: parsed.sourceAssignment,
+    relatedAssignments: parsed.relatedAssignments,
+    updated: parsed.updated,
+    created: parsed.created,
+    body: parsed.body,
+    tags: parsed.tags,
+    projectSlug: basename(projectRecord.projectPath),
+    projectTitle: projectRecord.summary.title
+  };
+}
+async function getResourceDetail(projectsDir2, projectSlug, itemSlug) {
+  if (itemSlug.startsWith("_")) return null;
+  const projectRecords = await listProjectRecords(projectsDir2);
+  const projectRecord = projectRecords.find(
+    (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
+  );
+  if (!projectRecord) return null;
+  const filePath = resolve12(projectRecord.projectPath, "resources", `${itemSlug}.md`);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile9(filePath, "utf-8");
+  const parsed = parseResource(content);
+  return {
+    name: parsed.name,
+    slug: itemSlug,
+    category: parsed.category,
+    source: parsed.source,
+    relatedAssignments: parsed.relatedAssignments,
+    updated: parsed.updated,
+    created: parsed.created,
+    body: parsed.body,
+    projectSlug: basename(projectRecord.projectPath),
+    projectTitle: projectRecord.summary.title
+  };
+}
 async function loadDependencyGraph(projectPath, assignments) {
   const statusPath = resolve12(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
@@ -5636,6 +5777,10 @@ function getDocumentPath(projectsDir2, documentType, projectSlug, assignmentSlug
       return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
       return assignmentSlug ? resolve12(projectsDir2, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+    case "memory":
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "memories", `${assignmentSlug}.md`) : null;
+    case "resource":
+      return assignmentSlug ? resolve12(projectsDir2, projectSlug, "resources", `${assignmentSlug}.md`) : null;
     default:
       return null;
   }
@@ -5656,6 +5801,10 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
       return `Append Decision: ${assignmentSlug || "assignment"}`;
     case "playbook":
       return `Edit Playbook: ${projectSlug}`;
+    case "memory":
+      return `Edit Memory: ${assignmentSlug || "memory"}`;
+    case "resource":
+      return `Edit Resource: ${assignmentSlug || "resource"}`;
     default:
       return projectSlug;
   }
@@ -6933,7 +7082,7 @@ var init_git_worktree = __esm({
 });
 
 // src/index.ts
-import { Command as Command5 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/init.ts
 init_paths();
@@ -7263,8 +7412,8 @@ async function migrateFromMarkdown(projectsDir2) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile35 } = await import("fs/promises");
-  const raw = await readFile35(filePath, "utf-8");
+  const { readFile: readFile43 } = await import("fs/promises");
+  const raw = await readFile43(filePath, "utf-8");
   const sessions = [];
   const lines = raw.split("\n");
   let inTable = false;
@@ -7315,8 +7464,8 @@ function rowToSession(row) {
   };
 }
 async function appendSession(_projectDir, session) {
-  const db2 = getSessionDb();
-  db2.prepare(`
+  const db3 = getSessionDb();
+  db3.prepare(`
     INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
@@ -7341,42 +7490,42 @@ async function appendSession(_projectDir, session) {
   );
 }
 async function updateSessionStatus(_projectDir, sessionId, status) {
-  const db2 = getSessionDb();
+  const db3 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
-  const result = isTerminal ? db2.prepare(
+  const result = isTerminal ? db3.prepare(
     "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId) : db2.prepare(
+  ).run(status, sessionId) : db3.prepare(
     "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
   ).run(status, sessionId);
   return result.changes > 0;
 }
 async function listAllSessions(_projectsDir) {
-  const db2 = getSessionDb();
-  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  const db3 = getSessionDb();
+  const rows = db3.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
   return rows.map(rowToSession);
 }
 async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
-  const db2 = getSessionDb();
+  const db3 = getSessionDb();
   if (assignmentSlug) {
-    const rows2 = db2.prepare(
+    const rows2 = db3.prepare(
       "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
     ).all(projectSlug, assignmentSlug);
     return rows2.map(rowToSession);
   }
-  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db3.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
   return rows.map(rowToSession);
 }
 async function deleteSessions(sessionIds) {
   if (sessionIds.length === 0) return 0;
-  const db2 = getSessionDb();
+  const db3 = getSessionDb();
   const placeholders = sessionIds.map(() => "?").join(", ");
-  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+  const result = db3.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
   return result.changes;
 }
 var DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
-async function readAssignmentStatusFromPath(assignmentMdPath) {
-  if (!await fileExists(assignmentMdPath)) return null;
-  const raw = await readFile10(assignmentMdPath, "utf-8");
+async function readAssignmentStatusFromPath(assignmentMdPath2) {
+  if (!await fileExists(assignmentMdPath2)) return null;
+  const raw = await readFile10(assignmentMdPath2, "utf-8");
   const match = raw.match(/^status:\s*(.+)$/m);
   return match ? match[1].trim() : null;
 }
@@ -7386,8 +7535,8 @@ async function readAssignmentStatus(projectDir, assignmentSlug) {
   );
 }
 async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
-  const db2 = getSessionDb();
-  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  const db3 = getSessionDb();
+  const activeSessions = db3.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
   if (activeSessions.length === 0) return 0;
   const assignmentStatuses = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
@@ -7424,10 +7573,10 @@ async function reconcileActiveSessions(projectsDir2, assignmentsDir2) {
   return totalUpdated;
 }
 async function listSessionsByAssignment(projectSlug, assignmentSlug) {
-  const db2 = getSessionDb();
-  const rows = projectSlug === null ? db2.prepare(
+  const db3 = getSessionDb();
+  const rows = projectSlug === null ? db3.prepare(
     "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
-  ).all(assignmentSlug) : db2.prepare(
+  ).all(assignmentSlug) : db3.prepare(
     "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
   ).all(projectSlug, assignmentSlug);
   return rows.map(rowToSession);
@@ -7633,8 +7782,8 @@ init_timestamp();
 init_fs();
 init_parser();
 import { Router } from "express";
-import { resolve as resolve15 } from "path";
-import { rm, readFile as readFile11 } from "fs/promises";
+import { resolve as resolve15, basename as basename2 } from "path";
+import { rm, readFile as readFile11, open as fsOpen } from "fs/promises";
 
 // src/dashboard/acceptance-criteria.ts
 function splitFrontmatter(content) {
@@ -7906,6 +8055,210 @@ function createWriteRouter(projectsDir2, assignmentsDir2) {
     }
     res.json(document);
   });
+  router.get("/api/projects/:slug/memories/:itemSlug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const itemSlug = getParam(req.params.itemSlug);
+    if (!isValidSlug(itemSlug)) {
+      res.status(400).json({ error: "Invalid memory slug." });
+      return;
+    }
+    const projectDir = await resolveProjectPath(projectsDir2, slug);
+    if (!projectDir) {
+      res.status(404).json({ error: `Project "${slug}" not found` });
+      return;
+    }
+    const document = await getEditableDocument(projectsDir2, "memory", basename2(projectDir), itemSlug);
+    if (!document) {
+      res.status(404).json({ error: "Memory not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/resources/:itemSlug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const itemSlug = getParam(req.params.itemSlug);
+    if (!isValidSlug(itemSlug)) {
+      res.status(400).json({ error: "Invalid resource slug." });
+      return;
+    }
+    const projectDir = await resolveProjectPath(projectsDir2, slug);
+    if (!projectDir) {
+      res.status(404).json({ error: `Project "${slug}" not found` });
+      return;
+    }
+    const document = await getEditableDocument(projectsDir2, "resource", basename2(projectDir), itemSlug);
+    if (!document) {
+      res.status(404).json({ error: "Resource not found" });
+      return;
+    }
+    res.json(document);
+  });
+  function itemFolder(kind) {
+    return kind === "memory" ? "memories" : "resources";
+  }
+  function renderItemStub(kind, params2) {
+    return kind === "memory" ? renderMemoryStub(params2) : renderResourceStub(params2);
+  }
+  function replaceStubBody(stub, body) {
+    const match = stub.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n)/);
+    if (!match) return stub;
+    return `${match[1]}
+${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"}`;
+  }
+  function extractFrontmatterBlock(content) {
+    const match = content.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n)/);
+    return match ? match[1] : null;
+  }
+  function parseItem(kind, content) {
+    return kind === "memory" ? parseMemory(content) : parseResource(content);
+  }
+  async function getItemDetail(kind, projectSlug, itemSlug) {
+    return kind === "memory" ? await getMemoryDetail(projectsDir2, projectSlug, itemSlug) : await getResourceDetail(projectsDir2, projectSlug, itemSlug);
+  }
+  async function resolveProjectDir(projectSlug) {
+    return resolveProjectPath(projectsDir2, projectSlug);
+  }
+  function rejectBadItemSlug(itemSlug, kind, res) {
+    if (isValidSlug(itemSlug)) return false;
+    res.status(400).json({
+      error: `Invalid ${kind} slug "${itemSlug}". Slugs must be lowercase letters, numbers, and hyphens only.`
+    });
+    return true;
+  }
+  for (const kind of ["memory", "resource"]) {
+    const folder = itemFolder(kind);
+    router.get(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const detail = await getItemDetail(kind, projectSlug, itemSlug);
+        if (!detail) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        res.json(detail);
+      } catch (error) {
+        console.error(`Error fetching ${kind} detail:`, error);
+        res.status(500).json({ error: `Failed to load ${kind}: ${error.message}` });
+      }
+    });
+    router.post(`/api/projects/:slug/${folder}`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const body = req.body ?? {};
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        if (!name) {
+          res.status(400).json({ error: "Name is required." });
+          return;
+        }
+        const requestedSlug = typeof body.slug === "string" && body.slug.trim() ? body.slug.trim() : slugify(name);
+        if (!requestedSlug || !isValidSlug(requestedSlug)) {
+          res.status(400).json({
+            error: `Slug "${requestedSlug}" is invalid. Slugs must be lowercase letters, numbers, and hyphens only.`
+          });
+          return;
+        }
+        const folderPath = resolve15(projectDir, folder);
+        await ensureDir(folderPath);
+        const filePath = resolve15(folderPath, `${requestedSlug}.md`);
+        const timestamp = nowTimestamp();
+        let content = renderItemStub(kind, {
+          slug: requestedSlug,
+          name,
+          projectSlug: basename2(projectDir),
+          timestamp
+        });
+        const customBody = typeof body.body === "string" ? body.body : "";
+        if (customBody.trim()) {
+          content = replaceStubBody(content, customBody);
+        }
+        try {
+          const handle = await fsOpen(filePath, "wx");
+          try {
+            await handle.writeFile(content, "utf-8");
+          } finally {
+            await handle.close();
+          }
+        } catch (err2) {
+          if (err2.code === "EEXIST") {
+            res.status(409).json({
+              error: `${kind === "memory" ? "Memory" : "Resource"} with slug "${requestedSlug}" already exists in project "${basename2(projectDir)}".`
+            });
+            return;
+          }
+          throw err2;
+        }
+        res.status(201).json({ slug: requestedSlug, projectSlug: basename2(projectDir), content });
+      } catch (error) {
+        console.error(`Error creating ${kind}:`, error);
+        res.status(500).json({ error: `Failed to create ${kind}: ${error.message}` });
+      }
+    });
+    router.patch(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const filePath = resolve15(projectDir, folder, `${itemSlug}.md`);
+        if (!await fileExists(filePath)) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        const nextContentRaw = requireContent(req, res);
+        if (!nextContentRaw) return;
+        const currentContent = await readFile11(filePath, "utf-8");
+        const frontmatterBlock = extractFrontmatterBlock(currentContent);
+        if (!frontmatterBlock) {
+          res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
+          return;
+        }
+        const next = parseItem(kind, nextContentRaw);
+        const nextBody = next.body.trimStart();
+        let merged = `${frontmatterBlock}
+${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
+        merged = setTopLevelField(merged, "updated", nowTimestamp());
+        await writeFileForce(filePath, merged);
+        const detail = await getItemDetail(kind, basename2(projectDir), itemSlug);
+        res.json({ [kind]: detail, content: merged });
+      } catch (error) {
+        console.error(`Error updating ${kind}:`, error);
+        res.status(500).json({ error: `Failed to update ${kind}: ${error.message}` });
+      }
+    });
+    router.delete(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const filePath = resolve15(projectDir, folder, `${itemSlug}.md`);
+        if (!await fileExists(filePath)) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        await rm(filePath);
+        res.status(204).end();
+      } catch (error) {
+        console.error(`Error deleting ${kind}:`, error);
+        res.status(500).json({ error: `Failed to delete ${kind}: ${error.message}` });
+      }
+    });
+  }
   router.post("/api/projects", async (req, res) => {
     try {
       const content = requireContent(req, res);
@@ -9736,8 +10089,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: resolve50 } = await import("path");
-      const { readFile: readFile35 } = await import("fs/promises");
+      const { resolve: resolve62 } = await import("path");
+      const { readFile: readFile43 } = 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);
@@ -9753,10 +10106,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir2) {
         (e) => e.itemIds.every((id) => completedIds.has(id))
       );
       const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-      await ensureDir(resolve50(todosDir2, "archive"));
+      await ensureDir(resolve62(todosDir2, "archive"));
       let archContent = "";
       if (await fileExists(archFile)) {
-        archContent = await readFile35(archFile, "utf-8");
+        archContent = await readFile43(archFile, "utf-8");
         archContent = archContent.trimEnd() + "\n\n";
       } else {
         archContent = `---
@@ -10015,7 +10368,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: readFile35 } = await import("fs/promises");
+        const { readFile: readFile43 } = 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;
@@ -10049,11 +10402,11 @@ workspace: ${workspace}
           } else {
             return { error: `Invalid target.assignment "${tg}"` };
           }
-          const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
-          if (!await fileExists2(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
+          const assignmentMdPath3 = resolvePath2(assignmentDir, "assignment.md");
+          if (!await fileExists2(assignmentMdPath3)) return { error: `Target assignment not found: ${assignmentMdPath3}` };
         }
-        const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
-        let content = await readFile35(assignmentMdPath, "utf-8");
+        const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
+        let content = await readFile43(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -10062,7 +10415,7 @@ workspace: ${workspace}
           }))
         );
         content = touchAssignmentUpdated2(content, nowTimestamp3());
-        await writeFileForce2(assignmentMdPath, content);
+        await writeFileForce2(assignmentMdPath2, content);
         if (!keepSource) {
           for (const item of items) {
             item.status = "completed";
@@ -10902,11 +11255,11 @@ workspace: ${slug}
           } else {
             return { error: `Invalid target.assignment "${tg}"` };
           }
-          const assignmentMdPath2 = resolve19(assignmentDir, "assignment.md");
-          if (!await fileExists(assignmentMdPath2)) return { error: `Target assignment not found: ${assignmentMdPath2}` };
+          const assignmentMdPath3 = resolve19(assignmentDir, "assignment.md");
+          if (!await fileExists(assignmentMdPath3)) return { error: `Target assignment not found: ${assignmentMdPath3}` };
         }
-        const assignmentMdPath = resolve19(assignmentDir, "assignment.md");
-        let content = await readFile14(assignmentMdPath, "utf-8");
+        const assignmentMdPath2 = resolve19(assignmentDir, "assignment.md");
+        let content = await readFile14(assignmentMdPath2, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -10915,7 +11268,7 @@ workspace: ${slug}
           }))
         );
         content = touchAssignmentUpdated2(content, nowTimestamp3());
-        await writeFileForce(assignmentMdPath, content);
+        await writeFileForce(assignmentMdPath2, content);
         if (!keepSource) {
           for (const item of items) {
             item.status = "completed";
@@ -12077,6 +12430,24 @@ function createDashboardServer(options) {
   app.use("/api/servers", createServersRouter(serversDir2, projectsDir2, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir2, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir3));
+  app.get("/api/memories", async (_req, res) => {
+    try {
+      const memories = await listAllMemories(projectsDir2);
+      res.json({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), memories });
+    } catch (error) {
+      console.error("Error listing memories:", error);
+      res.status(500).json({ error: `Failed to load memories: ${error.message}` });
+    }
+  });
+  app.get("/api/resources", async (_req, res) => {
+    try {
+      const resources = await listAllResources(projectsDir2);
+      res.json({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), resources });
+    } catch (error) {
+      console.error("Error listing resources:", error);
+      res.status(500).json({ error: `Failed to load resources: ${error.message}` });
+    }
+  });
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast, projectsDir2));
   app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir2, broadcast, todosDir2));
   app.use("/api/backup", createBackupRouter());
@@ -12454,7 +12825,7 @@ import {
 } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname8, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve25 } from "path";
+import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve25 } from "path";
 
 // src/utils/package-root.ts
 init_fs();
@@ -12916,7 +13287,7 @@ async function ensureClaudeUserMarketplace() {
 async function detectClaudeMarketplaceForTarget(targetDir) {
   const normalizedTargetDir = normalizeAbsoluteInstallPath(targetDir, "Claude plugin target");
   const pluginsDir = dirname8(normalizedTargetDir);
-  if (basename(pluginsDir) !== "plugins") {
+  if (basename3(pluginsDir) !== "plugins") {
     return null;
   }
   const rootDir = dirname8(pluginsDir);
@@ -12925,7 +13296,7 @@ async function detectClaudeMarketplaceForTarget(targetDir) {
     return null;
   }
   const marketplace = await readClaudeMarketplaceFile(manifestPath);
-  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename(rootDir);
+  const name = typeof marketplace.name === "string" && marketplace.name.trim() !== "" ? marketplace.name : basename3(rootDir);
   return {
     name,
     rootDir,
@@ -13396,7 +13767,16 @@ var KNOWN_SKILL_NAMES = [
   "clear-assignment",
   "save-session-summary",
   "track-session",
-  "track-server"
+  "track-server",
+  "capture-artifacts",
+  "replan",
+  "resume-session",
+  "syntaur-worktree",
+  "add-resource",
+  "add-memory",
+  "list-assignments",
+  "log-progress",
+  "set-workspace"
 ];
 var KNOWN_SKILLS = KNOWN_SKILL_NAMES;
 async function getSkillsDir() {
@@ -13459,8 +13839,8 @@ async function skillMatches(srcDir, destDir) {
 }
 async function isSymlink(path) {
   try {
-    const stat6 = await lstat2(path);
-    return stat6.isSymbolicLink();
+    const stat9 = await lstat2(path);
+    return stat9.isSymbolicLink();
   } catch {
     return false;
   }
@@ -13728,7 +14108,7 @@ async function installPluginCommand(options) {
     }
   }
   console.log("\nThe plugin is now available in Claude Code.");
-  console.log("  Slash commands: /grab-assignment, /plan-assignment, /complete-assignment, /create-assignment, /create-project, /track-session, /clear-assignment, /manage-statuses");
+  console.log("  Slash commands: /grab-assignment, /plan-assignment, /complete-assignment, /create-assignment, /create-project, /track-session, /clear-assignment, /manage-statuses, /replan, /resume-session, /syntaur-worktree, /add-resource, /add-memory, /list-assignments, /log-progress, /set-workspace");
   console.log("  Background: syntaur-protocol skill (auto-invoked)");
   console.log("  Hook: write boundary enforcement (PreToolUse) + SessionStart/End");
 }
@@ -14281,10 +14661,10 @@ async function installCodexPluginCommand(options) {
   }
   console.log("\nThe plugin is now available to Codex.");
   console.log(
-    "  Protocol skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment, save-session-summary"
+    "  Protocol skills: syntaur-protocol, create-project, create-assignment, grab-assignment, plan-assignment, complete-assignment, save-session-summary, manage-statuses, clear-assignment, replan, resume-session, syntaur-worktree, add-resource, add-memory, list-assignments, log-progress, set-workspace"
   );
   console.log("  Codex-specific: track-session skill (rollout path aware)");
-  console.log("  Slash commands: /track-session, /save-session-summary (no PreCompact hook on Codex \u2014 invoke manually before compaction)");
+  console.log("  Slash commands: /track-session, /save-session-summary, /replan, /resume-session, /syntaur-worktree, /add-resource, /add-memory, /list-assignments, /log-progress, /set-workspace (no PreCompact hook on Codex \u2014 invoke save-session-summary manually before compaction)");
   console.log("  Hooks: write boundary enforcement, session cleanup");
 }
 
@@ -14562,8 +14942,8 @@ async function setupAdapterCommand(framework, options) {
       `Project "${options.project}" not found at ${projectDir}.`
     );
   }
-  const assignmentMdPath = resolve31(assignmentDir, "assignment.md");
-  if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath)) {
+  const assignmentMdPath2 = resolve31(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentDir) || !await fileExists(assignmentMdPath2)) {
     throw new Error(
       `Assignment "${options.assignment}" not found at ${assignmentDir}.`
     );
@@ -14821,7 +15201,7 @@ function computeWorktreeDefaults(opts) {
   const repository = opts.existing.repository ?? detectCurrentGitRoot();
   const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
   const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch() ?? "main";
-  const worktreeBase = resolve34(
+  const worktreeBase = repository ? resolve34(repository, ".worktrees", branch) : resolve34(
     syntaurRoot(),
     "worktrees",
     opts.projectSlug || "standalone",
@@ -15524,9 +15904,9 @@ async function promoteTodos(ids, options) {
     throw new Error(`Invalid --to-assignment target "${target}". Use <project>/<slug> or a bare UUID.`);
   }
   const { fileExists: fileExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
-  if (!await fileExists2(assignmentMdPath)) {
-    throw new Error(`Target assignment not found: ${assignmentMdPath}`);
+  const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
+  if (!await fileExists2(assignmentMdPath2)) {
+    throw new Error(`Target assignment not found: ${assignmentMdPath2}`);
   }
   await injectPromotedTodos(assignmentDir, todos, scopeLabel);
   if (!options.keepSource) {
@@ -15541,12 +15921,12 @@ function describeScope(scope) {
 }
 async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
   const { resolve: resolvePath2 } = await import("path");
-  const { readFile: readFile35 } = await import("fs/promises");
+  const { readFile: readFile43 } = 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 assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
-  let content = await readFile35(assignmentMdPath, "utf-8");
+  const assignmentMdPath2 = resolvePath2(assignmentDir, "assignment.md");
+  let content = await readFile43(assignmentMdPath2, "utf-8");
   content = appendTodosToAssignmentBody2(
     content,
     todos.map((t) => ({
@@ -15555,7 +15935,7 @@ async function injectPromotedTodos(assignmentDir, todos, scopeLabel) {
     }))
   );
   content = touchAssignmentUpdated2(content, nowTimestamp3());
-  await writeFileForce2(assignmentMdPath, content);
+  await writeFileForce2(assignmentMdPath2, content);
 }
 async function markPromotedComplete(todos, todosPath, workspace, checklist, _scope, summary) {
   for (const item of todos) {
@@ -15591,8 +15971,8 @@ todoCommand.command("plan").description("Create or open a plan directory for a t
     }
     const planDir = todoPlanDir(todosPath, workspace, id);
     await ensureDir(planDir);
-    const { readdir: readdir19 } = await import("fs/promises");
-    const existingFiles = (await readdir19(planDir).catch(() => [])).filter(
+    const { readdir: readdir22 } = await import("fs/promises");
+    const existingFiles = (await readdir22(planDir).catch(() => [])).filter(
       (f) => /^plan(?:-v\d+)?\.md$/.test(f)
     );
     let target;
@@ -15677,10 +16057,10 @@ async function moveTodo(id, options) {
     if (await fileExists(newPlanDir)) {
       throw new Error(`Plan directory already exists at target: ${newPlanDir}; refusing to move.`);
     }
-    const { rename: rename7, mkdir: mkdir7 } = await import("fs/promises");
+    const { rename: rename8, mkdir: mkdir8 } = await import("fs/promises");
     const { dirname: dirname16 } = await import("path");
-    await mkdir7(dirname16(newPlanDir), { recursive: true });
-    await rename7(item.planDir, newPlanDir);
+    await mkdir8(dirname16(newPlanDir), { recursive: true });
+    await rename8(item.planDir, newPlanDir);
     item.planDir = newPlanDir;
   }
   sourceChecklist.items.splice(idx, 1);
@@ -15796,6 +16176,8 @@ backupCommand.command("config").description("Show or update backup configuration
 
 // src/commands/doctor.ts
 import { Command as Command3 } from "commander";
+import { readFile as readFile31 } from "fs/promises";
+import { isAbsolute as isAbsolute7, resolve as resolve47 } from "path";
 
 // src/utils/doctor/index.ts
 import { fileURLToPath as fileURLToPath6 } from "url";
@@ -15812,14 +16194,14 @@ async function buildCheckContext(cwd = process.cwd()) {
   const config = await readConfig();
   const root = syntaurRoot();
   const dbPath = resolve38(root, "syntaur.db");
-  let db2 = null;
+  let db3 = null;
   let dbError = null;
   if (await fileExists(dbPath)) {
     try {
-      db2 = new Database2(dbPath, { readonly: true, fileMustExist: true });
+      db3 = new Database2(dbPath, { readonly: true, fileMustExist: true });
     } catch (err2) {
       dbError = err2 instanceof Error ? err2.message : String(err2);
-      db2 = null;
+      db3 = null;
     }
   } else {
     dbError = `database file not found at ${dbPath}`;
@@ -15827,7 +16209,7 @@ async function buildCheckContext(cwd = process.cwd()) {
   return {
     config,
     syntaurRoot: root,
-    db: db2,
+    db: db3,
     dbError,
     cwd,
     now: /* @__PURE__ */ new Date()
@@ -17121,7 +17503,7 @@ function skipped(check, reason) {
 
 // src/utils/doctor/checks/integrations.ts
 init_fs();
-import { resolve as resolve44, dirname as dirname12, basename as basename2 } from "path";
+import { resolve as resolve44, dirname as dirname12, basename as basename4 } from "path";
 import { readdir as readdir16, readFile as readFile27 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 var CATEGORY6 = "integrations";
@@ -17224,7 +17606,7 @@ var claudeMarketplaceRegistered = {
       return skipped2(this, "claudePluginDir does not exist (run install-plugin)");
     }
     const pluginsParent = dirname12(dir);
-    if (basename2(pluginsParent) !== "plugins") {
+    if (basename4(pluginsParent) !== "plugins") {
       return {
         id: this.id,
         category: this.category,
@@ -17272,7 +17654,7 @@ var claudeMarketplaceRegistered = {
         autoFixable: false
       };
     }
-    const marketplaceName = parsed.name ?? basename2(marketplaceRoot);
+    const marketplaceName = parsed.name ?? basename4(marketplaceRoot);
     const hasSyntaurEntry = (parsed.plugins ?? []).some((p) => p?.name === "syntaur");
     const known = await readKnownMarketplaces();
     const registered = known[marketplaceName]?.installLocation === marketplaceRoot || Object.values(known).some((v) => v.installLocation === marketplaceRoot);
@@ -17865,7 +18247,93 @@ function renderJson(report) {
 // src/commands/doctor.ts
 init_fs();
 init_paths();
-var doctorCommand = new Command3("doctor").description("Diagnose Syntaur state and surface issues with suggested fixes").option("--json", "Emit structured JSON for programmatic consumers").option("--fix", "Apply safe auto-fixes (v1: no-op; reserved for future checks)").option("--only <check-id>", "Run only the check with this ID").option("--verbose", "Include passing checks in human output").action(async (options) => {
+init_frontmatter();
+var REQUIRED_WORKSPACE_FIELDS = [
+  "repository",
+  "worktreePath",
+  "branch",
+  "parentBranch"
+];
+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 = isAbsolute7(inputPath) ? inputPath : resolve47(cwd, inputPath);
+  const errors = [];
+  const warnings = [];
+  if (!await fileExists(absolute)) {
+    return {
+      ok: false,
+      path: absolute,
+      errors: [`File does not exist: ${absolute}`],
+      warnings: []
+    };
+  }
+  let content;
+  try {
+    content = await readFile31(absolute, "utf-8");
+  } catch (err2) {
+    return {
+      ok: false,
+      path: absolute,
+      errors: [
+        `Could not read file: ${err2 instanceof Error ? err2.message : String(err2)}`
+      ],
+      warnings: []
+    };
+  }
+  if (!content.startsWith("---")) {
+    errors.push("Missing YAML frontmatter \u2014 file does not start with `---`.");
+  }
+  let parsed;
+  try {
+    parsed = parseAssignmentFrontmatter(content);
+  } catch (err2) {
+    errors.push(
+      `Frontmatter parse error: ${err2 instanceof Error ? err2.message : String(err2)}`
+    );
+    return { ok: false, path: absolute, errors, warnings };
+  }
+  if (!parsed.id) errors.push("Missing or empty `id` field.");
+  if (!parsed.slug) errors.push("Missing or empty `slug` field.");
+  if (!parsed.title) errors.push("Missing or empty `title` field.");
+  if (!parsed.status) errors.push("Missing or empty `status` field.");
+  if (!parsed.created) errors.push("Missing or empty `created` field.");
+  else if (!ISO_DATE.test(parsed.created))
+    warnings.push(`Field \`created\` is not ISO 8601: "${parsed.created}".`);
+  if (!parsed.updated) errors.push("Missing or empty `updated` field.");
+  else if (!ISO_DATE.test(parsed.updated))
+    warnings.push(`Field \`updated\` is not ISO 8601: "${parsed.updated}".`);
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  const fmText = fmMatch ? fmMatch[1] : "";
+  for (const key of REQUIRED_WORKSPACE_FIELDS) {
+    if (!new RegExp(`^\\s+${key}:`, "m").test(fmText)) {
+      errors.push(`Workspace block is missing required field \`${key}\`.`);
+    }
+  }
+  return { ok: errors.length === 0, path: absolute, errors, warnings };
+}
+var doctorCommand = new Command3("doctor").description("Diagnose Syntaur state and surface issues with suggested fixes").option("--json", "Emit structured JSON for programmatic consumers").option("--fix", "Apply safe auto-fixes (v1: no-op; reserved for future checks)").option("--only <check-id>", "Run only the check with this ID").option("--verbose", "Include passing checks in human output").option(
+  "--assignment <path>",
+  "Validate a single assignment.md frontmatter and exit (used by set-workspace skill pre-write)"
+).action(async (options) => {
+  if (options.assignment) {
+    const result = await validateAssignmentFile(options.assignment);
+    if (options.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    } else if (result.ok) {
+      process.stdout.write(`OK ${result.path}
+`);
+      for (const w of result.warnings) process.stdout.write(`  warn: ${w}
+`);
+    } else {
+      process.stderr.write(`FAIL ${result.path}
+`);
+      for (const e of result.errors) process.stderr.write(`  error: ${e}
+`);
+      for (const w of result.warnings) process.stderr.write(`  warn: ${w}
+`);
+    }
+    process.exit(result.ok ? 0 : 1);
+  }
   if (!await fileExists(syntaurRoot())) {
     const msg = "~/.syntaur/ does not exist. Run `syntaur init` first.";
     if (options.json) {
@@ -18125,8 +18593,8 @@ init_uuid();
 init_timestamp();
 init_assignment_resolver();
 init_templates();
-import { resolve as resolve47 } from "path";
-import { readFile as readFile31 } from "fs/promises";
+import { resolve as resolve48 } from "path";
+import { readFile as readFile32 } from "fs/promises";
 function shortId() {
   return generateId().split("-")[0];
 }
@@ -18156,7 +18624,7 @@ async function commentCommand(target, text, options = {}) {
     if (!isValidSlug(target)) {
       throw new Error(`Invalid assignment slug "${target}".`);
     }
-    assignmentDir = resolve47(baseDir, options.project, "assignments", target);
+    assignmentDir = resolve48(baseDir, options.project, "assignments", target);
     assignmentRef = target;
   } else {
     const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
@@ -18166,13 +18634,13 @@ async function commentCommand(target, text, options = {}) {
     assignmentDir = resolved.assignmentDir;
     assignmentRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
   }
-  const commentsPath = resolve47(assignmentDir, "comments.md");
+  const commentsPath = resolve48(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 readFile31(commentsPath, "utf-8");
+    currentContent = await readFile32(commentsPath, "utf-8");
     const countMatch = currentContent.match(/^entryCount:\s*(\d+)/m);
     if (countMatch) currentCount = parseInt(countMatch[1], 10);
   } else {
@@ -18205,77 +18673,1578 @@ ${entry}`;
   }
 }
 
-// src/commands/request.ts
+// src/commands/capture.ts
+import { resolve as resolve51, relative as relative4 } from "path";
+import { copyFile as copyFile3, mkdir as mkdir7, realpath as realpath2, stat as stat6 } from "fs/promises";
+
+// src/utils/assignment-target.ts
 init_paths();
 init_fs();
 init_config2();
 init_slug();
-init_timestamp();
 init_assignment_resolver();
-init_assignment_todos();
-import { resolve as resolve48 } from "path";
-import { readFile as readFile32 } from "fs/promises";
-async function requestCommand(target, text, options = {}) {
-  if (!text || !text.trim()) {
-    throw new Error("Request text cannot be empty.");
-  }
-  const config = await readConfig();
-  const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
-  let assignmentDir;
-  let targetRef;
-  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}".`);
-    }
-    assignmentDir = resolve48(baseDir, options.project, "assignments", target);
-    targetRef = target;
-  } else {
-    const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
-    if (!resolved) {
-      throw new Error(`Target assignment "${target}" not found. Provide --project <slug> or a valid UUID.`);
-    }
-    assignmentDir = resolved.assignmentDir;
-    targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
-  }
-  const assignmentMdPath = resolve48(assignmentDir, "assignment.md");
-  if (!await fileExists(assignmentMdPath)) {
-    throw new Error(`assignment.md not found at ${assignmentMdPath}`);
+init_parser();
+import { resolve as resolve49 } from "path";
+import { readFile as readFile33 } from "fs/promises";
+var AssignmentTargetError = class extends Error {
+};
+async function readAssignmentFrontmatterId(assignmentDir) {
+  const path = resolve49(assignmentDir, "assignment.md");
+  if (!await fileExists(path)) return null;
+  try {
+    const content = await readFile33(path, "utf-8");
+    const [fm] = extractFrontmatter(content);
+    return getField(fm, "id");
+  } catch {
+    return null;
   }
-  const source = options.from ?? process.env.SYNTAUR_ASSIGNMENT ?? "unknown";
-  let content = await readFile32(assignmentMdPath, "utf-8");
-  content = appendTodosToAssignmentBody(content, [
-    { description: `${text.trim()} (from: ${source})` }
-  ]);
-  content = touchAssignmentUpdated(content, nowTimestamp());
-  await writeFileForce(assignmentMdPath, content);
-  console.log(`Added todo to ${targetRef}: ${text.trim()} (from: ${source})`);
 }
-
-// src/cli-default-command.ts
-init_config2();
-import { readdir as readdir18 } from "fs/promises";
-async function hasAnyProjectContent(projectsDir2) {
+async function readContextJson(cwd) {
+  const path = resolve49(cwd, ".syntaur", "context.json");
+  if (!await fileExists(path)) return null;
   try {
-    const entries = await readdir18(projectsDir2, { withFileTypes: true });
-    return entries.some((entry) => entry.isDirectory());
+    const raw = await readFile33(path, "utf-8");
+    return JSON.parse(raw);
   } catch {
-    return false;
+    return null;
   }
 }
-async function isSetupComplete() {
+async function resolveAssignmentTarget(input4, opts = {}) {
   const config = await readConfig();
-  if (config.onboarding.completed) {
-    return true;
+  const baseDir = opts.dir ? expandHome(opts.dir) : config.defaultProjectDir;
+  if (opts.project) {
+    if (!input4) {
+      throw new AssignmentTargetError(
+        "--project requires an assignment slug as a positional argument."
+      );
+    }
+    if (!isValidSlug(opts.project)) {
+      throw new AssignmentTargetError(`Invalid project slug "${opts.project}".`);
+    }
+    if (!isValidSlug(input4)) {
+      throw new AssignmentTargetError(`Invalid assignment slug "${input4}".`);
+    }
+    const projectDir = resolve49(baseDir, opts.project);
+    const projectMdPath = resolve49(projectDir, "project.md");
+    if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
+      throw new AssignmentTargetError(
+        `Project "${opts.project}" not found at ${projectDir}.`
+      );
+    }
+    const assignmentDir = resolve49(projectDir, "assignments", input4);
+    const assignmentMdPath2 = resolve49(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath2)) {
+      throw new AssignmentTargetError(
+        `Assignment "${input4}" not found in project "${opts.project}".`
+      );
+    }
+    const id = await readAssignmentFrontmatterId(assignmentDir) ?? input4;
+    return {
+      assignmentDir,
+      projectSlug: opts.project,
+      assignmentSlug: input4,
+      id,
+      standalone: false,
+      workspaceGroup: null
+    };
   }
-  const [
-    claudePluginDir,
-    codexPluginDir,
-    codexMarketplacePath,
-    hasProjectContent
-  ] = await Promise.all([
+  if (input4) {
+    const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), input4);
+    if (!resolved) {
+      throw new AssignmentTargetError(
+        `Assignment "${input4}" not found. Provide --project <slug> + <slug> or a valid standalone UUID.`
+      );
+    }
+    return resolved;
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const ctx = await readContextJson(cwd);
+  if (!ctx) {
+    throw new AssignmentTargetError(
+      "No assignment specified. Provide an argument, --project + slug, or run from a directory with .syntaur/context.json."
+    );
+  }
+  if (ctx.assignmentDir) {
+    const dir = expandHome(ctx.assignmentDir);
+    const assignmentMdPath2 = resolve49(dir, "assignment.md");
+    if (!await fileExists(assignmentMdPath2)) {
+      throw new AssignmentTargetError(
+        `.syntaur/context.json points to a missing assignment dir: ${dir}.`
+      );
+    }
+    const id = await readAssignmentFrontmatterId(dir);
+    if (!id || id.trim() === "") {
+      throw new AssignmentTargetError(
+        `.syntaur/context.json points to an assignment with no frontmatter \`id\`: ${dir}.`
+      );
+    }
+    const assignmentSlug = ctx.assignmentSlug ?? dir.split("/").pop() ?? "";
+    const projectSlug = ctx.projectSlug ?? null;
+    return {
+      assignmentDir: dir,
+      projectSlug,
+      assignmentSlug,
+      id,
+      standalone: projectSlug === null,
+      workspaceGroup: null
+    };
+  }
+  if (ctx.projectSlug && ctx.assignmentSlug) {
+    if (!isValidSlug(ctx.projectSlug) || !isValidSlug(ctx.assignmentSlug)) {
+      throw new AssignmentTargetError(
+        `.syntaur/context.json contains invalid slugs: project="${ctx.projectSlug}" assignment="${ctx.assignmentSlug}".`
+      );
+    }
+    const assignmentDir = resolve49(baseDir, ctx.projectSlug, "assignments", ctx.assignmentSlug);
+    const assignmentMdPath2 = resolve49(assignmentDir, "assignment.md");
+    if (!await fileExists(assignmentMdPath2)) {
+      throw new AssignmentTargetError(
+        `.syntaur/context.json points to a missing assignment: ${assignmentDir}.`
+      );
+    }
+    const id = await readAssignmentFrontmatterId(assignmentDir) ?? ctx.assignmentSlug;
+    return {
+      assignmentDir,
+      projectSlug: ctx.projectSlug,
+      assignmentSlug: ctx.assignmentSlug,
+      id,
+      standalone: false,
+      workspaceGroup: null
+    };
+  }
+  throw new AssignmentTargetError(
+    ".syntaur/context.json exists but contains neither assignmentDir nor projectSlug+assignmentSlug."
+  );
+}
+
+// src/commands/capture.ts
+init_paths();
+
+// src/utils/proof-artifact-id.ts
+import { randomBytes as randomBytes2 } from "crypto";
+function generateArtifactId() {
+  const ts = Date.now().toString(36);
+  const rand = randomBytes2(2).toString("hex");
+  return `${ts}-${rand}`;
+}
+var EXTENSIONS = {
+  screenshot: "png",
+  video: "mp4",
+  asciinema: "cast",
+  http: "txt",
+  text: "txt"
+};
+function extensionForKind(kind) {
+  const ext = EXTENSIONS[kind];
+  if (!ext) {
+    throw new Error(`Unknown artifact kind: ${kind}`);
+  }
+  return ext;
+}
+var ARTIFACT_KINDS = [
+  "screenshot",
+  "video",
+  "asciinema",
+  "http",
+  "text"
+];
+function isArtifactKind(value) {
+  return typeof value === "string" && ARTIFACT_KINDS.includes(value);
+}
+
+// src/commands/capture.ts
+init_fs();
+
+// src/db/proof-db.ts
+init_paths();
+import Database3 from "better-sqlite3";
+import { resolve as resolve50 } from "path";
+var db2 = null;
+var PROOF_SCHEMA_VERSION = "1";
+var SCHEMA_SQL2 = `
+CREATE TABLE IF NOT EXISTS artifacts (
+  id TEXT PRIMARY KEY,
+  assignment_id TEXT NOT NULL,
+  assignment_dir TEXT NOT NULL,
+  criterion_index INTEGER,
+  kind TEXT NOT NULL,
+  file_path TEXT,
+  note TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_artifacts_assignment ON artifacts(assignment_id);
+CREATE INDEX IF NOT EXISTS idx_artifacts_assignment_criterion ON artifacts(assignment_id, criterion_index);
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+`;
+function initProofDb(dbPath) {
+  if (db2) return db2;
+  const finalPath = dbPath ?? resolve50(syntaurRoot(), "syntaur.db");
+  db2 = new Database3(finalPath);
+  db2.pragma("journal_mode = WAL");
+  db2.exec(SCHEMA_SQL2);
+  db2.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+    "proof_schema_version",
+    PROOF_SCHEMA_VERSION
+  );
+  const database = db2;
+  const runMigrations = database.transaction(() => {
+  });
+  runMigrations.exclusive();
+  return db2;
+}
+function getProofDb() {
+  if (!db2) {
+    throw new Error("Proof database not initialized. Call initProofDb() first.");
+  }
+  return db2;
+}
+function insertArtifact(input4) {
+  const database = getProofDb();
+  database.prepare(
+    `INSERT INTO artifacts (id, assignment_id, assignment_dir, criterion_index, kind, file_path, note)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input4.id,
+    input4.assignmentId,
+    input4.assignmentDir,
+    input4.criterionIndex,
+    input4.kind,
+    input4.filePath,
+    input4.note
+  );
+}
+function listArtifactsByAssignment(assignmentId) {
+  const database = getProofDb();
+  const rows = database.prepare(
+    `SELECT id, assignment_id, assignment_dir, criterion_index, kind, file_path, note, created_at
+       FROM artifacts
+       WHERE assignment_id = ?
+       ORDER BY (criterion_index IS NULL), criterion_index, created_at`
+  ).all(assignmentId);
+  return rows;
+}
+
+// src/commands/capture.ts
+var MAX_ID_RETRIES = 5;
+function normalizeCriterionIndex(raw) {
+  if (raw === void 0 || raw === null || raw === "") return null;
+  if (typeof raw === "number") {
+    if (!Number.isInteger(raw) || raw < 0) {
+      throw new Error(`--criterion must be a non-negative integer (got "${raw}")`);
+    }
+    return raw;
+  }
+  const s = String(raw).trim();
+  if (!/^\d+$/.test(s)) {
+    throw new Error(`--criterion must be a non-negative integer (got "${raw}")`);
+  }
+  return parseInt(s, 10);
+}
+function isUniqueConstraintError(err2) {
+  if (!err2 || typeof err2 !== "object") return false;
+  const e = err2;
+  if (e.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || e.code === "SQLITE_CONSTRAINT_UNIQUE") return true;
+  if (e.code === "SQLITE_CONSTRAINT" && /UNIQUE|PRIMARY KEY/i.test(e.message ?? "")) return true;
+  return false;
+}
+async function captureCommand(target, options = {}) {
+  if (!options.kind) {
+    throw new Error(
+      `--kind is required. Must be one of: ${ARTIFACT_KINDS.join(", ")}.`
+    );
+  }
+  if (!isArtifactKind(options.kind)) {
+    throw new Error(
+      `Invalid --kind "${options.kind}". Must be one of: ${ARTIFACT_KINDS.join(", ")}.`
+    );
+  }
+  const kind = options.kind;
+  if (kind === "text") {
+    if (options.file) {
+      throw new Error("--kind=text forbids --file. Use --note for text payloads.");
+    }
+    if (!options.note || options.note.trim() === "") {
+      throw new Error("--kind=text requires --note.");
+    }
+  } else {
+    if (kind !== "http" && !options.file) {
+      throw new Error(`--kind=${kind} requires --file.`);
+    }
+    if (kind === "http" && !options.file && (!options.note || options.note.trim() === "")) {
+      throw new Error("--kind=http requires --file or --note (one or the other).");
+    }
+  }
+  const criterionIndex = normalizeCriterionIndex(options.criterion);
+  const resolved = await resolveAssignmentTarget(target, {
+    project: options.project,
+    dir: options.dir,
+    cwd: options.cwd
+  });
+  let resolvedSource = null;
+  if (options.file) {
+    const expanded = options.file.startsWith("~/") ? resolve51(process.env.HOME ?? "", options.file.slice(2)) : resolve51(options.file);
+    if (!await fileExists(expanded)) {
+      throw new Error(`--file does not exist: ${options.file}`);
+    }
+    let real;
+    try {
+      real = await realpath2(expanded);
+    } catch (e) {
+      throw new Error(
+        `--file is unreadable: ${options.file} (${e instanceof Error ? e.message : String(e)})`
+      );
+    }
+    const st = await stat6(real);
+    if (!st.isFile()) {
+      throw new Error(`--file is not a regular file: ${options.file}`);
+    }
+    resolvedSource = real;
+  }
+  if (!resolved.id || resolved.id.trim() === "") {
+    throw new Error(
+      `Resolved assignment is missing a frontmatter \`id\`: ${resolved.assignmentDir}. Cannot record artifact.`
+    );
+  }
+  initProofDb();
+  const subdir = criterionIndex === null ? "untagged" : String(criterionIndex);
+  const destDir = resolve51(proofDir(resolved.assignmentDir), subdir);
+  if (resolvedSource) await mkdir7(destDir, { recursive: true });
+  const ext = resolvedSource ? extensionForKind(kind) : null;
+  let id = null;
+  let relativeFilePath = null;
+  let absPath = null;
+  let lastErr = null;
+  for (let attempt = 0; attempt < MAX_ID_RETRIES; attempt += 1) {
+    const candidate = generateArtifactId();
+    const candidateAbsPath = resolvedSource && ext ? resolve51(destDir, `${candidate}.${ext}`) : null;
+    const candidateRel = candidateAbsPath ? relative4(resolved.assignmentDir, candidateAbsPath) : null;
+    try {
+      insertArtifact({
+        id: candidate,
+        assignmentId: resolved.id,
+        assignmentDir: resolved.assignmentDir,
+        criterionIndex,
+        kind,
+        filePath: candidateRel,
+        note: options.note ?? null
+      });
+      id = candidate;
+      absPath = candidateAbsPath;
+      relativeFilePath = candidateRel;
+      break;
+    } catch (e) {
+      if (isUniqueConstraintError(e)) {
+        lastErr = e;
+        continue;
+      }
+      throw e;
+    }
+  }
+  if (!id) {
+    throw new Error(
+      `Failed to generate a unique artifact id after ${MAX_ID_RETRIES} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+    );
+  }
+  if (resolvedSource && absPath) {
+    await copyFile3(resolvedSource, absPath);
+  }
+  const ref = resolved.standalone ? resolved.id : `${resolved.projectSlug}/${resolved.assignmentSlug}`;
+  const tagSuffix = criterionIndex === null ? "untagged" : `criterion ${criterionIndex}`;
+  console.log(`Captured artifact ${id} (${kind}) for ${ref} \u2014 ${tagSuffix}.`);
+  if (relativeFilePath) {
+    console.log(`  file: ${resolve51(resolved.assignmentDir, relativeFilePath)}`);
+  }
+}
+
+// src/commands/proof.ts
+import { Command as Command5 } from "commander";
+import { readFile as readFile34, writeFile as writeFile10, rename as rename7, stat as stat7 } from "fs/promises";
+import { resolve as resolve52, relative as relative5, isAbsolute as isAbsolute8 } from "path";
+import { randomBytes as randomBytes3 } from "crypto";
+
+// src/utils/acceptance-criteria-parse.ts
+var SECTION_HEADING = /^##\s+Acceptance Criteria\s*$/i;
+var NEXT_HEADING = /^#{1,2}\s+\S/;
+var CHECKBOX_LINE = /^\s*[-*]\s+\[( |x|X)\]\s+(.*)$/;
+function parseAcceptanceCriteria(content) {
+  const fmMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  const body = fmMatch ? content.slice(fmMatch[0].length) : content;
+  const lines = body.split("\n");
+  const sectionStart = lines.findIndex((line) => SECTION_HEADING.test(line.trim()));
+  if (sectionStart === -1) return [];
+  let sectionEnd = lines.length;
+  for (let i = sectionStart + 1; i < lines.length; i += 1) {
+    if (NEXT_HEADING.test(lines[i].trim())) {
+      sectionEnd = i;
+      break;
+    }
+  }
+  const criteria = [];
+  for (let i = sectionStart + 1; i < sectionEnd; i += 1) {
+    const m = lines[i].match(CHECKBOX_LINE);
+    if (!m) continue;
+    const checked = m[1].toLowerCase() === "x";
+    const text = m[2].trim();
+    criteria.push({ index: criteria.length, text, checked });
+  }
+  return criteria;
+}
+
+// src/commands/proof.ts
+init_fs();
+init_paths();
+
+// src/templates/proof-md.ts
+function renderArtifactBullet(a) {
+  const parts = [];
+  parts.push(`**${a.kind}**`);
+  parts.push(`\`${a.id}\``);
+  if (a.file_path) parts.push(`file: \`${a.file_path}\``);
+  if (a.note) parts.push(`note: ${a.note}`);
+  return `- ${parts.join(" \u2014 ")}`;
+}
+function renderProofMarkdown(params2) {
+  const { assignment, title, generated, criteria, artifactsByCriterion, untagged, staleByOriginalIndex } = params2;
+  const totalArtifacts = untagged.length + staleByOriginalIndex.length + Array.from(artifactsByCriterion.values()).reduce((sum, list) => sum + list.length, 0);
+  const lines = [];
+  lines.push("---");
+  lines.push(`assignment: ${assignment}`);
+  lines.push(`generated: "${generated}"`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# Proof \u2014 ${title}`);
+  lines.push("");
+  if (totalArtifacts === 0) {
+    lines.push("_No artifacts captured for this assignment yet._");
+    lines.push("");
+    return lines.join("\n");
+  }
+  for (const c2 of criteria) {
+    const checkbox2 = c2.checked ? "[x]" : "[ ]";
+    lines.push(`## ${c2.index}. ${checkbox2} ${c2.text}`);
+    lines.push("");
+    const tagged = artifactsByCriterion.get(c2.index) ?? [];
+    if (tagged.length === 0) {
+      lines.push("_no artifacts captured_");
+    } else {
+      for (const a of tagged) lines.push(renderArtifactBullet(a));
+    }
+    lines.push("");
+  }
+  if (untagged.length > 0 || staleByOriginalIndex.length > 0) {
+    lines.push("## Other artifacts");
+    lines.push("");
+    for (const a of untagged) lines.push(renderArtifactBullet(a));
+    for (const a of staleByOriginalIndex) {
+      const note = a.note ? ` \u2014 note: ${a.note}` : "";
+      const file = a.file_path ? ` \u2014 file: \`${a.file_path}\`` : "";
+      lines.push(
+        `- _(was tagged criterion ${a.criterion_index} \u2014 no longer present)_ **${a.kind}** \`${a.id}\`${file}${note}`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/utils/escape-html.ts
+function escapeHtml(value) {
+  if (value === null || value === void 0) return "";
+  const s = typeof value === "string" ? value : String(value);
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/templates/proof-html.ts
+var INLINE_TEXT_LIMIT_BYTES = 256 * 1024;
+var STYLE_BLOCK = `
+  body { max-width: 920px; margin: 2rem auto; font-family: system-ui, -apple-system, sans-serif; padding: 0 1rem; color: #222; line-height: 1.5; }
+  h1, h2, h3 { line-height: 1.25; }
+  nav.toc { padding: 0.5rem 1rem; background: #f9f9f9; border-radius: 4px; margin-bottom: 2rem; }
+  nav.toc ul { margin: 0; padding-left: 1.25rem; }
+  section.criterion { padding: 1rem 0; border-bottom: 1px solid #eee; }
+  section.criterion:last-of-type { border-bottom: none; }
+  img, video { max-width: 100%; height: auto; border-radius: 4px; display: block; }
+  pre { max-height: 480px; overflow: auto; padding: 1rem; background: #f5f5f5; border-radius: 4px; white-space: pre-wrap; word-break: break-word; }
+  .artifact { margin: 1rem 0; }
+  .artifact-meta { font-size: 0.85em; color: #666; margin-bottom: 0.25rem; }
+  .untagged { color: #666; font-size: 0.9em; }
+  .stale { color: #b04a4a; font-style: italic; font-size: 0.9em; }
+  .empty-criterion { color: #888; font-style: italic; }
+  a { color: #2563eb; }
+`;
+function renderArtifact(a, ctx) {
+  const idEsc = escapeHtml(a.id);
+  const noteHtml = a.note ? `<div class="artifact-meta">note: ${escapeHtml(a.note)}</div>` : "";
+  const filePathEsc = a.file_path ? escapeHtml(a.file_path) : null;
+  let body = "";
+  switch (a.kind) {
+    case "screenshot":
+      body = filePathEsc ? `<img src="${filePathEsc}" alt="screenshot artifact ${idEsc}">` : "<em>missing file</em>";
+      break;
+    case "video":
+      body = filePathEsc ? `<video controls preload="metadata" src="${filePathEsc}"></video>` : "<em>missing file</em>";
+      break;
+    case "asciinema":
+      body = filePathEsc ? `<a href="${filePathEsc}" download>Open .cast file (${idEsc})</a> &mdash; <code>asciinema play &lt;file&gt;</code> to play locally` : "<em>missing file</em>";
+      break;
+    case "http":
+    case "text": {
+      const inline = a.file_path ? ctx.inlineFiles.get(a.file_path) : null;
+      if (a.kind === "http" && a.file_path && inline === null) {
+        body = `<a href="${filePathEsc}" download>Open transcript (${idEsc})</a>`;
+      } else if (inline !== void 0 && inline !== null) {
+        body = `<pre><code>${escapeHtml(inline)}</code></pre>`;
+      } else if (a.note) {
+        body = `<pre><code>${escapeHtml(a.note)}</code></pre>`;
+      } else {
+        body = "<em>(empty)</em>";
+      }
+      break;
+    }
+    default:
+      body = `<em>unknown kind: ${escapeHtml(a.kind)}</em>`;
+  }
+  return `<div class="artifact">${noteHtml}${body}<div class="artifact-meta"><code>${idEsc}</code></div></div>`;
+}
+function renderProofHtml(params2, inlineFiles = /* @__PURE__ */ new Map()) {
+  const { assignment, title, generated, criteria, artifactsByCriterion, untagged, staleByOriginalIndex } = params2;
+  const ctx = { inlineFiles };
+  const totalArtifacts = untagged.length + staleByOriginalIndex.length + Array.from(artifactsByCriterion.values()).reduce((sum, list) => sum + list.length, 0);
+  const titleEsc = escapeHtml(title);
+  const assignmentEsc = escapeHtml(assignment);
+  const generatedEsc = escapeHtml(generated);
+  const tocItems = criteria.map((c2) => `<li><a href="#criterion-${c2.index}">${c2.index}. ${escapeHtml(c2.text)}</a></li>`).join("\n      ");
+  const otherTocItem = untagged.length > 0 || staleByOriginalIndex.length > 0 ? '<li><a href="#other-artifacts">Other artifacts</a></li>' : "";
+  const criteriaHtml = criteria.map((c2) => {
+    const tagged = artifactsByCriterion.get(c2.index) ?? [];
+    const heading = `<h2>${c2.index}. <input type="checkbox" disabled${c2.checked ? " checked" : ""}> ${escapeHtml(c2.text)}</h2>`;
+    const body = tagged.length === 0 ? '<p class="empty-criterion">no artifacts captured</p>' : tagged.map((a) => renderArtifact(a, ctx)).join("\n      ");
+    return `<section id="criterion-${c2.index}" class="criterion">
+      ${heading}
+      ${body}
+    </section>`;
+  }).join("\n    ");
+  const otherSection = untagged.length > 0 || staleByOriginalIndex.length > 0 ? `<section id="other-artifacts" class="criterion">
+      <h2>Other artifacts</h2>
+      ${untagged.map((a) => `<div class="untagged">${renderArtifact(a, ctx)}</div>`).join("\n      ")}
+      ${staleByOriginalIndex.map(
+    (a) => `<div class="stale">(was tagged criterion ${a.criterion_index ?? ""} \u2014 no longer present)
+      ${renderArtifact(a, ctx)}</div>`
+  ).join("\n      ")}
+    </section>` : "";
+  const emptyState = totalArtifacts === 0 && criteria.length === 0 ? "<p>No artifacts captured for this assignment yet.</p>" : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Proof \u2014 ${titleEsc}</title>
+  <style>${STYLE_BLOCK}</style>
+</head>
+<body>
+  <header>
+    <h1>Proof \u2014 ${titleEsc}</h1>
+    <p><small>Assignment: <code>${assignmentEsc}</code> \xB7 Generated: ${generatedEsc}</small></p>
+  </header>
+  ${criteria.length > 0 || untagged.length > 0 || staleByOriginalIndex.length > 0 ? `<nav class="toc"><ul>
+      ${tocItems}
+      ${otherTocItem}
+    </ul></nav>` : ""}
+  <main>
+    ${emptyState}
+    ${criteriaHtml}
+    ${otherSection}
+  </main>
+</body>
+</html>
+`;
+}
+
+// src/commands/proof.ts
+async function readAssignmentMeta(assignmentDir) {
+  const path = resolve52(assignmentDir, "assignment.md");
+  if (!await fileExists(path)) {
+    return { title: "", body: "" };
+  }
+  const content = await readFile34(path, "utf-8");
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  let title = "";
+  if (fmMatch) {
+    const titleLine = fmMatch[1].split("\n").find((l) => /^title:\s/i.test(l));
+    if (titleLine) {
+      const raw = titleLine.replace(/^title:\s*/i, "").trim();
+      title = raw.replace(/^["']|["']$/g, "");
+    }
+  }
+  return { title, body: content };
+}
+async function atomicWrite(destPath, content) {
+  const tmp = `${destPath}.${randomBytes3(4).toString("hex")}.tmp`;
+  await writeFile10(tmp, content, "utf-8");
+  await rename7(tmp, destPath);
+}
+function isWithin(root, target) {
+  const rel = relative5(root, target);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute8(rel);
+}
+function groupArtifacts(rows, criterionCount) {
+  const artifactsByCriterion = /* @__PURE__ */ new Map();
+  const untagged = [];
+  const staleByOriginalIndex = [];
+  for (const row of rows) {
+    const idx = row.criterion_index;
+    if (idx === null || idx === void 0) {
+      untagged.push(row);
+      continue;
+    }
+    if (idx >= 0 && idx < criterionCount) {
+      const list = artifactsByCriterion.get(idx) ?? [];
+      list.push(row);
+      artifactsByCriterion.set(idx, list);
+    } else {
+      staleByOriginalIndex.push(row);
+    }
+  }
+  return { artifactsByCriterion, untagged, staleByOriginalIndex };
+}
+async function loadInlineFiles(rows, assignmentDir) {
+  const out = /* @__PURE__ */ new Map();
+  const proofRoot = proofDir(assignmentDir);
+  for (const r of rows) {
+    if (!r.file_path) continue;
+    if (r.kind !== "http" && r.kind !== "text") continue;
+    const abs = resolve52(assignmentDir, r.file_path);
+    if (!isWithin(proofRoot, abs)) {
+      out.set(r.file_path, null);
+      continue;
+    }
+    if (!await fileExists(abs)) {
+      out.set(r.file_path, null);
+      continue;
+    }
+    const st = await stat7(abs);
+    if (st.size > INLINE_TEXT_LIMIT_BYTES) {
+      out.set(r.file_path, null);
+      continue;
+    }
+    try {
+      out.set(r.file_path, await readFile34(abs, "utf-8"));
+    } catch {
+      out.set(r.file_path, null);
+    }
+  }
+  return out;
+}
+async function proofBuildCommand(target, options = {}) {
+  const resolved = await resolveAssignmentTarget(target, {
+    project: options.project,
+    dir: options.dir,
+    cwd: options.cwd
+  });
+  const meta = await readAssignmentMeta(resolved.assignmentDir);
+  const criteria = parseAcceptanceCriteria(meta.body);
+  initProofDb();
+  const rows = listArtifactsByAssignment(resolved.id);
+  const { artifactsByCriterion, untagged, staleByOriginalIndex } = groupArtifacts(
+    rows,
+    criteria.length
+  );
+  const inlineFiles = await loadInlineFiles(rows, resolved.assignmentDir);
+  const renderParams = {
+    assignment: resolved.standalone ? resolved.id : `${resolved.projectSlug}/${resolved.assignmentSlug}`,
+    title: meta.title || resolved.assignmentSlug,
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    criteria,
+    artifactsByCriterion,
+    untagged,
+    staleByOriginalIndex
+  };
+  const md = renderProofMarkdown(renderParams);
+  const html = renderProofHtml(renderParams, inlineFiles);
+  const mdPath = resolve52(resolved.assignmentDir, "proof.md");
+  const htmlPath = resolve52(resolved.assignmentDir, "proof.html");
+  await atomicWrite(mdPath, md);
+  await atomicWrite(htmlPath, html);
+  console.log(`Wrote ${htmlPath}`);
+  console.log(`Wrote ${mdPath}`);
+  return { htmlPath, mdPath };
+}
+var proofCommand = new Command5("proof").description("Render proof artifacts for an assignment");
+proofCommand.command("build").description("Render proof.html and proof.md for an assignment").argument("[target]", "Assignment slug (with --project) or UUID; falls back to .syntaur/context.json").option("--project <slug>", "Project slug if the target is project-nested").option("--dir <path>", "Override default project directory").action(async (target, options) => {
+  try {
+    await proofBuildCommand(target, options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/request.ts
+init_paths();
+init_fs();
+init_config2();
+init_slug();
+init_timestamp();
+init_assignment_resolver();
+init_assignment_todos();
+import { resolve as resolve53 } from "path";
+import { readFile as readFile35 } from "fs/promises";
+async function requestCommand(target, text, options = {}) {
+  if (!text || !text.trim()) {
+    throw new Error("Request text cannot be empty.");
+  }
+  const config = await readConfig();
+  const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
+  let assignmentDir;
+  let targetRef;
+  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}".`);
+    }
+    assignmentDir = resolve53(baseDir, options.project, "assignments", target);
+    targetRef = target;
+  } else {
+    const resolved = await resolveAssignmentById(baseDir, assignmentsDir(), target);
+    if (!resolved) {
+      throw new Error(`Target assignment "${target}" not found. Provide --project <slug> or a valid UUID.`);
+    }
+    assignmentDir = resolved.assignmentDir;
+    targetRef = resolved.standalone ? resolved.id : resolved.assignmentSlug;
+  }
+  const assignmentMdPath2 = resolve53(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 readFile35(assignmentMdPath2, "utf-8");
+  content = appendTodosToAssignmentBody(content, [
+    { description: `${text.trim()} (from: ${source})` }
+  ]);
+  content = touchAssignmentUpdated(content, nowTimestamp());
+  await writeFileForce(assignmentMdPath2, content);
+  console.log(`Added todo to ${targetRef}: ${text.trim()} (from: ${source})`);
+}
+
+// src/commands/plan.ts
+init_fs();
+init_paths();
+import { Command as Command6 } from "commander";
+import { readFile as readFile36, readdir as readdir18 } from "fs/promises";
+import { resolve as resolve54 } from "path";
+async function readContextAssignmentDir(cwd) {
+  const path = resolve54(cwd, ".syntaur", "context.json");
+  if (!await fileExists(path)) return null;
+  try {
+    const raw = await readFile36(path, "utf-8");
+    const ctx = JSON.parse(raw);
+    if (typeof ctx.assignmentDir === "string" && ctx.assignmentDir.length > 0) {
+      return ctx.assignmentDir;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function resolveAssignmentDir(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.assignment) {
+    if (opts.project) {
+      return resolve54(defaultProjectDir(), opts.project, "assignments", opts.assignment);
+    }
+    return resolve54(assignmentsDir(), opts.assignment);
+  }
+  const fromCtx = await readContextAssignmentDir(cwd);
+  if (fromCtx) return fromCtx;
+  throw new Error(
+    "No active assignment. Pass --assignment <slug> --project <slug> or run from a workspace with .syntaur/context.json."
+  );
+}
+var PLAN_PATTERN = /^plan(?:-v(\d+))?\.md$/;
+async function listPlanFiles(assignmentDir) {
+  if (!await fileExists(assignmentDir)) return [];
+  const entries = await readdir18(assignmentDir, { withFileTypes: true });
+  const out = [];
+  for (const e of entries) {
+    if (!e.isFile()) continue;
+    const m = e.name.match(PLAN_PATTERN);
+    if (!m) continue;
+    const version2 = m[1] ? parseInt(m[1], 10) : 1;
+    out.push({ fileName: e.name, version: version2 });
+  }
+  out.sort((a, b) => a.version - b.version);
+  return out;
+}
+function nextPlanFileName(currentVersion) {
+  const next = currentVersion + 1;
+  return { fileName: `plan-v${next}.md`, version: next };
+}
+function planLabel(version2) {
+  return version2 === 1 ? "plan" : `plan v${version2}`;
+}
+function planLinkText(version2) {
+  return version2 === 1 ? "plan" : `plan v${version2}`;
+}
+function planFileName(version2) {
+  return version2 === 1 ? "plan.md" : `plan-v${version2}.md`;
+}
+function rewriteAssignmentTodos(content, oldVersion, newVersion) {
+  const lines = content.split("\n");
+  const todosHeaderIdx = lines.findIndex((l) => /^##\s+Todos\s*$/.test(l));
+  if (todosHeaderIdx === -1) {
+    throw new Error("assignment.md has no `## Todos` section to rewrite.");
+  }
+  let endIdx = lines.length;
+  for (let i = todosHeaderIdx + 1; i < lines.length; i++) {
+    if (/^##\s/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  const oldFile = planFileName(oldVersion);
+  const oldLink = `./${oldFile}`;
+  const newFile = planFileName(newVersion);
+  const newLabel = planLinkText(newVersion);
+  const supersededTag = `(superseded by plan-v${newVersion})`;
+  const CYCLE_VERB_PATTERN = /^(\s*-\s*\[[ xX]\]\s*)(Create|Review|Implement|Review implementation of)(\s+\[)/;
+  let rewrote = 0;
+  for (let i = todosHeaderIdx + 1; i < endIdx; i++) {
+    const line = lines[i];
+    if (!line.includes(oldLink)) continue;
+    if (!CYCLE_VERB_PATTERN.test(line)) continue;
+    if (line.includes("(superseded by plan-v")) continue;
+    let next = line.replace(/^(\s*-\s*)\[[ xX]\]/, "$1[x]");
+    next = next.replace(
+      /^(\s*-\s*\[x\]\s*)(.*)$/,
+      (_m, prefix, rest) => {
+        const body = rest.endsWith(" ") ? rest.trimEnd() : rest;
+        if (body.startsWith("~~") && body.endsWith("~~")) {
+          return `${prefix}${body} ${supersededTag}`;
+        }
+        return `${prefix}~~${body}~~ ${supersededTag}`;
+      }
+    );
+    lines[i] = next;
+    rewrote += 1;
+  }
+  const newTodos = [
+    `- [ ] Create [${newLabel}](./${newFile})`,
+    `- [ ] Review [${newLabel}](./${newFile})`,
+    `- [ ] Implement [${newLabel}](./${newFile})`,
+    `- [ ] Review implementation of [${newLabel}](./${newFile})`
+  ];
+  const insertAt = endIdx;
+  const prevLine = lines[insertAt - 1] ?? "";
+  const toInsert = [];
+  if (prevLine.trim() !== "") toInsert.push("");
+  toInsert.push(...newTodos);
+  lines.splice(insertAt, 0, ...toInsert);
+  return {
+    updated: lines.join("\n"),
+    rewrote,
+    appended: newTodos.length
+  };
+}
+function extractUncheckedTodos(planBody) {
+  const out = [];
+  for (const line of planBody.split("\n")) {
+    if (/^\s*-\s*\[\s\]\s+/.test(line)) {
+      out.push(line);
+    }
+  }
+  return out;
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function buildNewPlanStub(opts) {
+  const created = isoNow();
+  const oldLabel = planLabel(opts.oldVersion);
+  const carriedSection = opts.uncheckedTodos.length === 0 ? "_No unchecked tasks carried forward from the prior plan._" : opts.uncheckedTodos.join("\n");
+  return `---
+assignment: ${opts.assignmentSlug}
+status: draft
+created: "${created}"
+updated: "${created}"
+---
+
+# ${opts.assignmentSlug} \u2014 Implementation Plan v${opts.newVersion}
+
+**Date:** ${created.slice(0, 10)}
+**Supersedes:** [${oldLabel}](./${planFileName(opts.oldVersion)})
+
+## Objective
+
+<!-- Describe what changed and why a new plan is needed. -->
+
+## Carried-forward tasks
+
+${carriedSection}
+
+## Tasks
+
+<!-- Add the new plan tasks here. -->
+
+## Verification
+
+<!-- Add verification steps here. -->
+`;
+}
+async function runPlanVersion(options) {
+  const assignmentDir = await resolveAssignmentDir(options);
+  if (!await fileExists(assignmentDir)) {
+    throw new Error(`Assignment directory does not exist: ${assignmentDir}`);
+  }
+  const assignmentMdPath2 = resolve54(assignmentDir, "assignment.md");
+  if (!await fileExists(assignmentMdPath2)) {
+    throw new Error(`Missing assignment.md at: ${assignmentMdPath2}`);
+  }
+  const planFiles = await listPlanFiles(assignmentDir);
+  if (planFiles.length === 0) {
+    throw new Error(
+      `No plan.md (or plan-v<N>.md) found in ${assignmentDir}. Run /plan-assignment to create plan.md first.`
+    );
+  }
+  const current = planFiles[planFiles.length - 1];
+  const next = nextPlanFileName(current.version);
+  const newPath = resolve54(assignmentDir, next.fileName);
+  if (await fileExists(newPath) && !options.force) {
+    throw new Error(`${next.fileName} already exists. Use --force to overwrite.`);
+  }
+  const assignmentMd = await readFile36(assignmentMdPath2, "utf-8");
+  const slugMatch = assignmentMd.match(/^slug:\s*(.+?)\s*$/m);
+  const slug = slugMatch ? slugMatch[1].trim() : assignmentDir.split("/").pop() ?? "";
+  const oldPlanPath = resolve54(assignmentDir, current.fileName);
+  const oldPlanContent = await readFile36(oldPlanPath, "utf-8");
+  const oldBody = oldPlanContent.replace(/^---[\s\S]*?\n---\n?/, "");
+  const carriedTodos = extractUncheckedTodos(oldBody);
+  const stub = buildNewPlanStub({
+    assignmentSlug: slug,
+    newVersion: next.version,
+    oldVersion: current.version,
+    uncheckedTodos: carriedTodos
+  });
+  const { updated, rewrote, appended } = rewriteAssignmentTodos(
+    assignmentMd,
+    current.version,
+    next.version
+  );
+  await writeFileForce(newPath, stub);
+  await writeFileForce(assignmentMdPath2, updated);
+  console.log(
+    `Created ${next.fileName} (superseding ${current.fileName}). Rewrote ${rewrote} prior todo(s); appended ${appended} new todo(s).`
+  );
+  console.log(`Path: ${newPath}`);
+  console.log(`Carried forward: ${carriedTodos.length} unchecked task(s).`);
+}
+var planCommand = new Command6("plan").description("Manage plan files for the active assignment");
+planCommand.command("version").description(
+  "Create the next plan-v<N>.md, supersede the prior plan in assignment.md ## Todos, and carry forward unchecked tasks"
+).option("--assignment <slug>", "Assignment slug (UUID for standalone). Defaults to .syntaur/context.json").option("--project <slug>", "Project slug. Required when --assignment is given for a project-nested assignment").option("--force", "Overwrite if the next plan-v<N>.md already exists").action(async (options) => {
+  try {
+    await runPlanVersion(options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/session.ts
+init_fs();
+import { Command as Command7 } from "commander";
+import { readFile as readFile37, readdir as readdir19, stat as stat8 } from "fs/promises";
+import { resolve as resolve55 } from "path";
+async function readContext(cwd) {
+  const path = resolve55(cwd, ".syntaur", "context.json");
+  if (!await fileExists(path)) return null;
+  try {
+    const raw = await readFile37(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function findLatestSessionSummary(assignmentDir) {
+  const sessionsRoot = resolve55(assignmentDir, "sessions");
+  if (!await fileExists(sessionsRoot)) return null;
+  const entries = await readdir19(sessionsRoot, { withFileTypes: true });
+  let best = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const summaryPath = resolve55(sessionsRoot, entry.name, "summary.md");
+    if (!await fileExists(summaryPath)) continue;
+    const st = await stat8(summaryPath);
+    if (best === null || st.mtime.getTime() > best.mtime.getTime()) {
+      best = { sessionId: entry.name, path: summaryPath, mtime: st.mtime };
+    }
+  }
+  return best;
+}
+async function findOpenHandoff(assignmentDir) {
+  const handoffPath = resolve55(assignmentDir, "handoff.md");
+  if (!await fileExists(handoffPath)) return null;
+  const content = await readFile37(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;
+  return handoffPath;
+}
+async function buildResumeOutput(cwd) {
+  const warnings = [];
+  const context = await readContext(cwd);
+  if (!context) {
+    return {
+      ok: false,
+      context: null,
+      latestSession: null,
+      openHandoff: null,
+      warnings: [
+        "No .syntaur/context.json in current directory. Run grab-assignment first."
+      ]
+    };
+  }
+  if (!context.assignmentDir) {
+    return {
+      ok: false,
+      context,
+      latestSession: null,
+      openHandoff: null,
+      warnings: [
+        "context.json present but no assignmentDir field \u2014 only a session record exists. Nothing to resume."
+      ]
+    };
+  }
+  const latestSession = await findLatestSessionSummary(context.assignmentDir);
+  if (!latestSession) {
+    warnings.push(
+      `No session summary found under ${context.assignmentDir}/sessions/. Run /save-session-summary in a prior session to leave a resume baton.`
+    );
+  }
+  const openHandoff = await findOpenHandoff(context.assignmentDir);
+  return {
+    ok: true,
+    context,
+    latestSession: latestSession ? { sessionId: latestSession.sessionId, path: latestSession.path } : null,
+    openHandoff,
+    warnings
+  };
+}
+function renderHumanOutput(out) {
+  const lines = [];
+  if (!out.ok) {
+    lines.push("Cannot resume:");
+    for (const w of out.warnings) lines.push(`  - ${w}`);
+    return lines.join("\n");
+  }
+  const ctx = out.context;
+  lines.push("Resuming Syntaur session");
+  lines.push("");
+  lines.push(`  Project:        ${ctx.projectSlug ?? "(standalone)"}`);
+  lines.push(`  Assignment:     ${ctx.assignmentSlug ?? "(unknown)"}`);
+  if (ctx.title) lines.push(`  Title:          ${ctx.title}`);
+  if (ctx.branch) lines.push(`  Branch:         ${ctx.branch}`);
+  if (ctx.workspaceRoot) lines.push(`  Workspace root: ${ctx.workspaceRoot}`);
+  lines.push(`  Assignment dir: ${ctx.assignmentDir}`);
+  lines.push("");
+  if (out.latestSession) {
+    lines.push(`Latest session summary: ${out.latestSession.path}`);
+    lines.push(`Read it next to load What\u2019s Next + Open Questions.`);
+  } else {
+    lines.push("No prior session summary on disk.");
+  }
+  if (out.openHandoff) {
+    lines.push("");
+    lines.push(`Open handoff: ${out.openHandoff}`);
+    lines.push("Read it before continuing \u2014 there is an outstanding baton.");
+  }
+  if (out.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const w of out.warnings) lines.push(`  - ${w}`);
+  }
+  return lines.join("\n");
+}
+async function runSessionResume(options, cwd = process.cwd()) {
+  const out = await buildResumeOutput(cwd);
+  if (options.json) {
+    console.log(JSON.stringify(out, null, 2));
+  } else {
+    console.log(renderHumanOutput(out));
+  }
+  return out;
+}
+var sessionCommand = new Command7("session").description("Manage agent sessions for the active assignment");
+sessionCommand.command("resume").description(
+  "Re-orient a fresh session: print active assignment context, latest saved session summary, and any open handoff. Idempotent \u2014 does not mutate state."
+).option("--json", "Emit machine-readable JSON instead of human-readable text").action(async (options) => {
+  try {
+    const out = await runSessionResume(options);
+    if (!out.ok) process.exit(1);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/worktree.ts
+init_git_worktree();
+init_fs();
+init_paths();
+import { Command as Command8 } from "commander";
+import { readFile as readFile38 } from "fs/promises";
+import { resolve as resolve56 } from "path";
+async function readContext2(cwd) {
+  const path = resolve56(cwd, ".syntaur", "context.json");
+  if (!await fileExists(path)) return null;
+  try {
+    return JSON.parse(await readFile38(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function resolveAssignmentPath2(opts) {
+  if (opts.assignment) {
+    if (opts.project) {
+      return resolve56(
+        defaultProjectDir(),
+        opts.project,
+        "assignments",
+        opts.assignment,
+        "assignment.md"
+      );
+    }
+    return resolve56(assignmentsDir(), opts.assignment, "assignment.md");
+  }
+  const ctx = await readContext2(opts.cwd);
+  if (ctx?.assignmentDir) return resolve56(ctx.assignmentDir, "assignment.md");
+  throw new Error(
+    "No active assignment. Pass --assignment <slug> [--project <slug>] or run from a workspace with .syntaur/context.json."
+  );
+}
+async function runWorktreeCreate(options, cwd = process.cwd()) {
+  if (!options.branch) {
+    throw new Error("--branch is required.");
+  }
+  const repository = options.repository ?? cwd;
+  const parentBranch = options.parentBranch ?? "main";
+  const worktreePath = options.worktreePath ?? resolve56(repository, ".worktrees", options.branch);
+  const assignmentPath = await resolveAssignmentPath2({
+    assignment: options.assignment,
+    project: options.project,
+    cwd
+  });
+  if (!await fileExists(assignmentPath)) {
+    throw new Error(`Assignment file not found: ${assignmentPath}`);
+  }
+  await createWorktreeAndRecord({
+    repository,
+    branch: options.branch,
+    worktreePath,
+    parentBranch,
+    assignmentPath
+  });
+  return { worktreePath, assignmentPath };
+}
+var worktreeCommand = new Command8("worktree").description("Manage git worktrees bound to Syntaur assignments");
+worktreeCommand.command("create").description(
+  "Create a worktree at <repository>/.worktrees/<branch> and record it in the assignment workspace block. Atomic \u2014 rolls back the worktree if writing assignment.md fails."
+).requiredOption("--branch <name>", "Branch name to create (also used as worktree dir name)").option("--repository <path>", "Repository root (defaults to current working directory)").option("--parent-branch <name>", "Parent branch to fork from", "main").option("--assignment <slug>", "Assignment slug (UUID for standalone). Defaults to .syntaur/context.json").option("--project <slug>", "Project slug. Required when --assignment is given for a project-nested assignment").option("--worktree-path <path>", "Override the computed <repository>/.worktrees/<branch> path").action(async (options) => {
+  try {
+    const { worktreePath, assignmentPath } = await runWorktreeCreate(options);
+    console.log(`Created worktree at ${worktreePath}`);
+    console.log(`Recorded workspace fields in ${assignmentPath}`);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/resource.ts
+init_paths();
+init_fs();
+init_slug();
+import { Command as Command9 } from "commander";
+import { resolve as resolve58 } from "path";
+
+// src/utils/project-indexes.ts
+init_parser();
+init_fs();
+import { readdir as readdir20, readFile as readFile39 } from "fs/promises";
+import { resolve as resolve57 } from "path";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function readProjectSlug(projectDir) {
+  return projectDir.split("/").filter(Boolean).pop() ?? "";
+}
+async function listSlugFiles(dir) {
+  if (!await fileExists(dir)) return [];
+  const entries = await readdir20(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("_")).map((e) => e.name).sort();
+}
+function escapeCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+}
+function joinList(items) {
+  return items.length === 0 ? "\u2014" : items.map(escapeCell).join(", ");
+}
+async function rebuildResourcesIndex(projectDir) {
+  const dir = resolve57(projectDir, "resources");
+  await ensureDir(dir);
+  const files = await listSlugFiles(dir);
+  const slug = readProjectSlug(projectDir);
+  const lines = [];
+  lines.push("---");
+  lines.push(`project: ${slug}`);
+  lines.push(`generated: "${nowIso()}"`);
+  lines.push(`total: ${files.length}`);
+  lines.push("---");
+  lines.push("");
+  lines.push("# Resources");
+  lines.push("");
+  lines.push("| Name | Category | Source | Related Assignments | Updated |");
+  lines.push("|------|----------|--------|---------------------|---------|");
+  for (const fileName of files) {
+    const content = await readFile39(resolve57(dir, fileName), "utf-8");
+    const parsed = parseResource(content);
+    const slugBase = fileName.replace(/\.md$/, "");
+    const name = parsed.name || slugBase;
+    const link = `[${escapeCell(name)}](./${fileName})`;
+    lines.push(
+      `| ${link} | ${escapeCell(parsed.category)} | ${escapeCell(parsed.source)} | ${joinList(parsed.relatedAssignments)} | ${escapeCell(parsed.updated)} |`
+    );
+  }
+  lines.push("");
+  const indexPath = resolve57(dir, "_index.md");
+  await writeFileForce(indexPath, lines.join("\n"));
+  return { total: files.length, path: indexPath };
+}
+async function rebuildMemoriesIndex(projectDir) {
+  const dir = resolve57(projectDir, "memories");
+  await ensureDir(dir);
+  const files = await listSlugFiles(dir);
+  const slug = readProjectSlug(projectDir);
+  const lines = [];
+  lines.push("---");
+  lines.push(`project: ${slug}`);
+  lines.push(`generated: "${nowIso()}"`);
+  lines.push(`total: ${files.length}`);
+  lines.push("---");
+  lines.push("");
+  lines.push("# Memories");
+  lines.push("");
+  lines.push("| Name | Source | Scope | Source Assignment | Updated |");
+  lines.push("|------|--------|-------|-------------------|---------|");
+  for (const fileName of files) {
+    const content = await readFile39(resolve57(dir, fileName), "utf-8");
+    const parsed = parseMemory(content);
+    const slugBase = fileName.replace(/\.md$/, "");
+    const name = parsed.name || slugBase;
+    const link = `[${escapeCell(name)}](./${fileName})`;
+    lines.push(
+      `| ${link} | ${escapeCell(parsed.source)} | ${escapeCell(parsed.scope)} | ${escapeCell(parsed.sourceAssignment ?? "\u2014")} | ${escapeCell(parsed.updated)} |`
+    );
+  }
+  lines.push("");
+  const indexPath = resolve57(dir, "_index.md");
+  await writeFileForce(indexPath, lines.join("\n"));
+  return { total: files.length, path: indexPath };
+}
+
+// src/commands/resource.ts
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseList(value) {
+  if (!value) return [];
+  return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function yamlQuote(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function renderResourceFile(opts) {
+  const created = nowIso2();
+  const related = opts.relatedAssignments.length === 0 ? "[]" : `
+${opts.relatedAssignments.map((a) => `  - ${a}`).join("\n")}`;
+  return `---
+name: ${yamlQuote(opts.name)}
+category: ${yamlQuote(opts.category)}
+source: ${yamlQuote(opts.source)}
+relatedAssignments:${related}
+created: "${created}"
+updated: "${created}"
+---
+
+# ${opts.name}
+
+${opts.body ?? "<!-- Add notes about this resource here. -->"}
+`;
+}
+async function runResourceAdd(options) {
+  if (!isValidSlug(options.project)) {
+    throw new Error(`Invalid project slug: "${options.project}".`);
+  }
+  const projectDir = resolve58(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve58(projectDir, "project.md"))) {
+    throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
+  }
+  if (!options.name) throw new Error("--name is required.");
+  if (!options.source) throw new Error("--source is required.");
+  const slug = options.slug ?? slugify(options.name);
+  if (!isValidSlug(slug)) {
+    throw new Error(`Invalid resource slug: "${slug}".`);
+  }
+  const filePath = resolve58(projectDir, "resources", `${slug}.md`);
+  if (await fileExists(filePath) && !options.force) {
+    throw new Error(
+      `Resource "${slug}" already exists at ${filePath}. Use --force to overwrite.`
+    );
+  }
+  const content = renderResourceFile({
+    name: options.name,
+    source: options.source,
+    category: options.category ?? "",
+    relatedAssignments: parseList(options.relatedAssignments)
+  });
+  await writeFileForce(filePath, content);
+  const { path: indexPath, total } = await rebuildResourcesIndex(projectDir);
+  return { filePath, indexPath, total };
+}
+var resourceCommand = new Command9("resource").description("Manage project-level resource entries");
+resourceCommand.command("add").description(
+  "Add a project resource at <projectDir>/resources/<slug>.md and regenerate _index.md"
+).requiredOption("--project <slug>", "Project slug").requiredOption("--name <name>", "Human-readable resource name").requiredOption("--source <url-or-path>", "Resource source (URL or path)").option("--category <name>", "Optional category (e.g. dashboard, doc, ticket)").option("--slug <slug>", "Override the slug (default: slugify(--name))").option("--related-assignments <slugs>", "Comma-separated related assignment slugs").option("--force", "Overwrite if the resource file already exists").action(async (options) => {
+  try {
+    const { filePath, indexPath, total } = await runResourceAdd(options);
+    console.log(`Wrote ${filePath}`);
+    console.log(`Rebuilt ${indexPath} (${total} total resources).`);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/memory.ts
+init_paths();
+init_fs();
+init_slug();
+import { Command as Command10 } from "commander";
+import { resolve as resolve59 } from "path";
+function nowIso3() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseList2(value) {
+  if (!value) return [];
+  return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+function yamlQuote2(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function renderMemoryFile(opts) {
+  const created = nowIso3();
+  const related = opts.relatedAssignments.length === 0 ? "[]" : `
+${opts.relatedAssignments.map((a) => `  - ${a}`).join("\n")}`;
+  const sourceAssignment = opts.sourceAssignment === null ? "null" : yamlQuote2(opts.sourceAssignment);
+  return `---
+name: ${yamlQuote2(opts.name)}
+source: ${yamlQuote2(opts.source)}
+scope: ${yamlQuote2(opts.scope)}
+sourceAssignment: ${sourceAssignment}
+relatedAssignments:${related}
+created: "${created}"
+updated: "${created}"
+---
+
+# ${opts.name}
+
+${opts.body ?? "<!-- Capture the load-bearing context for this memory here. -->"}
+`;
+}
+async function runMemoryAdd(options) {
+  if (!isValidSlug(options.project)) {
+    throw new Error(`Invalid project slug: "${options.project}".`);
+  }
+  const projectDir = resolve59(defaultProjectDir(), options.project);
+  if (!await fileExists(resolve59(projectDir, "project.md"))) {
+    throw new Error(`Project "${options.project}" not found at ${projectDir}.`);
+  }
+  if (!options.name) throw new Error("--name is required.");
+  if (!options.source) throw new Error("--source is required.");
+  const slug = options.slug ?? slugify(options.name);
+  if (!isValidSlug(slug)) {
+    throw new Error(`Invalid memory slug: "${slug}".`);
+  }
+  const filePath = resolve59(projectDir, "memories", `${slug}.md`);
+  if (await fileExists(filePath) && !options.force) {
+    throw new Error(
+      `Memory "${slug}" already exists at ${filePath}. Use --force to overwrite.`
+    );
+  }
+  const content = renderMemoryFile({
+    name: options.name,
+    source: options.source,
+    scope: options.scope ?? "project",
+    sourceAssignment: options.sourceAssignment ?? null,
+    relatedAssignments: parseList2(options.relatedAssignments)
+  });
+  await writeFileForce(filePath, content);
+  const { path: indexPath, total } = await rebuildMemoriesIndex(projectDir);
+  return { filePath, indexPath, total };
+}
+var memoryCommand = new Command10("memory").description("Manage project-level memory entries");
+memoryCommand.command("add").description(
+  "Add a project memory at <projectDir>/memories/<slug>.md and regenerate _index.md"
+).requiredOption("--project <slug>", "Project slug").requiredOption("--name <name>", "Human-readable memory name").requiredOption("--source <text>", "Where this memory came from (conversation, decision, doc URL, etc.)").option("--scope <scope>", "Memory scope (default: project)", "project").option("--source-assignment <slug>", "Assignment slug this memory was captured during").option("--slug <slug>", "Override the slug (default: slugify(--name))").option("--related-assignments <slugs>", "Comma-separated related assignment slugs").option("--force", "Overwrite if the memory file already exists").action(async (options) => {
+  try {
+    const { filePath, indexPath, total } = await runMemoryAdd(options);
+    console.log(`Wrote ${filePath}`);
+    console.log(`Rebuilt ${indexPath} (${total} total memories).`);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/ls.ts
+init_api();
+init_paths();
+init_fs();
+init_frontmatter();
+import { Command as Command11 } from "commander";
+import { readFile as readFile40 } from "fs/promises";
+import { resolve as resolve60 } from "path";
+var AGE_PATTERN = /^(\d+)([dhwm])$/i;
+function parseAgeToCutoff(age) {
+  const match = age.match(AGE_PATTERN);
+  if (!match) {
+    throw new Error(
+      `Invalid --age value: "${age}". Use formats like 7d, 24h, 2w, 1m.`
+    );
+  }
+  const n = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  const ms = unit === "h" ? n * 60 * 60 * 1e3 : unit === "d" ? n * 24 * 60 * 60 * 1e3 : unit === "w" ? n * 7 * 24 * 60 * 60 * 1e3 : (
+    /* m: months ≈ 30 days */
+    n * 30 * 24 * 60 * 60 * 1e3
+  );
+  return new Date(Date.now() - ms);
+}
+function assignmentMdPath(item) {
+  if (item.projectSlug) {
+    return resolve60(
+      defaultProjectDir(),
+      item.projectSlug,
+      "assignments",
+      item.slug,
+      "assignment.md"
+    );
+  }
+  return resolve60(assignmentsDir(), item.id, "assignment.md");
+}
+async function loadTags(item) {
+  const path = assignmentMdPath(item);
+  if (!await fileExists(path)) return [];
+  try {
+    const content = await readFile40(path, "utf-8");
+    return parseAssignmentFrontmatter(content).tags;
+  } catch {
+    return [];
+  }
+}
+async function runLs(options) {
+  const board = await listAssignmentsBoard(
+    defaultProjectDir(),
+    assignmentsDir()
+  );
+  let items = board.assignments;
+  if (options.status) {
+    const statuses = options.status.split(",").map((s) => s.trim()).filter(Boolean);
+    items = items.filter((a) => statuses.includes(a.status));
+  }
+  if (options.project) {
+    items = items.filter((a) => a.projectSlug === options.project);
+  }
+  if (options.age) {
+    const cutoff = parseAgeToCutoff(options.age);
+    items = items.filter((a) => {
+      const updatedTs = Date.parse(a.updated);
+      return Number.isFinite(updatedTs) && updatedTs >= cutoff.getTime();
+    });
+  }
+  if (options.tag) {
+    const wanted = options.tag.split(",").map((s) => s.trim()).filter(Boolean);
+    const tagged = await Promise.all(
+      items.map(async (a) => {
+        const tags = await loadTags(a);
+        return { item: a, tags };
+      })
+    );
+    items = tagged.filter(({ tags }) => wanted.every((t) => tags.includes(t))).map(({ item }) => item);
+  }
+  return { items };
+}
+function pad(value, width) {
+  if (value.length >= width) return value.slice(0, width);
+  return value + " ".repeat(width - value.length);
+}
+function renderTable(items) {
+  if (items.length === 0) return "No assignments matched.";
+  const rows = items.map((a) => [
+    a.projectSlug ?? "(standalone)",
+    a.slug,
+    a.status,
+    a.priority,
+    a.assignee ?? "\u2014",
+    a.updated.slice(0, 10),
+    a.title
+  ]);
+  const header = ["PROJECT", "SLUG", "STATUS", "PRIORITY", "ASSIGNEE", "UPDATED", "TITLE"];
+  const all = [header, ...rows];
+  const widths = header.map(
+    (_, c2) => Math.min(60, Math.max(...all.map((row) => row[c2]?.length ?? 0)))
+  );
+  return all.map((row) => row.map((cell, c2) => pad(cell ?? "", widths[c2])).join("  ")).join("\n");
+}
+var lsCommand = new Command11("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) => {
+  try {
+    const { items } = await runLs(options);
+    if (options.json) {
+      console.log(JSON.stringify({ assignments: items }, null, 2));
+    } else {
+      console.log(renderTable(items));
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/cli-default-command.ts
+init_config2();
+import { readdir as readdir21 } from "fs/promises";
+async function hasAnyProjectContent(projectsDir2) {
+  try {
+    const entries = await readdir21(projectsDir2, { withFileTypes: true });
+    return entries.some((entry) => entry.isDirectory());
+  } catch {
+    return false;
+  }
+}
+async function isSetupComplete() {
+  const config = await readConfig();
+  if (config.onboarding.completed) {
+    return true;
+  }
+  const [
+    claudePluginDir,
+    codexPluginDir,
+    codexMarketplacePath,
+    hasProjectContent
+  ] = await Promise.all([
     getConfiguredOrLegacyManagedPluginDir("claude"),
     getConfiguredOrLegacyManagedPluginDir("codex"),
     getConfiguredOrLegacyMarketplacePath(),
@@ -18296,20 +20265,20 @@ async function getDefaultCommandName() {
 init_paths();
 init_fs();
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { readFile as readFile34 } from "fs/promises";
-import { dirname as dirname15, join as join8, resolve as resolve49 } from "path";
+import { readFile as readFile42 } from "fs/promises";
+import { dirname as dirname15, join as join8, resolve as resolve61 } from "path";
 import { spawn as spawn4 } from "child_process";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // src/utils/version.ts
 import { fileURLToPath as fileURLToPath7 } from "url";
-import { readFile as readFile33 } from "fs/promises";
+import { readFile as readFile41 } from "fs/promises";
 import { dirname as dirname14, join as join7 } from "path";
 async function readPackageVersion(scriptUrl) {
   try {
     const scriptPath = fileURLToPath7(scriptUrl);
     const pkgRoot = dirname14(dirname14(scriptPath));
-    const raw = await readFile33(join7(pkgRoot, "package.json"), "utf-8");
+    const raw = await readFile41(join7(pkgRoot, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -18318,7 +20287,7 @@ async function readPackageVersion(scriptUrl) {
 }
 
 // src/utils/npx-prompt.ts
-var STATE_FILE = resolve49(syntaurRoot(), "npx-install.json");
+var STATE_FILE = resolve61(syntaurRoot(), "npx-install.json");
 var META_ARGS = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version", "help"]);
 var GLOBAL_VERSION_TIMEOUT_MS = 2e3;
 function isRunningViaNpx(scriptUrl) {
@@ -18339,7 +20308,7 @@ function isRunningViaNpx(scriptUrl) {
 async function readState() {
   if (!await fileExists(STATE_FILE)) return null;
   try {
-    const raw = await readFile34(STATE_FILE, "utf-8");
+    const raw = await readFile42(STATE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -18398,7 +20367,7 @@ async function readGlobalVersion() {
   try {
     const manifestPath = join8(rootPath, "syntaur", "package.json");
     if (!await fileExists(manifestPath)) return null;
-    const raw = await readFile34(manifestPath, "utf-8");
+    const raw = await readFile42(manifestPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {
@@ -18517,7 +20486,7 @@ async function maybePromptInstall(scriptUrl) {
 
 // src/index.ts
 await maybePromptInstall(import.meta.url);
-var program = new Command5();
+var program = new Command12();
 var version = await readPackageVersion(import.meta.url) ?? "0.0.0";
 program.name("syntaur").description("CLI scaffolding tool for the Syntaur protocol").version(version);
 program.command("init").description("Initialize ~/.syntaur/ directory structure and config").option("--force", "Overwrite existing config file").action(async (options) => {
@@ -18568,6 +20537,17 @@ program.command("comment").description("Add a comment to an assignment (CLI-medi
     process.exit(1);
   }
 });
+program.command("capture").description("Capture a typed proof artifact for an assignment").argument("[target]", "Assignment slug (with --project) or UUID; falls back to .syntaur/context.json").option("--kind <type>", "Artifact kind: screenshot | video | asciinema | http | text").option("--file <path>", "Source file to ingest (forbidden for --kind=text)").option("--criterion <index>", "Optional 0-based criterion index to tag").option("--note <text>", "Optional note (required for --kind=text)").option("--project <slug>", "Project slug if the target is project-nested").option("--dir <path>", "Override default project directory").action(async (target, options) => {
+  try {
+    await captureCommand(target, options);
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+});
 program.command("request").description("Append a todo to another assignment (cross-assignment work request)").argument("<target>", "Target assignment slug (with --project) or UUID (standalone)").argument("<text>", "Todo text").option("--project <slug>", "Project slug if the target is project-nested").option("--from <source>", "Source assignment (default: $SYNTAUR_ASSIGNMENT)").option("--dir <path>", "Override default project directory").action(async (target, text, options) => {
   try {
     await requestCommand(target, text, options);
@@ -18878,6 +20858,13 @@ program.addCommand(todoCommand);
 program.addCommand(backupCommand);
 program.addCommand(doctorCommand);
 program.addCommand(agentsCommand);
+program.addCommand(proofCommand);
+program.addCommand(planCommand);
+program.addCommand(sessionCommand);
+program.addCommand(worktreeCommand);
+program.addCommand(resourceCommand);
+program.addCommand(memoryCommand);
+program.addCommand(lsCommand);
 if (process.argv.length <= 2) {
   process.argv.push(await getDefaultCommandName());
 }