syntaur 0.70.0 → 0.71.0

package/dist/launch/index.js

@@ -35,9 +35,9 @@ function expandHome(p) {
   return p;
 }
 function syntaurRoot() {
-  const override = process.env.SYNTAUR_HOME;
-  if (override && override.length > 0) {
-    return resolve(expandHome(override));
+  const override2 = process.env.SYNTAUR_HOME;
+  if (override2 && override2.length > 0) {
+    return resolve(expandHome(override2));
   }
   return resolve(homedir(), ".syntaur");
 }
@@ -634,6 +634,7 @@ function parseAssignmentFrontmatter(fileContent) {
     planApproval: parsePlanApproval(frontmatter),
     parked: getField2("parked") === "true",
     reviewRequested: getField2("reviewRequested") === "true",
+    reworkRequested: getField2("reworkRequested") === "true",
     implementationStarted: getField2("implementationStarted") === "true",
     override: parseOverride(frontmatter),
     facts: parseFactsMap(frontmatter),
@@ -947,6 +948,7 @@ function parseAssignmentFull(fileContent) {
     disposition: getField(fm, "disposition"),
     parked: getField(fm, "parked") === "true",
     reviewRequested: getField(fm, "reviewRequested") === "true",
+    reworkRequested: getField(fm, "reworkRequested") === "true",
     implementationStarted: getField(fm, "implementationStarted") === "true",
     planApproval: (() => {
       const file = getNestedField(fm, "planApproval", "file");
@@ -1426,7 +1428,9 @@ var init_derive_config = __esm({
         },
         {
           phase: "review",
-          when: "acAllChecked:true OR reviewRequested:true",
+          // Rework (a new `implement` stage after `review`) must leave review even
+          // when ACs stay checked — hence `AND NOT reworkRequested` (stage-fact-status-bridge).
+          when: "(acAllChecked:true OR reviewRequested:true) AND NOT reworkRequested:true",
           next: "Complete, or address review feedback"
         }
       ],
@@ -1493,6 +1497,7 @@ var init_fields = __esm({
       blocked: { kind: "bool" },
       parked: { kind: "bool" },
       reviewrequested: { kind: "bool", get: (i) => i["reviewRequested"] },
+      reworkrequested: { kind: "bool", get: (i) => i["reworkRequested"] },
       pinned: { kind: "bool" }
     };
   }
@@ -2272,6 +2277,7 @@ function queryFieldNames(declarations) {
     "blocked",
     "parked",
     "reviewRequested",
+    "reworkRequested",
     "pinned"
   ];
   const custom = [];
@@ -2310,6 +2316,7 @@ var init_fact_registry = __esm({
       blocked: { kind: "bool" },
       parked: { kind: "bool" },
       reviewrequested: { kind: "bool", get: (i) => i["reviewRequested"] },
+      reworkrequested: { kind: "bool", get: (i) => i["reworkRequested"] },
       pinned: { kind: "bool" }
     };
   }
@@ -4344,7 +4351,7 @@ function compiledWhen(registry, when) {
   return pred;
 }
 function deriveDimensions(input) {
-  const { facts, derive, currentStatus, terminalStatuses, knownStatusIds, override } = input;
+  const { facts, derive, currentStatus, terminalStatuses, knownStatusIds, override: override2 } = input;
   const registry = input.registry ?? DERIVE_FIELDS;
   if (terminalStatuses.has(currentStatus)) return null;
   const ctx = { now: 0 };
@@ -4378,8 +4385,8 @@ function deriveDimensions(input) {
       derivedStatus = phase;
   }
   let status = derivedStatus;
-  if (override && override.status && !terminalStatuses.has(override.status) && knownStatusIds.has(override.status)) {
-    status = override.status;
+  if (override2 && override2.status && !terminalStatuses.has(override2.status) && knownStatusIds.has(override2.status)) {
+    status = override2.status;
   }
   return { phase, disposition, derivedStatus, status, nextAction };
 }
@@ -4670,6 +4677,7 @@ async function computeFactsDetailed(input) {
     blocked: frontmatter.blockedReason !== null,
     parked: frontmatter.parked,
     reviewRequested: frontmatter.reviewRequested,
+    reworkRequested: frontmatter.reworkRequested,
     pinned: frontmatter.override !== null
   };
   const attestations = [];
@@ -4981,6 +4989,139 @@ var init_help = __esm({
   }
 });
 
+// src/db/engagement-schema.ts
+var ENGAGEMENT_SCHEMA_VERSION, ENGAGEMENT_DDL;
+var init_engagement_schema = __esm({
+  "src/db/engagement-schema.ts"() {
+    "use strict";
+    ENGAGEMENT_SCHEMA_VERSION = "1";
+    ENGAGEMENT_DDL = `
+CREATE TABLE IF NOT EXISTS engagement (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id      TEXT    NOT NULL,
+  assignment_id   TEXT,
+  project_slug    TEXT,
+  assignment_slug TEXT,
+  stage           TEXT    NOT NULL DEFAULT 'implement',
+  started_at      TEXT    NOT NULL,
+  ended_at        TEXT,
+  tokens_at_open  TEXT,
+  tokens_at_close TEXT,
+  close_reason    TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS one_active_per_session
+  ON engagement(session_id) WHERE ended_at IS NULL;
+CREATE INDEX IF NOT EXISTS idx_engagement_session ON engagement(session_id);
+CREATE INDEX IF NOT EXISTS idx_engagement_assignment ON engagement(assignment_id);
+CREATE INDEX IF NOT EXISTS idx_engagement_slug ON engagement(project_slug, assignment_slug);
+`;
+  }
+});
+
+// src/db/engagement-backfill.ts
+import { readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { resolve as resolve13 } from "path";
+function safeReaddir(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function readAssignmentId(assignmentMdPath) {
+  try {
+    const fm = parseAssignmentFrontmatter(readFileSync(assignmentMdPath, "utf-8"));
+    return fm.id || null;
+  } catch {
+    return null;
+  }
+}
+function transcriptMtimeIso(path) {
+  if (!path) return null;
+  try {
+    return statSync2(path).mtime.toISOString();
+  } catch {
+    return null;
+  }
+}
+function projectKey(projectSlug, assignmentSlug) {
+  return JSON.stringify([projectSlug, assignmentSlug]);
+}
+function buildSlugIdMaps() {
+  const root = syntaurRoot();
+  const project = /* @__PURE__ */ new Map();
+  const standalone = /* @__PURE__ */ new Map();
+  const projectsDir = resolve13(root, "projects");
+  for (const proj of safeReaddir(projectsDir)) {
+    if (!proj.isDirectory()) continue;
+    const asgRoot = resolve13(projectsDir, proj.name, "assignments");
+    for (const asg of safeReaddir(asgRoot)) {
+      if (!asg.isDirectory()) continue;
+      const id = readAssignmentId(resolve13(asgRoot, asg.name, "assignment.md"));
+      if (id) project.set(projectKey(proj.name, asg.name), id);
+    }
+  }
+  const standaloneDir = resolve13(root, "assignments");
+  for (const asg of safeReaddir(standaloneDir)) {
+    if (!asg.isDirectory()) continue;
+    const id = readAssignmentId(resolve13(standaloneDir, asg.name, "assignment.md"));
+    if (id) standalone.set(asg.name, id);
+  }
+  return { project, standalone };
+}
+function backfillEngagements(db2) {
+  const { project, standalone } = buildSlugIdMaps();
+  const sessions = db2.prepare(
+    `SELECT session_id, project_slug, assignment_slug, status, started, ended,
+              transcript_path, updated_at
+         FROM sessions`
+  ).all();
+  const insert = db2.prepare(
+    `INSERT INTO engagement
+       (session_id, assignment_id, project_slug, assignment_slug, stage,
+        started_at, ended_at, tokens_at_open, tokens_at_close, close_reason)
+     VALUES
+       (@session_id, @assignment_id, @project_slug, @assignment_slug, 'implement',
+        @started_at, @ended_at, NULL, NULL, @close_reason)`
+  );
+  const counts = { backfilled: 0, attributed: 0, unattributed: 0 };
+  for (const s of sessions) {
+    let assignmentId = null;
+    if (s.project_slug && s.assignment_slug) {
+      assignmentId = project.get(projectKey(s.project_slug, s.assignment_slug)) ?? null;
+    } else if (!s.project_slug && s.assignment_slug) {
+      assignmentId = standalone.get(s.assignment_slug) ?? null;
+    }
+    const isActive = s.status === "active";
+    let endedAt = null;
+    let closeReason = null;
+    if (!isActive) {
+      endedAt = s.ended ?? transcriptMtimeIso(s.transcript_path) ?? s.updated_at ?? s.started;
+      closeReason = s.status === "completed" ? "completed" : "abandoned";
+    }
+    insert.run({
+      session_id: s.session_id,
+      assignment_id: assignmentId,
+      project_slug: s.project_slug,
+      assignment_slug: s.assignment_slug,
+      started_at: s.started,
+      ended_at: endedAt,
+      close_reason: closeReason
+    });
+    counts.backfilled++;
+    if (assignmentId) counts.attributed++;
+    else counts.unattributed++;
+  }
+  return counts;
+}
+var init_engagement_backfill = __esm({
+  "src/db/engagement-backfill.ts"() {
+    "use strict";
+    init_paths();
+    init_frontmatter();
+  }
+});
+
 // src/dashboard/session-db.ts
 var session_db_exports = {};
 __export(session_db_exports, {
@@ -4992,18 +5133,23 @@ __export(session_db_exports, {
   resetSessionDb: () => resetSessionDb
 });
 import Database2 from "better-sqlite3";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 import { readdir as readdir8 } from "fs/promises";
 function initSessionDb(dbPath) {
   if (db) return db;
-  const finalPath = dbPath ?? resolve13(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve14(syntaurRoot(), "syntaur.db");
   db = new Database2(finalPath);
   db.pragma("journal_mode = WAL");
   db.exec(SCHEMA_SQL);
+  db.exec(ENGAGEMENT_DDL);
   db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
     "schema_version",
     SCHEMA_VERSION
   );
+  db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+    "engagement_schema_version",
+    ENGAGEMENT_SCHEMA_VERSION
+  );
   const database = db;
   const runMigrations = database.transaction(() => {
     const vBeforeV2 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
@@ -5130,9 +5276,43 @@ function initSessionDb(dbPath) {
         UPDATE meta SET value = '5' WHERE key = 'schema_version';
       `);
     }
+    const vBeforeV6 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV6 === "5") {
+      database.exec(ENGAGEMENT_DDL);
+      const counts = backfillEngagements(database);
+      database.exec(`
+        CREATE TABLE sessions_v6 (
+          session_id TEXT PRIMARY KEY,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          transcript_path TEXT,
+          pid INTEGER,
+          pid_started_at TEXT,
+          original_head_sha TEXT,
+          activity TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v6
+          SELECT session_id, agent, started, ended, status, path, description,
+                 transcript_path, pid, pid_started_at, original_head_sha, NULL,
+                 created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v6 RENAME TO sessions;
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '6' WHERE key = 'schema_version';
+      `);
+      console.log(
+        `engagement backfill: backfilled=${counts.backfilled} attributed=${counts.attributed} unattributed=${counts.unattributed}`
+      );
+    }
   });
   runMigrations.exclusive();
-  db.exec(POST_MIGRATION_INDEXES_SQL);
   return db;
 }
 function isSessionDbInitialized() {
@@ -5164,20 +5344,38 @@ async function migrateFromMarkdown(projectsDir) {
   const allSessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const projectDir = resolve13(projectsDir, entry.name);
-    const indexPath = resolve13(projectDir, "_index-sessions.md");
+    const projectDir = resolve14(projectsDir, entry.name);
+    const indexPath = resolve14(projectDir, "_index-sessions.md");
     if (!await fileExists(indexPath)) continue;
     const sessions = await parseMarkdownSessionsIndex(indexPath, entry.name);
     allSessions.push(...sessions);
   }
   if (allSessions.length === 0) return 0;
   const insert = database.prepare(`
-    INSERT OR IGNORE INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
+    INSERT OR IGNORE INTO sessions (session_id, agent, started, status, path)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  const insertEngagement = database.prepare(`
+    INSERT INTO engagement (session_id, project_slug, assignment_slug, stage, started_at, ended_at, close_reason)
+    SELECT @sid, @ps, @as, 'implement', @started, @ended, @reason
+     WHERE NOT EXISTS (
+       SELECT 1 FROM engagement WHERE session_id = @sid AND ended_at IS NULL
+     )
   `);
   const insertAll = database.transaction((sessions) => {
     for (const s of sessions) {
-      insert.run(s.sessionId, s.projectSlug, s.assignmentSlug, s.agent, s.started, s.status, s.path);
+      const res = insert.run(s.sessionId, s.agent, s.started, s.status, s.path);
+      if (res.changes > 0 && (s.projectSlug || s.assignmentSlug)) {
+        const terminal = s.status === "completed" || s.status === "stopped";
+        insertEngagement.run({
+          sid: s.sessionId,
+          ps: s.projectSlug ?? null,
+          as: s.assignmentSlug ?? null,
+          started: s.started,
+          ended: terminal ? s.started : null,
+          reason: terminal ? s.status === "completed" ? "completed" : "abandoned" : null
+        });
+      }
     }
   });
   insertAll(allSessions);
@@ -5220,19 +5418,19 @@ async function parseMarkdownSessionsIndex(filePath, projectSlug) {
   }
   return sessions;
 }
-var db, SCHEMA_VERSION, SCHEMA_SQL, POST_MIGRATION_INDEXES_SQL;
+var db, SCHEMA_VERSION, SCHEMA_SQL;
 var init_session_db = __esm({
   "src/dashboard/session-db.ts"() {
     "use strict";
     init_paths();
     init_fs();
+    init_engagement_schema();
+    init_engagement_backfill();
     db = null;
-    SCHEMA_VERSION = "5";
+    SCHEMA_VERSION = "6";
     SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS sessions (
   session_id TEXT PRIMARY KEY,
-  project_slug TEXT,
-  assignment_slug TEXT,
   agent TEXT NOT NULL,
   started TEXT NOT NULL,
   ended TEXT,
@@ -5243,34 +5441,172 @@ CREATE TABLE IF NOT EXISTS sessions (
   pid INTEGER,
   pid_started_at TEXT,
   original_head_sha TEXT,
+  activity TEXT,
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   updated_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
 CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
 CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
-`;
-    POST_MIGRATION_INDEXES_SQL = `
-CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_slug);
-CREATE INDEX IF NOT EXISTS idx_sessions_assignment ON sessions(project_slug, assignment_slug);
 `;
   }
 });
 
+// src/db/engagement-tokens.ts
+function serializeSnapshot(snapshot) {
+  return snapshot === null ? null : JSON.stringify(snapshot);
+}
+function tableExists(name) {
+  const row = getSessionDb().prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name);
+  return row !== void 0;
+}
+function getCumulativeTokenSource() {
+  return override ?? productionCumulativeTokenSource;
+}
+var productionCumulativeTokenSource, override;
+var init_engagement_tokens = __esm({
+  "src/db/engagement-tokens.ts"() {
+    "use strict";
+    init_session_db();
+    productionCumulativeTokenSource = async (sessionId) => {
+      const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const db2 = getSessionDb();
+      const collectorRow = db2.prepare("SELECT value FROM meta WHERE key = 'usage_last_collector_run'").get();
+      const collectorRunAt = collectorRow?.value ?? null;
+      const models = {};
+      if (tableExists("usage_events")) {
+        const rows = db2.prepare(
+          `SELECT model, input_tokens, output_tokens, cache_creation_tokens,
+                cache_read_tokens, total_tokens, total_cost
+           FROM usage_events
+          WHERE session_id = ?`
+        ).all(sessionId);
+        for (const r of rows) {
+          models[r.model] = {
+            input: r.input_tokens,
+            output: r.output_tokens,
+            cacheCreation: r.cache_creation_tokens,
+            cacheRead: r.cache_read_tokens,
+            total: r.total_tokens,
+            cost: r.total_cost
+          };
+        }
+      }
+      return { models, collectorRunAt, capturedAt };
+    };
+    override = null;
+  }
+});
+
+// src/db/engagement-db.ts
+function getOpenEngagement(sessionId) {
+  const row = getSessionDb().prepare(
+    "SELECT * FROM engagement WHERE session_id = ? AND ended_at IS NULL LIMIT 1"
+  ).get(sessionId);
+  return row ?? null;
+}
+function getLatestEngagement(sessionId) {
+  const row = getSessionDb().prepare(
+    `SELECT * FROM engagement WHERE session_id = ?
+        ORDER BY (ended_at IS NULL) DESC, started_at DESC, id DESC
+        LIMIT 1`
+  ).get(sessionId);
+  return row ?? null;
+}
+function hasAnyEngagement(sessionId) {
+  return getSessionDb().prepare("SELECT 1 FROM engagement WHERE session_id = ? LIMIT 1").get(sessionId) !== void 0;
+}
+function insertClosedEngagement(input) {
+  const res = getSessionDb().prepare(
+    `INSERT INTO engagement
+         (session_id, assignment_id, project_slug, assignment_slug, stage, started_at, ended_at, close_reason)
+       VALUES (@sessionId, @assignmentId, @projectSlug, @assignmentSlug, @stage, @startedAt, @endedAt, @closeReason)`
+  ).run({
+    sessionId: input.sessionId,
+    assignmentId: input.assignmentId ?? null,
+    projectSlug: input.projectSlug ?? null,
+    assignmentSlug: input.assignmentSlug ?? null,
+    stage: input.stage ?? DEFAULT_STAGE,
+    startedAt: input.startedAt,
+    endedAt: input.endedAt,
+    closeReason: input.closeReason
+  });
+  return getEngagementById(Number(res.lastInsertRowid));
+}
+function getEngagementById(id) {
+  const row = getSessionDb().prepare("SELECT * FROM engagement WHERE id = ?").get(id);
+  if (!row) throw new Error(`engagement ${id} not found after insert`);
+  return row;
+}
+function openEngagement(input) {
+  const res = getSessionDb().prepare(
+    `INSERT INTO engagement
+         (session_id, assignment_id, project_slug, assignment_slug, stage, started_at, tokens_at_open)
+       VALUES (@sessionId, @assignmentId, @projectSlug, @assignmentSlug, @stage, @startedAt, @tokensAtOpen)`
+  ).run({
+    sessionId: input.sessionId,
+    assignmentId: input.assignmentId ?? null,
+    projectSlug: input.projectSlug ?? null,
+    assignmentSlug: input.assignmentSlug ?? null,
+    stage: input.stage ?? DEFAULT_STAGE,
+    startedAt: input.startedAt,
+    tokensAtOpen: serializeSnapshot(input.tokensAtOpen ?? null)
+  });
+  return getEngagementById(Number(res.lastInsertRowid));
+}
+function closeEngagementById(input) {
+  const res = getSessionDb().prepare(
+    `UPDATE engagement
+          SET ended_at = @endedAt,
+              tokens_at_close = @tokensAtClose,
+              close_reason = @closeReason
+        WHERE id = @id AND started_at = @startedAt AND ended_at IS NULL`
+  ).run({
+    id: input.id,
+    startedAt: input.startedAt,
+    endedAt: input.endedAt,
+    tokensAtClose: serializeSnapshot(input.tokensAtClose ?? null),
+    closeReason: input.closeReason
+  });
+  return res.changes > 0;
+}
+function ensureOpenEngagement(input) {
+  if (getOpenEngagement(input.sessionId)) return null;
+  try {
+    return openEngagement(input);
+  } catch (err) {
+    if (err instanceof Error && /UNIQUE constraint failed/.test(err.message)) {
+      return null;
+    }
+    throw err;
+  }
+}
+var DEFAULT_STAGE;
+var init_engagement_db = __esm({
+  "src/db/engagement-db.ts"() {
+    "use strict";
+    init_session_db();
+    init_engagement_tokens();
+    DEFAULT_STAGE = "implement";
+  }
+});
+
 // src/dashboard/agent-sessions.ts
 var agent_sessions_exports = {};
 __export(agent_sessions_exports, {
+  SessionResurrectionError: () => SessionResurrectionError,
   appendSession: () => appendSession,
   deleteSessions: () => deleteSessions,
   getSessionById: () => getSessionById,
   listAllSessions: () => listAllSessions,
   listProjectSessions: () => listProjectSessions,
   listSessionsByAssignment: () => listSessionsByAssignment,
+  livenessStopSession: () => livenessStopSession,
   parseSessionsIndex: () => parseSessionsIndex,
   reconcileActiveSessions: () => reconcileActiveSessions,
   updateSessionStatus: () => updateSessionStatus
 });
 import { readFile as readFile11 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 function rowToSession(row) {
   return {
     sessionId: row.session_id,
@@ -5286,28 +5622,64 @@ function rowToSession(row) {
     pid: row.pid ?? null,
     pidStartedAt: row.pid_started_at ?? null,
     originalHeadSha: row.original_head_sha ?? null,
+    activity: row.activity ?? null,
     updatedAt: row.updated_at ?? null
   };
 }
 async function parseSessionsIndex(_projectDir, projectSlug) {
   const db2 = getSessionDb();
-  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db2.prepare(`${SESSION_SELECT_WITH_BINDING} WHERE e.project_slug = ? ORDER BY s.started DESC`).all(projectSlug);
   return rows.map(rowToSession);
 }
+function reopenEngagementIfMissing(sessionId, freshBinding, freshStartedAt, tokensAtOpen) {
+  if (getOpenEngagement(sessionId)) return;
+  if (freshBinding && (freshBinding.projectSlug || freshBinding.assignmentSlug)) {
+    ensureOpenEngagement({
+      sessionId,
+      assignmentId: freshBinding.assignmentId ?? null,
+      projectSlug: freshBinding.projectSlug,
+      assignmentSlug: freshBinding.assignmentSlug,
+      stage: "implement",
+      startedAt: freshStartedAt,
+      tokensAtOpen: tokensAtOpen ?? null
+    });
+    return;
+  }
+  const latest = getLatestEngagement(sessionId);
+  if (latest && (latest.project_slug || latest.assignment_slug)) {
+    ensureOpenEngagement({
+      sessionId,
+      assignmentId: latest.assignment_id,
+      projectSlug: latest.project_slug,
+      assignmentSlug: latest.assignment_slug,
+      stage: "implement",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tokensAtOpen: tokensAtOpen ?? null
+    });
+  }
+}
 async function appendSession(_projectDir, session, opts) {
   const db2 = getSessionDb();
-  db2.prepare(`
-    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path, pid, pid_started_at, original_head_sha)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  let openSnapshot = null;
+  try {
+    openSnapshot = await getCumulativeTokenSource()(session.sessionId);
+  } catch {
+    openSnapshot = null;
+  }
+  const upsert = db2.prepare(`
+    INSERT INTO sessions (session_id, agent, started, status, path, description, transcript_path, pid, pid_started_at, original_head_sha)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(session_id) DO UPDATE SET
-      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 = 'completed' THEN status
                             WHEN status = 'stopped' AND NOT (? AND excluded.status = 'active') THEN status
                             ELSE excluded.status
                           END,
+      ended             = CASE
+                            WHEN status = 'stopped' AND ? AND excluded.status = 'active' THEN NULL
+                            ELSE ended
+                          END,
       path              = COALESCE(NULLIF(excluded.path, ''),              path),
       description       = COALESCE(NULLIF(excluded.description, ''),       description),
       transcript_path   = COALESCE(NULLIF(excluded.transcript_path, ''),   transcript_path),
@@ -5315,59 +5687,151 @@ async function appendSession(_projectDir, session, opts) {
       pid_started_at    = COALESCE(NULLIF(excluded.pid_started_at, ''),    pid_started_at),
       original_head_sha = COALESCE(NULLIF(original_head_sha, ''), NULLIF(excluded.original_head_sha, '')),
       updated_at        = datetime('now')
-  `).run(
-    session.sessionId,
-    session.projectSlug ?? null,
-    session.assignmentSlug ?? null,
-    session.agent,
-    session.started,
-    session.status,
-    session.path,
-    session.description ?? null,
-    session.transcriptPath ?? null,
-    session.pid ?? null,
-    session.pidStartedAt ?? null,
-    session.originalHeadSha ?? null,
-    opts?.reviveStopped ? 1 : 0
-  );
+  `);
+  const apply = db2.transaction(() => {
+    upsert.run(
+      session.sessionId,
+      session.agent,
+      session.started,
+      session.status,
+      session.path,
+      session.description ?? null,
+      session.transcriptPath ?? null,
+      session.pid ?? null,
+      session.pidStartedAt ?? null,
+      session.originalHeadSha ?? null,
+      opts?.reviveStopped ? 1 : 0,
+      // status CASE: revive guard
+      opts?.reviveStopped ? 1 : 0
+      // ended CASE: clear stale ended on revive
+    );
+    const persisted = db2.prepare("SELECT status, ended FROM sessions WHERE session_id = ?").get(session.sessionId);
+    const freshBinding = {
+      assignmentId: session.assignmentId ?? null,
+      projectSlug: session.projectSlug ?? null,
+      assignmentSlug: session.assignmentSlug ?? null
+    };
+    if (persisted?.status === "active") {
+      reopenEngagementIfMissing(
+        session.sessionId,
+        freshBinding,
+        session.started ?? (/* @__PURE__ */ new Date()).toISOString(),
+        openSnapshot
+      );
+    } else if (persisted && (freshBinding.projectSlug || freshBinding.assignmentSlug) && !hasAnyEngagement(session.sessionId)) {
+      insertClosedEngagement({
+        sessionId: session.sessionId,
+        projectSlug: freshBinding.projectSlug,
+        assignmentSlug: freshBinding.assignmentSlug,
+        startedAt: session.started ?? (/* @__PURE__ */ new Date()).toISOString(),
+        endedAt: persisted.ended ?? session.started ?? (/* @__PURE__ */ new Date()).toISOString(),
+        closeReason: persisted.status === "completed" ? "completed" : "abandoned"
+      });
+    }
+  });
+  apply.immediate();
 }
 async function updateSessionStatus(_projectDir, sessionId, status, endedAt) {
   const db2 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
-  const result = isTerminal ? db2.prepare(
-    "UPDATE sessions SET status = ?, ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, endedAt ?? null, sessionId) : db2.prepare(
-    "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, sessionId);
-  return result.changes > 0;
+  if (!isTerminal) {
+    let reviveSnapshot = null;
+    try {
+      reviveSnapshot = await getCumulativeTokenSource()(sessionId);
+    } catch {
+      reviveSnapshot = null;
+    }
+    const apply2 = db2.transaction(() => {
+      const current = db2.prepare("SELECT status FROM sessions WHERE session_id = ?").get(sessionId);
+      if (!current) return false;
+      if (current.status === "completed") {
+        throw new SessionResurrectionError(
+          `Refusing to revive completed session "${sessionId}" to active. A completed session is final.`
+        );
+      }
+      const res = db2.prepare(
+        "UPDATE sessions SET status = ?, ended = NULL, updated_at = datetime('now') WHERE session_id = ?"
+      ).run(status, sessionId);
+      if (res.changes > 0) {
+        reopenEngagementIfMissing(sessionId, null, (/* @__PURE__ */ new Date()).toISOString(), reviveSnapshot);
+      }
+      return res.changes > 0;
+    });
+    return apply2.immediate();
+  }
+  const captured = getOpenEngagement(sessionId);
+  let snapshot = null;
+  try {
+    snapshot = await getCumulativeTokenSource()(sessionId);
+  } catch {
+    snapshot = null;
+  }
+  const apply = db2.transaction(() => {
+    const stillTerminal = captured ? closeEngagementById({
+      id: captured.id,
+      startedAt: captured.started_at,
+      closeReason: status === "completed" ? "completed" : "abandoned",
+      tokensAtClose: snapshot,
+      endedAt: endedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    }) : getOpenEngagement(sessionId) === null;
+    if (!stillTerminal) return false;
+    const res = db2.prepare(
+      "UPDATE sessions SET status = ?, ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ?"
+    ).run(status, endedAt ?? null, sessionId);
+    return res.changes > 0;
+  });
+  return apply.immediate();
+}
+function livenessStopSession(input) {
+  const db2 = getSessionDb();
+  const endedAt = input.endedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const apply = db2.transaction(() => {
+    const stillDead = input.engagementId != null && input.engagementStartedAt != null ? closeEngagementById({
+      id: input.engagementId,
+      startedAt: input.engagementStartedAt,
+      closeReason: "liveness_gc",
+      tokensAtClose: input.tokensAtClose ?? null,
+      endedAt
+    }) : getOpenEngagement(input.sessionId) === null;
+    if (!stillDead) return false;
+    const res = db2.prepare(
+      "UPDATE sessions SET status = 'stopped', ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ? AND status = 'active'"
+    ).run(input.endedAt ?? null, input.sessionId);
+    return res.changes > 0;
+  });
+  return apply.immediate();
 }
 async function listAllSessions(_projectsDir) {
   const db2 = getSessionDb();
-  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  const rows = db2.prepare(`${SESSION_SELECT_WITH_BINDING} ORDER BY s.started DESC`).all();
   return rows.map(rowToSession);
 }
 function getSessionById(sessionId) {
   const db2 = getSessionDb();
-  const row = db2.prepare("SELECT * FROM sessions WHERE session_id = ? LIMIT 1").get(sessionId);
+  const row = db2.prepare(`${SESSION_SELECT_WITH_BINDING} WHERE s.session_id = ? LIMIT 1`).get(sessionId);
   return row ? rowToSession(row) : null;
 }
 async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
   const db2 = getSessionDb();
   if (assignmentSlug) {
     const rows2 = db2.prepare(
-      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+      `${SESSION_SELECT_WITH_BINDING} WHERE e.project_slug = ? AND e.assignment_slug = ? ORDER BY s.started DESC`
     ).all(projectSlug, assignmentSlug);
     return rows2.map(rowToSession);
   }
-  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db2.prepare(`${SESSION_SELECT_WITH_BINDING} WHERE e.project_slug = ? ORDER BY s.started DESC`).all(projectSlug);
   return rows.map(rowToSession);
 }
 async function deleteSessions(sessionIds) {
   if (sessionIds.length === 0) return 0;
   const db2 = getSessionDb();
   const placeholders = sessionIds.map(() => "?").join(", ");
-  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
-  return result.changes;
+  const run2 = db2.transaction(() => {
+    db2.prepare(`DELETE FROM engagement WHERE session_id IN (${placeholders})`).run(...sessionIds);
+    const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+    return result.changes;
+  });
+  return run2.immediate();
 }
 async function readAssignmentStatusFromPath(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
@@ -5377,39 +5841,44 @@ async function readAssignmentStatusFromPath(assignmentMdPath) {
 }
 async function readAssignmentStatus(projectDir, assignmentSlug) {
   return readAssignmentStatusFromPath(
-    resolve14(projectDir, "assignments", assignmentSlug, "assignment.md")
+    resolve15(projectDir, "assignments", assignmentSlug, "assignment.md")
   );
 }
 async function reconcileActiveSessions(projectsDir, assignmentsDir) {
   const db2 = getSessionDb();
-  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  const activeSessions = db2.prepare(
+    `SELECT s.*, e.project_slug AS project_slug, e.assignment_slug AS assignment_slug
+         FROM sessions s
+         JOIN engagement e ON e.session_id = s.session_id AND e.ended_at IS NULL
+        WHERE s.status = 'active' AND e.assignment_slug IS NOT NULL`
+  ).all();
   if (activeSessions.length === 0) return 0;
   const assignmentStatuses = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
   for (const session of activeSessions) {
     const aslug = session.assignment_slug;
     if (!aslug) continue;
-    const projectKey = session.project_slug ?? "__standalone__";
-    const key = `${projectKey}/${aslug}`;
+    const projectKey2 = session.project_slug ?? "__standalone__";
+    const key = `${projectKey2}/${aslug}`;
     if (seen.has(key)) continue;
     seen.add(key);
     if (session.project_slug) {
       const status = await readAssignmentStatus(
-        resolve14(projectsDir, session.project_slug),
+        resolve15(projectsDir, session.project_slug),
         aslug
       );
       if (status) assignmentStatuses.set(key, status);
     } else if (assignmentsDir) {
       const status = await readAssignmentStatusFromPath(
-        resolve14(assignmentsDir, aslug, "assignment.md")
+        resolve15(assignmentsDir, aslug, "assignment.md")
       );
       if (status) assignmentStatuses.set(key, status);
     }
   }
   let totalUpdated = 0;
   for (const session of activeSessions) {
-    const projectKey = session.project_slug ?? "__standalone__";
-    const key = `${projectKey}/${session.assignment_slug}`;
+    const projectKey2 = session.project_slug ?? "__standalone__";
+    const key = `${projectKey2}/${session.assignment_slug}`;
     const assignmentStatus = assignmentStatuses.get(key);
     if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
     const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
@@ -5421,18 +5890,34 @@ async function reconcileActiveSessions(projectsDir, assignmentsDir) {
 async function listSessionsByAssignment(projectSlug, assignmentSlug) {
   const db2 = getSessionDb();
   const rows = projectSlug === null ? db2.prepare(
-    "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
+    `${SESSION_SELECT_WITH_BINDING} WHERE e.assignment_slug = ? AND e.project_slug IS NULL ORDER BY s.started DESC`
   ).all(assignmentSlug) : db2.prepare(
-    "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+    `${SESSION_SELECT_WITH_BINDING} WHERE e.project_slug = ? AND e.assignment_slug = ? ORDER BY s.started DESC`
   ).all(projectSlug, assignmentSlug);
   return rows.map(rowToSession);
 }
-var DONE_ASSIGNMENT_STATUSES;
+var SESSION_SELECT_WITH_BINDING, SessionResurrectionError, DONE_ASSIGNMENT_STATUSES;
 var init_agent_sessions = __esm({
   "src/dashboard/agent-sessions.ts"() {
     "use strict";
     init_fs();
     init_session_db();
+    init_engagement_db();
+    init_engagement_tokens();
+    SESSION_SELECT_WITH_BINDING = `
+SELECT s.*,
+       e.project_slug    AS project_slug,
+       e.assignment_slug AS assignment_slug,
+       e.assignment_id   AS assignment_id
+  FROM sessions s
+  LEFT JOIN engagement e ON e.id = (
+    SELECT e2.id FROM engagement e2
+     WHERE e2.session_id = s.session_id
+     ORDER BY (e2.ended_at IS NULL) DESC, e2.started_at DESC, e2.id DESC
+     LIMIT 1
+  )`;
+    SessionResurrectionError = class extends Error {
+    };
     DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
   }
 });
@@ -5462,7 +5947,7 @@ var init_classify = __esm({
 
 // src/dashboard/api.ts
 import { readdir as readdir9, readFile as readFile12, writeFile as writeFile3, stat as stat2 } from "fs/promises";
-import { resolve as resolve15, dirname as dirname2, basename } from "path";
+import { resolve as resolve16, dirname as dirname2, basename } from "path";
 function activeAssignments(items) {
   return items.filter((item) => item.archived !== true);
 }
@@ -5486,8 +5971,8 @@ async function computeStandaloneRecords(assignmentsDir) {
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve15(assignmentsDir, entry.name);
-    const assignmentMdPath = resolve15(assignmentDir, "assignment.md");
+    const assignmentDir = resolve16(assignmentsDir, entry.name);
+    const assignmentMdPath = resolve16(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
       const content = await readFile12(assignmentMdPath, "utf-8");
@@ -5591,15 +6076,15 @@ async function getStandaloneAvailableTransitions(assignment) {
   return actions;
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve15(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve15(assignmentDir, "assignment.md");
+  const assignmentDir = resolve16(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve16(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
   const assignmentContent = await readFile12(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
-  const projectMdPath = resolve15(projectsDir, projectSlug, "project.md");
+  const projectMdPath = resolve16(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
     const projectContent = await readFile12(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
@@ -5607,7 +6092,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let plan = null;
   const planFile = await latestPlanFile(assignmentDir);
   if (planFile) {
-    const planPath = resolve15(assignmentDir, planFile);
+    const planPath = resolve16(assignmentDir, planFile);
     if (await fileExists(planPath)) {
       const planContent = await readFile12(planPath, "utf-8");
       const parsed = parsePlan(planContent);
@@ -5619,7 +6104,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     }
   }
   let scratchpad = null;
-  const scratchpadPath = resolve15(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve16(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
     const scratchpadContent = await readFile12(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
@@ -5629,7 +6114,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve15(assignmentDir, "handoff.md");
+  const handoffPath = resolve16(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
     const handoffContent = await readFile12(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
@@ -5640,7 +6125,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve15(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve16(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
     const decisionRecordContent = await readFile12(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
@@ -5651,7 +6136,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve15(assignmentDir, "progress.md");
+  const progressPath = resolve16(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
     const progressContent = await readFile12(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
@@ -5662,7 +6147,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve15(assignmentDir, "comments.md");
+  const commentsPath = resolve16(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
     const commentsContent = await readFile12(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
@@ -5696,7 +6181,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     archivedReason: assignment.archivedReason,
     ...deriveStatusVirtuals(assignment, terminalStatuses),
     override: assignment.override,
-    derived: await buildDerivedDetail(assignment, assignmentDir, resolve15(projectsDir, projectSlug)),
+    derived: await buildDerivedDetail(assignment, assignmentDir, resolve16(projectsDir, projectSlug)),
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -5787,7 +6272,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve15(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve16(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -5820,14 +6305,14 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve15(sourceDir, "assignment.md");
+  const assignmentMd = resolve16(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
     const content = await readFile12(assignmentMd, "utf-8");
     const todosMatch = content.match(/^## Todos\s*$([\s\S]*?)(?=^## |$(?![\r\n]))/m);
     if (todosMatch) bodies.push(todosMatch[1]);
   }
   for (const filename of ["progress.md", "comments.md", "handoff.md"]) {
-    const path = resolve15(sourceDir, filename);
+    const path = resolve16(sourceDir, filename);
     if (await fileExists(path)) {
       try {
         bodies.push(await readFile12(path, "utf-8"));
@@ -5888,45 +6373,45 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve15(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve16(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
   const assignmentContent = await readFile12(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planFile = await latestPlanFile(assignmentDir);
   if (planFile) {
-    const planPath = resolve15(assignmentDir, planFile);
+    const planPath = resolve16(assignmentDir, planFile);
     if (await fileExists(planPath)) {
       const parsed = parsePlan(await readFile12(planPath, "utf-8"));
       plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
     }
   }
   let scratchpad = null;
-  const scratchpadPath = resolve15(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve16(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
     const parsed = parseScratchpad(await readFile12(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve15(assignmentDir, "handoff.md");
+  const handoffPath = resolve16(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
     const parsed = parseHandoff(await readFile12(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve15(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve16(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
     const parsed = parseDecisionRecord(await readFile12(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve15(assignmentDir, "progress.md");
+  const progressPath = resolve16(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
     const parsed = parseProgress(await readFile12(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve15(assignmentDir, "comments.md");
+  const commentsPath = resolve16(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
     const parsed = parseComments(await readFile12(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
@@ -5992,8 +6477,8 @@ async function computeProjectRecords(projectsDir, traces) {
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
   const maybeRecords = await Promise.all(
     projectDirs.map(async (entry) => {
-      const projectPath = resolve15(projectsDir, entry.name);
-      const projectMdPath = resolve15(projectPath, "project.md");
+      const projectPath = resolve16(projectsDir, entry.name);
+      const projectMdPath = resolve16(projectPath, "project.md");
       if (!await fileExists(projectMdPath)) {
         return null;
       }
@@ -6040,7 +6525,7 @@ async function computeProjectRecords(projectsDir, traces) {
   return records;
 }
 async function listAssignmentRecords(projectPath, traces) {
-  const assignmentsDir = resolve15(projectPath, "assignments");
+  const assignmentsDir = resolve16(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
@@ -6048,7 +6533,7 @@ async function listAssignmentRecords(projectPath, traces) {
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
-      const assignmentMd = resolve15(assignmentsDir, entry.name, "assignment.md");
+      const assignmentMd = resolve16(assignmentsDir, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) {
         return null;
       }
@@ -6064,7 +6549,7 @@ async function listAssignmentRecords(projectPath, traces) {
   return records;
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve15(projectPath, "_status.md");
+  const statusPath = resolve16(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
     const statusContent = await readFile12(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
@@ -6239,7 +6724,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve15(projectsDir, projectSlug);
+  const projectPath = resolve16(projectsDir, projectSlug);
   const traces = options?.traces;
   for (const definition of transitionDefs) {
     const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
@@ -6287,7 +6772,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, de
         continue;
       }
     }
-    const dependencyPath = resolve15(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve16(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
@@ -6308,7 +6793,7 @@ function parseTimestamp(timestamp) {
   return Number.isFinite(parsed) ? parsed : 0;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve15(
+  const commentsPath = resolve16(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -6673,7 +7158,7 @@ init_agents_schema();
 init_cwd();
 import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir2, writeFile as writeFile4 } from "fs/promises";
-import { isAbsolute as isAbsolute3, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve17 } from "path";
 init_paths();
 init_playbooks();
 init_cwd();
@@ -6910,7 +7395,7 @@ async function resolveSessionPlan(input, terminal) {
 // src/launch/execute.ts
 import { spawn as spawn3 } from "child_process";
 import { homedir as homedir5 } from "os";
-import { basename as basename2, join as join6, resolve as resolve17 } from "path";
+import { basename as basename2, join as join6, resolve as resolve18 } from "path";
 
 // src/utils/terminal-probe.ts
 import { spawnSync as spawnSync2 } from "child_process";
@@ -6988,7 +7473,7 @@ init_config2();
 
 // src/utils/session-id.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { mkdirSync, readFileSync, statSync as statSync2, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync2, statSync as statSync3, writeFileSync } from "fs";
 import { homedir as homedir4 } from "os";
 import { dirname as dirname3, join as join5 } from "path";
 
@@ -7072,7 +7557,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve19, reject) => {
+  await new Promise((resolve20, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -7082,7 +7567,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve19();
+      resolve20();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -7143,7 +7628,7 @@ async function registerLaunchAtBirth(plan, child) {
       markerDir
     );
     if (!sessionId) return;
-    if (autoTrack === "workspaces-only" && !await fileExists(resolve17(plan.cwd, ".syntaur", "context.json"))) {
+    if (autoTrack === "workspaces-only" && !await fileExists(resolve18(plan.cwd, ".syntaur", "context.json"))) {
       return;
     }
     const { initSessionDb: initSessionDb2 } = await Promise.resolve().then(() => (init_session_db(), session_db_exports));
@@ -7319,8 +7804,8 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname4, resolve as resolve18, join as join7 } from "path";
-import { realpathSync, readFileSync as readFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve19, join as join7 } from "path";
+import { realpathSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
   { kind: "pnpm", re: /\/pnpm\/dlx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -7345,7 +7830,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath = opts.realpath ?? realpathSync.native;
-  const readFile13 = opts.readFile ?? ((p) => readFileSync2(p, "utf-8"));
+  const readFile13 = opts.readFile ?? ((p) => readFileSync3(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath);
   if (resolved === null) {
@@ -7398,7 +7883,7 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve18(syntaurRoot(), "npx-handler-nudge");
+  return resolve19(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";