syntaur 0.45.0 → 0.47.0

package/dist/dashboard/server.js

@@ -3366,6 +3366,7 @@ function cloneDefaultConfig() {
     ...DEFAULT_CONFIG,
     onboarding: { ...DEFAULT_CONFIG.onboarding },
     agentDefaults: { ...DEFAULT_CONFIG.agentDefaults },
+    session: { ...DEFAULT_CONFIG.session },
     integrations: { ...DEFAULT_CONFIG.integrations },
     backup: DEFAULT_CONFIG.backup ? { ...DEFAULT_CONFIG.backup } : null,
     statuses: DEFAULT_CONFIG.statuses ? {
@@ -4715,6 +4716,11 @@ async function readConfig() {
         fm["agentDefaults.autoCreateWorktree"]
       ) ? fm["agentDefaults.autoCreateWorktree"] : DEFAULT_CONFIG.agentDefaults.autoCreateWorktree
     },
+    session: {
+      autoTrack: SESSION_AUTO_TRACK_VALUES.includes(
+        fm["session.autoTrack"]
+      ) ? fm["session.autoTrack"] : DEFAULT_CONFIG.session.autoTrack
+    },
     integrations: {
       claudePluginDir: parseOptionalAbsolutePath(
         fm["integrations.claudePluginDir"],
@@ -4814,7 +4820,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var DEFAULT_DERIVE_CONFIG, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var DEFAULT_DERIVE_CONFIG, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, SESSION_AUTO_TRACK_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -4880,6 +4886,9 @@ var init_config2 = __esm({
         autoApprove: false,
         autoCreateWorktree: "ask"
       },
+      session: {
+        autoTrack: "all"
+      },
       integrations: {
         claudePluginDir: null,
         codexPluginDir: null,
@@ -4900,6 +4909,7 @@ var init_config2 = __esm({
       }
     };
     AUTO_CREATE_WORKTREE_VALUES = ["skip", "ask", "always"];
+    SESSION_AUTO_TRACK_VALUES = ["all", "workspaces-only", "off"];
     AgentConfigError = class extends Error {
     };
     DEFAULT_STATUS_COLORS = {
@@ -5760,6 +5770,15 @@ var init_help = __esm({
 });
 
 // src/dashboard/session-db.ts
+var session_db_exports = {};
+__export(session_db_exports, {
+  closeSessionDb: () => closeSessionDb,
+  getSessionDb: () => getSessionDb,
+  initSessionDb: () => initSessionDb,
+  isSessionDbInitialized: () => isSessionDbInitialized,
+  migrateFromMarkdown: () => migrateFromMarkdown,
+  resetSessionDb: () => resetSessionDb
+});
 import Database from "better-sqlite3";
 import { resolve as resolve9 } from "path";
 import { readdir as readdir5 } from "fs/promises";
@@ -5904,6 +5923,9 @@ function initSessionDb(dbPath) {
   db.exec(POST_MIGRATION_INDEXES_SQL);
   return db;
 }
+function isSessionDbInitialized() {
+  return db !== null;
+}
 function getSessionDb() {
   if (!db) {
     throw new Error(
@@ -5918,6 +5940,9 @@ function closeSessionDb() {
     db = null;
   }
 }
+function resetSessionDb() {
+  db = null;
+}
 async function migrateFromMarkdown(projectsDir) {
   const database = getSessionDb();
   const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
@@ -5948,8 +5973,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile23 } = await import("fs/promises");
-  const raw2 = await readFile23(filePath, "utf-8");
+  const { readFile: readFile25 } = await import("fs/promises");
+  const raw2 = await readFile25(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -6036,10 +6061,11 @@ function rowToSession(row) {
     transcriptPath: row.transcript_path ?? null,
     pid: row.pid ?? null,
     pidStartedAt: row.pid_started_at ?? null,
-    originalHeadSha: row.original_head_sha ?? null
+    originalHeadSha: row.original_head_sha ?? null,
+    updatedAt: row.updated_at ?? null
   };
 }
-async function appendSession(_projectDir, session) {
+async function appendSession(_projectDir, session, opts) {
   const db4 = getSessionDb();
   db4.prepare(`
     INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path, pid, pid_started_at, original_head_sha)
@@ -6048,7 +6074,11 @@ async function appendSession(_projectDir, session) {
       project_slug      = COALESCE(NULLIF(excluded.project_slug, ''),      project_slug),
       assignment_slug   = COALESCE(NULLIF(excluded.assignment_slug, ''),   assignment_slug),
       agent             = excluded.agent,
-      status            = CASE WHEN status IN ('completed','stopped') THEN status ELSE excluded.status END,
+      status            = CASE
+                            WHEN status = 'completed' THEN status
+                            WHEN status = 'stopped' AND NOT (? AND excluded.status = 'active') THEN status
+                            ELSE excluded.status
+                          END,
       path              = COALESCE(NULLIF(excluded.path, ''),              path),
       description       = COALESCE(NULLIF(excluded.description, ''),       description),
       transcript_path   = COALESCE(NULLIF(excluded.transcript_path, ''),   transcript_path),
@@ -6068,15 +6098,16 @@ async function appendSession(_projectDir, session) {
     session.transcriptPath ?? null,
     session.pid ?? null,
     session.pidStartedAt ?? null,
-    session.originalHeadSha ?? null
+    session.originalHeadSha ?? null,
+    opts?.reviveStopped ? 1 : 0
   );
 }
-async function updateSessionStatus(_projectDir, sessionId, status) {
+async function updateSessionStatus(_projectDir, sessionId, status, endedAt) {
   const db4 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
   const result = isTerminal ? db4.prepare(
-    "UPDATE sessions SET status = ?, ended = datetime('now'), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId) : db4.prepare(
+    "UPDATE sessions SET status = ?, ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, endedAt ?? null, sessionId) : db4.prepare(
     "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
   ).run(status, sessionId);
   return result.changes > 0;
@@ -6385,8 +6416,8 @@ function scanKey(serversDir2, projectsDir, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve34) => {
-    const timer2 = setTimeout(resolve34, ms);
+  return new Promise((resolve38) => {
+    const timer2 = setTimeout(resolve38, ms);
     if (typeof timer2.unref === "function") {
       timer2.unref();
     }
@@ -9324,6 +9355,431 @@ var init_api = __esm({
   }
 });
 
+// src/templates/cursor-rules.ts
+function renderCursorProtocol() {
+  return `---
+description: Syntaur protocol rules for multi-agent coordination
+globs:
+alwaysApply: true
+---
+
+# Syntaur Protocol
+
+You are working within the Syntaur protocol for multi-agent project coordination.
+
+## Directory Structure
+
+\`\`\`
+~/.syntaur/
+  config.md
+  projects/
+    <project-slug>/
+      manifest.md            # Derived: root navigation (read-only)
+      project.md             # Human-authored: project overview (read-only)
+      _index-assignments.md  # Derived (read-only)
+      _index-plans.md        # Derived (read-only)
+      _index-decisions.md    # Derived (read-only)
+      _status.md             # Derived (read-only)
+      assignments/
+        <assignment-slug>/
+          assignment.md      # Agent-writable: source of truth for state (includes ## Todos)
+          plan*.md           # Agent-writable: versioned implementation plans (optional, one per ## Todos entry)
+          progress.md        # Agent-writable, append-only: timestamped progress log
+          comments.md        # CLI-mediated: threaded questions/notes/feedback (via \`syntaur comment\`)
+          scratchpad.md      # Agent-writable: working notes
+          handoff.md         # Agent-writable: append-only cross-ticket outbound at completion
+          decision-record.md # Agent-writable: append-only decision log
+          sessions/
+            <session-id>/
+              summary.md     # Agent-writable: per-session continuity (single doc, overwritten)
+      resources/
+        _index.md            # Derived (read-only)
+        <resource-slug>.md   # Shared-writable
+      memories/
+        _index.md            # Derived (read-only)
+        <memory-slug>.md     # Shared-writable
+  assignments/
+    <assignment-id>/         # Standalone assignments \u2014 folder = UUID, \`project: null\`, slug display-only
+      assignment.md
+      plan*.md
+      progress.md
+      comments.md
+      scratchpad.md
+      handoff.md
+      decision-record.md
+      sessions/<session-id>/summary.md  # Per-session continuity (same as project-nested)
+\`\`\`
+
+## Write Boundary Rules (CRITICAL)
+
+### Files you may WRITE:
+1. **Your assignment folder** -- only the assignment you are currently working on:
+   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`progress.md\`, \`scratchpad.md\`, \`handoff.md\` (cross-ticket outbound at completion), \`decision-record.md\`
+   - \`sessions/<session-id>/summary.md\` -- per-session continuity (single doc per session id, overwritten on save). Distinct from \`handoff.md\`.
+   - Path (project-nested): \`~/.syntaur/projects/<project>/assignments/<your-assignment>/\`
+   - Path (standalone): \`~/.syntaur/assignments/<your-assignment-uuid>/\`
+2. **Shared resources and memories** at the project level:
+   - \`~/.syntaur/projects/<project>/resources/<slug>.md\`
+   - \`~/.syntaur/projects/<project>/memories/<slug>.md\`
+3. **Your workspace** -- source code files in the current working directory (the directory where this adapter file lives). If your assignment's frontmatter specifies a \`workspace\` field, read it at runtime to determine the exact boundary.
+
+> **Note:** The \`setup-adapter\` command does not parse assignment frontmatter for workspace paths. Workspace boundaries are resolved by the agent at runtime by reading \`assignment.md\` frontmatter. If no \`workspace\` field is set, treat the current working directory as your workspace.
+
+### Files written only via CLI (never edit directly):
+- \`comments.md\` (any assignment) -- use \`syntaur comment <slug-or-uuid> "body" [--type question|note|feedback] [--reply-to <id>]\`
+- Another assignment's \`## Todos\` section -- use \`syntaur request <source> <target> "text"\` to request cross-assignment work
+
+### Files you must NEVER write:
+1. \`project.md\` -- human-authored, read-only
+2. \`manifest.md\` -- derived, rebuilt by tooling
+3. Any file prefixed with \`_\` -- derived
+4. Other agents' assignment folders (except via the CLI-mediated channels above)
+5. Any files outside your workspace boundary
+
+## Assignment Lifecycle
+
+| Status | Meaning |
+|--------|---------|
+| \`pending\` | Not yet started |
+| \`in_progress\` | Actively being worked on |
+| \`blocked\` | Manually blocked (requires blockedReason) |
+| \`review\` | Work complete, awaiting review |
+| \`completed\` | Done |
+| \`failed\` | Could not be completed |
+
+## Valid State Transitions
+
+| From | Command | To |
+|------|---------|-----|
+| pending | start | in_progress |
+| pending | block | blocked |
+| in_progress | block | blocked |
+| in_progress | review | review |
+| in_progress | complete | completed |
+| in_progress | fail | failed |
+| blocked | unblock | in_progress |
+| review | start | in_progress |
+| review | complete | completed |
+| review | fail | failed |
+
+## Lifecycle Commands
+
+Use the \`syntaur\` CLI for state transitions and coordination:
+- \`syntaur assign <slug> --agent <name> --project <project>\` -- set assignee
+- \`syntaur start <slug> --project <project>\` -- pending -> in_progress
+- \`syntaur review <slug> --project <project>\` -- in_progress -> review
+- \`syntaur complete <slug> --project <project>\` -- in_progress/review -> completed
+- \`syntaur block <slug> --project <project> --reason <text>\` -- block an assignment
+- \`syntaur unblock <slug> --project <project>\` -- unblock
+- \`syntaur fail <slug> --project <project>\` -- mark as failed
+- \`syntaur create-assignment "Title" [--type <type>] [--project <slug> | --one-off]\` -- create project-nested or standalone assignment
+- \`syntaur comment <slug-or-uuid> "body" --type question|note|feedback [--reply-to <id>]\` -- append to \`comments.md\` (questions support resolve toggle via dashboard)
+- \`syntaur request <source> <target> "text"\` -- append a todo to another assignment's \`## Todos\` annotated \`(from: <source>)\`
+
+## Playbooks
+
+Playbooks are user-defined behavioral rules stored in \`~/.syntaur/playbooks/\`. Read the playbook manifest before starting work:
+
+\`\`\`bash
+cat ~/.syntaur/playbooks/manifest.md
+\`\`\`
+
+Follow the rules in each playbook. They take precedence over default conventions when they conflict.
+
+## Conventions
+
+- Assignment frontmatter is the single source of truth for state. \`project\` is the containing project slug (\`null\` for standalone); \`type\` is a classification validated against \`config.md\` \`types.definitions\` when present.
+- Slugs are lowercase, hyphen-separated. Standalone assignment folders are named by UUID; \`slug\` is display-only in that case.
+- Always read \`project.md\` at the project level (when project-nested) before starting work.
+- Append timestamped entries to \`progress.md\` (never to \`assignment.md\`).
+- Record questions, notes, and feedback via \`syntaur comment\`. Never edit \`comments.md\` directly.
+- To route work to another assignment, use \`syntaur request\`.
+- Commit frequently with messages referencing the assignment slug.
+`;
+}
+function renderCursorAssignment(params2) {
+  return `---
+description: Syntaur assignment context for ${params2.projectSlug}/${params2.assignmentSlug}
+globs:
+alwaysApply: true
+---
+
+# Current Assignment Context
+
+- **Project:** ${params2.projectSlug}
+- **Assignment:** ${params2.assignmentSlug}
+- **Project directory:** ${params2.projectDir}
+- **Assignment directory:** ${params2.assignmentDir}
+
+## Reading Order
+
+Before starting work, read these files in order:
+1. \`${params2.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+2. \`${params2.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+3. any \`${params2.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+4. \`${params2.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+5. \`${params2.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
+6. \`${params2.assignmentDir}/handoff.md\` -- cross-ticket outbound history (entries from prior agents/humans handing this assignment off)
+7. The latest \`${params2.assignmentDir}/sessions/<sid>/summary.md\` if present -- previous-session continuity (selected by \`summary.md\` file mtime; read it for "what was done / what's next" before resuming work in flight)
+
+## Your Writable Files
+
+You may write directly to these files inside your assignment folder:
+- \`${params2.assignmentDir}/assignment.md\`
+- \`${params2.assignmentDir}/plan*.md\` (0 or more versioned plan files, e.g., \`plan.md\`, \`plan-v2.md\`)
+- \`${params2.assignmentDir}/progress.md\` (append timestamped entries, newest first)
+- \`${params2.assignmentDir}/scratchpad.md\`
+- \`${params2.assignmentDir}/handoff.md\`
+- \`${params2.assignmentDir}/decision-record.md\`
+- \`${params2.assignmentDir}/sessions/<session-id>/summary.md\` (per-session continuity)
+
+Do NOT edit \`${params2.assignmentDir}/comments.md\` directly \u2014 use \`syntaur comment\`. Do NOT edit other assignments' files \u2014 use \`syntaur request\` for cross-assignment todos.
+
+And source code files in your workspace. Read the \`workspace\` field from your assignment's frontmatter to determine the exact boundary. If not set, the current working directory is your workspace.
+`;
+}
+var init_cursor_rules = __esm({
+  "src/templates/cursor-rules.ts"() {
+    "use strict";
+  }
+});
+
+// src/templates/codex-agents.ts
+function renderCodexAgents(params2) {
+  return `# Syntaur Protocol -- Agent Instructions
+
+This project uses the Syntaur protocol for multi-agent project coordination.
+
+## Current Assignment
+
+- **Project:** ${params2.projectSlug}
+- **Assignment:** ${params2.assignmentSlug}
+- **Project directory:** ${params2.projectDir}
+- **Assignment directory:** ${params2.assignmentDir}
+
+## Preferred Workflow
+
+If the global Syntaur Codex plugin is installed, prefer these workflows instead of ad hoc protocol edits:
+
+- \`syntaur-operator\` agent -- use for broad Syntaur protocol work or when a task spans multiple lifecycle steps
+- \`syntaur-protocol\` -- background protocol and write-boundary rules
+- \`create-project\` -- scaffold a project
+- \`create-assignment\` -- create a new assignment (use \`--type <bug|feature|chore|...>\` to classify; use \`--one-off\` to create a standalone assignment at \`~/.syntaur/assignments/<uuid>/\` with no parent project)
+- \`grab-assignment\` -- claim work, create \`.syntaur/context.json\`, and register a session
+- \`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.
+
+## Reading Order
+
+Before starting work, read these files in order:
+1. \`${params2.projectDir}/manifest.md\` -- root navigation entry point (project-nested assignments only)
+2. \`${params2.projectDir}/project.md\` -- project overview and goals (project-nested assignments only)
+3. \`${params2.assignmentDir}/assignment.md\` -- your assignment details, acceptance criteria, todos, current status. Frontmatter now includes \`project: <slug> | null\` (null for standalone) and \`type: <classification> | null\`.
+4. any \`${params2.assignmentDir}/plan*.md\` files linked from active todos in the \`## Todos\` section (may be 0, 1, or many)
+5. \`${params2.assignmentDir}/progress.md\` -- reverse-chron progress log (if present)
+6. \`${params2.assignmentDir}/comments.md\` -- threaded questions/notes/feedback (if present)
+7. \`${params2.assignmentDir}/handoff.md\` -- cross-ticket outbound history (entries from prior agents/humans handing this assignment off)
+8. The latest \`${params2.assignmentDir}/sessions/<sid>/summary.md\` if present -- previous-session continuity (read it for "what was done / what's next" before resuming work in flight)
+
+## Context File
+
+- Treat \`.syntaur/context.json\` in the current working directory as the active assignment context when it exists.
+- Use that file to resolve the workspace boundary, assignment path, and project path (the active assignment binding). The active session id, however, is resolved from *your* running process -- prefer \`$CLAUDE_CODE_SESSION_ID\` (or the peer \`OPENCODE_SESSION_ID\` / \`PI_SESSION_ID\`), otherwise run \`syntaur session resolve-id\`; the \`sessionId\` scalar in context.json is only a clobberable legacy hint, not authoritative.
+- If there is no context file yet and you are supposed to work on an assignment, claim or set up the assignment before editing code.
+
+## Directory Structure
+
+\`\`\`
+~/.syntaur/
+  config.md
+  projects/
+    <project-slug>/
+      manifest.md            # Derived: root navigation (read-only)
+      project.md             # Human-authored: project overview (read-only)
+      _index-assignments.md  # Derived (read-only)
+      _index-plans.md        # Derived (read-only)
+      _index-decisions.md    # Derived (read-only)
+      _status.md             # Derived (read-only)
+      assignments/
+        <assignment-slug>/
+          assignment.md      # Agent-writable: source of truth for state (includes ## Todos)
+          plan*.md           # Agent-writable: versioned implementation plans (optional, one per ## Todos entry)
+          progress.md        # Agent-writable, append-only: timestamped progress log
+          comments.md        # CLI-mediated: threaded questions/notes/feedback (via \`syntaur comment\`)
+          scratchpad.md      # Agent-writable: working notes
+          handoff.md         # Agent-writable: append-only cross-ticket outbound at completion
+          decision-record.md # Agent-writable: append-only decision log
+          sessions/
+            <session-id>/
+              summary.md     # Agent-writable: per-session continuity (single doc, overwritten)
+      resources/
+        _index.md            # Derived (read-only)
+        <resource-slug>.md   # Shared-writable
+      memories/
+        _index.md            # Derived (read-only)
+        <memory-slug>.md     # Shared-writable
+  assignments/
+    <assignment-id>/         # Standalone assignments \u2014 folder = UUID, \`project: null\`, slug display-only
+      assignment.md
+      plan*.md
+      progress.md
+      comments.md
+      scratchpad.md
+      handoff.md
+      decision-record.md
+      sessions/<session-id>/summary.md  # Per-session continuity (same as project-nested)
+\`\`\`
+
+## Write Boundary Rules (CRITICAL)
+
+### Files you may WRITE:
+1. **Your assignment folder** -- only the assignment you are currently working on:
+   - \`assignment.md\`, \`plan*.md\` (0 or more versioned plan files), \`progress.md\`, \`scratchpad.md\`, \`handoff.md\` (cross-ticket outbound at completion), \`decision-record.md\`
+   - \`sessions/<session-id>/summary.md\` -- per-session continuity (single doc per session id, overwritten on save). Distinct from \`handoff.md\`.
+   - Path: \`${params2.assignmentDir}/\`
+2. **Shared resources and memories** at the project level:
+   - \`${params2.projectDir}/resources/<slug>.md\`
+   - \`${params2.projectDir}/memories/<slug>.md\`
+3. **Your workspace** -- source code files in the current working directory (the directory where this AGENTS.md lives). If your assignment's frontmatter specifies a \`workspace\` field, read it at runtime to determine the exact boundary.
+
+> **Note:** Workspace boundaries are resolved by the agent at runtime by reading \`assignment.md\` frontmatter. If no \`workspace\` field is set, treat the current working directory as your workspace.
+
+### Files written only via CLI (never edit directly):
+- \`comments.md\` (any assignment) -- use \`syntaur comment <slug-or-uuid> "body" [--type question|note|feedback] [--reply-to <id>]\`
+- Another assignment's \`## Todos\` section -- use \`syntaur request <source> <target> "text"\` to request cross-assignment work
+
+### Files you must NEVER write:
+1. \`project.md\` -- human-authored, read-only
+2. \`manifest.md\` -- derived, rebuilt by tooling
+3. Any file prefixed with \`_\` -- derived
+4. Other agents' assignment folders (except via the CLI-mediated channels above)
+5. Any files outside your workspace boundary
+
+## Assignment Lifecycle
+
+| Status | Meaning |
+|--------|---------|
+| \`pending\` | Not yet started |
+| \`in_progress\` | Actively being worked on |
+| \`blocked\` | Manually blocked (requires blockedReason) |
+| \`review\` | Work complete, awaiting review |
+| \`completed\` | Done |
+| \`failed\` | Could not be completed |
+
+## Valid State Transitions
+
+| From | Command | To |
+|------|---------|-----|
+| pending | start | in_progress |
+| pending | block | blocked |
+| in_progress | block | blocked |
+| in_progress | review | review |
+| in_progress | complete | completed |
+| in_progress | fail | failed |
+| blocked | unblock | in_progress |
+| review | start | in_progress |
+| review | complete | completed |
+| review | fail | failed |
+
+## Lifecycle Commands
+
+Use the \`syntaur\` CLI for state transitions and coordination:
+- \`syntaur assign ${params2.assignmentSlug} --agent <name> --project ${params2.projectSlug}\` -- set assignee
+- \`syntaur start ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- pending -> in_progress
+- \`syntaur review ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- in_progress -> review
+- \`syntaur complete ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- in_progress/review -> completed
+- \`syntaur block ${params2.assignmentSlug} --project ${params2.projectSlug} --reason <text>\` -- block
+- \`syntaur unblock ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- unblock
+- \`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>] [--transcribe] ${params2.assignmentSlug} --project ${params2.projectSlug}\` -- record a proof artifact. \`--kind=text\` requires \`--note\` and forbids \`--file\`. Criterion linkage is optional. \`--transcribe\` is video-only and writes a sibling \`<id>.transcript.md\` (requires \`ELEVENLABS_API_KEY\` + \`ffmpeg\`).
+- \`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
+
+If Syntaur state looks inconsistent (missing files, stale manifests, unexpected hook blocks), run \`syntaur doctor\` to diagnose. Use \`--json\` for structured output.
+
+## Playbooks
+
+Playbooks are user-defined behavioral rules stored in \`~/.syntaur/playbooks/\`. Before starting work, read the playbook manifest and then each referenced playbook:
+
+\`\`\`bash
+cat ~/.syntaur/playbooks/manifest.md
+\`\`\`
+
+Read each linked playbook and follow the rules in its body section. The \`when_to_use\` field tells you when each playbook applies. Playbooks take precedence over default conventions when they conflict.
+
+## Conventions
+
+- Assignment frontmatter is the single source of truth for state. \`project\` is the containing project slug (\`null\` for standalone); \`type\` is a classification validated against \`config.md\` \`types.definitions\` when present.
+- Slugs are lowercase, hyphen-separated. For standalone assignments, \`slug\` is display-only; the folder is named by the UUID.
+- Always read \`project.md\` at the project level (when project-nested) before starting work.
+- Keep \`assignment.md\` acceptance criteria and \`## Todos\` updated as work lands; append timestamped entries to \`progress.md\` (never to \`assignment.md\`).
+- Keep active plan file(s) current after planning changes. Write \`handoff.md\` (via \`complete-assignment\`) at the cross-ticket boundary; write \`sessions/<sid>/summary.md\` (via \`/save-session-summary\`) before compaction or before ending a session mid-assignment so a future session can resume cleanly.
+- When requirements shift, supersede the prior plan todo (\`- [x] ~~...~~ (superseded by plan-v<N>)\`) and write a new plan file instead of rewriting the old one.
+- Record questions, notes, and feedback via \`syntaur comment\`. Never edit \`comments.md\` directly. Resolve questions via the dashboard UI (toggle on the question entry).
+- To route work to another assignment, use \`syntaur request\`.
+- Commit frequently with messages referencing the assignment slug.
+`;
+}
+var init_codex_agents = __esm({
+  "src/templates/codex-agents.ts"() {
+    "use strict";
+  }
+});
+
+// src/templates/opencode-config.ts
+function renderOpenCodeConfig(params2) {
+  const config = {
+    instructions: [
+      `Read AGENTS.md in this directory for Syntaur protocol (v2.0) instructions.`,
+      `Read ${params2.projectDir}/project.md for project overview (project-nested assignments only).`,
+      `Append timestamped progress entries to the assignment's progress.md (not to assignment.md).`,
+      `Use 'syntaur comment <slug-or-uuid> "body" --type question|note|feedback' to append to comments.md \u2014 never edit it directly.`,
+      `Use 'syntaur request <source> <target> "text"' to append a todo to another assignment's ## Todos.`,
+      `Assignment folders are project-nested at ~/.syntaur/projects/<slug>/assignments/<aslug>/ or standalone at ~/.syntaur/assignments/<uuid>/ (project: null, slug display-only).`
+    ]
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+var init_opencode_config = __esm({
+  "src/templates/opencode-config.ts"() {
+    "use strict";
+  }
+});
+
+// src/templates/hermes-soul.ts
+function renderHermesSoul(params2) {
+  const body = renderCodexAgents(params2);
+  return `# SOUL -- Syntaur Protocol Operator
+
+This agent follows the Syntaur protocol for multi-agent project coordination.
+Hermes loads this file as part of its identity / system context; treat the
+Write Boundary Rules and Lifecycle sections below as binding.
+
+${body}`;
+}
+var init_hermes_soul = __esm({
+  "src/templates/hermes-soul.ts"() {
+    "use strict";
+    init_codex_agents();
+  }
+});
+
 // src/lifecycle/recompute.ts
 var recompute_exports = {};
 __export(recompute_exports, {
@@ -9563,20 +10019,370 @@ var LOCK_FILE, LOCK_STALE_MS, LOCK_WAIT_MS, LOCK_MAX_WAITS, CAS_RETRIES, MIGRATI
 var init_recompute = __esm({
   "src/lifecycle/recompute.ts"() {
     "use strict";
-    init_config2();
-    init_fs();
+    init_config2();
+    init_fs();
+    init_paths();
+    init_timestamp();
+    init_facts();
+    init_derive();
+    init_frontmatter();
+    init_types();
+    LOCK_FILE = ".derive.lock";
+    LOCK_STALE_MS = 3e4;
+    LOCK_WAIT_MS = 50;
+    LOCK_MAX_WAITS = 100;
+    CAS_RETRIES = 3;
+    MIGRATION_MARKER = "derive-migrated";
+  }
+});
+
+// src/utils/transcript.ts
+import { open as open2 } from "fs/promises";
+async function derivePathFromTranscript(transcriptPath) {
+  if (!transcriptPath) return null;
+  let handle;
+  try {
+    handle = await open2(transcriptPath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stream = handle.createReadStream({ encoding: "utf-8" });
+    let buffer = "";
+    let scanned = 0;
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const cwd = extractCwd(line);
+        if (cwd) {
+          stream.destroy();
+          return cwd;
+        }
+        scanned++;
+        if (scanned >= MAX_LINES_SCANNED) {
+          stream.destroy();
+          return null;
+        }
+        nl = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) {
+      const cwd = extractCwd(buffer);
+      if (cwd) return cwd;
+    }
+    return null;
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+function extractCwd(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed[0] !== "{") return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
+      return parsed.cwd;
+    }
+  } catch {
+  }
+  return null;
+}
+var MAX_LINES_SCANNED;
+var init_transcript = __esm({
+  "src/utils/transcript.ts"() {
+    "use strict";
+    MAX_LINES_SCANNED = 50;
+  }
+});
+
+// src/utils/process-info.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function captureProcessStartedAt(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  try {
+    const out = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? null : trimmed;
+  } catch {
+    return null;
+  }
+}
+var init_process_info = __esm({
+  "src/utils/process-info.ts"() {
+    "use strict";
+  }
+});
+
+// src/usage/cwd-extractor.ts
+import { open as open3, readdir as readdir11, stat as stat2 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+async function extractClaudeSessionMeta(jsonlPath) {
+  const cwd = await derivePathFromTranscript(jsonlPath);
+  if (!cwd) return null;
+  const basename6 = jsonlPath.split("/").pop() ?? "";
+  const sessionId = basename6.replace(/\.jsonl$/, "");
+  if (!sessionId) return null;
+  const startTs = await readFirstTimestamp(jsonlPath);
+  const endTs = await readLastTimestamp(jsonlPath);
+  return {
+    tool: "claude",
+    sessionId,
+    cwd,
+    startTs,
+    endTs,
+    path: jsonlPath
+  };
+}
+async function extractCodexSessionMeta(jsonlPath) {
+  let handle;
+  try {
+    handle = await open3(jsonlPath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stream = handle.createReadStream({ encoding: "utf-8" });
+    let buffer = "";
+    let firstLine = null;
+    for await (const chunk of stream) {
+      buffer += chunk;
+      const nl = buffer.indexOf("\n");
+      if (nl !== -1) {
+        firstLine = buffer.slice(0, nl);
+        stream.destroy();
+        break;
+      }
+    }
+    if (!firstLine && buffer.length > 0) firstLine = buffer;
+    if (!firstLine) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(firstLine);
+    } catch {
+      return null;
+    }
+    if (!parsed || typeof parsed !== "object") return null;
+    const obj = parsed;
+    if (obj.type !== "session_meta") return null;
+    const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : null;
+    const payload = obj.payload;
+    const id = payload && typeof payload.id === "string" ? payload.id : null;
+    const cwd = payload && typeof payload.cwd === "string" ? payload.cwd : null;
+    if (!timestamp || !id || !cwd) return null;
+    const endTs = await readLastTimestamp(jsonlPath) ?? timestamp;
+    return {
+      tool: "codex",
+      sessionId: id,
+      cwd,
+      startTs: timestamp,
+      endTs,
+      path: jsonlPath
+    };
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function* walkClaudeProjects(opts = {}) {
+  const root = expandHome(opts.root ?? "~/.claude/projects");
+  const dirs = await listDirSafe(root);
+  for (const dirent of dirs) {
+    if (!dirent.isDirectory) continue;
+    const dirPath = join3(root, dirent.name);
+    const files = await listDirSafe(dirPath);
+    let cachedCwd = null;
+    for (const f of files) {
+      if (!f.isFile || !f.name.endsWith(".jsonl")) continue;
+      const filePath = join3(dirPath, f.name);
+      if (opts.sinceMtimeMs !== void 0) {
+        const mtime = await mtimeMs(filePath);
+        if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
+      }
+      let meta;
+      if (cachedCwd) {
+        const sessionId = f.name.replace(/\.jsonl$/, "");
+        const startTs = await readFirstTimestamp(filePath);
+        const endTs = await readLastTimestamp(filePath);
+        meta = { tool: "claude", sessionId, cwd: cachedCwd, startTs, endTs, path: filePath };
+      } else {
+        meta = await extractClaudeSessionMeta(filePath);
+        if (meta) cachedCwd = meta.cwd;
+      }
+      if (meta) yield meta;
+    }
+  }
+}
+async function* walkCodexSessions(opts = {}) {
+  const root = resolveCodexSessionsRoot(opts.root);
+  for await (const filePath of walkJsonlRecursive(root)) {
+    const basename6 = filePath.split("/").pop() ?? "";
+    if (!basename6.endsWith(".jsonl")) continue;
+    if (opts.sinceMtimeMs !== void 0) {
+      const mtime = await mtimeMs(filePath);
+      if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
+    }
+    const meta = await extractCodexSessionMeta(filePath);
+    if (meta) yield meta;
+  }
+}
+function resolveCodexSessionsRoot(override) {
+  if (override) return expandHome(override);
+  const fromSessionsEnv = process.env.CODEX_SESSIONS_DIR;
+  if (fromSessionsEnv && fromSessionsEnv.length > 0) return expandHome(fromSessionsEnv);
+  const fromHomeEnv = process.env.CODEX_HOME;
+  if (fromHomeEnv && fromHomeEnv.length > 0) return join3(expandHome(fromHomeEnv), "sessions");
+  return join3(homedir3(), ".codex", "sessions");
+}
+async function listDirSafe(path) {
+  try {
+    const entries = await readdir11(path, { withFileTypes: true });
+    return entries.map((e) => ({
+      name: e.name,
+      isFile: e.isFile(),
+      isDirectory: e.isDirectory()
+    }));
+  } catch {
+    return [];
+  }
+}
+async function* walkJsonlRecursive(root) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = await listDirSafe(current);
+    for (const e of entries) {
+      const full = join3(current, e.name);
+      if (e.isDirectory) {
+        stack.push(full);
+      } else if (e.isFile && e.name.endsWith(".jsonl")) {
+        yield full;
+      }
+    }
+  }
+}
+async function mtimeMs(path) {
+  try {
+    const s = await stat2(path);
+    return s.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function readFirstTimestamp(path) {
+  let handle;
+  try {
+    handle = await open3(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stream = handle.createReadStream({ encoding: "utf-8" });
+    let buffer = "";
+    let scanned = 0;
+    for await (const chunk of stream) {
+      buffer += chunk;
+      let nl = buffer.indexOf("\n");
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const ts = extractTimestamp(line);
+        if (ts) {
+          stream.destroy();
+          return ts;
+        }
+        scanned++;
+        if (scanned >= SCAN_LINE_CAP) {
+          stream.destroy();
+          return null;
+        }
+        nl = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.length > 0) return extractTimestamp(buffer);
+    return null;
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+async function readLastTimestamp(path) {
+  let handle;
+  try {
+    handle = await open3(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const stats = await handle.stat();
+    const size = stats.size;
+    if (size === 0) return null;
+    for (const windowBytes of [TAIL_READ_BYTES, TAIL_READ_BYTES_MAX]) {
+      const start = Math.max(0, size - windowBytes);
+      const length = size - start;
+      const buf = Buffer.alloc(length);
+      await handle.read(buf, 0, length, start);
+      const text = buf.toString("utf-8");
+      const lines = text.split("\n");
+      if (start > 0) lines.shift();
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const ts = extractTimestamp(lines[i]);
+        if (ts) return ts;
+      }
+      if (start === 0) break;
+    }
+    return null;
+  } finally {
+    await handle.close().catch(() => {
+    });
+  }
+}
+function extractTimestamp(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed[0] !== "{") return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.timestamp === "string" && parsed.timestamp.length > 0) {
+      return parsed.timestamp;
+    }
+  } catch {
+  }
+  return null;
+}
+var SCAN_LINE_CAP, TAIL_READ_BYTES, TAIL_READ_BYTES_MAX;
+var init_cwd_extractor = __esm({
+  "src/usage/cwd-extractor.ts"() {
+    "use strict";
     init_paths();
-    init_timestamp();
-    init_facts();
-    init_derive();
-    init_frontmatter();
-    init_types();
-    LOCK_FILE = ".derive.lock";
-    LOCK_STALE_MS = 3e4;
-    LOCK_WAIT_MS = 50;
-    LOCK_MAX_WAITS = 100;
-    CAS_RETRIES = 3;
-    MIGRATION_MARKER = "derive-migrated";
+    init_transcript();
+    SCAN_LINE_CAP = 50;
+    TAIL_READ_BYTES = 8 * 1024;
+    TAIL_READ_BYTES_MAX = 64 * 1024;
+  }
+});
+
+// src/utils/session-id.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { mkdirSync, readFileSync, statSync as statSync3, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join4 } from "path";
+function isSafeSessionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && SAFE_SESSION_ID.test(value);
+}
+var SAFE_SESSION_ID;
+var init_session_id = __esm({
+  "src/utils/session-id.ts"() {
+    "use strict";
+    init_process_info();
+    init_cwd_extractor();
+    SAFE_SESSION_ID = /^[A-Za-z0-9_-]+$/;
   }
 });
 
@@ -9627,6 +10433,420 @@ var init_assignment_todos = __esm({
   }
 });
 
+// src/targets/renderers.ts
+var RENDERERS;
+var init_renderers = __esm({
+  "src/targets/renderers.ts"() {
+    "use strict";
+    init_cursor_rules();
+    init_codex_agents();
+    init_opencode_config();
+    init_hermes_soul();
+    RENDERERS = {
+      codexAgents: (ctx) => renderCodexAgents(ctx),
+      cursorProtocol: () => renderCursorProtocol(),
+      cursorAssignment: (ctx) => renderCursorAssignment(ctx),
+      openCodeConfig: (ctx) => renderOpenCodeConfig({ projectDir: ctx.projectDir }),
+      hermesSoul: (ctx) => renderHermesSoul(ctx)
+    };
+  }
+});
+
+// src/targets/user-descriptors.ts
+import { resolve as resolve34 } from "path";
+import { readFile as readFile23, readdir as readdir16 } from "fs/promises";
+var VALID_RENDERER_KEYS;
+var init_user_descriptors = __esm({
+  "src/targets/user-descriptors.ts"() {
+    "use strict";
+    init_fs();
+    init_paths();
+    init_renderers();
+    VALID_RENDERER_KEYS = new Set(Object.keys(RENDERERS));
+  }
+});
+
+// src/targets/registry.ts
+import { homedir as homedir6 } from "os";
+import { join as join8, resolve as resolve35 } from "path";
+function home(...segments) {
+  return resolve35(homedir6(), ...segments);
+}
+function hermesHome() {
+  const env = process.env.HERMES_HOME;
+  return env && env.length > 0 ? resolve35(env) : home(".hermes");
+}
+function hermesSkillsDir() {
+  return resolve35(hermesHome(), "skills");
+}
+function codexHome() {
+  const env = process.env.CODEX_HOME;
+  return env && env.length > 0 ? resolve35(env) : home(".codex");
+}
+function toDiscovered(meta) {
+  if (!meta) return null;
+  return {
+    sessionId: meta.sessionId,
+    cwd: meta.cwd,
+    startedAt: meta.startTs,
+    endedAt: meta.endTs,
+    transcriptPath: meta.path
+  };
+}
+var detectDir, claudeSessions, codexSessions, AGENT_TARGETS, AGENT_TARGETS_BY_ID;
+var init_registry = __esm({
+  "src/targets/registry.ts"() {
+    "use strict";
+    init_fs();
+    init_cwd_extractor();
+    init_user_descriptors();
+    detectDir = (dir) => () => fileExists(dir);
+    claudeSessions = {
+      globs: (root) => [join8(root ?? home(".claude", "projects"), "*", "*.jsonl")],
+      parse: async (file) => toDiscovered(await extractClaudeSessionMeta(file)),
+      walk: async function* (opts = {}) {
+        for await (const meta of walkClaudeProjects({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
+          const d = toDiscovered(meta);
+          if (d) yield d;
+        }
+      }
+    };
+    codexSessions = {
+      globs: (root) => [join8(root ?? resolveCodexSessionsRoot(), "**", "*.jsonl")],
+      parse: async (file) => toDiscovered(await extractCodexSessionMeta(file)),
+      walk: async function* (opts = {}) {
+        for await (const meta of walkCodexSessions({ root: opts.root, sinceMtimeMs: opts.sinceMtimeMs })) {
+          const d = toDiscovered(meta);
+          if (d) yield d;
+        }
+      }
+    };
+    AGENT_TARGETS = [
+      {
+        id: "cursor",
+        displayName: "Cursor",
+        skillsShAgentId: "cursor",
+        detect: detectDir(home(".cursor")),
+        skillsDir: { global: home(".cursor", "skills") },
+        instructions: {
+          files: [
+            { path: ".cursor/rules/syntaur-protocol.mdc", renderer: "cursorProtocol" },
+            { path: ".cursor/rules/syntaur-assignment.mdc", renderer: "cursorAssignment" }
+          ]
+        }
+      },
+      {
+        // codex is BOTH an adapter (writes AGENTS.md) AND a native plugin.
+        id: "codex",
+        displayName: "Codex",
+        skillsShAgentId: "codex",
+        nativePlugin: "codex",
+        detect: detectDir(codexHome()),
+        skillsDir: { global: resolve35(codexHome(), "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        sessions: codexSessions
+      },
+      {
+        id: "opencode",
+        displayName: "OpenCode",
+        skillsShAgentId: "opencode",
+        detect: detectDir(home(".config", "opencode")),
+        skillsDir: { global: home(".config", "opencode", "skills") },
+        instructions: {
+          files: [
+            { path: "AGENTS.md", renderer: "codexAgents" },
+            { path: "opencode.json", renderer: "openCodeConfig" }
+          ]
+        }
+      },
+      {
+        // claude has NO adapter today (not in the old SUPPORTED_FRAMEWORKS) — the
+        // full plugin path owns its skills/hooks/commands. Native-plugin only.
+        id: "claude",
+        displayName: "Claude Code",
+        skillsShAgentId: "claude-code",
+        nativePlugin: "claude",
+        detect: detectDir(home(".claude")),
+        skillsDir: { global: home(".claude", "skills") },
+        sessions: claudeSessions
+      },
+      {
+        id: "pi",
+        displayName: "Pi",
+        skillsShAgentId: "pi",
+        detect: detectDir(home(".pi")),
+        skillsDir: { global: home(".pi", "agent", "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        tier3: {
+          kind: "pi-extension",
+          source: "platforms/pi/extensions/syntaur",
+          installDir: () => home(".pi", "agent", "extensions", "syntaur"),
+          entry: "index.ts"
+        }
+      },
+      {
+        id: "openclaw",
+        displayName: "OpenClaw",
+        skillsShAgentId: "openclaw",
+        detect: detectDir(home(".openclaw")),
+        skillsDir: { global: home(".openclaw", "skills") },
+        instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
+        // OpenClaw runs on pi-coding-agent (design memo), so it reuses the pi
+        // extension SOURCE; only the install dir differs.
+        tier3: {
+          kind: "pi-extension",
+          source: "platforms/pi/extensions/syntaur",
+          installDir: () => home(".openclaw", "extensions", "syntaur"),
+          entry: "index.ts"
+        }
+      },
+      {
+        id: "hermes",
+        displayName: "Hermes Agent",
+        skillsShAgentId: "hermes-agent",
+        detect: () => fileExists(hermesHome()),
+        skillsDir: { global: hermesSkillsDir() },
+        instructions: { files: [{ path: "SOUL.md", renderer: "hermesSoul" }] },
+        tier3: {
+          kind: "hermes-plugin",
+          source: "platforms/hermes/plugins/syntaur",
+          installDir: () => resolve35(hermesHome(), "plugins", "syntaur"),
+          entry: "plugin.yaml"
+        }
+      }
+    ];
+    AGENT_TARGETS_BY_ID = Object.fromEntries(
+      AGENT_TARGETS.map((t) => [t.id, t])
+    );
+  }
+});
+
+// src/sessions/scanner.ts
+var scanner_exports2 = {};
+__export(scanner_exports2, {
+  scanSessions: () => scanSessions
+});
+import { execFile as execFile3, execFileSync as execFileSync4 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { statSync as statSync4 } from "fs";
+import { readFile as readFile24 } from "fs/promises";
+import { resolve as resolve36 } from "path";
+function emptySummary() {
+  return { discovered: 0, inserted: 0, revived: 0, swept: 0, skipped: 0, changed: false };
+}
+function defaultStatMtimeMs(path) {
+  try {
+    return statSync4(path).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function defaultIsPidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function defaultPidStartedAt(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  try {
+    const out = execFileSync4("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? null : trimmed;
+  } catch {
+    return null;
+  }
+}
+async function defaultOpenFiles(files) {
+  const open5 = /* @__PURE__ */ new Set();
+  for (let i = 0; i < files.length; i += LSOF_CHUNK) {
+    const chunk = files.slice(i, i + LSOF_CHUNK);
+    let stdout = "";
+    try {
+      const result = await execFileAsync("lsof", ["-Fn", "--", ...chunk], {
+        maxBuffer: 8 * 1024 * 1024
+      });
+      stdout = result.stdout;
+    } catch (err) {
+      const maybe = err.stdout;
+      stdout = typeof maybe === "string" ? maybe : "";
+    }
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("n") && line.length > 1) open5.add(line.slice(1));
+    }
+  }
+  return open5;
+}
+async function readContextLink(cwd, cache2) {
+  if (cache2.has(cwd)) return cache2.get(cwd);
+  let link = null;
+  const path = resolve36(cwd, ".syntaur", "context.json");
+  if (await fileExists(path)) {
+    try {
+      const parsed = JSON.parse(await readFile24(path, "utf-8"));
+      link = {
+        projectSlug: typeof parsed.projectSlug === "string" ? parsed.projectSlug : null,
+        assignmentSlug: typeof parsed.assignmentSlug === "string" ? parsed.assignmentSlug : null
+      };
+    } catch {
+      link = { projectSlug: null, assignmentSlug: null };
+    }
+  }
+  cache2.set(cwd, link);
+  return link;
+}
+function readWatermark() {
+  const db4 = getSessionDb();
+  const row = db4.prepare("SELECT value FROM meta WHERE key = ?").get(WATERMARK_KEY);
+  if (!row) return null;
+  const parsed = Number.parseInt(row.value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function writeWatermark(ms) {
+  const db4 = getSessionDb();
+  db4.prepare(
+    "INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(WATERMARK_KEY, String(ms));
+}
+async function scanSessions(opts = {}, deps = {}) {
+  const summary = emptySummary();
+  const autoTrack = deps.autoTrack ?? (await readConfig()).session.autoTrack;
+  if (autoTrack === "off") return summary;
+  const now = deps.now ?? (() => Date.now());
+  const statMtimeMs = deps.statMtimeMs ?? defaultStatMtimeMs;
+  const openFiles = deps.openFiles ?? defaultOpenFiles;
+  const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
+  const pidStartedAt = deps.pidStartedAt ?? defaultPidStartedAt;
+  const targets = (deps.targets ?? AGENT_TARGETS).filter((t) => t.sessions !== void 0);
+  const scanStartMs = now();
+  const watermark = opts.full ? null : readWatermark();
+  const discovered = [];
+  for (const target of targets) {
+    const walk = target.sessions.walk({
+      root: deps.roots?.[target.id],
+      sinceMtimeMs: watermark ?? void 0
+    });
+    for await (const session of walk) {
+      if (!isSafeSessionId(session.sessionId)) continue;
+      discovered.push({ ...session, agent: target.id });
+    }
+  }
+  summary.discovered = discovered.length;
+  const openSet = await openFiles(discovered.map((d) => d.transcriptPath));
+  const contextCache = /* @__PURE__ */ new Map();
+  for (const d of discovered) {
+    const link = await readContextLink(d.cwd, contextCache);
+    if (autoTrack === "workspaces-only" && link === null) {
+      summary.skipped += 1;
+      continue;
+    }
+    const mtime = statMtimeMs(d.transcriptPath);
+    const heldOpen = openSet.has(d.transcriptPath);
+    const isLive = heldOpen || mtime !== null && now() - mtime < FRESH_MTIME_MS;
+    const prev = getSessionById(d.sessionId);
+    const status = isLive ? "active" : prev?.status ?? "stopped";
+    const started = d.startedAt ?? (mtime !== null ? new Date(mtime).toISOString() : new Date(now()).toISOString());
+    await appendSession(
+      "",
+      {
+        sessionId: d.sessionId,
+        projectSlug: link?.projectSlug ?? null,
+        assignmentSlug: link?.assignmentSlug ?? null,
+        agent: d.agent,
+        started,
+        status,
+        path: d.cwd,
+        description: null,
+        transcriptPath: d.transcriptPath,
+        pid: null,
+        pidStartedAt: null,
+        originalHeadSha: null
+      },
+      // Narrow revival rule: only LIVE-PROCESS evidence (a process holding the
+      // transcript open) may flip a stopped row back to active. mtime freshness
+      // alone must not — a session stopped moments ago by its SessionEnd hook
+      // still has a fresh transcript for up to 5 minutes and would flap back to
+      // active. `completed` always sticks (appendSession enforces).
+      { reviveStopped: heldOpen }
+    );
+    if (!isLive) {
+      const after = getSessionById(d.sessionId);
+      if (after && after.status === "stopped" && !after.ended) {
+        const endedAt = d.endedAt ?? (mtime !== null ? new Date(mtime).toISOString() : void 0);
+        await updateSessionStatus("", d.sessionId, "stopped", endedAt);
+      }
+    }
+    if (!prev) {
+      summary.inserted += 1;
+      summary.changed = true;
+    } else {
+      if (prev.status === "stopped" && heldOpen) {
+        summary.revived += 1;
+        summary.changed = true;
+      }
+      if (link?.projectSlug && !prev.projectSlug || link?.assignmentSlug && !prev.assignmentSlug) {
+        summary.changed = true;
+      }
+    }
+  }
+  const db4 = getSessionDb();
+  const activeRows = db4.prepare("SELECT session_id, pid, pid_started_at, transcript_path FROM sessions WHERE status = 'active'").all();
+  const sweepCandidates = [];
+  for (const row of activeRows) {
+    if (row.pid !== null) {
+      const alive = isPidAlive(row.pid) && (!row.pid_started_at || (pidStartedAt(row.pid) ?? row.pid_started_at) === row.pid_started_at);
+      if (alive) continue;
+    }
+    if (row.transcript_path) {
+      sweepCandidates.push({ sessionId: row.session_id, transcriptPath: row.transcript_path });
+    } else if (row.pid !== null) {
+      sweepCandidates.push({ sessionId: row.session_id, transcriptPath: null });
+    }
+  }
+  const sweepOpenSet = await openFiles(
+    sweepCandidates.map((c) => c.transcriptPath).filter((p) => p !== null)
+  );
+  for (const candidate of sweepCandidates) {
+    if (candidate.transcriptPath) {
+      if (sweepOpenSet.has(candidate.transcriptPath)) continue;
+      const mtime = statMtimeMs(candidate.transcriptPath);
+      if (mtime !== null && now() - mtime < FRESH_MTIME_MS) continue;
+      const endedAt = mtime !== null ? new Date(mtime).toISOString() : void 0;
+      if (await updateSessionStatus("", candidate.sessionId, "stopped", endedAt)) {
+        summary.swept += 1;
+        summary.changed = true;
+      }
+    } else if (await updateSessionStatus("", candidate.sessionId, "stopped")) {
+      summary.swept += 1;
+      summary.changed = true;
+    }
+  }
+  writeWatermark(scanStartMs);
+  return summary;
+}
+var execFileAsync, FRESH_MTIME_MS, LSOF_CHUNK, WATERMARK_KEY;
+var init_scanner2 = __esm({
+  "src/sessions/scanner.ts"() {
+    "use strict";
+    init_fs();
+    init_config2();
+    init_session_id();
+    init_registry();
+    init_session_db();
+    init_agent_sessions();
+    execFileAsync = promisify3(execFile3);
+    FRESH_MTIME_MS = 5 * 60 * 1e3;
+    LSOF_CHUNK = 64;
+    WATERMARK_KEY = "sessions_scan_last_ms";
+  }
+});
+
 // src/dashboard/server.ts
 init_paths();
 init_api();
@@ -9634,7 +10854,7 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve33 } from "path";
+import { resolve as resolve37 } from "path";
 import { writeFile as writeFile8, unlink as unlink8 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
@@ -9929,11 +11149,9 @@ function createWatcher(options) {
         debounceKey,
         setTimeout(() => {
           pendingEvents.delete(debounceKey);
-          const message = {
-            type: "leases-updated",
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          onMessage(message);
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          onMessage({ type: "leases-updated", timestamp });
+          onMessage({ type: "agent-sessions-updated", timestamp });
         }, debounceMs)
       );
     };
@@ -10004,7 +11222,11 @@ var SORT_FIELDS = [
   "assignee",
   "dependencies",
   "created",
-  "updated"
+  "updated",
+  "started",
+  "lastActivity",
+  "projectName",
+  "agentName"
 ];
 var SORT_DIRECTIONS = ["asc", "desc"];
 var DENSITIES = ["comfortable", "compact"];
@@ -10017,7 +11239,7 @@ var GROUPINGS = [
   "project"
 ];
 var ACTIVITIES = ["all", "stale", "fresh"];
-var DATE_RANGE_FIELDS = ["created", "updated"];
+var DATE_RANGE_FIELDS = ["created", "updated", "started"];
 var DATE_RANGE_PRESETS = [
   "last_24h",
   "last_7d",
@@ -10266,6 +11488,7 @@ function makeSeededView(id, name, filterOverrides) {
     id,
     name,
     workspace: null,
+    entityType: "assignment",
     config: {
       viewMode: "list",
       filters: { ...DEFAULT_FILTERS, ...filterOverrides },
@@ -10303,7 +11526,13 @@ function isWidgetConfig(value) {
   if (obj.kind === "saved-view") {
     return typeof obj.viewId === "string" && obj.viewId.length > 0;
   }
-  return obj.kind === "agent-sessions" || obj.kind === "inventories";
+  if (obj.kind === "agent-sessions") {
+    if (obj.viewId !== void 0) {
+      return typeof obj.viewId === "string" && obj.viewId.length > 0;
+    }
+    return true;
+  }
+  return obj.kind === "inventories";
 }
 function isListSectionVisibility(value) {
   if (!value || typeof value !== "object") return false;
@@ -10340,6 +11569,9 @@ function isSavedViewConfig(value) {
 function isSavedView(value) {
   if (!value || typeof value !== "object") return false;
   const obj = value;
+  if (obj.entityType !== void 0 && obj.entityType !== "assignment" && obj.entityType !== "session") {
+    return false;
+  }
   return typeof obj.id === "string" && obj.id.length > 0 && typeof obj.name === "string" && (obj.workspace === null || typeof obj.workspace === "string") && isSavedViewConfig(obj.config) && typeof obj.createdAt === "string" && typeof obj.updatedAt === "string";
 }
 function isDashboardSlot(value) {
@@ -10434,6 +11666,8 @@ function createSavedView(file, input, now = () => (/* @__PURE__ */ new Date()).t
     id: randomUUID(),
     name: input.name,
     workspace: input.workspace,
+    // Only persist entityType when explicitly a session view; absent === assignment.
+    ...input.entityType === "session" ? { entityType: "session" } : {},
     config: input.config,
     createdAt: ts,
     updatedAt: ts
@@ -10532,12 +11766,16 @@ function validateCreateBody(body) {
   if (!isSavedViewConfig(obj.config)) {
     return { ok: false, error: "config must be a valid SavedViewConfig" };
   }
+  if (obj.entityType !== void 0 && obj.entityType !== "assignment" && obj.entityType !== "session") {
+    return { ok: false, error: "entityType must be 'assignment' or 'session'" };
+  }
   return {
     ok: true,
     value: {
       name: obj.name.trim(),
       workspace: obj.workspace,
-      config: obj.config
+      config: obj.config,
+      ...obj.entityType !== void 0 ? { entityType: obj.entityType } : {}
     }
   };
 }
@@ -11537,6 +12775,12 @@ tags: []
 `;
 }
 
+// src/templates/index.ts
+init_cursor_rules();
+init_codex_agents();
+init_opencode_config();
+init_hermes_soul();
+
 // src/dashboard/api-write.ts
 init_lifecycle();
 init_parser();
@@ -14261,86 +15505,11 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir2) {
 // src/dashboard/api-agent-sessions.ts
 init_agent_sessions();
 init_fs();
+init_transcript();
 import { Router as Router4 } from "express";
 import { resolve as resolve21 } from "path";
-
-// src/utils/transcript.ts
-import { open as open2 } from "fs/promises";
-var MAX_LINES_SCANNED = 50;
-async function derivePathFromTranscript(transcriptPath) {
-  if (!transcriptPath) return null;
-  let handle;
-  try {
-    handle = await open2(transcriptPath, "r");
-  } catch {
-    return null;
-  }
-  try {
-    const stream = handle.createReadStream({ encoding: "utf-8" });
-    let buffer = "";
-    let scanned = 0;
-    for await (const chunk of stream) {
-      buffer += chunk;
-      let nl = buffer.indexOf("\n");
-      while (nl !== -1) {
-        const line = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        const cwd = extractCwd(line);
-        if (cwd) {
-          stream.destroy();
-          return cwd;
-        }
-        scanned++;
-        if (scanned >= MAX_LINES_SCANNED) {
-          stream.destroy();
-          return null;
-        }
-        nl = buffer.indexOf("\n");
-      }
-    }
-    if (buffer.length > 0) {
-      const cwd = extractCwd(buffer);
-      if (cwd) return cwd;
-    }
-    return null;
-  } finally {
-    await handle.close().catch(() => {
-    });
-  }
-}
-function extractCwd(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0 || trimmed[0] !== "{") return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed.cwd === "string" && parsed.cwd.length > 0) {
-      return parsed.cwd;
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/dashboard/api-agent-sessions.ts
 init_config2();
-
-// src/utils/process-info.ts
-import { execFileSync as execFileSync2 } from "child_process";
-function captureProcessStartedAt(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return null;
-  try {
-    const out = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const trimmed = out.trim();
-    return trimmed === "" ? null : trimmed;
-  } catch {
-    return null;
-  }
-}
-
-// src/dashboard/api-agent-sessions.ts
+init_process_info();
 init_git_worktree();
 init_cwd();
 function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
@@ -15234,13 +16403,20 @@ async function resolveSessionPlan(input, terminal) {
     env: process.env,
     agentId: agent.id,
     fallbackWarning,
-    shellFallbackWarning
+    shellFallbackWarning,
+    // Resume continues the SAME session id; fork mints a new one in-agent.
+    session: { sessionId: (input.mode ?? "resume") === "resume" ? session.sessionId : null }
   };
 }
 
 // src/launch/execute.ts
 import { spawn as spawn3 } from "child_process";
-import { basename as basename4 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename as basename4, join as join5, resolve as resolve23 } from "path";
+init_fs();
+init_config2();
+init_session_id();
+init_process_info();
 var CMUX_BUNDLE_ID = "com.cmuxterm.app";
 var CMUX_READINESS_MAX_MS = 20 * 250;
 var CMUX_LAUNCH_TIMEOUT_MS = CMUX_READINESS_MAX_MS + 3e3;
@@ -15265,8 +16441,8 @@ function buildShellCommandLine(plan) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname5, resolve as resolve23, join as join3 } from "path";
-import { realpathSync, readFileSync, mkdirSync } from "fs";
+import { dirname as dirname6, resolve as resolve24, join as join6 } from "path";
+import { realpathSync, readFileSync as readFileSync2, mkdirSync as mkdirSync2 } from "fs";
 
 // src/dashboard/api-launch-preflight.ts
 init_assignment_resolver();
@@ -15543,32 +16719,32 @@ import { Router as Router9 } from "express";
 // src/utils/status-config-resolution.ts
 init_frontmatter();
 import { readFile as readFile18, writeFile as writeFile5, rm as rm2 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 
 // src/utils/assignment-walk.ts
 init_fs();
-import { resolve as resolve24 } from "path";
-import { readdir as readdir11 } from "fs/promises";
+import { resolve as resolve25 } from "path";
+import { readdir as readdir12 } from "fs/promises";
 async function listAssignmentsByProject(projectsDir, standaloneDir) {
   const result = {
     withAssignmentMd: [],
     orphanFolders: []
   };
   if (await fileExists(projectsDir)) {
-    const projects = await readdir11(projectsDir, { withFileTypes: true });
+    const projects = await readdir12(projectsDir, { withFileTypes: true });
     for (const m of projects) {
       if (!m.isDirectory()) continue;
       if (m.name.startsWith(".") || m.name.startsWith("_")) continue;
-      const assignmentsDir2 = resolve24(projectsDir, m.name, "assignments");
+      const assignmentsDir2 = resolve25(projectsDir, m.name, "assignments");
       if (!await fileExists(assignmentsDir2)) continue;
-      const entries = await readdir11(assignmentsDir2, { withFileTypes: true });
+      const entries = await readdir12(assignmentsDir2, { withFileTypes: true });
       for (const a of entries) {
         if (!a.isDirectory()) continue;
         if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-        const assignmentDir = resolve24(assignmentsDir2, a.name);
-        const assignmentMd = resolve24(assignmentDir, "assignment.md");
+        const assignmentDir = resolve25(assignmentsDir2, a.name);
+        const assignmentMd = resolve25(assignmentDir, "assignment.md");
         const entry = {
-          projectDir: resolve24(projectsDir, m.name),
+          projectDir: resolve25(projectsDir, m.name),
           projectSlug: m.name,
           assignmentDir,
           assignmentSlug: a.name,
@@ -15583,12 +16759,12 @@ async function listAssignmentsByProject(projectsDir, standaloneDir) {
     }
   }
   if (standaloneDir !== null && await fileExists(standaloneDir)) {
-    const entries = await readdir11(standaloneDir, { withFileTypes: true });
+    const entries = await readdir12(standaloneDir, { withFileTypes: true });
     for (const a of entries) {
       if (!a.isDirectory()) continue;
       if (a.name.startsWith(".") || a.name.startsWith("_")) continue;
-      const assignmentDir = resolve24(standaloneDir, a.name);
-      const assignmentMd = resolve24(assignmentDir, "assignment.md");
+      const assignmentDir = resolve25(standaloneDir, a.name);
+      const assignmentMd = resolve25(assignmentDir, "assignment.md");
       const entry = {
         projectDir: standaloneDir,
         projectSlug: null,
@@ -15780,7 +16956,7 @@ async function applyStatusResolutions(resolutions, affected, validTargets) {
       } catch {
         continue;
       }
-      const assignmentDir = dirname6(a.path);
+      const assignmentDir = dirname7(a.path);
       try {
         await rm2(assignmentDir, { recursive: true, force: true });
         deleted++;
@@ -16098,7 +17274,7 @@ import { Router as Router10 } from "express";
 init_paths();
 import Database2 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var db2 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL2 = `
@@ -16185,7 +17361,7 @@ function isBusyError(err) {
 }
 function initLeasesDb(dbPath) {
   if (db2) return db2;
-  const finalPath = dbPath ?? resolve25(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve26(syntaurRoot(), "syntaur.db");
   db2 = new Database2(finalPath);
   db2.pragma("journal_mode = WAL");
   db2.pragma("busy_timeout = 5000");
@@ -16334,7 +17510,7 @@ import { Router as Router11 } from "express";
 // src/db/usage-db.ts
 init_paths();
 import Database3 from "better-sqlite3";
-import { resolve as resolve26 } from "path";
+import { resolve as resolve27 } from "path";
 var db3 = null;
 var USAGE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL3 = `
@@ -16391,7 +17567,7 @@ CREATE INDEX IF NOT EXISTS idx_usage_daily_day
 `;
 function initUsageDb(dbPath) {
   if (db3) return db3;
-  const finalPath = dbPath ?? resolve26(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve27(syntaurRoot(), "syntaur.db");
   db3 = new Database3(finalPath);
   db3.pragma("journal_mode = WAL");
   db3.pragma("busy_timeout = 5000");
@@ -16650,7 +17826,7 @@ init_slug();
 init_timestamp();
 init_fs();
 import { Router as Router12 } from "express";
-import { resolve as resolve27 } from "path";
+import { resolve as resolve28 } from "path";
 import { readFile as readFile19 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
@@ -16733,7 +17909,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve27(playbooksDir2, resolved.filename);
+      const filePath = resolve28(playbooksDir2, resolved.filename);
       const content = await readFile19(filePath, "utf-8");
       res.json({
         documentType: "playbook",
@@ -16759,7 +17935,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve27(playbooksDir2, `${slug}.md`);
+      const filePath = resolve28(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -16783,7 +17959,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req.params.slug}" not found` });
         return;
       }
-      const filePath = resolve27(playbooksDir2, resolved.filename);
+      const filePath = resolve28(playbooksDir2, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: resolved.slug, path: filePath });
@@ -16831,8 +18007,8 @@ init_parser2();
 init_fs();
 init_paths();
 import { Router as Router14 } from "express";
-import { readdir as readdir13 } from "fs/promises";
-import { resolve as resolvePath, dirname as dirname8 } from "path";
+import { readdir as readdir14 } from "fs/promises";
+import { resolve as resolvePath, dirname as dirname9 } from "path";
 import { rename as rename6, mkdir as mkdir4 } from "fs/promises";
 init_slug();
 
@@ -16842,7 +18018,7 @@ init_parser2();
 // src/commands/create-assignment.ts
 init_slug();
 init_timestamp();
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 init_paths();
 init_fs();
 init_config2();
@@ -16920,14 +18096,14 @@ async function createAssignmentCommand(title, options) {
   if (options.oneOff) {
     const standaloneRoot = assignmentsDir();
     folderName = id;
-    assignmentDir = resolve28(standaloneRoot, folderName);
+    assignmentDir = resolve29(standaloneRoot, folderName);
     projectSlug = null;
     await ensureDir(standaloneRoot);
   } else {
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
     projectSlug = options.project;
-    const projectDir = resolve28(baseDir, projectSlug);
-    const projectMdPath = resolve28(projectDir, "project.md");
+    const projectDir = resolve29(baseDir, projectSlug);
+    const projectMdPath = resolve29(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(
         `Project "${projectSlug}" not found at ${projectDir}.
@@ -16935,9 +18111,9 @@ Run 'syntaur create-project' first or use --one-off.`
       );
     }
     if (dependsOn.length > 0) {
-      const depDirBase = resolve28(projectDir, "assignments");
+      const depDirBase = resolve29(projectDir, "assignments");
       for (const dep of dependsOn) {
-        const depDir = resolve28(depDirBase, dep);
+        const depDir = resolve29(depDirBase, dep);
         if (!await fileExists(depDir)) {
           console.warn(
             `Warning: dependency "${dep}" does not exist in project "${projectSlug}" yet.`
@@ -16946,7 +18122,7 @@ Run 'syntaur create-project' first or use --one-off.`
       }
     }
     folderName = assignmentSlug;
-    assignmentDir = resolve28(projectDir, "assignments", folderName);
+    assignmentDir = resolve29(projectDir, "assignments", folderName);
   }
   if (await fileExists(assignmentDir)) {
     throw new Error(
@@ -16958,7 +18134,7 @@ Use --slug to specify a different slug.`
   const companionAssignmentRef = projectSlug === null ? id : assignmentSlug;
   const files = [
     [
-      resolve28(assignmentDir, "assignment.md"),
+      resolve29(assignmentDir, "assignment.md"),
       renderAssignment({
         id,
         slug: assignmentSlug,
@@ -16976,35 +18152,35 @@ Use --slug to specify a different slug.`
       })
     ],
     [
-      resolve28(assignmentDir, "scratchpad.md"),
+      resolve29(assignmentDir, "scratchpad.md"),
       renderScratchpad({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve28(assignmentDir, "handoff.md"),
+      resolve29(assignmentDir, "handoff.md"),
       renderHandoff({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve28(assignmentDir, "decision-record.md"),
+      resolve29(assignmentDir, "decision-record.md"),
       renderDecisionRecord({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve28(assignmentDir, "progress.md"),
+      resolve29(assignmentDir, "progress.md"),
       renderProgress({
         assignment: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve28(assignmentDir, "comments.md"),
+      resolve29(assignmentDir, "comments.md"),
       renderComments({
         assignment: companionAssignmentRef,
         timestamp
@@ -17177,8 +18353,8 @@ init_api();
 import { raw } from "express";
 
 // src/todos/attachments.ts
-import { mkdir as mkdir3, readdir as readdir12, stat as stat2, rename as rename5, rm as rm3, unlink as unlink6, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve29, basename as basename5, dirname as dirname7, extname } from "path";
+import { mkdir as mkdir3, readdir as readdir13, stat as stat3, rename as rename5, rm as rm3, unlink as unlink6, writeFile as writeFile6, cp } from "fs/promises";
+import { resolve as resolve30, basename as basename5, dirname as dirname8, extname } from "path";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -17265,16 +18441,16 @@ function sanitizeAttachmentName(name) {
   return n;
 }
 function attachmentsRootDir(todosDir2) {
-  return resolve29(todosDir2, "attachments");
+  return resolve30(todosDir2, "attachments");
 }
 function attachmentDirFor(todosDir2, scopeId, todoId) {
   assertScope(scopeId);
   assertTodoId(todoId);
-  return resolve29(attachmentsRootDir(todosDir2), scopeId, todoId);
+  return resolve30(attachmentsRootDir(todosDir2), scopeId, todoId);
 }
 async function dirExists(p) {
   try {
-    return (await stat2(p)).isDirectory();
+    return (await stat3(p)).isDirectory();
   } catch {
     return false;
   }
@@ -17284,7 +18460,7 @@ async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes)
   await mkdir3(dir, { recursive: true });
   const id = generateArtifactId();
   const filename = sanitizeAttachmentName(originalName);
-  await writeFile6(resolve29(dir, `${id}__${filename}`), bytes);
+  await writeFile6(resolve30(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -17297,7 +18473,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir12(dir);
+    names = await readdir13(dir);
   } catch {
     return [];
   }
@@ -17309,7 +18485,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
     if (!ATTACHMENT_ID_RE.test(id)) continue;
     const filename = stored.slice(sep2 + 2);
     try {
-      const st = await stat2(resolve29(dir, stored));
+      const st = await stat3(resolve30(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -17320,10 +18496,10 @@ async function listAttachments(todosDir2, scopeId, todoId) {
 }
 async function readScopeAttachments(todosDir2, scopeId) {
   assertScope(scopeId);
-  const scopeDir = resolve29(attachmentsRootDir(todosDir2), scopeId);
+  const scopeDir = resolve30(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
-    todoIds = await readdir12(scopeDir);
+    todoIds = await readdir13(scopeDir);
   } catch {
     return {};
   }
@@ -17340,7 +18516,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const dir = attachmentDirFor(todosDir2, scopeId, todoId);
   let names;
   try {
-    names = await readdir12(dir);
+    names = await readdir13(dir);
   } catch {
     return null;
   }
@@ -17348,7 +18524,7 @@ async function resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId) {
   const stored = names.find((n) => n.startsWith(prefix));
   if (!stored) return null;
   const filename = stored.slice(prefix.length);
-  return { path: resolve29(dir, stored), filename, mime: mimeForName(filename) };
+  return { path: resolve30(dir, stored), filename, mime: mimeForName(filename) };
 }
 async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
   const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
@@ -17368,7 +18544,7 @@ async function moveAttachments(srcTodosDir, srcScopeId, dstTodosDir, dstScopeId,
   const src = attachmentDirFor(srcTodosDir, srcScopeId, todoId);
   if (!await dirExists(src)) return;
   const dst = attachmentDirFor(dstTodosDir, dstScopeId, todoId);
-  await mkdir3(dirname7(dst), { recursive: true });
+  await mkdir3(dirname8(dst), { recursive: true });
   try {
     await rename5(src, dst);
   } catch (err) {
@@ -17644,7 +18820,7 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.get("/", async (_req, res) => {
     try {
       await ensureDir(todosDir2);
-      const files = await readdir13(todosDir2).catch(() => []);
+      const files = await readdir14(todosDir2).catch(() => []);
       const workspaces = [];
       for (const file of files) {
         if (typeof file !== "string") continue;
@@ -17760,8 +18936,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.post("/:workspace/archive", async (req, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve34 } = await import("path");
-      const { readFile: readFile23 } = await import("fs/promises");
+      const { resolve: resolve38 } = await import("path");
+      const { readFile: readFile25 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req.params.workspace);
       const outcome = await wsLock(workspace, async () => {
@@ -17777,10 +18953,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
           (e) => e.itemIds.every((id) => completedIds.has(id))
         );
         const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-        await ensureDir(resolve34(todosDir2, "archive"));
+        await ensureDir(resolve38(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile23(archFile, "utf-8");
+          archContent = await readFile25(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -18069,7 +19245,7 @@ workspace: ${workspace}
         const { readConfig: readConfig2 } = 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: readFile23 } = await import("fs/promises");
+        const { readFile: readFile25 } = 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;
@@ -18090,7 +19266,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile23(assignmentMdPath, "utf-8");
+        let content = await readFile25(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -18207,7 +19383,7 @@ workspace: ${workspace}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir4(dirname8(newPlanDir), { recursive: true });
+          await mkdir4(dirname9(newPlanDir), { recursive: true });
           await rename6(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -18286,7 +19462,7 @@ init_paths();
 init_slug();
 import { Router as Router15 } from "express";
 import { mkdir as mkdir5, readFile as readFile20, rename as rename7 } from "fs/promises";
-import { resolve as resolve30, dirname as dirname9 } from "path";
+import { resolve as resolve31, dirname as dirname10 } from "path";
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -18302,7 +19478,7 @@ function params(req) {
   return req.params;
 }
 async function projectExists(projectsDir, slug) {
-  return fileExists(resolve30(projectsDir, slug, "project.md"));
+  return fileExists(resolve31(projectsDir, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
@@ -18319,7 +19495,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir5(resolve30(todosDir2, "archive"), { recursive: false });
+    await mkdir5(resolve31(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -18982,15 +20158,15 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve30(projectsDir, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve31(projectsDir, parts[0], "assignments", parts[1]);
           assignmentRef = `${parts[0]}/${parts[1]}`;
         } else if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(tg)) {
-          assignmentDir = resolve30(assignmentsDirFn(), tg);
+          assignmentDir = resolve31(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath = resolve30(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolve31(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
         let content = await readFile20(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
@@ -19131,7 +20307,7 @@ workspace: ${slug}
           return { status: 409, error: "attachments already exist in target" };
         }
         if (item.planDir && newPlanDir) {
-          await mkdir5(dirname9(newPlanDir), { recursive: true });
+          await mkdir5(dirname10(newPlanDir), { recursive: true });
           await rename7(item.planDir, newPlanDir);
           item.planDir = newPlanDir;
         }
@@ -19195,7 +20371,7 @@ workspace: ${slug}
 
 // src/dashboard/api-bundles.ts
 import { Router as Router16 } from "express";
-import { readdir as readdir14 } from "fs/promises";
+import { readdir as readdir15 } from "fs/promises";
 
 // src/todos/bundle-parser.ts
 init_parser();
@@ -19319,7 +20495,7 @@ function createBundlesRouter(todosDir2, broadcast) {
     try {
       await ensureDir(todosDir2);
       const bundles = await readBundles(todosDir2);
-      const workspaceFiles = await readdir14(todosDir2).catch(() => []);
+      const workspaceFiles = await readdir15(todosDir2).catch(() => []);
       const itemsByKey = /* @__PURE__ */ new Map();
       for (const f of workspaceFiles) {
         if (typeof f !== "string") continue;
@@ -19372,7 +20548,7 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router17 } from "express";
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 init_parser2();
 function deriveStatus2(bundle, items) {
   const members = bundle.todoIds.map((id) => items.find((i) => i.id === id)).filter((i) => i !== void 0);
@@ -19414,7 +20590,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
   router.get("/", async (req, res) => {
     try {
       const slug = getProjectIdParam2(req.params.projectId);
-      const projectMd = resolve31(projectsDir, slug, "project.md");
+      const projectMd = resolve32(projectsDir, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -19443,8 +20619,8 @@ init_fs();
 init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile22, writeFile as writeFile7, unlink as unlink7, stat as stat3, open as open3, rename as rename8 } from "fs/promises";
-import { resolve as resolve32, join as join4 } from "path";
+import { cp as cp2, mkdtemp, rm as rm4, readFile as readFile22, writeFile as writeFile7, unlink as unlink7, stat as stat4, open as open4, rename as rename8 } from "fs/promises";
+import { resolve as resolve33, join as join7 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -19484,7 +20660,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve32(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve33(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -19495,10 +20671,10 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock2() {
-  const lockPath = resolve32(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve33(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
-    const handle = await open3(lockPath, "wx");
+    const handle = await open4(lockPath, "wx");
     await handle.write(String(process.pid));
     await handle.close();
     return lockPath;
@@ -19537,12 +20713,12 @@ async function cloneOrInit(repoUrl, destDir) {
 }
 async function copyRecursive(src, dest) {
   if (!await fileExists(src)) return;
-  const s = await stat3(src);
+  const s = await stat4(src);
   if (s.isDirectory()) {
     await ensureDir(dest);
     await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve32(dest, ".."));
+    await ensureDir(resolve33(dest, ".."));
     await cp2(src, dest, { force: true });
   }
 }
@@ -19574,11 +20750,11 @@ async function backupToGithub(overrides) {
   let tmpDir = null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    tmpDir = await mkdtemp(join4(tmpdir(), "syntaur-backup-"));
+    tmpDir = await mkdtemp(join7(tmpdir(), "syntaur-backup-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       const { sourcePath, repoPath, isFile } = await resolveCategoryPath(category);
-      const destPath = join4(tmpDir, repoPath);
+      const destPath = join7(tmpDir, repoPath);
       if (isFile) {
         await rm4(destPath, { force: true });
       } else {
@@ -19590,7 +20766,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve32(destPath, ".."));
+        await ensureDir(resolve33(destPath, ".."));
         await writeFile7(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -19644,7 +20820,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve32(localPath, ".."));
+    await ensureDir(resolve33(localPath, ".."));
     await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -19706,7 +20882,7 @@ async function restoreFromGithub(overrides) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   try {
     await updateBackupConfig({ lastRestore: timestamp });
-    tmpDir = await mkdtemp(join4(tmpdir(), "syntaur-restore-"));
+    tmpDir = await mkdtemp(join7(tmpdir(), "syntaur-restore-"));
     await cloneOrInit(repo, tmpDir);
     for (const category of categories) {
       if (category === "config") {
@@ -19715,7 +20891,7 @@ async function restoreFromGithub(overrides) {
       }
       try {
         const { sourcePath: localPath, repoPath, isFile } = await resolveCategoryPath(category);
-        const repoSrcPath = join4(tmpDir, repoPath);
+        const repoSrcPath = join7(tmpDir, repoPath);
         if (!await fileExists(repoSrcPath)) {
           console.warn(`Category "${category}" not found in backup repo, skipping.`);
           continue;
@@ -19745,7 +20921,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve32(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve33(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -19906,7 +21082,7 @@ async function stopAutodiscovery() {
 function runReconcile() {
   if (activeReconcile || !savedOptions) return;
   const opts = savedOptions;
-  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids, opts.assignmentsDir).catch((err) => {
+  activeReconcile = reconcile(opts.serversDir, opts.projectsDir, opts.excludePids, opts.assignmentsDir, opts.onAgentSessionsChanged).catch((err) => {
     console.error("[autodiscovery] reconcile failed:", err);
   }).finally(() => {
     activeReconcile = null;
@@ -20027,7 +21203,7 @@ async function isProcessAlive(pid) {
     return false;
   }
 }
-async function reconcile(serversDir2, projectsDir, excludePids, assignmentsDir2) {
+async function reconcile(serversDir2, projectsDir, excludePids, assignmentsDir2, onAgentSessionsChanged) {
   const names = await listSessionFiles(serversDir2);
   const existingFiles = /* @__PURE__ */ new Map();
   for (const name of names) {
@@ -20044,6 +21220,16 @@ async function reconcile(serversDir2, projectsDir, excludePids, assignmentsDir2)
   if (tmuxChanged || processChanged || cleanupChanged) {
     clearScanCache();
   }
+  const { isSessionDbInitialized: isSessionDbInitialized2 } = await Promise.resolve().then(() => (init_session_db(), session_db_exports));
+  if (isSessionDbInitialized2()) {
+    try {
+      const { scanSessions: scanSessions2 } = await Promise.resolve().then(() => (init_scanner2(), scanner_exports2));
+      const summary = await scanSessions2({});
+      if (summary.changed) onAgentSessionsChanged?.();
+    } catch (err) {
+      console.error("[autodiscovery] session scan failed:", err);
+    }
+  }
 }
 
 // src/dashboard/server.ts
@@ -20093,7 +21279,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve33(syntaurRoot(), "config.md")
+        resolve37(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -20611,14 +21797,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve33(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve37(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req, res) => {
       if (req.path.startsWith("/api") || req.path === "/ws" || req.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve33(dashboardDistPath, "index.html");
+      const indexPath = resolve37(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -20652,8 +21838,8 @@ function createDashboardServer(options) {
         if (!await migrationGate()) return;
         try {
           const context = await resolveDeriveContext2();
-          const projectDir = projectSlug ? resolve33(projectsDir, projectSlug) : null;
-          const path = projectDir ? resolve33(projectDir, "assignments", assignmentSlug, "assignment.md") : resolve33(assignmentsDir2, assignmentSlug, "assignment.md");
+          const projectDir = projectSlug ? resolve37(projectsDir, projectSlug) : null;
+          const path = projectDir ? resolve37(projectDir, "assignments", assignmentSlug, "assignment.md") : resolve37(assignmentsDir2, assignmentSlug, "assignment.md");
           if (!await fileExists(path)) return;
           const result = await recomputeAndWrite2(path, {
             cause: "derive",
@@ -20689,8 +21875,8 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
-        dbPath: resolve33(syntaurRoot(), "syntaur.db"),
-        configPath: resolve33(syntaurRoot(), "config.md"),
+        dbPath: resolve37(syntaurRoot(), "syntaur.db"),
+        configPath: resolve37(syntaurRoot(), "config.md"),
         onMessage: broadcast,
         onAssignmentChanged: (projectSlug, assignmentSlug) => {
           void recomputeOne(projectSlug, assignmentSlug);
@@ -20701,7 +21887,16 @@ function createDashboardServer(options) {
         }
       });
       void sweepAll("boot-reconcile");
-      startAutodiscovery({ serversDir: serversDir2, projectsDir, assignmentsDir: assignmentsDir2, excludePids: /* @__PURE__ */ new Set([process.pid]) });
+      startAutodiscovery({
+        serversDir: serversDir2,
+        projectsDir,
+        assignmentsDir: assignmentsDir2,
+        excludePids: /* @__PURE__ */ new Set([process.pid]),
+        // Same WS frame the REST mutations emit, so the UI refreshes when the
+        // session scan inserts/revives/sweeps rows. Autodiscovery's immediate
+        // first run covers "scan at dashboard start".
+        onAgentSessionsChanged: () => broadcast({ type: "agent-sessions-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() })
+      });
       return new Promise((resolvePromise, reject) => {
         server.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
@@ -20713,7 +21908,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve33(syntaurRoot(), "dashboard-port");
+          const portFile = resolve37(syntaurRoot(), "dashboard-port");
           writeFile8(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -20732,7 +21927,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve33(syntaurRoot(), "dashboard-port");
+      const portFile = resolve37(syntaurRoot(), "dashboard-port");
       await unlink8(portFile).catch(() => {
       });
       server.closeAllConnections?.();