syntaur 0.69.0 → 0.71.0

package/dist/dashboard/server.js

@@ -36,9 +36,9 @@ function expandHome(p) {
   return p;
 }
 function syntaurRoot() {
-  const override = process.env.SYNTAUR_HOME;
-  if (override && override.length > 0) {
-    return resolve(expandHome(override));
+  const override3 = process.env.SYNTAUR_HOME;
+  if (override3 && override3.length > 0) {
+    return resolve(expandHome(override3));
   }
   return resolve(homedir(), ".syntaur");
 }
@@ -122,7 +122,7 @@ function getTargetStatus(_from, command, table) {
   if (!table) {
     return DEFAULT_COMMAND_TARGETS.get(command) ?? null;
   }
-  return table.get(command) ?? table.get(`${_from}:${command}`) ?? null;
+  return table.get(`${_from}:${command}`) ?? table.get(command) ?? null;
 }
 var DEFAULT_COMMAND_TARGETS, DEFAULT_TRANSITION_TABLE;
 var init_state_machine = __esm({
@@ -452,6 +452,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),
@@ -634,11 +635,11 @@ function updatePlanApproval(fileContent, approval) {
     approval === null ? null : { file: approval.file, digest: approval.digest, by: approval.by, at: approval.at }
   );
 }
-function updateOverride(fileContent, override) {
+function updateOverride(fileContent, override3) {
   return updateNestedBlock(
     fileContent,
     "override",
-    override === null ? null : { status: override.status, source: override.source, reason: override.reason, at: override.at }
+    override3 === null ? null : { status: override3.status, source: override3.source, reason: override3.reason, at: override3.at }
   );
 }
 function updateFactsMap(fileContent, name, value) {
@@ -1271,6 +1272,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");
@@ -2737,7 +2739,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"
         }
       ],
@@ -2804,6 +2808,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" }
     };
   }
@@ -3597,6 +3602,7 @@ function queryFieldNames(declarations) {
     "blocked",
     "parked",
     "reviewRequested",
+    "reworkRequested",
     "pinned"
   ];
   const custom = [];
@@ -3635,6 +3641,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" }
     };
   }
@@ -5633,7 +5640,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: override3 } = input;
   const registry = input.registry ?? DERIVE_FIELDS;
   if (terminalStatuses.has(currentStatus)) return null;
   const ctx = { now: 0 };
@@ -5667,8 +5674,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 (override3 && override3.status && !terminalStatuses.has(override3.status) && knownStatusIds.has(override3.status)) {
+    status = override3.status;
   }
   return { phase, disposition, derivedStatus, status, nextAction };
 }
@@ -5954,6 +5961,18 @@ async function resolveAssignmentById(projectsDir, assignmentsDir2, id) {
   }
   return standaloneMatch ?? projectMatch ?? null;
 }
+async function resolveAssignmentBySlug(projectsDir, assignmentsDir2, projectSlug, assignmentSlug) {
+  const path = projectSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : resolve9(assignmentsDir2, assignmentSlug, "assignment.md");
+  if (!await fileExists(path)) return { exists: false, id: null };
+  try {
+    const content = await readFile7(path, "utf-8");
+    const [fm] = extractFrontmatter2(content);
+    const id = getField(fm, "id");
+    return { exists: true, id: id ?? null };
+  } catch {
+    return { exists: false, id: null };
+  }
+}
 var init_assignment_resolver = __esm({
   "src/utils/assignment-resolver.ts"() {
     "use strict";
@@ -6322,8 +6341,7 @@ async function areDependenciesSatisfied(projectDir, dependsOn, terminalStatuses)
     if (!await fileExists(depPath)) return false;
     try {
       const content = await readFile9(depPath, "utf-8");
-      const m = content.match(/^status:\s*(.+)$/m);
-      const status = m ? m[1].trim() : "";
+      const { status } = parseAssignmentFrontmatter(content);
       if (!terminalStatuses.has(status)) return false;
     } catch {
       return false;
@@ -6390,6 +6408,7 @@ async function computeFactsDetailed(input) {
     blocked: frontmatter.blockedReason !== null,
     parked: frontmatter.parked,
     reviewRequested: frontmatter.reviewRequested,
+    reworkRequested: frontmatter.reworkRequested,
     pinned: frontmatter.override !== null
   };
   const attestations = [];
@@ -6438,6 +6457,7 @@ var init_facts = __esm({
     init_fs();
     init_git_worktree();
     init_derive();
+    init_frontmatter();
     HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
     PLAN_FILE_RE = /^plan(?:-v(\d+))?\.md$/;
   }
@@ -7443,6 +7463,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(db5) {
+  const { project, standalone } = buildSlugIdMaps();
+  const sessions = db5.prepare(
+    `SELECT session_id, project_slug, assignment_slug, status, started, ended,
+              transcript_path, updated_at
+         FROM sessions`
+  ).all();
+  const insert = db5.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, {
@@ -7454,18 +7607,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 (db2) return db2;
-  const finalPath = dbPath ?? resolve13(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve14(syntaurRoot(), "syntaur.db");
   db2 = new Database2(finalPath);
   db2.pragma("journal_mode = WAL");
   db2.exec(SCHEMA_SQL2);
+  db2.exec(ENGAGEMENT_DDL);
   db2.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
     "schema_version",
     SCHEMA_VERSION
   );
+  db2.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+    "engagement_schema_version",
+    ENGAGEMENT_SCHEMA_VERSION
+  );
   const database = db2;
   const runMigrations = database.transaction(() => {
     const vBeforeV2 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
@@ -7592,9 +7750,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();
-  db2.exec(POST_MIGRATION_INDEXES_SQL);
   return db2;
 }
 function isSessionDbInitialized() {
@@ -7626,20 +7818,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);
@@ -7647,8 +7857,8 @@ async function migrateFromMarkdown(projectsDir) {
   return allSessions.length;
 }
 async function parseMarkdownSessionsIndex(filePath, projectSlug) {
-  const { readFile: readFile32 } = await import("fs/promises");
-  const raw2 = await readFile32(filePath, "utf-8");
+  const { readFile: readFile31 } = await import("fs/promises");
+  const raw2 = await readFile31(filePath, "utf-8");
   const sessions = [];
   const lines = raw2.split("\n");
   let inTable = false;
@@ -7682,19 +7892,19 @@ async function parseMarkdownSessionsIndex(filePath, projectSlug) {
   }
   return sessions;
 }
-var db2, SCHEMA_VERSION, SCHEMA_SQL2, POST_MIGRATION_INDEXES_SQL;
+var db2, SCHEMA_VERSION, SCHEMA_SQL2;
 var init_session_db = __esm({
   "src/dashboard/session-db.ts"() {
     "use strict";
     init_paths();
     init_fs();
+    init_engagement_schema();
+    init_engagement_backfill();
     db2 = null;
-    SCHEMA_VERSION = "5";
+    SCHEMA_VERSION = "6";
     SCHEMA_SQL2 = `
 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,
@@ -7705,34 +7915,175 @@ 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 parseSnapshot(json) {
+  return json === null ? null : JSON.parse(json);
+}
+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 db5 = getSessionDb();
+      const collectorRow = db5.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 = db5.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,
@@ -7748,28 +8099,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 db5 = getSessionDb();
-  const rows = db5.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db5.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 db5 = getSessionDb();
-  db5.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 = db5.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),
@@ -7777,59 +8164,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 = db5.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 = db5.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 db5 = getSessionDb();
   const isTerminal = status === "completed" || status === "stopped";
-  const result = isTerminal ? db5.prepare(
-    "UPDATE sessions SET status = ?, ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ?"
-  ).run(status, endedAt ?? null, sessionId) : db5.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 = db5.transaction(() => {
+      const current = db5.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 = db5.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 = db5.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 = db5.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 db5 = getSessionDb();
+  const endedAt = input.endedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const apply = db5.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 = db5.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 db5 = getSessionDb();
-  const rows = db5.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  const rows = db5.prepare(`${SESSION_SELECT_WITH_BINDING} ORDER BY s.started DESC`).all();
   return rows.map(rowToSession);
 }
 function getSessionById(sessionId) {
   const db5 = getSessionDb();
-  const row = db5.prepare("SELECT * FROM sessions WHERE session_id = ? LIMIT 1").get(sessionId);
+  const row = db5.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 db5 = getSessionDb();
   if (assignmentSlug) {
     const rows2 = db5.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 = db5.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  const rows = db5.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 db5 = getSessionDb();
   const placeholders = sessionIds.map(() => "?").join(", ");
-  const result = db5.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
-  return result.changes;
+  const run3 = db5.transaction(() => {
+    db5.prepare(`DELETE FROM engagement WHERE session_id IN (${placeholders})`).run(...sessionIds);
+    const result = db5.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+    return result.changes;
+  });
+  return run3.immediate();
 }
 async function readAssignmentStatusFromPath(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
@@ -7839,39 +8318,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, assignmentsDir2) {
   const db5 = getSessionDb();
-  const activeSessions = db5.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  const activeSessions = db5.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 (assignmentsDir2) {
       const status = await readAssignmentStatusFromPath(
-        resolve14(assignmentsDir2, aslug, "assignment.md")
+        resolve15(assignmentsDir2, 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";
@@ -7883,18 +8367,34 @@ async function reconcileActiveSessions(projectsDir, assignmentsDir2) {
 async function listSessionsByAssignment(projectSlug, assignmentSlug) {
   const db5 = getSessionDb();
   const rows = projectSlug === null ? db5.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) : db5.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"]);
   }
 });
@@ -7987,7 +8487,7 @@ var init_classify = __esm({
 
 // src/dashboard/servers.ts
 import { readdir as readdir9, readFile as readFile12, unlink as unlink2 } from "fs/promises";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 function sanitizeSessionName(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -8035,7 +8535,7 @@ async function registerSession(dir, rawName) {
     lastRefreshed: now,
     overrides: {}
   });
-  await writeFileForce(resolve15(dir, `${name}.md`), content);
+  await writeFileForce(resolve16(dir, `${name}.md`), content);
   return name;
 }
 async function listSessionFiles(dir) {
@@ -8044,7 +8544,7 @@ async function listSessionFiles(dir) {
   return entries.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
 }
 async function readSessionFile(dir, name) {
-  const filePath = resolve15(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve16(dir, `${sanitizeSessionName(name)}.md`);
   if (!await fileExists(filePath)) return null;
   const raw2 = await readFile12(filePath, "utf-8");
   const [frontmatter] = extractFrontmatter2(raw2);
@@ -8086,7 +8586,7 @@ async function readSessionFile(dir, name) {
   };
 }
 async function removeSession(dir, name) {
-  const filePath = resolve15(dir, `${sanitizeSessionName(name)}.md`);
+  const filePath = resolve16(dir, `${sanitizeSessionName(name)}.md`);
   if (await fileExists(filePath)) {
     await unlink2(filePath);
   }
@@ -8095,7 +8595,7 @@ async function updateLastRefreshed(dir, name) {
   const data = await readSessionFile(dir, name);
   if (!data) return;
   const content = buildSessionContent({ ...data, lastRefreshed: nowTimestamp2() });
-  await writeFileForce(resolve15(dir, `${sanitizeSessionName(name)}.md`), content);
+  await writeFileForce(resolve16(dir, `${sanitizeSessionName(name)}.md`), content);
 }
 async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment) {
   const data = await readSessionFile(dir, sessionName);
@@ -8107,7 +8607,7 @@ async function setOverride(dir, sessionName, windowIndex, paneIndex, assignment)
     delete data.overrides[key];
   }
   const content = buildSessionContent({ ...data });
-  await writeFileForce(resolve15(dir, `${sanitizeSessionName(sessionName)}.md`), content);
+  await writeFileForce(resolve16(dir, `${sanitizeSessionName(sessionName)}.md`), content);
 }
 async function registerAutoSession(dir, rawName, opts) {
   const name = sanitizeSessionName(rawName);
@@ -8124,7 +8624,7 @@ async function registerAutoSession(dir, rawName, opts) {
     ports: opts.ports,
     cwd: opts.cwd
   });
-  await writeFileForce(resolve15(dir, `${name}.md`), content);
+  await writeFileForce(resolve16(dir, `${name}.md`), content);
   return name;
 }
 var init_servers = __esm({
@@ -8159,7 +8659,7 @@ __export(scanner_exports, {
 });
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 import { realpath } from "fs/promises";
 function clearScanCache() {
   cache2 = null;
@@ -8175,8 +8675,8 @@ function scanKey(serversDir2, projectsDir, assignmentsDir2) {
   return `${serversDir2}\0${projectsDir}\0${assignmentsDir2 ?? ""}`;
 }
 function delay(ms) {
-  return new Promise((resolve47) => {
-    const timer3 = setTimeout(resolve47, ms);
+  return new Promise((resolve49) => {
+    const timer3 = setTimeout(resolve49, ms);
     if (typeof timer3.unref === "function") {
       timer3.unref();
     }
@@ -8312,8 +8812,8 @@ async function getGitInfo(cwd) {
   let isWorktree = false;
   if (commonDir && gitDir && commonDir !== gitDir) {
     try {
-      const resolvedCommon = await realpath(resolve16(cwd, commonDir));
-      const resolvedGit = await realpath(resolve16(cwd, gitDir));
+      const resolvedCommon = await realpath(resolve17(cwd, commonDir));
+      const resolvedGit = await realpath(resolve17(cwd, gitDir));
       isWorktree = resolvedCommon !== resolvedGit;
     } catch {
       isWorktree = false;
@@ -8415,16 +8915,16 @@ async function scanSession(sessionData, lsofOutput, workspaceRecords, procSnapsh
         const gitInfo = gitInfoCache.get(rp.cwd) ?? { branch: null, worktree: false };
         const ports = panePorts.get(key) ?? [];
         const urls = ports.map((p) => `http://localhost:${p}`);
-        const override = sessionData.overrides[key];
+        const override3 = sessionData.overrides[key];
         let assignment = null;
-        if (override) {
+        if (override3) {
           const rec = workspaceRecords.find(
-            (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
+            (r) => r.projectSlug === override3.project && r.assignmentSlug === override3.assignment
           );
           assignment = {
-            project: override.project,
-            slug: override.assignment,
-            title: rec?.assignmentTitle ?? override.assignment
+            project: override3.project,
+            slug: override3.assignment,
+            title: rec?.assignmentTitle ?? override3.assignment
           };
         } else {
           assignment = await autoLinkPane(rp.cwd, gitInfo.branch, workspaceRecords);
@@ -8478,16 +8978,16 @@ async function scanProcessSession(sessionData, lsofOutput, workspaceRecords) {
   }
   const ports = findListeningPorts(lsofOutput, /* @__PURE__ */ new Set([sessionData.pid]));
   const gitInfo = await getGitInfo(sessionData.cwd);
-  const override = sessionData.overrides["0:0"];
+  const override3 = sessionData.overrides["0:0"];
   let assignment = null;
-  if (override) {
+  if (override3) {
     const rec = workspaceRecords.find(
-      (r) => r.projectSlug === override.project && r.assignmentSlug === override.assignment
+      (r) => r.projectSlug === override3.project && r.assignmentSlug === override3.assignment
     );
     assignment = {
-      project: override.project,
-      slug: override.assignment,
-      title: rec?.assignmentTitle ?? override.assignment
+      project: override3.project,
+      slug: override3.assignment,
+      title: rec?.assignmentTitle ?? override3.assignment
     };
   } else {
     assignment = await autoLinkPane(sessionData.cwd, gitInfo.branch, workspaceRecords);
@@ -8651,7 +9151,7 @@ __export(api_exports, {
   resolveWorkspaceMembers: () => resolveWorkspaceMembers
 });
 import { readdir as readdir10, readFile as readFile13, writeFile as writeFile3, stat as stat2 } from "fs/promises";
-import { resolve as resolve17, dirname as dirname2, basename } from "path";
+import { resolve as resolve18, dirname as dirname2, basename } from "path";
 function clearFrontmatterField(content, key) {
   const fieldRegex = new RegExp(`^(${escapeRegExp2(key)}:)\\s*.*$`, "m");
   return content.replace(fieldRegex, `$1 null`);
@@ -8735,8 +9235,8 @@ async function computeStandaloneRecords(assignmentsDir2) {
   const records = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const assignmentDir = resolve17(assignmentsDir2, entry.name);
-    const assignmentMdPath = resolve17(assignmentDir, "assignment.md");
+    const assignmentDir = resolve18(assignmentsDir2, entry.name);
+    const assignmentMdPath = resolve18(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentMdPath)) continue;
     try {
       const content = await readFile13(assignmentMdPath, "utf-8");
@@ -8823,7 +9323,7 @@ async function listProjects(projectsDir) {
   return projectRecords.filter((record) => !isProjectArchived(record.summary)).map((record) => record.summary);
 }
 async function readWorkspaceRegistry(projectsDir) {
-  const registryPath = resolve17(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve18(dirname2(projectsDir), "workspaces.json");
   try {
     const raw2 = await readFile13(registryPath, "utf-8");
     const parsed = JSON.parse(raw2);
@@ -8833,7 +9333,7 @@ async function readWorkspaceRegistry(projectsDir) {
   }
 }
 async function writeWorkspaceRegistry(projectsDir, workspaces) {
-  const registryPath = resolve17(dirname2(projectsDir), "workspaces.json");
+  const registryPath = resolve18(dirname2(projectsDir), "workspaces.json");
   await writeFile3(registryPath, JSON.stringify(workspaces, null, 2) + "\n", "utf-8");
 }
 async function listWorkspaces(projectsDir, assignmentsDir2) {
@@ -8924,7 +9424,7 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
   if (cascade) {
     const timestamp = nowTimestamp();
     for (const slug of projectsReferencing) {
-      const path = resolve17(projectsDir, slug, "project.md");
+      const path = resolve18(projectsDir, slug, "project.md");
       const raw2 = await readFile13(path, "utf-8");
       let next = clearFrontmatterField(raw2, "workspace");
       next = setUpdatedField(next, timestamp);
@@ -8933,7 +9433,7 @@ async function deleteWorkspace(projectsDir, name, opts = {}) {
     }
     for (const id of standalonesReferencing) {
       if (!opts.assignmentsDir) break;
-      const path = resolve17(opts.assignmentsDir, id, "assignment.md");
+      const path = resolve18(opts.assignmentsDir, id, "assignment.md");
       const raw2 = await readFile13(path, "utf-8");
       let next = clearFrontmatterField(raw2, "workspaceGroup");
       next = setUpdatedField(next, timestamp);
@@ -9212,7 +9712,7 @@ async function getEditableDocumentById(projectsDir, assignmentsDir2, documentTyp
   }
   const fileName = documentType === "assignment" ? "assignment.md" : documentType === "plan" ? "plan.md" : documentType === "scratchpad" ? "scratchpad.md" : documentType === "handoff" ? "handoff.md" : documentType === "decision-record" ? "decision-record.md" : null;
   if (!fileName) return null;
-  const filePath = resolve17(resolved.assignmentDir, fileName);
+  const filePath = resolve18(resolved.assignmentDir, fileName);
   if (!await fileExists(filePath)) return null;
   const content = await readFile13(filePath, "utf-8");
   const label = resolved.id;
@@ -9228,8 +9728,8 @@ async function getEditableDocumentById(projectsDir, assignmentsDir2, documentTyp
   };
 }
 async function getProjectDetail(projectsDir, slug) {
-  const projectPath = resolve17(projectsDir, slug);
-  const projectMdPath = resolve17(projectPath, "project.md");
+  const projectPath = resolve18(projectsDir, slug);
+  const projectMdPath = resolve18(projectPath, "project.md");
   if (!await fileExists(projectMdPath)) {
     return null;
   }
@@ -9266,15 +9766,15 @@ async function getProjectDetail(projectsDir, slug) {
   };
 }
 async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
-  const assignmentDir = resolve17(projectsDir, projectSlug, "assignments", assignmentSlug);
-  const assignmentMdPath = resolve17(assignmentDir, "assignment.md");
+  const assignmentDir = resolve18(projectsDir, projectSlug, "assignments", assignmentSlug);
+  const assignmentMdPath = resolve18(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) {
     return null;
   }
   const assignmentContent = await readFile13(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let projectWorkspace = null;
-  const projectMdPath = resolve17(projectsDir, projectSlug, "project.md");
+  const projectMdPath = resolve18(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectMdPath)) {
     const projectContent = await readFile13(projectMdPath, "utf-8");
     projectWorkspace = parseProject(projectContent).workspace;
@@ -9282,7 +9782,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
   let plan = null;
   const planFile = await latestPlanFile(assignmentDir);
   if (planFile) {
-    const planPath = resolve17(assignmentDir, planFile);
+    const planPath = resolve18(assignmentDir, planFile);
     if (await fileExists(planPath)) {
       const planContent = await readFile13(planPath, "utf-8");
       const parsed = parsePlan(planContent);
@@ -9294,7 +9794,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     }
   }
   let scratchpad = null;
-  const scratchpadPath = resolve17(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve18(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
     const scratchpadContent = await readFile13(scratchpadPath, "utf-8");
     const parsed = parseScratchpad(scratchpadContent);
@@ -9304,7 +9804,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let handoff = null;
-  const handoffPath = resolve17(assignmentDir, "handoff.md");
+  const handoffPath = resolve18(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
     const handoffContent = await readFile13(handoffPath, "utf-8");
     const parsed = parseHandoff(handoffContent);
@@ -9315,7 +9815,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve17(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve18(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
     const decisionRecordContent = await readFile13(decisionRecordPath, "utf-8");
     const parsed = parseDecisionRecord(decisionRecordContent);
@@ -9326,7 +9826,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let progress = null;
-  const progressPath = resolve17(assignmentDir, "progress.md");
+  const progressPath = resolve18(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
     const progressContent = await readFile13(progressPath, "utf-8");
     const parsed = parseProgress(progressContent);
@@ -9337,7 +9837,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     };
   }
   let comments = null;
-  const commentsPath = resolve17(assignmentDir, "comments.md");
+  const commentsPath = resolve18(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
     const commentsContent = await readFile13(commentsPath, "utf-8");
     const parsed = parseComments(commentsContent);
@@ -9371,7 +9871,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     archivedReason: assignment.archivedReason,
     ...deriveStatusVirtuals(assignment, terminalStatuses),
     override: assignment.override,
-    derived: await buildDerivedDetail(assignment, assignmentDir, resolve17(projectsDir, projectSlug)),
+    derived: await buildDerivedDetail(assignment, assignmentDir, resolve18(projectsDir, projectSlug)),
     created: assignment.created,
     updated: assignment.updated,
     body: assignment.body,
@@ -9462,7 +9962,7 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir2) {
         slug: a.slug,
         title: a.title,
         projectSlug: rec.summary.slug,
-        assignmentDir: resolve17(rec.projectPath, "assignments", a.slug)
+        assignmentDir: resolve18(rec.projectPath, "assignments", a.slug)
       });
     }
   }
@@ -9495,14 +9995,14 @@ async function computeReferencedBy(target, projectsDir, assignmentsDir2) {
 }
 async function countMentionsInAssignment(sourceDir, target) {
   const bodies = [];
-  const assignmentMd = resolve17(sourceDir, "assignment.md");
+  const assignmentMd = resolve18(sourceDir, "assignment.md");
   if (await fileExists(assignmentMd)) {
     const content = await readFile13(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 = resolve17(sourceDir, filename);
+    const path = resolve18(sourceDir, filename);
     if (await fileExists(path)) {
       try {
         bodies.push(await readFile13(path, "utf-8"));
@@ -9563,45 +10063,45 @@ async function getAssignmentDetailById(projectsDir, assignmentsDir2, id) {
 }
 async function buildStandaloneAssignmentDetail(resolved) {
   const assignmentDir = resolved.assignmentDir;
-  const assignmentMdPath = resolve17(assignmentDir, "assignment.md");
+  const assignmentMdPath = resolve18(assignmentDir, "assignment.md");
   if (!await fileExists(assignmentMdPath)) return null;
   const assignmentContent = await readFile13(assignmentMdPath, "utf-8");
   const assignment = parseAssignmentFull(assignmentContent);
   let plan = null;
   const planFile = await latestPlanFile(assignmentDir);
   if (planFile) {
-    const planPath = resolve17(assignmentDir, planFile);
+    const planPath = resolve18(assignmentDir, planFile);
     if (await fileExists(planPath)) {
       const parsed = parsePlan(await readFile13(planPath, "utf-8"));
       plan = { status: parsed.status, updated: parsed.updated, body: parsed.body };
     }
   }
   let scratchpad = null;
-  const scratchpadPath = resolve17(assignmentDir, "scratchpad.md");
+  const scratchpadPath = resolve18(assignmentDir, "scratchpad.md");
   if (await fileExists(scratchpadPath)) {
     const parsed = parseScratchpad(await readFile13(scratchpadPath, "utf-8"));
     scratchpad = { updated: parsed.updated, body: parsed.body };
   }
   let handoff = null;
-  const handoffPath = resolve17(assignmentDir, "handoff.md");
+  const handoffPath = resolve18(assignmentDir, "handoff.md");
   if (await fileExists(handoffPath)) {
     const parsed = parseHandoff(await readFile13(handoffPath, "utf-8"));
     handoff = { updated: parsed.updated, handoffCount: parsed.handoffCount, body: parsed.body };
   }
   let decisionRecord = null;
-  const decisionRecordPath = resolve17(assignmentDir, "decision-record.md");
+  const decisionRecordPath = resolve18(assignmentDir, "decision-record.md");
   if (await fileExists(decisionRecordPath)) {
     const parsed = parseDecisionRecord(await readFile13(decisionRecordPath, "utf-8"));
     decisionRecord = { updated: parsed.updated, decisionCount: parsed.decisionCount, body: parsed.body };
   }
   let progress = null;
-  const progressPath = resolve17(assignmentDir, "progress.md");
+  const progressPath = resolve18(assignmentDir, "progress.md");
   if (await fileExists(progressPath)) {
     const parsed = parseProgress(await readFile13(progressPath, "utf-8"));
     progress = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
   }
   let comments = null;
-  const commentsPath = resolve17(assignmentDir, "comments.md");
+  const commentsPath = resolve18(assignmentDir, "comments.md");
   if (await fileExists(commentsPath)) {
     const parsed = parseComments(await readFile13(commentsPath, "utf-8"));
     comments = { updated: parsed.updated, entryCount: parsed.entryCount, entries: parsed.entries };
@@ -9667,8 +10167,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 = resolve17(projectsDir, entry.name);
-      const projectMdPath = resolve17(projectPath, "project.md");
+      const projectPath = resolve18(projectsDir, entry.name);
+      const projectMdPath = resolve18(projectPath, "project.md");
       if (!await fileExists(projectMdPath)) {
         return null;
       }
@@ -9715,7 +10215,7 @@ async function computeProjectRecords(projectsDir, traces) {
   return records;
 }
 async function listAssignmentRecords(projectPath, traces) {
-  const assignmentsDir2 = resolve17(projectPath, "assignments");
+  const assignmentsDir2 = resolve18(projectPath, "assignments");
   if (!await fileExists(assignmentsDir2)) {
     return [];
   }
@@ -9723,7 +10223,7 @@ async function listAssignmentRecords(projectPath, traces) {
   const dirEntries = entries.filter((entry) => entry.isDirectory());
   const maybeRecords = await Promise.all(
     dirEntries.map(async (entry) => {
-      const assignmentMd = resolve17(assignmentsDir2, entry.name, "assignment.md");
+      const assignmentMd = resolve18(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) {
         return null;
       }
@@ -9739,7 +10239,7 @@ async function listAssignmentRecords(projectPath, traces) {
   return records;
 }
 async function listResources(projectPath) {
-  const resourcesDir = resolve17(projectPath, "resources");
+  const resourcesDir = resolve18(projectPath, "resources");
   if (!await fileExists(resourcesDir)) {
     return [];
   }
@@ -9749,7 +10249,7 @@ async function listResources(projectPath) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve17(resourcesDir, entry.name);
+    const filePath = resolve18(resourcesDir, entry.name);
     const content = await readFile13(filePath, "utf-8");
     const parsed = parseResource(content);
     results.push({
@@ -9765,7 +10265,7 @@ async function listResources(projectPath) {
   return results;
 }
 async function listMemories(projectPath) {
-  const memoriesDir = resolve17(projectPath, "memories");
+  const memoriesDir = resolve18(projectPath, "memories");
   if (!await fileExists(memoriesDir)) {
     return [];
   }
@@ -9775,7 +10275,7 @@ async function listMemories(projectPath) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_")) {
       continue;
     }
-    const filePath = resolve17(memoriesDir, entry.name);
+    const filePath = resolve18(memoriesDir, entry.name);
     const content = await readFile13(filePath, "utf-8");
     const parsed = parseMemory(content);
     results.push({
@@ -9824,8 +10324,8 @@ async function listAllResources(projectsDir) {
   return all;
 }
 async function resolveProjectPath(projectsDir, projectSlug) {
-  const direct = resolve17(projectsDir, projectSlug);
-  if (await fileExists(resolve17(direct, "project.md"))) return direct;
+  const direct = resolve18(projectsDir, projectSlug);
+  if (await fileExists(resolve18(direct, "project.md"))) return direct;
   const records = await listProjectRecords(projectsDir);
   const match = records.find((r) => r.summary.slug === projectSlug);
   return match ? match.projectPath : null;
@@ -9837,7 +10337,7 @@ async function getMemoryDetail(projectsDir, projectSlug, itemSlug) {
     (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
   );
   if (!projectRecord) return null;
-  const filePath = resolve17(projectRecord.projectPath, "memories", `${itemSlug}.md`);
+  const filePath = resolve18(projectRecord.projectPath, "memories", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
   const content = await readFile13(filePath, "utf-8");
   const parsed = parseMemory(content);
@@ -9863,7 +10363,7 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
     (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
   );
   if (!projectRecord) return null;
-  const filePath = resolve17(projectRecord.projectPath, "resources", `${itemSlug}.md`);
+  const filePath = resolve18(projectRecord.projectPath, "resources", `${itemSlug}.md`);
   if (!await fileExists(filePath)) return null;
   const content = await readFile13(filePath, "utf-8");
   const parsed = parseResource(content);
@@ -9881,7 +10381,7 @@ async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
   };
 }
 async function loadDependencyGraph(projectPath, assignments) {
-  const statusPath = resolve17(projectPath, "_status.md");
+  const statusPath = resolve18(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
     const statusContent = await readFile13(statusPath, "utf-8");
     const parsed = parseStatus(statusContent);
@@ -10050,7 +10550,7 @@ function toAssignmentSummary(assignment, terminalStatuses) {
 async function toAssignmentBoardItem(projectsDir, projectRecord, assignment) {
   const config = await getStatusConfig();
   const { terminalStatuses } = config;
-  const assignmentDir = resolve17(projectRecord.projectPath, "assignments", assignment.slug);
+  const assignmentDir = resolve18(projectRecord.projectPath, "assignments", assignment.slug);
   const projectDir = projectRecord.projectPath;
   let facts;
   try {
@@ -10111,7 +10611,7 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
-  const projectPath = resolve17(projectsDir, projectSlug);
+  const projectPath = resolve18(projectsDir, projectSlug);
   const traces = options?.traces;
   for (const definition of transitionDefs) {
     const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
@@ -10159,7 +10659,7 @@ async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, de
         continue;
       }
     }
-    const dependencyPath = resolve17(projectPath, "assignments", dependency, "assignment.md");
+    const dependencyPath = resolve18(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);
       continue;
@@ -10239,13 +10739,13 @@ async function collectStaleCandidates(projectsDir, assignmentsDir2) {
   const out = [];
   for (const record of projectRecords) {
     if (isProjectArchived(record.summary)) continue;
-    const projectPath = resolve17(projectsDir, record.summary.slug);
+    const projectPath = resolve18(projectsDir, record.summary.slug);
     const depMap = /* @__PURE__ */ new Map();
     for (const a of record.assignments) depMap.set(a.slug, a.status);
     for (const assignment of activeAssignments(record.assignments)) {
       const depsSatisfied = assignment.dependsOn.length === 0 ? true : (await getUnmetDependencies(projectPath, assignment.dependsOn, terminalStatuses, depMap)).length === 0;
       const lastActivityMs = await readProgressActivityMs(
-        resolve17(projectPath, "assignments", assignment.slug, "progress.md"),
+        resolve18(projectPath, "assignments", assignment.slug, "progress.md"),
         now
       );
       const reasons = classifyAssignmentRecord(assignment, terminalStatuses, depsSatisfied, lastActivityMs, thresholds);
@@ -10256,7 +10756,7 @@ async function collectStaleCandidates(projectsDir, assignmentsDir2) {
   }
   for (const sr of standaloneRecords) {
     if (sr.record.archived === true) continue;
-    const lastActivityMs = await readProgressActivityMs(resolve17(sr.assignmentDir, "progress.md"), now);
+    const lastActivityMs = await readProgressActivityMs(resolve18(sr.assignmentDir, "progress.md"), now);
     const reasons = classifyAssignmentRecord(sr.record, terminalStatuses, true, lastActivityMs, thresholds);
     if (reasons.length > 0) out.push({ assignmentId: sr.record.id, projectSlug: null, reasons });
   }
@@ -10275,7 +10775,7 @@ async function buildOverviewSegmentBuckets(projectsDir, projectRecords, standalo
       depMap.set(a.slug, a.status);
     }
     const visibleAssignments = activeAssignments(record.assignments);
-    const projectPath = resolve17(projectsDir, record.summary.slug);
+    const projectPath = resolve18(projectsDir, record.summary.slug);
     const resolvedTransitions = await Promise.all(
       visibleAssignments.map(async (assignment) => {
         const t0 = traces ? performance.now() : 0;
@@ -10289,7 +10789,7 @@ async function buildOverviewSegmentBuckets(projectsDir, projectRecords, standalo
         if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
         const depsSatisfied = assignment.dependsOn.length === 0 ? true : (await getUnmetDependencies(projectPath, assignment.dependsOn, terminalStatuses, depMap)).length === 0;
         const lastActivityMs = await readProgressActivityMs(
-          resolve17(projectPath, "assignments", assignment.slug, "progress.md"),
+          resolve18(projectPath, "assignments", assignment.slug, "progress.md"),
           now
         );
         return { assignment, availableTransitions, depsSatisfied, lastActivityMs };
@@ -10363,7 +10863,7 @@ async function buildOverviewSegmentBuckets(projectsDir, projectRecords, standalo
       const t0 = traces ? performance.now() : 0;
       const availableTransitions = await getStandaloneAvailableTransitions(sr.record);
       if (traces) accumulatePhase(traces, "get-available-transitions", performance.now() - t0);
-      const lastActivityMs = await readProgressActivityMs(resolve17(sr.assignmentDir, "progress.md"), now);
+      const lastActivityMs = await readProgressActivityMs(resolve18(sr.assignmentDir, "progress.md"), now);
       return { sr, availableTransitions, lastActivityMs };
     })
   );
@@ -10533,7 +11033,7 @@ function parseTimestamp(timestamp) {
   return Number.isFinite(parsed) ? parsed : 0;
 }
 async function countOpenQuestions(projectPath, assignmentSlug) {
-  const commentsPath = resolve17(
+  const commentsPath = resolve18(
     projectPath,
     "assignments",
     assignmentSlug,
@@ -10564,21 +11064,21 @@ function getProjectActivityTimestamp(projectUpdated, assignments) {
 function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug) {
   switch (documentType) {
     case "project":
-      return resolve17(projectsDir, projectSlug, "project.md");
+      return resolve18(projectsDir, projectSlug, "project.md");
     case "assignment":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md") : null;
     case "plan":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "plan.md") : null;
     case "scratchpad":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "scratchpad.md") : null;
     case "handoff":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
     case "memory":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "memories", `${assignmentSlug}.md`) : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "memories", `${assignmentSlug}.md`) : null;
     case "resource":
-      return assignmentSlug ? resolve17(projectsDir, projectSlug, "resources", `${assignmentSlug}.md`) : null;
+      return assignmentSlug ? resolve18(projectsDir, projectSlug, "resources", `${assignmentSlug}.md`) : null;
     default:
       return null;
   }
@@ -10615,7 +11115,7 @@ async function listPlaybooks(playbooksDir2) {
   const playbooks = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name.startsWith("_") || entry.name === "manifest.md") continue;
-    const filePath = resolve17(playbooksDir2, entry.name);
+    const filePath = resolve18(playbooksDir2, entry.name);
     const raw2 = await readFile13(filePath, "utf-8");
     const parsed = parsePlaybook(raw2);
     const slug = parsed.slug || entry.name.replace(/\.md$/, "");
@@ -11220,12 +11720,12 @@ __export(recompute_exports, {
 });
 import { createHash as createHash2 } from "crypto";
 import { open, readdir as readdir12, readFile as readFile17, unlink as unlink5, stat as stat3 } from "fs/promises";
-import { basename as basename3, dirname as dirname4, resolve as resolve22 } from "path";
+import { basename as basename3, dirname as dirname4, resolve as resolve23 } from "path";
 async function isDeriveMigrated() {
-  return fileExists(resolve22(syntaurRoot(), MIGRATION_MARKER));
+  return fileExists(resolve23(syntaurRoot(), MIGRATION_MARKER));
 }
 async function markDeriveMigrated() {
-  await writeFileForce(resolve22(syntaurRoot(), MIGRATION_MARKER), `${nowTimestamp()}
+  await writeFileForce(resolve23(syntaurRoot(), MIGRATION_MARKER), `${nowTimestamp()}
 `);
 }
 async function resolveDeriveContext() {
@@ -11242,7 +11742,7 @@ async function resolveDeriveContext() {
   };
 }
 async function acquireLock(assignmentDir) {
-  const lockPath = resolve22(assignmentDir, LOCK_FILE);
+  const lockPath = resolve23(assignmentDir, LOCK_FILE);
   const token = `${process.pid}:${createHash2("sha256").update(`${Math.random()}${Date.now()}`).digest("hex").slice(0, 12)}`;
   for (let attempt = 0; attempt <= LOCK_MAX_WAITS; attempt++) {
     try {
@@ -11386,7 +11886,7 @@ async function recomputeAndWrite(assignmentPath, opts) {
   }
 }
 async function recomputeDependents(projectDir, changedSlug, opts) {
-  const assignmentsDir2 = resolve22(projectDir, "assignments");
+  const assignmentsDir2 = resolve23(projectDir, "assignments");
   let entries;
   try {
     entries = await readdir12(assignmentsDir2);
@@ -11396,7 +11896,7 @@ async function recomputeDependents(projectDir, changedSlug, opts) {
   const results = [];
   for (const slug of entries) {
     if (slug === changedSlug) continue;
-    const path = resolve22(assignmentsDir2, slug, "assignment.md");
+    const path = resolve23(assignmentsDir2, slug, "assignment.md");
     if (!await fileExists(path)) continue;
     try {
       const fm = parseAssignmentFrontmatter(await readFile17(path, "utf-8"));
@@ -11426,8 +11926,8 @@ async function recomputeAll(projectsDir, standaloneDir, opts) {
   } catch {
   }
   for (const project of projects) {
-    const projectDir = resolve22(projectsDir, project);
-    const assignmentsDir2 = resolve22(projectDir, "assignments");
+    const projectDir = resolve23(projectsDir, project);
+    const assignmentsDir2 = resolve23(projectDir, "assignments");
     let slugs = [];
     try {
       slugs = await readdir12(assignmentsDir2);
@@ -11435,7 +11935,7 @@ async function recomputeAll(projectsDir, standaloneDir, opts) {
       continue;
     }
     for (const slug of slugs) {
-      const path = resolve22(assignmentsDir2, slug, "assignment.md");
+      const path = resolve23(assignmentsDir2, slug, "assignment.md");
       if (await fileExists(path)) await sweepOne(path, projectDir);
     }
   }
@@ -11446,7 +11946,7 @@ async function recomputeAll(projectsDir, standaloneDir, opts) {
     } catch {
     }
     for (const id of ids) {
-      const path = resolve22(standaloneDir, id, "assignment.md");
+      const path = resolve23(standaloneDir, id, "assignment.md");
       if (await fileExists(path)) await sweepOne(path, null);
     }
   }
@@ -11454,7 +11954,7 @@ async function recomputeAll(projectsDir, standaloneDir, opts) {
 }
 async function recomputeAssignmentDir(assignmentDir, cause, by) {
   try {
-    const assignmentPath = resolve22(assignmentDir, "assignment.md");
+    const assignmentPath = resolve23(assignmentDir, "assignment.md");
     if (!await fileExists(assignmentPath)) return null;
     const parent = dirname4(assignmentDir);
     const projectDir = basename3(parent) === "assignments" ? dirname4(parent) : null;
@@ -11486,6 +11986,27 @@ var init_recompute = __esm({
   }
 });
 
+// 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/utils/transcript.ts
 import { open as open2 } from "fs/promises";
 async function derivePathFromTranscript(transcriptPath) {
@@ -11549,31 +12070,10 @@ var init_transcript = __esm({
   }
 });
 
-// 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 readdir13, stat as stat4 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
 async function extractClaudeSessionMeta(jsonlPath) {
   const cwd = await derivePathFromTranscript(jsonlPath);
   if (!cwd) return null;
@@ -11646,12 +12146,12 @@ async function* walkClaudeProjects(opts = {}) {
   const dirs = await listDirSafe(root);
   for (const dirent of dirs) {
     if (!dirent.isDirectory) continue;
-    const dirPath = join4(root, dirent.name);
+    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 = join4(dirPath, f.name);
+      const filePath = join3(dirPath, f.name);
       if (opts.sinceMtimeMs !== void 0) {
         const mtime = await mtimeMs(filePath);
         if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -11683,13 +12183,13 @@ async function* walkCodexSessions(opts = {}) {
     if (meta) yield meta;
   }
 }
-function resolveCodexSessionsRoot(override) {
-  if (override) return expandHome(override);
+function resolveCodexSessionsRoot(override3) {
+  if (override3) return expandHome(override3);
   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 join4(expandHome(fromHomeEnv), "sessions");
-  return join4(homedir3(), ".codex", "sessions");
+  if (fromHomeEnv && fromHomeEnv.length > 0) return join3(expandHome(fromHomeEnv), "sessions");
+  return join3(homedir2(), ".codex", "sessions");
 }
 async function extractPiSessionMeta(jsonlPath) {
   const basename7 = jsonlPath.split("/").pop() ?? "";
@@ -11743,23 +12243,23 @@ async function extractPiSessionMeta(jsonlPath) {
     });
   }
 }
-function resolvePiSessionsRoot(override) {
-  if (override) return expandHome(override);
+function resolvePiSessionsRoot(override3) {
+  if (override3) return expandHome(override3);
   const fromHomeEnv = process.env.PI_AGENT_DIR;
-  if (fromHomeEnv && fromHomeEnv.length > 0) return join4(expandHome(fromHomeEnv), "sessions");
-  return join4(homedir3(), ".pi", "agent", "sessions");
+  if (fromHomeEnv && fromHomeEnv.length > 0) return join3(expandHome(fromHomeEnv), "sessions");
+  return join3(homedir2(), ".pi", "agent", "sessions");
 }
 async function* walkPiSessions(opts = {}) {
   const root = resolvePiSessionsRoot(opts.root);
   const dirs = await listDirSafe(root);
   for (const dirent of dirs) {
     if (!dirent.isDirectory) continue;
-    const dirPath = join4(root, dirent.name);
+    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 = join4(dirPath, f.name);
+      const filePath = join3(dirPath, f.name);
       if (opts.sinceMtimeMs !== void 0) {
         const mtime = await mtimeMs(filePath);
         if (mtime !== null && mtime < opts.sinceMtimeMs) continue;
@@ -11799,7 +12299,7 @@ async function* walkJsonlRecursive(root) {
     const current = stack.pop();
     const entries = await listDirSafe(current);
     for (const e of entries) {
-      const full = join4(current, e.name);
+      const full = join3(current, e.name);
       if (e.isDirectory) {
         stack.push(full);
       } else if (e.isFile && e.name.endsWith(".jsonl")) {
@@ -11910,17 +12410,17 @@ var init_cwd_extractor = __esm({
 
 // 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 join5 } from "path";
+import { mkdirSync, readFileSync as readFileSync2, statSync as statSync4, writeFileSync } from "fs";
+import { homedir as homedir3 } 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);
 }
 function readRuntimeMarker(pid, dir) {
   if (!Number.isInteger(pid) || pid <= 0) return null;
-  const path = join5(dir, `${pid}.json`);
+  const path = join4(dir, `${pid}.json`);
   try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
     if (parsed && typeof parsed === "object" && typeof parsed.sessionId === "string" && parsed.sessionId.length > 0) {
       return parsed;
     }
@@ -11930,7 +12430,7 @@ function readRuntimeMarker(pid, dir) {
   }
 }
 function writeRuntimeMarker(pid, marker, dir) {
-  const path = join5(dir, `${pid}.json`);
+  const path = join4(dir, `${pid}.json`);
   mkdirSync(dirname5(path), { recursive: true });
   writeFileSync(path, JSON.stringify(marker));
 }
@@ -11991,6 +12491,22 @@ var init_assignment_todos = __esm({
   }
 });
 
+// src/utils/path-canon.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve44 } from "path";
+function canonicalPath(p) {
+  try {
+    return realpathSync2(resolve44(p));
+  } catch {
+    return resolve44(p).replace(/\/+$/, "");
+  }
+}
+var init_path_canon = __esm({
+  "src/utils/path-canon.ts"() {
+    "use strict";
+  }
+});
+
 // src/targets/renderers.ts
 var RENDERERS;
 var init_renderers = __esm({
@@ -12011,7 +12527,7 @@ var init_renderers = __esm({
 });
 
 // src/targets/user-descriptors.ts
-import { resolve as resolve43 } from "path";
+import { resolve as resolve45 } from "path";
 import { readFile as readFile30, readdir as readdir18 } from "fs/promises";
 var VALID_RENDERER_KEYS;
 var init_user_descriptors = __esm({
@@ -12026,20 +12542,20 @@ var init_user_descriptors = __esm({
 
 // src/targets/registry.ts
 import { homedir as homedir7 } from "os";
-import { join as join10, resolve as resolve44 } from "path";
+import { join as join10, resolve as resolve46 } from "path";
 function home(...segments) {
-  return resolve44(homedir7(), ...segments);
+  return resolve46(homedir7(), ...segments);
 }
 function hermesHome() {
   const env = process.env.HERMES_HOME;
-  return env && env.length > 0 ? resolve44(env) : home(".hermes");
+  return env && env.length > 0 ? resolve46(env) : home(".hermes");
 }
 function hermesSkillsDir() {
-  return resolve44(hermesHome(), "skills");
+  return resolve46(hermesHome(), "skills");
 }
 function codexHome() {
   const env = process.env.CODEX_HOME;
-  return env && env.length > 0 ? resolve44(env) : home(".codex");
+  return env && env.length > 0 ? resolve46(env) : home(".codex");
 }
 function toDiscovered(meta) {
   if (!meta) return null;
@@ -12110,7 +12626,7 @@ var init_registry = __esm({
         skillsShAgentId: "codex",
         nativePlugin: "codex",
         detect: detectDir(codexHome()),
-        skillsDir: { global: resolve44(codexHome(), "skills") },
+        skillsDir: { global: resolve46(codexHome(), "skills") },
         instructions: { files: [{ path: "AGENTS.md", renderer: "codexAgents" }] },
         sessions: codexSessions
       },
@@ -12179,7 +12695,7 @@ var init_registry = __esm({
         tier3: {
           kind: "hermes-plugin",
           source: "platforms/hermes/plugins/syntaur",
-          installDir: () => resolve44(hermesHome(), "plugins", "syntaur"),
+          installDir: () => resolve46(hermesHome(), "plugins", "syntaur"),
           entry: "plugin.yaml"
         }
       }
@@ -12190,22 +12706,75 @@ var init_registry = __esm({
   }
 });
 
+// src/sessions/agent-view.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+function toActivityState(raw2) {
+  switch (raw2) {
+    case "working":
+    case "idle":
+    case "awaiting-input":
+      return raw2;
+    default:
+      return null;
+  }
+}
+function parseAgentView(json) {
+  const live = /* @__PURE__ */ new Map();
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return live;
+  }
+  const entries = Array.isArray(parsed) ? parsed : Array.isArray(parsed.agents) ? parsed.agents : [];
+  for (const entry of entries) {
+    if (entry === null || typeof entry !== "object") continue;
+    const e = entry;
+    const id = typeof e.session_id === "string" ? e.session_id : typeof e.sessionId === "string" ? e.sessionId : null;
+    if (!id) continue;
+    live.set(id, toActivityState(e.activity ?? e.status) ?? "idle");
+  }
+  return live;
+}
+function getAgentViewSource() {
+  return override2 ?? productionAgentViewSource;
+}
+var execFileAsync, productionAgentViewSource, override2;
+var init_agent_view = __esm({
+  "src/sessions/agent-view.ts"() {
+    "use strict";
+    execFileAsync = promisify3(execFile3);
+    productionAgentViewSource = async () => {
+      try {
+        const { stdout } = await execFileAsync("claude", ["agents", "--json"], {
+          timeout: 5e3,
+          maxBuffer: 8 * 1024 * 1024
+        });
+        return parseAgentView(stdout);
+      } catch {
+        return /* @__PURE__ */ new Map();
+      }
+    };
+    override2 = null;
+  }
+});
+
 // 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 readFile31 } from "fs/promises";
-import { resolve as resolve45 } from "path";
+import { execFile as execFile4, execFileSync as execFileSync4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { statSync as statSync5 } from "fs";
+import { resolve as resolve47 } 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;
+    return statSync5(path).mtimeMs;
   } catch {
     return null;
   }
@@ -12238,7 +12807,7 @@ async function defaultOpenFiles(files) {
     const chunk = files.slice(i, i + LSOF_CHUNK);
     let stdout = "";
     try {
-      const result = await execFileAsync("lsof", ["-Fn", "--", ...chunk], {
+      const result = await execFileAsync2("lsof", ["-Fn", "--", ...chunk], {
         maxBuffer: 8 * 1024 * 1024
       });
       stdout = result.stdout;
@@ -12252,23 +12821,17 @@ async function defaultOpenFiles(files) {
   }
   return open6;
 }
-async function readContextLink(cwd, cache3) {
+function canonicalizeOpenSet(open6) {
+  const out = /* @__PURE__ */ new Set();
+  for (const p of open6) out.add(canonicalPath(p));
+  return out;
+}
+async function isWorkspace(cwd, cache3) {
   if (cache3.has(cwd)) return cache3.get(cwd);
-  let link = null;
-  const path = resolve45(cwd, ".syntaur", "context.json");
-  if (await fileExists(path)) {
-    try {
-      const parsed = JSON.parse(await readFile31(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 };
-    }
-  }
-  cache3.set(cwd, link);
-  return link;
+  const path = resolve47(cwd, ".syntaur", "context.json");
+  const present = await fileExists(path);
+  cache3.set(cwd, present);
+  return present;
 }
 function readWatermark() {
   const db5 = getSessionDb();
@@ -12292,9 +12855,16 @@ async function scanSessions(opts = {}, deps = {}) {
   const openFiles = deps.openFiles ?? defaultOpenFiles;
   const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
   const pidStartedAt = deps.pidStartedAt ?? defaultPidStartedAt;
+  const agentView = deps.agentView ?? getAgentViewSource();
   const targets = (deps.targets ?? AGENT_TARGETS).filter((t) => t.sessions !== void 0);
   const scanStartMs = now();
   const watermark = opts.full ? null : readWatermark();
+  let liveActivity;
+  try {
+    liveActivity = await agentView();
+  } catch {
+    liveActivity = /* @__PURE__ */ new Map();
+  }
   const discovered = [];
   for (const target of targets) {
     const walk = target.sessions.walk({
@@ -12307,17 +12877,20 @@ async function scanSessions(opts = {}, deps = {}) {
     }
   }
   summary.discovered = discovered.length;
-  const openSet = await openFiles(discovered.map((d) => d.transcriptPath));
-  const contextCache = /* @__PURE__ */ new Map();
+  const openSet = canonicalizeOpenSet(
+    await openFiles(discovered.map((d) => d.transcriptPath))
+  );
+  const workspaceCache = /* @__PURE__ */ new Map();
   for (const d of discovered) {
-    const link = await readContextLink(d.cwd, contextCache);
-    if (autoTrack === "workspaces-only" && link === null) {
+    const isWs = await isWorkspace(d.cwd, workspaceCache);
+    if (autoTrack === "workspaces-only" && !isWs) {
       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 heldOpen = openSet.has(canonicalPath(d.transcriptPath));
+    const agentViewLive = liveActivity.has(d.sessionId);
+    const isLive = heldOpen || agentViewLive || 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());
@@ -12325,8 +12898,11 @@ async function scanSessions(opts = {}, deps = {}) {
       "",
       {
         sessionId: d.sessionId,
-        projectSlug: link?.projectSlug ?? null,
-        assignmentSlug: link?.assignmentSlug ?? null,
+        // Auto-discovered sessions are UNATTRIBUTED: the scanner no longer binds
+        // them to the cwd context.json assignment scalar (see isWorkspace). An
+        // explicit grab/track opens an engagement edge to attribute them.
+        projectSlug: null,
+        assignmentSlug: null,
         agent: d.agent,
         started,
         status,
@@ -12338,11 +12914,12 @@ async function scanSessions(opts = {}, deps = {}) {
         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 }
+      // transcript open) OR Agent-View live evidence 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 || agentViewLive }
     );
     if (!isLive) {
       const after = getSessionById(d.sessionId);
@@ -12355,19 +12932,25 @@ async function scanSessions(opts = {}, deps = {}) {
       summary.inserted += 1;
       summary.changed = true;
     } else {
-      if (prev.status === "stopped" && heldOpen) {
+      if (prev.status === "stopped" && (heldOpen || agentViewLive)) {
         summary.revived += 1;
         summary.changed = true;
       }
-      if (link?.projectSlug && !prev.projectSlug || link?.assignmentSlug && !prev.assignmentSlug) {
-        summary.changed = true;
-      }
     }
   }
   const db5 = getSessionDb();
+  if (liveActivity.size > 0) {
+    const setActivity = db5.prepare(
+      "UPDATE sessions SET activity = ?, updated_at = datetime('now') WHERE session_id = ? AND activity IS NOT ?"
+    );
+    for (const [sid, activity] of liveActivity) {
+      if (setActivity.run(activity, sid, activity).changes > 0) summary.changed = true;
+    }
+  }
   const activeRows = db5.prepare("SELECT session_id, pid, pid_started_at, transcript_path FROM sessions WHERE status = 'active'").all();
   const sweepCandidates = [];
   for (const row of activeRows) {
+    if (liveActivity.has(row.session_id)) continue;
     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;
@@ -12378,20 +12961,33 @@ async function scanSessions(opts = {}, deps = {}) {
       sweepCandidates.push({ sessionId: row.session_id, transcriptPath: null });
     }
   }
-  const sweepOpenSet = await openFiles(
-    sweepCandidates.map((c) => c.transcriptPath).filter((p) => p !== null)
+  const sweepOpenSet = canonicalizeOpenSet(
+    await openFiles(
+      sweepCandidates.map((c) => c.transcriptPath).filter((p) => p !== null)
+    )
   );
   for (const candidate of sweepCandidates) {
+    let endedAt;
     if (candidate.transcriptPath) {
-      if (sweepOpenSet.has(candidate.transcriptPath)) continue;
+      if (sweepOpenSet.has(canonicalPath(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")) {
+      endedAt = mtime !== null ? new Date(mtime).toISOString() : void 0;
+    }
+    const open6 = getOpenEngagement(candidate.sessionId);
+    let snap = null;
+    try {
+      snap = await getCumulativeTokenSource()(candidate.sessionId);
+    } catch {
+      snap = null;
+    }
+    if (livenessStopSession({
+      sessionId: candidate.sessionId,
+      engagementId: open6?.id ?? null,
+      engagementStartedAt: open6?.started_at ?? null,
+      endedAt,
+      tokensAtClose: snap
+    })) {
       summary.swept += 1;
       summary.changed = true;
     }
@@ -12399,17 +12995,21 @@ async function scanSessions(opts = {}, deps = {}) {
   writeWatermark(scanStartMs);
   return summary;
 }
-var execFileAsync, FRESH_MTIME_MS, LSOF_CHUNK, WATERMARK_KEY;
+var execFileAsync2, FRESH_MTIME_MS, LSOF_CHUNK, WATERMARK_KEY;
 var init_scanner2 = __esm({
   "src/sessions/scanner.ts"() {
     "use strict";
     init_fs();
+    init_path_canon();
     init_config2();
     init_session_id();
     init_registry();
     init_session_db();
     init_agent_sessions();
-    execFileAsync = promisify3(execFile3);
+    init_engagement_db();
+    init_engagement_tokens();
+    init_agent_view();
+    execFileAsync2 = promisify4(execFile4);
     FRESH_MTIME_MS = 5 * 60 * 1e3;
     LSOF_CHUNK = 64;
     WATERMARK_KEY = "sessions_scan_last_ms";
@@ -12457,19 +13057,19 @@ init_assignment_resolver();
 init_agent_sessions();
 import express from "express";
 import { createServer } from "http";
-import { resolve as resolve46 } from "path";
+import { resolve as resolve48 } from "path";
 import { writeFile as writeFile8, unlink as unlink9 } from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/dashboard/session-liveness.ts
 import { execFileSync } from "child_process";
-import { statSync as statSync2 } from "fs";
+import { statSync as statSync3 } from "fs";
 var FIVE_MINUTES_MS = 5 * 60 * 1e3;
 var DEFAULT_DEPS = {
   now: () => Date.now(),
   statMtimeMs: (path) => {
     try {
-      return statSync2(path).mtimeMs;
+      return statSync3(path).mtimeMs;
     } catch {
       return null;
     }
@@ -12965,10 +13565,10 @@ function mergePatch(current, patch) {
 init_paths();
 init_fs();
 import { readFile as readFile14, rename as rename3, unlink as unlink3 } from "fs/promises";
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 function corruptFilePath() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve18(syntaurRoot(), `view-prefs.corrupt-${ts}.json`);
+  return resolve19(syntaurRoot(), `view-prefs.corrupt-${ts}.json`);
 }
 function isViewPrefsFileShape(value) {
   if (!value || typeof value !== "object") return false;
@@ -13240,10 +13840,10 @@ init_paths();
 init_fs();
 import { readFile as readFile15, rename as rename4, unlink as unlink4 } from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 function corruptFilePath2() {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve19(syntaurRoot(), `saved-views.corrupt-${ts}.json`);
+  return resolve20(syntaurRoot(), `saved-views.corrupt-${ts}.json`);
 }
 function isSavedViewsFileShape(value) {
   if (!value || typeof value !== "object") return false;
@@ -13618,19 +14218,19 @@ init_timestamp();
 init_fs();
 init_git_worktree();
 import { Router as Router2 } from "express";
-import { resolve as resolve23, basename as basename4, isAbsolute as isAbsolute4 } from "path";
+import { resolve as resolve24, basename as basename4, isAbsolute as isAbsolute4 } from "path";
 import { rm, readFile as readFile18, open as fsOpen, stat as fsStat, realpath as fsRealpath } from "fs/promises";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/utils/worktree-defaults.ts
 init_paths();
 import { spawnSync as spawnSync2 } from "child_process";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 function computeWorktreeDefaults(opts) {
   const repository = opts.existing.repository ?? detectCurrentGitRoot(opts.cwd);
   const branch = opts.projectSlug ? `syntaur/${opts.projectSlug}/${opts.assignmentSlug}` : `syntaur/${opts.assignmentSlug}`;
   const parentBranch = opts.existing.parentBranch ?? detectCurrentBranch(opts.cwd) ?? "main";
-  const worktreeBase = repository ? resolve20(repository, ".worktrees", branch) : resolve20(
+  const worktreeBase = repository ? resolve21(repository, ".worktrees", branch) : resolve21(
     syntaurRoot(),
     "worktrees",
     opts.projectSlug || "standalone",
@@ -13849,7 +14449,7 @@ function recreateOutcomeToHttp(outcome) {
 init_fs();
 init_parser();
 import { readdir as readdir11, readFile as readFile16 } from "fs/promises";
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 function toSourceAssignment(parsed, fallbackId) {
   const repository = parsed.workspace.repository?.trim();
   const branch = parsed.workspace.branch?.trim();
@@ -13866,29 +14466,29 @@ function toSourceAssignment(parsed, fallbackId) {
 async function getProjectRepositoryCandidates(projectsDir, projectSlug) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const projectPath = resolve21(projectsDir, projectSlug, "project.md");
+  const projectPath = resolve22(projectsDir, projectSlug, "project.md");
   if (await fileExists(projectPath)) {
     const project = parseProject(await readFile16(projectPath, "utf-8"));
     for (const raw2 of project.repositories) {
       const path = raw2.trim();
       if (!path) continue;
-      const abs = resolve21(path);
+      const abs = resolve22(path);
       if (seen.has(abs)) continue;
       seen.add(abs);
       out.push({ path: abs, source: "project", sourceAssignmentSlug: null });
     }
   }
-  const assignmentsDir2 = resolve21(projectsDir, projectSlug, "assignments");
+  const assignmentsDir2 = resolve22(projectsDir, projectSlug, "assignments");
   if (await fileExists(assignmentsDir2)) {
     const entries = await readdir11(assignmentsDir2, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const assignmentMd = resolve21(assignmentsDir2, entry.name, "assignment.md");
+      const assignmentMd = resolve22(assignmentsDir2, entry.name, "assignment.md");
       if (!await fileExists(assignmentMd)) continue;
       const parsed = parseAssignmentFull(await readFile16(assignmentMd, "utf-8"));
       const repo = parsed.workspace.repository?.trim();
       if (!repo) continue;
-      const abs = resolve21(repo);
+      const abs = resolve22(repo);
       if (seen.has(abs)) continue;
       seen.add(abs);
       out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
@@ -13906,12 +14506,12 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
-    const assignmentMd = resolve21(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve22(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
     const parsed = parseAssignmentFull(await readFile16(assignmentMd, "utf-8"));
     const repo = parsed.workspace.repository?.trim();
     if (!repo) continue;
-    const abs = resolve21(repo);
+    const abs = resolve22(repo);
     if (seen.has(abs)) continue;
     seen.add(abs);
     out.push({ path: abs, source: "sibling", sourceAssignmentSlug: parsed.slug });
@@ -13919,7 +14519,7 @@ async function getStandaloneRepositoryCandidates(assignmentsDir2, excludeAssignm
   return out;
 }
 async function getProjectSourceAssignments(projectsDir, projectSlug, excludeSlug) {
-  const assignmentsDir2 = resolve21(projectsDir, projectSlug, "assignments");
+  const assignmentsDir2 = resolve22(projectsDir, projectSlug, "assignments");
   if (!await fileExists(assignmentsDir2)) return [];
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -13927,7 +14527,7 @@ async function getProjectSourceAssignments(projectsDir, projectSlug, excludeSlug
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeSlug) continue;
-    const assignmentMd = resolve21(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve22(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
     const parsed = parseAssignmentFull(await readFile16(assignmentMd, "utf-8"));
     const source = toSourceAssignment(parsed, entry.name);
@@ -13946,7 +14546,7 @@ async function getStandaloneSourceAssignments(assignmentsDir2, excludeAssignment
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name === excludeAssignmentId) continue;
-    const assignmentMd = resolve21(assignmentsDir2, entry.name, "assignment.md");
+    const assignmentMd = resolve22(assignmentsDir2, entry.name, "assignment.md");
     if (!await fileExists(assignmentMd)) continue;
     const parsed = parseAssignmentFull(await readFile16(assignmentMd, "utf-8"));
     const source = toSourceAssignment(parsed, entry.name);
@@ -14641,7 +15241,7 @@ async function handleWorktreeCreate(req2, res, ctx) {
     });
     const branch = typeof bodyBranch === "string" && bodyBranch.trim() ? bodyBranch.trim() : defaults.branch;
     const parentBranch = typeof bodyParent === "string" && bodyParent.trim() ? bodyParent.trim() : defaults.parentBranch;
-    const worktreePath = resolve23(repo, ".worktrees", branch);
+    const worktreePath = resolve24(repo, ".worktrees", branch);
     const refCheck = spawnSync3("git", ["-C", repo, "check-ref-format", "--branch", branch], {
       encoding: "utf-8"
     });
@@ -14936,9 +15536,9 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           });
           return;
         }
-        const folderPath = resolve23(projectDir, folder);
+        const folderPath = resolve24(projectDir, folder);
         await ensureDir(folderPath);
-        const filePath = resolve23(folderPath, `${requestedSlug}.md`);
+        const filePath = resolve24(folderPath, `${requestedSlug}.md`);
         const timestamp = nowTimestamp();
         let content = renderItemStub(kind, {
           slug: requestedSlug,
@@ -14982,7 +15582,7 @@ ${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve23(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve24(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
@@ -15018,7 +15618,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
-        const filePath = resolve23(projectDir, folder, `${itemSlug}.md`);
+        const filePath = resolve24(projectDir, folder, `${itemSlug}.md`);
         if (!await fileExists(filePath)) {
           res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
           return;
@@ -15052,26 +15652,26 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid slug "${slug}". Must be lowercase and hyphen-separated.` });
         return;
       }
-      const projectDir = resolve23(projectsDir, slug);
+      const projectDir = resolve24(projectsDir, slug);
       if (await fileExists(projectDir)) {
         res.status(409).json({ error: `Project "${slug}" already exists` });
         return;
       }
       const title = fields.title;
       const timestamp = fields.created || nowTimestamp();
-      await ensureDir(resolve23(projectDir, "assignments"));
-      await ensureDir(resolve23(projectDir, "resources"));
-      await ensureDir(resolve23(projectDir, "memories"));
-      await writeFileForce(resolve23(projectDir, "project.md"), content);
+      await ensureDir(resolve24(projectDir, "assignments"));
+      await ensureDir(resolve24(projectDir, "resources"));
+      await ensureDir(resolve24(projectDir, "memories"));
+      await writeFileForce(resolve24(projectDir, "project.md"), content);
       try {
         const companions = [
-          [resolve23(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
-          [resolve23(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
-          [resolve23(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
-          [resolve23(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
-          [resolve23(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
-          [resolve23(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
-          [resolve23(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
+          [resolve24(projectDir, "manifest.md"), renderManifest({ slug, timestamp })],
+          [resolve24(projectDir, "_index-assignments.md"), renderIndexAssignments({ slug, title, timestamp })],
+          [resolve24(projectDir, "_index-plans.md"), renderIndexPlans({ slug, title, timestamp })],
+          [resolve24(projectDir, "_index-decisions.md"), renderIndexDecisions({ slug, title, timestamp })],
+          [resolve24(projectDir, "_status.md"), renderStatus({ slug, title, timestamp })],
+          [resolve24(projectDir, "resources", "_index.md"), renderResourcesIndex({ slug, title, timestamp })],
+          [resolve24(projectDir, "memories", "_index.md"), renderMemoriesIndex({ slug, title, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -15092,8 +15692,8 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.post("/api/projects/:slug/assignments", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectDir = resolve23(projectsDir, projectSlug);
-      const projectMdPath = resolve23(projectDir, "project.md");
+      const projectDir = resolve24(projectsDir, projectSlug);
+      const projectMdPath = resolve24(projectDir, "project.md");
       if (!await fileExists(projectMdPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -15123,7 +15723,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         res.status(400).json({ error: `Invalid priority "${priority}". Must be low, medium, high, or critical.` });
         return;
       }
-      const assignmentDir = resolve23(projectDir, "assignments", assignmentSlug);
+      const assignmentDir = resolve24(projectDir, "assignments", assignmentSlug);
       if (await fileExists(assignmentDir)) {
         res.status(409).json({
           error: `Assignment "${assignmentSlug}" already exists in project "${projectSlug}"`
@@ -15141,12 +15741,12 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
         command: "create",
         by: null
       }) : content;
-      await writeFileForce(resolve23(assignmentDir, "assignment.md"), seededContent);
+      await writeFileForce(resolve24(assignmentDir, "assignment.md"), seededContent);
       try {
         const companions = [
-          [resolve23(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
-          [resolve23(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
-          [resolve23(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
+          [resolve24(assignmentDir, "scratchpad.md"), renderScratchpad({ assignmentSlug, timestamp })],
+          [resolve24(assignmentDir, "handoff.md"), renderHandoff({ assignmentSlug, timestamp })],
+          [resolve24(assignmentDir, "decision-record.md"), renderDecisionRecord({ assignmentSlug, timestamp })]
         ];
         for (const [filePath, fileContent] of companions) {
           await writeFileForce(filePath, fileContent);
@@ -15174,7 +15774,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
   router.patch("/api/projects/:slug", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve24(projectsDir, projectSlug, "project.md");
       const currentContent = await readCurrentDocument(projectPath);
       if (!currentContent) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
@@ -15207,7 +15807,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentPath = resolve23(
+      const assignmentPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15273,7 +15873,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentPath = resolve23(
+      const assignmentPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15309,7 +15909,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const planPath = resolve23(
+      const planPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15347,7 +15947,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const scratchpadPath = resolve23(
+      const scratchpadPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15385,7 +15985,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const handoffPath = resolve23(
+      const handoffPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15423,7 +16023,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const decisionPath = resolve23(
+      const decisionPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15461,7 +16061,7 @@ ${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const commentsPath = resolve23(
+      const commentsPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15517,7 +16117,7 @@ ${entry}`;
       }
       await writeFileForce(commentsPath, next);
       try {
-        const assignmentMdPath = resolve23(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
+        const assignmentMdPath = resolve24(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
         if (await fileExists(assignmentMdPath)) {
           const fm = parseAssignmentFull(await readFile18(assignmentMdPath, "utf-8"));
           emitDashboardEvent(fm.id, projectSlug, "comment-added", {
@@ -15542,7 +16142,7 @@ ${entry}`;
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
       const commentId = getParam(req2.params.commentId);
-      const commentsPath = resolve23(
+      const commentsPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15585,7 +16185,7 @@ ${entry}`;
       await writeFileForce(commentsPath, withUpdated);
       if (target.resolved !== true && resolved === true) {
         try {
-          const assignmentMdPath = resolve23(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
+          const assignmentMdPath = resolve24(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
           if (await fileExists(assignmentMdPath)) {
             const fm = parseAssignmentFull(await readFile18(assignmentMdPath, "utf-8"));
             emitDashboardEvent(fm.id, projectSlug, "comment-resolved", { commentId });
@@ -15603,7 +16203,7 @@ ${entry}`;
   router.post("/api/projects/:slug/move-workspace", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve24(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -15651,7 +16251,7 @@ ${entry}`;
         });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       let content = await readFile18(assignmentPath, "utf-8");
       content = setTopLevelField(content, "workspaceGroup", workspaceGroup ?? null);
       content = setTopLevelField(content, "updated", nowTimestamp());
@@ -15668,7 +16268,7 @@ ${entry}`;
     async (req2, res) => {
       try {
         const projectSlug = getParam(req2.params.slug);
-        const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+        const projectPath = resolve24(projectsDir, projectSlug, "project.md");
         if (!await fileExists(projectPath)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
@@ -15727,7 +16327,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req2.params.slug);
         const assignmentSlug = getParam(req2.params.aslug);
-        const assignmentPath = resolve23(
+        const assignmentPath = resolve24(
           projectsDir,
           projectSlug,
           "assignments",
@@ -15776,7 +16376,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req2.params.slug);
         const assignmentSlug = getParam(req2.params.aslug);
-        const assignmentPath = resolve23(
+        const assignmentPath = resolve24(
           projectsDir,
           projectSlug,
           "assignments",
@@ -15835,7 +16435,7 @@ ${entry}`;
       try {
         const projectSlug = getParam(req2.params.slug);
         const assignmentSlug = getParam(req2.params.aslug);
-        const assignmentPath = resolve23(
+        const assignmentPath = resolve24(
           projectsDir,
           projectSlug,
           "assignments",
@@ -15868,7 +16468,7 @@ ${entry}`;
           res.status(404).json({ error: `Assignment "${id}" not found` });
           return;
         }
-        const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+        const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
         const parsedForSlug = parseAssignmentFull(await readFile18(assignmentPath, "utf-8"));
         const assignmentSlugForBranch = parsedForSlug.slug || resolved.id;
         await handleWorktreeCreate(req2, res, {
@@ -15925,7 +16525,7 @@ ${entry}`;
   router.post("/api/projects/:slug/status-override", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve24(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -15952,7 +16552,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentPath = resolve23(
+      const assignmentPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -15983,7 +16583,7 @@ ${entry}`;
       const result = await recomputeAndWrite2(assignmentPath, {
         cause: clearing ? "unpin" : "pin",
         by: "human",
-        projectDir: resolve23(projectsDir, projectSlug),
+        projectDir: resolve24(projectsDir, projectSlug),
         context,
         mutate: (content) => {
           if (clearing) return updateOverride2(content, null);
@@ -16014,7 +16614,7 @@ ${entry}`;
   router.post("/api/projects/:slug/archive", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve24(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -16031,7 +16631,7 @@ ${entry}`;
   router.post("/api/projects/:slug/unarchive", async (req2, res) => {
     try {
       const projectSlug = getParam(req2.params.slug);
-      const projectPath = resolve23(projectsDir, projectSlug, "project.md");
+      const projectPath = resolve24(projectsDir, projectSlug, "project.md");
       if (!await fileExists(projectPath)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -16048,7 +16648,7 @@ ${entry}`;
   async function handleAssignmentArchive(req2, res, archived) {
     const projectSlug = getParam(req2.params.slug);
     const assignmentSlug = getParam(req2.params.aslug);
-    const assignmentPath = resolve23(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
+    const assignmentPath = resolve24(projectsDir, projectSlug, "assignments", assignmentSlug, "assignment.md");
     if (!await fileExists(assignmentPath)) {
       res.status(404).json({ error: "Assignment not found" });
       return;
@@ -16088,7 +16688,7 @@ ${entry}`;
       res.status(404).json({ error: `Assignment "${id}" not found` });
       return;
     }
-    const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+    const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
     const content = await readFile18(assignmentPath, "utf-8");
     const reason = archived ? archiveReason(req2.body) : null;
     await writeFileForce(assignmentPath, applyArchiveFields(content, archived, reason));
@@ -16117,7 +16717,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentPath = resolve23(
+      const assignmentPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -16155,7 +16755,7 @@ ${entry}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentPath = resolve23(
+      const assignmentPath = resolve24(
         projectsDir,
         projectSlug,
         "assignments",
@@ -16193,8 +16793,8 @@ ${entry}`;
         res.status(400).json({ error: `Unsupported transition command "${req2.params.command}"` });
         return;
       }
-      const projectDir = resolve23(projectsDir, projectSlug);
-      const assignmentPath = resolve23(projectDir, "assignments", assignmentSlug, "assignment.md");
+      const projectDir = resolve24(projectsDir, projectSlug);
+      const assignmentPath = resolve24(projectDir, "assignments", assignmentSlug, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -16275,8 +16875,8 @@ ${entry}`;
     try {
       const projectSlug = getParam(req2.params.slug);
       const assignmentSlug = getParam(req2.params.aslug);
-      const assignmentDir = resolve23(projectsDir, projectSlug, "assignments", assignmentSlug);
-      const assignmentPath = resolve23(assignmentDir, "assignment.md");
+      const assignmentDir = resolve24(projectsDir, projectSlug, "assignments", assignmentSlug);
+      const assignmentPath = resolve24(assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: `Assignment "${assignmentSlug}" not found in project "${projectSlug}"` });
         return;
@@ -16331,7 +16931,7 @@ ${entry}`;
           return;
         }
         const id2 = generateId();
-        const assignmentDir2 = resolve23(assignmentsDir2, id2);
+        const assignmentDir2 = resolve24(assignmentsDir2, id2);
         if (await fileExists(assignmentDir2)) {
           res.status(500).json({ error: "UUID collision \u2014 try again" });
           return;
@@ -16350,25 +16950,25 @@ ${entry}`;
             by: null
           });
         }
-        await writeFileForce(resolve23(assignmentDir2, "assignment.md"), normalizedContent);
+        await writeFileForce(resolve24(assignmentDir2, "assignment.md"), normalizedContent);
         await writeFileForce(
-          resolve23(assignmentDir2, "scratchpad.md"),
+          resolve24(assignmentDir2, "scratchpad.md"),
           renderScratchpad({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve23(assignmentDir2, "handoff.md"),
+          resolve24(assignmentDir2, "handoff.md"),
           renderHandoff({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve23(assignmentDir2, "decision-record.md"),
+          resolve24(assignmentDir2, "decision-record.md"),
           renderDecisionRecord({ assignmentSlug: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve23(assignmentDir2, "progress.md"),
+          resolve24(assignmentDir2, "progress.md"),
           renderProgress({ assignment: id2, timestamp: timestamp2 })
         );
         await writeFileForce(
-          resolve23(assignmentDir2, "comments.md"),
+          resolve24(assignmentDir2, "comments.md"),
           renderComments({ assignment: id2, timestamp: timestamp2 })
         );
         if (seededHere) {
@@ -16393,7 +16993,7 @@ ${entry}`;
         return;
       }
       const id = generateId();
-      const assignmentDir = resolve23(assignmentsDir2, id);
+      const assignmentDir = resolve24(assignmentsDir2, id);
       if (await fileExists(assignmentDir)) {
         res.status(500).json({ error: "UUID collision \u2014 try again" });
         return;
@@ -16413,25 +17013,25 @@ ${entry}`;
         project: null,
         type: typeof type === "string" ? type : void 0
       });
-      await writeFileForce(resolve23(assignmentDir, "assignment.md"), assignmentContent);
+      await writeFileForce(resolve24(assignmentDir, "assignment.md"), assignmentContent);
       await writeFileForce(
-        resolve23(assignmentDir, "scratchpad.md"),
+        resolve24(assignmentDir, "scratchpad.md"),
         renderScratchpad({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve23(assignmentDir, "handoff.md"),
+        resolve24(assignmentDir, "handoff.md"),
         renderHandoff({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve23(assignmentDir, "decision-record.md"),
+        resolve24(assignmentDir, "decision-record.md"),
         renderDecisionRecord({ assignmentSlug: id, timestamp })
       );
       await writeFileForce(
-        resolve23(assignmentDir, "progress.md"),
+        resolve24(assignmentDir, "progress.md"),
         renderProgress({ assignment: id, timestamp })
       );
       await writeFileForce(
-        resolve23(assignmentDir, "comments.md"),
+        resolve24(assignmentDir, "comments.md"),
         renderComments({ assignment: id, timestamp })
       );
       emitDashboardEvent(id, null, "status-change", {
@@ -16564,7 +17164,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -16629,7 +17229,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const planPath = resolve23(resolved.assignmentDir, "plan.md");
+      const planPath = resolve24(resolved.assignmentDir, "plan.md");
       const currentContent = await readCurrentDocument(planPath);
       if (!currentContent) {
         res.status(404).json({ error: "Plan not found" });
@@ -16663,7 +17263,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const scratchpadPath = resolve23(resolved.assignmentDir, "scratchpad.md");
+      const scratchpadPath = resolve24(resolved.assignmentDir, "scratchpad.md");
       const currentContent = await readCurrentDocument(scratchpadPath);
       if (!currentContent) {
         res.status(404).json({ error: "Scratchpad not found" });
@@ -16697,7 +17297,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const handoffPath = resolve23(resolved.assignmentDir, "handoff.md");
+      const handoffPath = resolve24(resolved.assignmentDir, "handoff.md");
       const currentContent = await readCurrentDocument(handoffPath);
       if (!currentContent) {
         res.status(404).json({ error: "Handoff log not found" });
@@ -16737,7 +17337,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const decisionPath = resolve23(resolved.assignmentDir, "decision-record.md");
+      const decisionPath = resolve24(resolved.assignmentDir, "decision-record.md");
       const currentContent = await readCurrentDocument(decisionPath);
       if (!currentContent) {
         res.status(404).json({ error: "Decision record not found" });
@@ -16777,7 +17377,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -16799,7 +17399,7 @@ ${entry}`;
       const { recomputeAndWrite: recomputeAndWrite2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
       const { updateOverride: updateOverride2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
       const context = await resolveDeriveContext2();
-      const projectDirForId = resolved.standalone ? null : resolve23(resolved.assignmentDir, "..", "..");
+      const projectDirForId = resolved.standalone ? null : resolve24(resolved.assignmentDir, "..", "..");
       const result = await recomputeAndWrite2(assignmentPath, {
         cause: clearing ? "unpin" : "pin",
         by: "human",
@@ -16839,7 +17439,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -16879,7 +17479,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       if (!await fileExists(assignmentPath)) {
         res.status(404).json({ error: "Assignment not found" });
         return;
@@ -16912,7 +17512,7 @@ ${entry}`;
         res.status(404).json({ error: `Assignment "${id}" not found` });
         return;
       }
-      const assignmentPath = resolve23(resolved.assignmentDir, "assignment.md");
+      const assignmentPath = resolve24(resolved.assignmentDir, "assignment.md");
       const currentContent = await readCurrentDocument(assignmentPath);
       if (!currentContent) {
         res.status(404).json({ error: "Assignment not found" });
@@ -16960,8 +17560,8 @@ ${entry}`;
       }
       const { recomputeAndWrite: recomputeAndWrite2, recomputeDependents: recomputeDependents2, resolveDeriveContext: resolveDeriveContext2 } = await Promise.resolve().then(() => (init_recompute(), recompute_exports));
       const context = await resolveDeriveContext2();
-      const byIdPath = resolve23(resolved.assignmentDir, "assignment.md");
-      const byIdProjectDir = resolved.standalone ? null : resolve23(resolved.assignmentDir, "..", "..");
+      const byIdPath = resolve24(resolved.assignmentDir, "assignment.md");
+      const byIdProjectDir = resolved.standalone ? null : resolve24(resolved.assignmentDir, "..", "..");
       if (command === "block" || command === "unblock") {
         const { updateAssignmentFile: updateAssignmentFile2 } = await Promise.resolve().then(() => (init_frontmatter(), frontmatter_exports));
         const result = await recomputeAndWrite2(byIdPath, {
@@ -17082,7 +17682,7 @@ function validateTitleBody(body) {
   return { ok: true, value: trimmed };
 }
 async function appendCommentTo(assignmentDir, assignmentRef, req2, res, reloadDetail) {
-  const commentsPath = resolve23(assignmentDir, "comments.md");
+  const commentsPath = resolve24(assignmentDir, "comments.md");
   const { body, author, type, replyTo } = req2.body || {};
   if (!body || typeof body !== "string" || !body.trim()) {
     res.status(400).json({ error: "body is required" });
@@ -17129,7 +17729,7 @@ ${entry}`;
   }
   await writeFileForce(commentsPath, next);
   try {
-    const assignmentMdPath = resolve23(assignmentDir, "assignment.md");
+    const assignmentMdPath = resolve24(assignmentDir, "assignment.md");
     if (await fileExists(assignmentMdPath)) {
       const fm = parseAssignmentFull(await readFile18(assignmentMdPath, "utf-8"));
       emitDashboardEvent(fm.id, fm.project, "comment-added", {
@@ -17146,7 +17746,7 @@ ${entry}`;
   res.status(201).json({ assignment, comment: { id: comment.id } });
 }
 async function toggleCommentResolvedAt(assignmentDir, commentId, req2, res, reloadDetail) {
-  const commentsPath = resolve23(assignmentDir, "comments.md");
+  const commentsPath = resolve24(assignmentDir, "comments.md");
   if (!await fileExists(commentsPath)) {
     res.status(404).json({ error: "Comments file not found" });
     return;
@@ -17180,7 +17780,7 @@ async function toggleCommentResolvedAt(assignmentDir, commentId, req2, res, relo
   await writeFileForce(commentsPath, withUpdated);
   if (target.resolved !== true && desired === true) {
     try {
-      const assignmentMdPath = resolve23(assignmentDir, "assignment.md");
+      const assignmentMdPath = resolve24(assignmentDir, "assignment.md");
       if (await fileExists(assignmentMdPath)) {
         const fm = parseAssignmentFull(await readFile18(assignmentMdPath, "utf-8"));
         emitDashboardEvent(fm.id, fm.project, "comment-resolved", { commentId });
@@ -17312,9 +17912,12 @@ function createServersRouter(serversDir2, projectsDir, assignmentsDir2) {
 // src/dashboard/api-agent-sessions.ts
 init_agent_sessions();
 init_fs();
+init_session_id();
+init_assignment_resolver();
+init_paths();
 init_transcript();
 import { Router as Router4 } from "express";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 init_config2();
 init_process_info();
 init_git_worktree();
@@ -17338,7 +17941,7 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
     try {
       const { projectSlug } = req2.params;
       const assignment = req2.query.assignment;
-      const projectDir = resolve24(projectsDir, projectSlug);
+      const projectDir = resolve25(projectsDir, projectSlug);
       if (!await fileExists(projectDir)) {
         res.status(404).json({ error: `Project "${projectSlug}" not found` });
         return;
@@ -17367,21 +17970,45 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
         });
         return;
       }
+      if (!isSafeSessionId(sessionId)) {
+        res.status(400).json({
+          error: "sessionId is malformed. Pass the real agent-generated session id."
+        });
+        return;
+      }
       if (projectSlug) {
-        const projectDir = resolve24(projectsDir, projectSlug);
+        const projectDir = resolve25(projectsDir, projectSlug);
         if (!await fileExists(projectDir)) {
           res.status(404).json({ error: `Project "${projectSlug}" not found` });
           return;
         }
       }
+      let assignmentId = null;
+      if (assignmentSlug) {
+        const resolvedAssignment = await resolveAssignmentBySlug(
+          projectsDir,
+          assignmentsDir2 ?? assignmentsDir(),
+          projectSlug || null,
+          assignmentSlug
+        );
+        if (!resolvedAssignment.exists) {
+          res.status(404).json({ error: `Assignment "${assignmentSlug}" not found` });
+          return;
+        }
+        assignmentId = resolvedAssignment.id;
+      }
       const derivedPath = await derivePathFromTranscript(transcriptPath);
       const recordedPath = derivedPath ?? path ?? "";
       const pid = typeof rawPid === "number" && Number.isFinite(rawPid) && rawPid > 0 ? rawPid : null;
       const pidStartedAt = pid !== null ? captureProcessStartedAt(pid) : null;
       const originalHeadSha = isExistingDir(recordedPath) ? await captureHeadSha(recordedPath) : null;
       const session = {
-        projectSlug: projectSlug || null,
+        // L: a POST with no assignmentSlug is registration-only (unbound) — do
+        // NOT open a project-bound engagement for an arbitrary session. Binding
+        // requires a validated assignment selector (existence-checked above).
+        projectSlug: assignmentSlug ? projectSlug || null : null,
         assignmentSlug: assignmentSlug || null,
+        assignmentId,
         agent,
         sessionId,
         started: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17460,6 +18087,10 @@ function createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2) {
       broadcast?.({ type: "agent-sessions-updated", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       res.json({ updated: true });
     } catch (error) {
+      if (error instanceof SessionResurrectionError) {
+        res.status(409).json({ error: error.message });
+        return;
+      }
       res.status(500).json({ error: error instanceof Error ? error.message : "Update failed" });
     }
   });
@@ -17784,8 +18415,8 @@ import { Router as Router6 } from "express";
 // src/utils/terminal-probe.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 var APP_BUNDLE_IDS = {
   "terminal-app": "com.apple.Terminal",
   iterm: "com.googlecode.iterm2",
@@ -17802,7 +18433,7 @@ var APP_FIXED_PATHS = {
   "terminal-app": "/System/Applications/Utilities/Terminal.app"
 };
 function defaultApplicationsDirs() {
-  return ["/Applications", join3(homedir2(), "Applications")];
+  return ["/Applications", join5(homedir4(), "Applications")];
 }
 function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const fixed = APP_FIXED_PATHS[terminal];
@@ -17810,7 +18441,7 @@ function findAppBundle(terminal, dirs = defaultApplicationsDirs()) {
   const bundleName = APP_BUNDLE_NAMES[terminal];
   if (bundleName) {
     for (const dir of dirs) {
-      const candidate = join3(dir, bundleName);
+      const candidate = join5(dir, bundleName);
       if (existsSync2(candidate)) return candidate;
     }
   }
@@ -17840,11 +18471,11 @@ var defaultCmuxLsappinfoRunner = () => {
 function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunnerOverride) {
   const bundle = findAppBundle("cmux", applicationsDirsOverride);
   if (bundle) {
-    const cli = join3(bundle, "Contents/Resources/bin/cmux");
+    const cli = join5(bundle, "Contents/Resources/bin/cmux");
     if (existsSync2(cli)) return cli;
   }
   for (const dir of cliDirsOverride ?? CMUX_CLI_DIRS) {
-    const cli = join3(dir, "cmux");
+    const cli = join5(dir, "cmux");
     if (existsSync2(cli)) return cli;
   }
   if (process.platform === "darwin") {
@@ -17853,7 +18484,7 @@ function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunn
     if (stdout) {
       const match = stdout.match(/"LSBundlePath"="([^"]+)"/);
       if (match) {
-        const cli = join3(match[1], "Contents/Resources/bin/cmux");
+        const cli = join5(match[1], "Contents/Resources/bin/cmux");
         if (existsSync2(cli)) return cli;
       }
     }
@@ -17992,7 +18623,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 isAbsolute5, resolve as resolve25 } from "path";
+import { isAbsolute as isAbsolute5, resolve as resolve26 } from "path";
 init_paths();
 init_playbooks();
 init_cwd();
@@ -18195,6 +18826,12 @@ async function resolveSessionPlan(input, terminal) {
       }
     }
   }
+  if (!cwd.trim()) {
+    throw new LaunchError(
+      "workspace-path-invalid",
+      `Session ${input.id} has no recorded working directory and no linked assignment workspace resolved \u2014 refusing to launch in an unknown directory.`
+    );
+  }
   const agent = getAgents(input.config).find((a) => a.id === session.agent);
   if (!agent) {
     throw new LaunchError(
@@ -18223,7 +18860,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 basename5, join as join6, resolve as resolve26 } from "path";
+import { basename as basename5, join as join6, resolve as resolve27 } from "path";
 init_fs();
 init_config2();
 init_session_id();
@@ -18271,7 +18908,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve47, reject) => {
+  await new Promise((resolve49, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -18281,7 +18918,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve47();
+      resolve49();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -18342,7 +18979,7 @@ async function registerLaunchAtBirth(plan, child) {
       markerDir
     );
     if (!sessionId) return;
-    if (autoTrack === "workspaces-only" && !await fileExists(resolve26(plan.cwd, ".syntaur", "context.json"))) {
+    if (autoTrack === "workspaces-only" && !await fileExists(resolve27(plan.cwd, ".syntaur", "context.json"))) {
       return;
     }
     const { initSessionDb: initSessionDb2 } = await Promise.resolve().then(() => (init_session_db(), session_db_exports));
@@ -18518,8 +19155,8 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname6, resolve as resolve27, join as join7 } from "path";
-import { realpathSync, readFileSync as readFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname6, resolve as resolve28, join as join7 } from "path";
+import { realpathSync, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
 
 // src/dashboard/api-launch-preflight.ts
 init_assignment_resolver();
@@ -19585,7 +20222,7 @@ import { Router as Router12 } from "express";
 init_paths();
 import Database3 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve28 } from "path";
+import { resolve as resolve29 } from "path";
 var db3 = null;
 var LEASE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL3 = `
@@ -19672,7 +20309,7 @@ function isBusyError(err) {
 }
 function initLeasesDb(dbPath) {
   if (db3) return db3;
-  const finalPath = dbPath ?? resolve28(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve29(syntaurRoot(), "syntaur.db");
   db3 = new Database3(finalPath);
   db3.pragma("journal_mode = WAL");
   db3.pragma("busy_timeout = 5000");
@@ -19825,14 +20462,14 @@ init_paths();
 init_timestamp();
 import { randomUUID as randomUUID4 } from "crypto";
 import { readFile as readFile20, readdir as readdir14, rm as rm3 } from "fs/promises";
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 function schedulesDir() {
-  const override = process.env.SYNTAUR_SCHEDULES_DIR;
-  if (override && override.length > 0) return resolve29(override);
-  return resolve29(syntaurRoot(), "schedules");
+  const override3 = process.env.SYNTAUR_SCHEDULES_DIR;
+  if (override3 && override3.length > 0) return resolve30(override3);
+  return resolve30(syntaurRoot(), "schedules");
 }
 function jobPath(id) {
-  return resolve29(schedulesDir(), `${jobFileSafe(id)}.md`);
+  return resolve30(schedulesDir(), `${jobFileSafe(id)}.md`);
 }
 function jobFileSafe(id) {
   if (!/^[A-Za-z0-9_-]+$/.test(id)) {
@@ -19975,7 +20612,7 @@ async function listJobs() {
   for (const name of names) {
     if (!name.endsWith(".md")) continue;
     try {
-      jobs.push(parseJobFile(await readFile20(resolve29(schedulesDir(), name), "utf-8")));
+      jobs.push(parseJobFile(await readFile20(resolve30(schedulesDir(), name), "utf-8")));
     } catch {
     }
   }
@@ -19986,12 +20623,12 @@ async function listJobs() {
 // src/schedules/event-log.ts
 init_timestamp();
 import { appendFile, readFile as readFile21, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname8, resolve as resolve30 } from "path";
+import { dirname as dirname8, resolve as resolve31 } from "path";
 function eventLogPath(jobId) {
   if (!/^[A-Za-z0-9_-]+$/.test(jobId)) {
     throw new Error(`Unsafe schedule id: ${JSON.stringify(jobId)}`);
   }
-  return resolve30(schedulesDir(), `${jobId}.jsonl`);
+  return resolve31(schedulesDir(), `${jobId}.jsonl`);
 }
 async function appendEvent(jobId, type, data) {
   const event = { type, at: nowTimestamp(), ...data ? { data } : {} };
@@ -20024,7 +20661,7 @@ async function readEvents(jobId) {
 // src/schedules/attempt.ts
 import { createHash as createHash3 } from "crypto";
 import { open as open4, readFile as readFile22, stat as stat5, unlink as unlink6 } from "fs/promises";
-import { resolve as resolve31 } from "path";
+import { resolve as resolve32 } from "path";
 
 // src/schedules/triggers.ts
 import { Cron } from "croner";
@@ -20044,8 +20681,7 @@ function predictReset(_provider, anchor) {
 }
 function verifyReset(provider, anchor, now) {
   const reset = predictReset(provider, anchor);
-  if (now.getTime() >= Date.parse(reset)) return { eligible: true };
-  return { eligible: false, rescheduleToIso: reset };
+  return { eligible: now.getTime() >= Date.parse(reset) };
 }
 
 // src/schedules/triggers.ts
@@ -20069,13 +20705,15 @@ function evaluateKind(trigger, job, ctx) {
   switch (trigger.kind) {
     case "at": {
       const at = Date.parse(trigger.at);
-      const due = !Number.isNaN(at) && ctx.now.getTime() >= at;
+      const beforeCreation = !Number.isNaN(createdAtMs) && at < createdAtMs;
+      const due = !Number.isNaN(at) && ctx.now.getTime() >= at && !beforeCreation;
       return { due, dedupeKey: `at:${trigger.at}`, nextFireIso: trigger.at };
     }
     case "in": {
       const anchor = Date.parse(trigger.anchorIso);
       const fireAt = anchor + trigger.durationMs;
-      const due = !Number.isNaN(anchor) && ctx.now.getTime() >= fireAt;
+      const beforeCreation = !Number.isNaN(createdAtMs) && fireAt < createdAtMs;
+      const due = !Number.isNaN(anchor) && ctx.now.getTime() >= fireAt && !beforeCreation;
       const fireIso = Number.isNaN(anchor) ? null : iso(new Date(fireAt));
       return { due, dedupeKey: `in:${fireAt}`, nextFireIso: fireIso };
     }
@@ -20109,7 +20747,7 @@ function evaluateAfterReset(trigger, now) {
   if (v.eligible) {
     return { due: true, dedupeKey: `after-reset:${trigger.anchor.windowStartIso}`, nextFireIso: predicted };
   }
-  return { due: false, nextFireIso: predicted, rescheduleToIso: v.rescheduleToIso };
+  return { due: false, nextFireIso: predicted };
 }
 function evaluateWhenStatus(trigger, job, ctx, createdAtMs) {
   const fm = ctx.assignment;
@@ -20202,7 +20840,7 @@ var LOCK_WAIT_MS2 = 50;
 var LOCK_MAX_WAITS2 = 100;
 var MAX_CONSUMED_EDGES = 50;
 async function acquireJobLock(id) {
-  const lockPath = resolve31(schedulesDir(), `${id}.lock`);
+  const lockPath = resolve32(schedulesDir(), `${id}.lock`);
   const token = `${process.pid}:${createHash3("sha256").update(`${Math.random()}${Date.now()}`).digest("hex").slice(0, 12)}`;
   for (let attempt = 0; attempt <= LOCK_MAX_WAITS2; attempt++) {
     try {
@@ -20517,7 +21155,7 @@ async function reapStale(jobs, deps) {
 
 // src/schedules/unattended.ts
 import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve32 } from "path";
+import { resolve as resolve33 } from "path";
 var UnattendedRefusalError = class extends Error {
   constructor(message) {
     super(message);
@@ -20533,7 +21171,7 @@ function assertUnattendedTerminalSupported(terminal) {
 }
 function isKillSwitchEngaged() {
   if (process.env.SYNTAUR_SCHEDULES_DISABLED === "1") return true;
-  return existsSync3(resolve32(schedulesDir(), "KILL"));
+  return existsSync3(resolve33(schedulesDir(), "KILL"));
 }
 function canFire(job, deps) {
   const killSwitch = deps.killSwitch ?? isKillSwitchEngaged;
@@ -20685,25 +21323,25 @@ init_paths();
 init_assignment_resolver();
 init_frontmatter();
 import { readFile as readFile23 } from "fs/promises";
-import { resolve as resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 
 // src/schedules/launch-ack.ts
 init_session_id();
-import { readdirSync } from "fs";
+import { readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join8 } from "path";
 function defaultSleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function runtimeSessionsDir() {
-  const override = process.env.SYNTAUR_RUNTIME_SESSIONS_DIR;
-  return override && override.length > 0 ? override : join8(homedir6(), ".syntaur", "runtime", "sessions");
+  const override3 = process.env.SYNTAUR_RUNTIME_SESSIONS_DIR;
+  return override3 && override3.length > 0 ? override3 : join8(homedir6(), ".syntaur", "runtime", "sessions");
 }
 function defaultAckProbe(handle) {
   const dir = runtimeSessionsDir();
   let names;
   try {
-    names = readdirSync(dir);
+    names = readdirSync2(dir);
   } catch {
     return null;
   }
@@ -20745,7 +21383,7 @@ async function defaultReadAssignment(assignmentId) {
   const resolved = await resolveAssignmentById(projectsDir, assignmentsDir(), assignmentId);
   if (!resolved) return null;
   try {
-    const content = await readFile23(resolve33(resolved.assignmentDir, "assignment.md"), "utf-8");
+    const content = await readFile23(resolve34(resolved.assignmentDir, "assignment.md"), "utf-8");
     return parseAssignmentFrontmatter(content);
   } catch {
     return null;
@@ -20837,7 +21475,7 @@ import { Router as Router14 } from "express";
 // src/db/usage-db.ts
 init_paths();
 import Database4 from "better-sqlite3";
-import { resolve as resolve34 } from "path";
+import { resolve as resolve35 } from "path";
 var db4 = null;
 var USAGE_SCHEMA_VERSION = "1";
 var SCHEMA_SQL4 = `
@@ -20911,7 +21549,7 @@ function nowIso2() {
 }
 function initUsageDb(dbPath) {
   if (db4) return db4;
-  const finalPath = dbPath ?? resolve34(syntaurRoot(), "syntaur.db");
+  const finalPath = dbPath ?? resolve35(syntaurRoot(), "syntaur.db");
   db4 = new Database4(finalPath);
   db4.pragma("journal_mode = WAL");
   db4.pragma("busy_timeout = 5000");
@@ -21088,6 +21726,199 @@ function listDistinctTools() {
 
 // src/dashboard/api-usage.ts
 init_api();
+
+// src/usage/engagement-cost.ts
+init_session_db();
+init_engagement_tokens();
+
+// src/usage/pricing.ts
+var PER_MILLION = 1e6;
+var MODEL_PRICING = {
+  // Moonshot Kimi K2.6 — the model pi emits today. Official Moonshot list price.
+  // source: https://platform.moonshot.ai/ (official) — cross-checked
+  //         https://openrouter.ai/moonshotai/kimi-k2.6 (retrieved 2026-06-17)
+  "moonshotai/kimi-k2.6": { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0.95 },
+  // Moonshot Kimi K2.5 — prior Kimi model. Official Moonshot list price.
+  // source: https://platform.moonshot.ai/ — cross-checked
+  //         https://openrouter.ai/moonshotai/kimi-k2.5 (retrieved 2026-06-17)
+  "moonshotai/kimi-k2.5": { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0.6 },
+  // Z.ai (Zhipu) GLM-5.2 — official z.ai platform list price.
+  // source: https://docs.z.ai/guides/overview/pricing — cross-checked
+  //         https://openrouter.ai/z-ai/glm-5 (retrieved 2026-06-18)
+  "zai-org/glm-5.2": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 1.4 },
+  // MiniMax M2.5 — official MiniMax platform list price. No separately-pinned
+  // cached-read rate is published, so cacheRead is set conservatively to the
+  // input rate (upper bound); revise if MiniMax publishes a cache rate.
+  // source: https://platform.minimax.io/docs/guides/pricing-token-plan
+  //         — cross-checked https://openrouter.ai/minimax/minimax-m2.5 (retrieved 2026-06-18)
+  "minimaxai/minimax-m2.5": { input: 0.15, output: 0.9, cacheRead: 0.15, cacheWrite: 0.15 }
+  // NOTE: opaque Synthetic tier aliases like `syn:large:text` have no public
+  // per-token rate (they route to whatever Synthetic assigns), so they remain
+  // unpriced (→ $0). Reseller discounts (e.g. DeepInfra K2.6 0.75/3.50/0.15) are
+  // rejected by the canonical-source rule and are NOT used here.
+};
+function normalizeModelKey(model) {
+  return model.replace(/^\s*\[[^\]]*\]\s*/, "").replace(/^hf:/i, "").trim().toLowerCase();
+}
+function priceForModel(model, tokens) {
+  const rate = MODEL_PRICING[normalizeModelKey(model)];
+  if (!rate) return null;
+  return (tokens.inputTokens * rate.input + tokens.outputTokens * rate.output + tokens.cacheReadTokens * rate.cacheRead + tokens.cacheCreationTokens * rate.cacheWrite) / PER_MILLION;
+}
+
+// src/usage/engagement-cost.ts
+var EMPTY = {
+  cost: 0,
+  pricedWindowCount: 0,
+  uncomputableWindowCount: 0,
+  negativeDeltaCount: 0
+};
+function engagementDb() {
+  let db5;
+  try {
+    db5 = getSessionDb();
+  } catch {
+    return null;
+  }
+  const has = db5.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'engagement'").get();
+  return has ? db5 : null;
+}
+function sinceBound(since) {
+  return since ? `${since}T00:00:00.000Z` : void 0;
+}
+function untilBound(until) {
+  return until ? `${until}T23:59:59.999Z` : void 0;
+}
+function toBuckets(open6, close) {
+  const o = open6 ?? { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, total: 0, cost: 0 };
+  const c = close ?? { input: 0, output: 0, cacheCreation: 0, cacheRead: 0, total: 0, cost: 0 };
+  return {
+    inputTokens: Math.max(0, c.input - o.input),
+    outputTokens: Math.max(0, c.output - o.output),
+    cacheCreationTokens: Math.max(0, c.cacheCreation - o.cacheCreation),
+    cacheReadTokens: Math.max(0, c.cacheRead - o.cacheRead)
+  };
+}
+function windowCost(openJson, closeJson, modelFilter) {
+  const open6 = parseSnapshot(openJson);
+  const close = parseSnapshot(closeJson);
+  if (!open6 || !close) return null;
+  let cost = 0;
+  let hadNegative = false;
+  const models = /* @__PURE__ */ new Set([
+    ...Object.keys(open6.models),
+    ...Object.keys(close.models)
+  ]);
+  for (const model of models) {
+    if (modelFilter && model !== modelFilter) continue;
+    const openCost = open6.models[model]?.cost ?? 0;
+    const closeCost = close.models[model]?.cost ?? 0;
+    let contribution = closeCost - openCost;
+    if (contribution < 0) {
+      hadNegative = true;
+      contribution = 0;
+    } else if (contribution === 0) {
+      const buckets = toBuckets(open6.models[model], close.models[model]);
+      if (buckets.inputTokens + buckets.outputTokens + buckets.cacheCreationTokens + buckets.cacheReadTokens > 0) {
+        const priced = priceForModel(model, buckets);
+        if (priced && priced > 0) contribution = priced;
+      }
+    }
+    cost += contribution;
+  }
+  return { cost, hadNegative };
+}
+function rollupWindows(rows, modelFilter) {
+  const out = { ...EMPTY };
+  for (const row of rows) {
+    const wc = windowCost(row.tokens_at_open, row.tokens_at_close, modelFilter);
+    if (wc === null) {
+      out.uncomputableWindowCount += 1;
+      continue;
+    }
+    out.pricedWindowCount += 1;
+    out.cost += wc.cost;
+    if (wc.hadNegative) out.negativeDeltaCount += 1;
+  }
+  return out;
+}
+function assignmentWindowCost(opts) {
+  const db5 = engagementDb();
+  if (!db5) return { ...EMPTY };
+  const clauses = ["ended_at IS NOT NULL"];
+  const params2 = [];
+  if (opts.assignmentId) {
+    clauses.push("assignment_id = ?");
+    params2.push(opts.assignmentId);
+  } else {
+    const proj = opts.projectSlug && opts.projectSlug.length > 0 ? opts.projectSlug : null;
+    if (proj === null) {
+      clauses.push("project_slug IS NULL");
+    } else {
+      clauses.push("project_slug = ?");
+      params2.push(proj);
+    }
+    clauses.push("assignment_slug = ?");
+    params2.push(opts.assignmentSlug ?? null);
+  }
+  const since = sinceBound(opts.since);
+  const until = untilBound(opts.until);
+  if (since) {
+    clauses.push("ended_at >= ?");
+    params2.push(since);
+  }
+  if (until) {
+    clauses.push("ended_at <= ?");
+    params2.push(until);
+  }
+  const rows = db5.prepare(
+    `SELECT assignment_id, assignment_slug, tokens_at_open, tokens_at_close
+         FROM engagement
+        WHERE ${clauses.join(" AND ")}`
+  ).all(...params2);
+  return rollupWindows(rows, opts.model);
+}
+function projectWindowCosts(opts) {
+  const db5 = engagementDb();
+  if (!db5) return /* @__PURE__ */ new Map();
+  const clauses = ["ended_at IS NOT NULL", "project_slug = ?", "assignment_slug IS NOT NULL"];
+  const params2 = [opts.projectSlug];
+  const since = sinceBound(opts.since);
+  const until = untilBound(opts.until);
+  if (since) {
+    clauses.push("ended_at >= ?");
+    params2.push(since);
+  }
+  if (until) {
+    clauses.push("ended_at <= ?");
+    params2.push(until);
+  }
+  const rows = db5.prepare(
+    `SELECT assignment_id, assignment_slug, tokens_at_open, tokens_at_close
+         FROM engagement
+        WHERE ${clauses.join(" AND ")}`
+  ).all(...params2);
+  const grouped = /* @__PURE__ */ new Map();
+  const idForSlug = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const slug = row.assignment_slug;
+    const bucket = grouped.get(slug);
+    if (bucket) bucket.push(row);
+    else grouped.set(slug, [row]);
+    if (row.assignment_id && !idForSlug.get(slug)) idForSlug.set(slug, row.assignment_id);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [slug, bucket] of grouped) {
+    out.set(slug, {
+      assignmentSlug: slug,
+      assignmentId: idForSlug.get(slug) ?? null,
+      ...rollupWindows(bucket, opts.model)
+    });
+  }
+  return out;
+}
+
+// src/dashboard/api-usage.ts
 function createUsageRouter(projectsDir, assignmentsDir2) {
   const router = Router14();
   router.get("/facets", (_req, res) => {
@@ -21127,14 +21958,12 @@ function createUsageRouter(projectsDir, assignmentsDir2) {
     try {
       initUsageDb();
       const projectSlug = req2.params.projectSlug;
-      const rows = listDaily({
-        ...extractCommonFilter(req2.query),
-        projectSlug
-      });
+      const common = extractCommonFilter(req2.query);
+      const rows = listDaily({ ...common, projectSlug });
       res.json({
         projectSlug,
         daily: rows,
-        summary: summarize(rows, "assignment")
+        summary: projectAssignmentRollup(projectSlug, rows, common)
       });
     } catch (error) {
       res.status(500).json({
@@ -21160,7 +21989,13 @@ function createUsageRouter(projectsDir, assignmentsDir2) {
         assignmentSlug,
         daily: dailyRows,
         events: eventRows,
-        summary: buildAssignmentSummary(dailyRows)
+        summary: buildAssignmentSummary(dailyRows, {
+          projectSlug,
+          assignmentSlug,
+          since: common.since,
+          until: common.until,
+          model: common.model
+        })
       });
     } catch (error) {
       res.status(500).json({
@@ -21185,7 +22020,15 @@ function createUsageRouter(projectsDir, assignmentsDir2) {
         assignmentId: assignmentSlug,
         daily: dailyRows,
         events: eventRows,
-        summary: buildAssignmentSummary(dailyRows)
+        // Standalone: engagement stores `project_slug IS NULL` (the reader maps
+        // a null/empty projectSlug to the NULL match).
+        summary: buildAssignmentSummary(dailyRows, {
+          projectSlug: null,
+          assignmentSlug,
+          since: common.since,
+          until: common.until,
+          model: common.model
+        })
       });
     } catch (error) {
       res.status(500).json({
@@ -21235,13 +22078,17 @@ function byModelBreakdown(rows) {
   }
   return [...map.values()].sort((a, b) => b.totalTokens - a.totalTokens);
 }
-function buildAssignmentSummary(rows) {
+function buildAssignmentSummary(rows, costKey) {
   const totals = summarize(rows, "assignment")[0];
+  const windows = assignmentWindowCost(costKey);
   return {
     totalTokens: totals?.totalTokens ?? 0,
-    totalCost: totals?.totalCost ?? 0,
+    totalCost: windows.cost,
     lastEventDay: totals?.lastEventDay ?? null,
-    byModel: byModelBreakdown(rows)
+    byModel: byModelBreakdown(rows),
+    pricedWindowCount: windows.pricedWindowCount,
+    uncomputableWindowCount: windows.uncomputableWindowCount,
+    negativeDeltaCount: windows.negativeDeltaCount
   };
 }
 function summarize(rows, mode) {
@@ -21265,27 +22112,70 @@ function summarize(rows, mode) {
   }
   return [...map.values()].sort((a, b) => b.totalTokens - a.totalTokens);
 }
+function projectAssignmentRollup(projectSlug, rows, common) {
+  const byAssignment = /* @__PURE__ */ new Map();
+  for (const row of summarize(rows, "assignment")) {
+    byAssignment.set(row.assignmentSlug, {
+      ...row,
+      totalCost: 0,
+      // Counts present on EVERY per-assignment row (a daily-only assignment with
+      // no closed window stays at 0/0/0); window overlay below replaces them.
+      pricedWindowCount: 0,
+      uncomputableWindowCount: 0,
+      negativeDeltaCount: 0
+    });
+  }
+  const windows = projectWindowCosts({
+    projectSlug,
+    since: common.since,
+    until: common.until,
+    model: common.model
+  });
+  for (const [assignmentSlug, w] of windows) {
+    const existing = byAssignment.get(assignmentSlug);
+    if (existing) {
+      existing.totalCost = w.cost;
+      existing.pricedWindowCount = w.pricedWindowCount;
+      existing.uncomputableWindowCount = w.uncomputableWindowCount;
+      existing.negativeDeltaCount = w.negativeDeltaCount;
+    } else {
+      byAssignment.set(assignmentSlug, {
+        projectSlug,
+        assignmentSlug,
+        totalTokens: 0,
+        totalCost: w.cost,
+        lastEventDay: "",
+        pricedWindowCount: w.pricedWindowCount,
+        uncomputableWindowCount: w.uncomputableWindowCount,
+        negativeDeltaCount: w.negativeDeltaCount
+      });
+    }
+  }
+  return [...byAssignment.values()].sort(
+    (a, b) => b.totalCost - a.totalCost || b.totalTokens - a.totalTokens
+  );
+}
 
 // src/dashboard/api-events.ts
 init_fs();
 init_parser();
 init_events_db();
 import { Router as Router15 } from "express";
-import { resolve as resolve35 } from "path";
+import { resolve as resolve36 } from "path";
 import { readFile as readFile24 } from "fs/promises";
 function createEventsRouter(projectsDir, assignmentsDir2) {
   const router = Router15();
   router.get("/projects/:slug/assignments/:aslug/events", async (req2, res) => {
     try {
       const { slug, aslug } = req2.params;
-      const assignmentMdPath = resolve35(
+      const assignmentMdPath = resolve36(
         projectsDir,
         slug,
         "assignments",
         aslug,
         "assignment.md"
       );
-      const id = await readAssignmentId(assignmentMdPath);
+      const id = await readAssignmentId2(assignmentMdPath);
       if (!id) {
         res.json({ events: [] });
         return;
@@ -21299,8 +22189,8 @@ function createEventsRouter(projectsDir, assignmentsDir2) {
   router.get("/standalone/assignments/:id/events", async (req2, res) => {
     try {
       const { id: dirId } = req2.params;
-      const assignmentMdPath = resolve35(assignmentsDir2, dirId, "assignment.md");
-      const id = await readAssignmentId(assignmentMdPath) ?? dirId;
+      const assignmentMdPath = resolve36(assignmentsDir2, dirId, "assignment.md");
+      const id = await readAssignmentId2(assignmentMdPath) ?? dirId;
       res.json({ events: loadEvents(id, req2.query) });
     } catch (error) {
       console.warn("[events] failed to list standalone events:", error);
@@ -21309,7 +22199,7 @@ function createEventsRouter(projectsDir, assignmentsDir2) {
   });
   return router;
 }
-async function readAssignmentId(assignmentMdPath) {
+async function readAssignmentId2(assignmentMdPath) {
   if (!await fileExists(assignmentMdPath)) return null;
   const content = await readFile24(assignmentMdPath, "utf-8");
   const [fm] = extractFrontmatter2(content);
@@ -21356,7 +22246,7 @@ init_assignment_walk();
 init_parser();
 init_facts();
 init_state_machine();
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 import { readFile as readFile25 } from "fs/promises";
 
 // src/inbox/types.ts
@@ -21537,7 +22427,7 @@ async function computeInbox(opts) {
     if (opts.project !== void 0 && entry.projectSlug !== opts.project) continue;
     let parsed;
     try {
-      const content = await readFile25(resolve36(entry.assignmentDir, "assignment.md"), "utf-8");
+      const content = await readFile25(resolve37(entry.assignmentDir, "assignment.md"), "utf-8");
       parsed = parseAssignmentFull(content);
     } catch {
       continue;
@@ -21580,7 +22470,7 @@ async function computeInbox(opts) {
       });
     }
     if (!typeFilter || typeFilter.has("question")) {
-      const commentsPath = resolve36(entry.assignmentDir, "comments.md");
+      const commentsPath = resolve37(entry.assignmentDir, "comments.md");
       if (await fileExists(commentsPath)) {
         try {
           const content = await readFile25(commentsPath, "utf-8");
@@ -21694,7 +22584,7 @@ init_slug();
 init_timestamp();
 init_fs();
 import { Router as Router17 } from "express";
-import { resolve as resolve37 } from "path";
+import { resolve as resolve38 } from "path";
 import { readFile as readFile26 } from "fs/promises";
 init_playbooks();
 function statusForPlaybookError(code) {
@@ -21777,7 +22667,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req2.params.slug}" not found` });
         return;
       }
-      const filePath = resolve37(playbooksDir2, resolved.filename);
+      const filePath = resolve38(playbooksDir2, resolved.filename);
       const content = await readFile26(filePath, "utf-8");
       res.json({
         documentType: "playbook",
@@ -21803,7 +22693,7 @@ function createPlaybooksRouter(playbooksDir2) {
         return;
       }
       await ensureDir(playbooksDir2);
-      const filePath = resolve37(playbooksDir2, `${slug}.md`);
+      const filePath = resolve38(playbooksDir2, `${slug}.md`);
       if (await fileExists(filePath)) {
         res.status(409).json({ error: `Playbook "${slug}" already exists` });
         return;
@@ -21827,7 +22717,7 @@ function createPlaybooksRouter(playbooksDir2) {
         res.status(404).json({ error: `Playbook "${req2.params.slug}" not found` });
         return;
       }
-      const filePath = resolve37(playbooksDir2, resolved.filename);
+      const filePath = resolve38(playbooksDir2, resolved.filename);
       await writeFileForce(filePath, content);
       await rebuildPlaybookManifest(playbooksDir2);
       res.json({ slug: resolved.slug, path: filePath });
@@ -21890,7 +22780,7 @@ init_uuid();
 init_paths();
 init_fs();
 init_config2();
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 async function createAssignmentCommand(title, options) {
   if (!title.trim()) {
     throw new Error("Assignment title cannot be empty.");
@@ -21965,14 +22855,14 @@ async function createAssignmentCommand(title, options) {
   if (options.oneOff) {
     const standaloneRoot = assignmentsDir();
     folderName = id;
-    assignmentDir = resolve38(standaloneRoot, folderName);
+    assignmentDir = resolve39(standaloneRoot, folderName);
     projectSlug = null;
     await ensureDir(standaloneRoot);
   } else {
     const baseDir = options.dir ? expandHome(options.dir) : config.defaultProjectDir;
     projectSlug = options.project;
-    const projectDir = resolve38(baseDir, projectSlug);
-    const projectMdPath = resolve38(projectDir, "project.md");
+    const projectDir = resolve39(baseDir, projectSlug);
+    const projectMdPath = resolve39(projectDir, "project.md");
     if (!await fileExists(projectDir) || !await fileExists(projectMdPath)) {
       throw new Error(
         `Project "${projectSlug}" not found at ${projectDir}.
@@ -21980,9 +22870,9 @@ Run 'syntaur create-project' first or use --one-off.`
       );
     }
     if (dependsOn.length > 0) {
-      const depDirBase = resolve38(projectDir, "assignments");
+      const depDirBase = resolve39(projectDir, "assignments");
       for (const dep of dependsOn) {
-        const depDir = resolve38(depDirBase, dep);
+        const depDir = resolve39(depDirBase, dep);
         if (!await fileExists(depDir)) {
           console.warn(
             `Warning: dependency "${dep}" does not exist in project "${projectSlug}" yet.`
@@ -21991,7 +22881,7 @@ Run 'syntaur create-project' first or use --one-off.`
       }
     }
     folderName = assignmentSlug;
-    assignmentDir = resolve38(projectDir, "assignments", folderName);
+    assignmentDir = resolve39(projectDir, "assignments", folderName);
   }
   if (await fileExists(assignmentDir)) {
     throw new Error(
@@ -22003,7 +22893,7 @@ Use --slug to specify a different slug.`
   const companionAssignmentRef = projectSlug === null ? id : assignmentSlug;
   const files = [
     [
-      resolve38(assignmentDir, "assignment.md"),
+      resolve39(assignmentDir, "assignment.md"),
       renderAssignment({
         id,
         slug: assignmentSlug,
@@ -22021,35 +22911,35 @@ Use --slug to specify a different slug.`
       })
     ],
     [
-      resolve38(assignmentDir, "scratchpad.md"),
+      resolve39(assignmentDir, "scratchpad.md"),
       renderScratchpad({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve38(assignmentDir, "handoff.md"),
+      resolve39(assignmentDir, "handoff.md"),
       renderHandoff({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve38(assignmentDir, "decision-record.md"),
+      resolve39(assignmentDir, "decision-record.md"),
       renderDecisionRecord({
         assignmentSlug: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve38(assignmentDir, "progress.md"),
+      resolve39(assignmentDir, "progress.md"),
       renderProgress({
         assignment: companionAssignmentRef,
         timestamp
       })
     ],
     [
-      resolve38(assignmentDir, "comments.md"),
+      resolve39(assignmentDir, "comments.md"),
       renderComments({
         assignment: companionAssignmentRef,
         timestamp
@@ -22223,7 +23113,7 @@ import { raw } from "express";
 
 // src/todos/attachments.ts
 import { mkdir as mkdir4, readdir as readdir15, stat as stat6, rename as rename5, rm as rm4, unlink as unlink7, writeFile as writeFile6, cp } from "fs/promises";
-import { resolve as resolve39, basename as basename6, dirname as dirname9, extname } from "path";
+import { resolve as resolve40, basename as basename6, dirname as dirname9, extname } from "path";
 
 // src/utils/proof-artifact-id.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -22310,12 +23200,12 @@ function sanitizeAttachmentName(name) {
   return n;
 }
 function attachmentsRootDir(todosDir2) {
-  return resolve39(todosDir2, "attachments");
+  return resolve40(todosDir2, "attachments");
 }
 function attachmentDirFor(todosDir2, scopeId, todoId) {
   assertScope(scopeId);
   assertTodoId(todoId);
-  return resolve39(attachmentsRootDir(todosDir2), scopeId, todoId);
+  return resolve40(attachmentsRootDir(todosDir2), scopeId, todoId);
 }
 async function dirExists(p) {
   try {
@@ -22329,7 +23219,7 @@ async function writeAttachment(todosDir2, scopeId, todoId, originalName, bytes)
   await mkdir4(dir, { recursive: true });
   const id = generateArtifactId();
   const filename = sanitizeAttachmentName(originalName);
-  await writeFile6(resolve39(dir, `${id}__${filename}`), bytes);
+  await writeFile6(resolve40(dir, `${id}__${filename}`), bytes);
   return {
     id,
     filename,
@@ -22354,7 +23244,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
     if (!ATTACHMENT_ID_RE.test(id)) continue;
     const filename = stored.slice(sep2 + 2);
     try {
-      const st = await stat6(resolve39(dir, stored));
+      const st = await stat6(resolve40(dir, stored));
       if (!st.isFile()) continue;
       out.push({ id, filename, mime: mimeForName(filename), size: st.size, createdAt: st.mtime.toISOString() });
     } catch {
@@ -22365,7 +23255,7 @@ async function listAttachments(todosDir2, scopeId, todoId) {
 }
 async function readScopeAttachments(todosDir2, scopeId) {
   assertScope(scopeId);
-  const scopeDir = resolve39(attachmentsRootDir(todosDir2), scopeId);
+  const scopeDir = resolve40(attachmentsRootDir(todosDir2), scopeId);
   let todoIds;
   try {
     todoIds = await readdir15(scopeDir);
@@ -22393,7 +23283,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: resolve39(dir, stored), filename, mime: mimeForName(filename) };
+  return { path: resolve40(dir, stored), filename, mime: mimeForName(filename) };
 }
 async function deleteAttachment(todosDir2, scopeId, todoId, attachmentId) {
   const resolved = await resolveAttachmentFile(todosDir2, scopeId, todoId, attachmentId);
@@ -22809,8 +23699,8 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
   router.post("/:workspace/archive", async (req2, res) => {
     try {
       const { archivePath: archivePath2 } = await Promise.resolve().then(() => (init_parser2(), parser_exports));
-      const { resolve: resolve47 } = await import("path");
-      const { readFile: readFile32 } = await import("fs/promises");
+      const { resolve: resolve49 } = await import("path");
+      const { readFile: readFile31 } = await import("fs/promises");
       const { writeFileForce: writeFileForce2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
       const workspace = getWorkspaceParam(req2.params.workspace);
       const outcome = await wsLock(workspace, async () => {
@@ -22826,10 +23716,10 @@ function createTodosRouter(todosDir2, broadcast, projectsDir) {
           (e) => e.itemIds.every((id) => completedIds.has(id))
         );
         const archFile = archivePath2(todosDir2, workspace, checklist.archiveInterval);
-        await ensureDir(resolve47(todosDir2, "archive"));
+        await ensureDir(resolve49(todosDir2, "archive"));
         let archContent = "";
         if (await fileExists(archFile)) {
-          archContent = await readFile32(archFile, "utf-8");
+          archContent = await readFile31(archFile, "utf-8");
           archContent = archContent.trimEnd() + "\n\n";
         } else {
           archContent = `---
@@ -23130,7 +24020,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: readFile32 } = await import("fs/promises");
+        const { readFile: readFile31 } = 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;
@@ -23151,7 +24041,7 @@ workspace: ${workspace}
         }
         const assignmentMdPath = resolvePath2(assignmentDir, "assignment.md");
         if (!await fileExists2(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
-        let content = await readFile32(assignmentMdPath, "utf-8");
+        let content = await readFile31(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
           content,
           items.map((it) => ({
@@ -23347,7 +24237,7 @@ init_paths();
 init_slug();
 import { Router as Router20 } from "express";
 import { mkdir as mkdir6, readFile as readFile27, rename as rename7 } from "fs/promises";
-import { resolve as resolve40, dirname as dirname11 } from "path";
+import { resolve as resolve41, dirname as dirname11 } from "path";
 init_api();
 var WORKSPACE_REGEX2 = /^[a-z0-9_][a-z0-9-]*$/;
 function touchItem4(item) {
@@ -23363,7 +24253,7 @@ function params(req2) {
   return req2.params;
 }
 async function projectExists(projectsDir, slug) {
-  return fileExists(resolve40(projectsDir, slug, "project.md"));
+  return fileExists(resolve41(projectsDir, slug, "project.md"));
 }
 async function ensureProjectTodosDir(projectsDir, slug) {
   const todosDir2 = projectTodosDir(projectsDir, slug);
@@ -23380,7 +24270,7 @@ async function ensureProjectTodosDir(projectsDir, slug) {
     throw err;
   }
   try {
-    await mkdir6(resolve40(todosDir2, "archive"), { recursive: false });
+    await mkdir6(resolve41(todosDir2, "archive"), { recursive: false });
   } catch (err) {
     const code = err.code;
     if (code === "EEXIST") return;
@@ -24059,15 +24949,15 @@ workspace: ${slug}
         if (tg.includes("/")) {
           const parts = tg.split("/");
           if (parts.length !== 2) return { error: `Invalid target.assignment "${tg}"` };
-          assignmentDir = resolve40(projectsDir, parts[0], "assignments", parts[1]);
+          assignmentDir = resolve41(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 = resolve40(assignmentsDirFn(), tg);
+          assignmentDir = resolve41(assignmentsDirFn(), tg);
           assignmentRef = tg;
         } else {
           return { error: `Invalid target.assignment "${tg}"` };
         }
-        const assignmentMdPath = resolve40(assignmentDir, "assignment.md");
+        const assignmentMdPath = resolve41(assignmentDir, "assignment.md");
         if (!await fileExists(assignmentMdPath)) return { error: `Target assignment not found: ${assignmentMdPath}` };
         let content = await readFile27(assignmentMdPath, "utf-8");
         content = appendTodosToAssignmentBody2(
@@ -24449,7 +25339,7 @@ init_fs();
 init_paths();
 init_slug();
 import { Router as Router22 } from "express";
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } 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);
@@ -24491,7 +25381,7 @@ function createProjectBundlesRouter(projectsDir, broadcast) {
   router.get("/", async (req2, res) => {
     try {
       const slug = getProjectIdParam2(req2.params.projectId);
-      const projectMd = resolve41(projectsDir, slug, "project.md");
+      const projectMd = resolve42(projectsDir, slug, "project.md");
       if (!await fileExists(projectMd)) {
         notFound2(res, slug);
         return;
@@ -24521,7 +25411,7 @@ init_config2();
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { cp as cp2, mkdtemp, rm as rm5, readFile as readFile29, writeFile as writeFile7, unlink as unlink8, stat as stat7, open as open5, rename as rename8 } from "fs/promises";
-import { resolve as resolve42, join as join9 } from "path";
+import { resolve as resolve43, join as join9 } from "path";
 import { tmpdir } from "os";
 var exec2 = promisify2(execFile2);
 var VALID_CATEGORIES = ["projects", "playbooks", "todos", "servers", "config"];
@@ -24561,7 +25451,7 @@ async function resolveCategoryPath(category) {
     case "servers":
       return { sourcePath: serversDir(), repoPath: "servers", isFile: false };
     case "config":
-      return { sourcePath: resolve42(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
+      return { sourcePath: resolve43(syntaurRoot(), "config.md"), repoPath: "config.md", isFile: true };
   }
 }
 async function checkGitInstalled() {
@@ -24572,7 +25462,7 @@ async function checkGitInstalled() {
   }
 }
 async function acquireLock2() {
-  const lockPath = resolve42(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve43(syntaurRoot(), LOCK_FILE_NAME);
   await ensureDir(syntaurRoot());
   try {
     const handle = await open5(lockPath, "wx");
@@ -24619,7 +25509,7 @@ async function copyRecursive(src, dest) {
     await ensureDir(dest);
     await cp2(src, dest, { recursive: true, force: true });
   } else {
-    await ensureDir(resolve42(dest, ".."));
+    await ensureDir(resolve43(dest, ".."));
     await cp2(src, dest, { force: true });
   }
 }
@@ -24667,7 +25557,7 @@ async function backupToGithub(overrides) {
       }
       if (category === "config") {
         const sanitized = await readSanitizedConfig(sourcePath);
-        await ensureDir(resolve42(destPath, ".."));
+        await ensureDir(resolve43(destPath, ".."));
         await writeFile7(destPath, sanitized, "utf-8");
       } else {
         await copyRecursive(sourcePath, destPath);
@@ -24721,7 +25611,7 @@ async function backupToGithub(overrides) {
 }
 async function safeRestoreCategory(localPath, repoSrcPath, isFile) {
   if (isFile) {
-    await ensureDir(resolve42(localPath, ".."));
+    await ensureDir(resolve43(localPath, ".."));
     await cp2(repoSrcPath, localPath, { force: true });
     return;
   }
@@ -24822,7 +25712,7 @@ async function restoreFromGithub(overrides) {
 }
 async function getBackupStatus() {
   const config = await readConfig();
-  const lockPath = resolve42(syntaurRoot(), LOCK_FILE_NAME);
+  const lockPath = resolve43(syntaurRoot(), LOCK_FILE_NAME);
   const locked = await fileExists(lockPath);
   return {
     repo: config.backup?.repo ?? null,
@@ -25305,7 +26195,7 @@ async function runCcusage(opts = {}) {
   };
 }
 function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
-  return new Promise((resolve47) => {
+  return new Promise((resolve49) => {
     const child = spawn4(binary, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -25319,7 +26209,7 @@ function runOnce(binary, args, env, timeoutMs, maxOutputBytes) {
       if (settled) return;
       settled = true;
       clearTimeout(timer3);
-      resolve47(result);
+      resolve49(result);
     };
     const timer3 = setTimeout(() => {
       timedOut = true;
@@ -25370,9 +26260,13 @@ function resolveAttribution(input, db5) {
   const database = db5 ?? getSessionDb();
   const direct = database.prepare(
     `SELECT project_slug, assignment_slug
-         FROM sessions
-        WHERE session_id = ?`
-  ).get(input.sessionId);
+         FROM engagement
+        WHERE session_id = ?
+          AND julianday(started_at) <= julianday(?)
+          AND (ended_at IS NULL OR julianday(ended_at) > julianday(?))
+        ORDER BY julianday(started_at) DESC
+        LIMIT 1`
+  ).get(input.sessionId, input.eventTs, input.eventTs);
   if (direct) {
     return {
       projectSlug: direct.project_slug,
@@ -25381,25 +26275,43 @@ function resolveAttribution(input, db5) {
   }
   if (input.cwd) {
     const exact = database.prepare(
-      `SELECT project_slug, assignment_slug
-           FROM sessions
-          WHERE path = ?
-            AND julianday(started) <= julianday(?)
-            AND (ended IS NULL OR julianday(ended) >= julianday(?))
-          ORDER BY started DESC
+      `SELECT 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
+          WHERE s.path = ?
+            AND julianday(s.started) <= julianday(?)
+            AND (s.ended IS NULL OR julianday(s.ended) >= julianday(?))
+            AND julianday(e.started_at) <= julianday(?)
+            AND (e.ended_at IS NULL OR julianday(e.ended_at) > julianday(?))
+          ORDER BY julianday(s.started) DESC, julianday(e.started_at) DESC
           LIMIT 1`
-    ).get(input.cwd, input.eventTs, input.eventTs);
+    ).get(
+      input.cwd,
+      input.eventTs,
+      input.eventTs,
+      input.eventTs,
+      input.eventTs
+    );
     if (exact) {
       return { projectSlug: exact.project_slug, assignmentSlug: exact.assignment_slug };
     }
     if (input.eventTs.endsWith("T00:00:00.000Z")) {
       const sameDay = database.prepare(
-        `SELECT DISTINCT project_slug, assignment_slug
-             FROM sessions
-            WHERE path = ?
-              AND date(started) <= date(?)
-              AND (ended IS NULL OR date(ended) >= date(?))`
-      ).all(input.cwd, input.eventTs, input.eventTs);
+        `SELECT DISTINCT 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
+            WHERE s.path = ?
+              AND date(s.started) <= date(?)
+              AND (s.ended IS NULL OR date(s.ended) >= date(?))
+              AND date(e.started_at) <= date(?)
+              AND (e.ended_at IS NULL OR date(e.ended_at) >= date(?))`
+      ).all(
+        input.cwd,
+        input.eventTs,
+        input.eventTs,
+        input.eventTs,
+        input.eventTs
+      );
       if (sameDay.length === 1) {
         return {
           projectSlug: sameDay[0].project_slug,
@@ -25470,41 +26382,6 @@ function runRollup() {
   return { daysComputed, rowsWritten };
 }
 
-// src/usage/pricing.ts
-var PER_MILLION = 1e6;
-var MODEL_PRICING = {
-  // Moonshot Kimi K2.6 — the model pi emits today. Official Moonshot list price.
-  // source: https://platform.moonshot.ai/ (official) — cross-checked
-  //         https://openrouter.ai/moonshotai/kimi-k2.6 (retrieved 2026-06-17)
-  "moonshotai/kimi-k2.6": { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0.95 },
-  // Moonshot Kimi K2.5 — prior Kimi model. Official Moonshot list price.
-  // source: https://platform.moonshot.ai/ — cross-checked
-  //         https://openrouter.ai/moonshotai/kimi-k2.5 (retrieved 2026-06-17)
-  "moonshotai/kimi-k2.5": { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0.6 },
-  // Z.ai (Zhipu) GLM-5.2 — official z.ai platform list price.
-  // source: https://docs.z.ai/guides/overview/pricing — cross-checked
-  //         https://openrouter.ai/z-ai/glm-5 (retrieved 2026-06-18)
-  "zai-org/glm-5.2": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 1.4 },
-  // MiniMax M2.5 — official MiniMax platform list price. No separately-pinned
-  // cached-read rate is published, so cacheRead is set conservatively to the
-  // input rate (upper bound); revise if MiniMax publishes a cache rate.
-  // source: https://platform.minimax.io/docs/guides/pricing-token-plan
-  //         — cross-checked https://openrouter.ai/minimax/minimax-m2.5 (retrieved 2026-06-18)
-  "minimaxai/minimax-m2.5": { input: 0.15, output: 0.9, cacheRead: 0.15, cacheWrite: 0.15 }
-  // NOTE: opaque Synthetic tier aliases like `syn:large:text` have no public
-  // per-token rate (they route to whatever Synthetic assigns), so they remain
-  // unpriced (→ $0). Reseller discounts (e.g. DeepInfra K2.6 0.75/3.50/0.15) are
-  // rejected by the canonical-source rule and are NOT used here.
-};
-function normalizeModelKey(model) {
-  return model.replace(/^\s*\[[^\]]*\]\s*/, "").replace(/^hf:/i, "").trim().toLowerCase();
-}
-function priceForModel(model, tokens) {
-  const rate = MODEL_PRICING[normalizeModelKey(model)];
-  if (!rate) return null;
-  return (tokens.inputTokens * rate.input + tokens.outputTokens * rate.output + tokens.cacheReadTokens * rate.cacheRead + tokens.cacheCreationTokens * rate.cacheWrite) / PER_MILLION;
-}
-
 // src/usage/collect.ts
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
 function formatDayFromCcusageDate(yyyymmdd) {
@@ -25723,7 +26600,7 @@ function createDashboardServer(options) {
   (async () => {
     try {
       const configResult = await migrateLegacyConfig(
-        resolve46(syntaurRoot(), "config.md")
+        resolve48(syntaurRoot(), "config.md")
       );
       const projectResult = await migrateLegacyProjectFiles(projectsDir);
       const summary = summarizeMigration(projectResult, configResult);
@@ -26246,14 +27123,14 @@ function createDashboardServer(options) {
   app.use("/api/backup", createBackupRouter());
   if (serveStaticUi && dashboardDistPath) {
     const sendOpts = { dotfiles: "allow" };
-    app.use("/assets", express.static(resolve46(dashboardDistPath, "assets"), sendOpts));
+    app.use("/assets", express.static(resolve48(dashboardDistPath, "assets"), sendOpts));
     app.use(express.static(dashboardDistPath, { ...sendOpts, index: false, fallthrough: true }));
     app.get("{*path}", async (req2, res) => {
       if (req2.path.startsWith("/api") || req2.path === "/ws" || req2.path.startsWith("/assets")) {
         res.status(404).json({ error: "Not Found" });
         return;
       }
-      const indexPath = resolve46(dashboardDistPath, "index.html");
+      const indexPath = resolve48(dashboardDistPath, "index.html");
       if (!await fileExists(indexPath)) {
         res.status(503).send(
           'Dashboard not built. Run "npm run build:dashboard" first.'
@@ -26289,8 +27166,8 @@ function createDashboardServer(options) {
         if (!await migrationGate()) return;
         try {
           const context = await resolveDeriveContext2();
-          const projectDir = projectSlug ? resolve46(projectsDir, projectSlug) : null;
-          const path = projectDir ? resolve46(projectDir, "assignments", assignmentSlug, "assignment.md") : resolve46(assignmentsDir2, assignmentSlug, "assignment.md");
+          const projectDir = projectSlug ? resolve48(projectsDir, projectSlug) : null;
+          const path = projectDir ? resolve48(projectDir, "assignments", assignmentSlug, "assignment.md") : resolve48(assignmentsDir2, assignmentSlug, "assignment.md");
           if (!await fileExists(path)) return;
           const result = await recomputeAndWrite2(path, {
             cause: "derive",
@@ -26343,8 +27220,8 @@ function createDashboardServer(options) {
         serversDir: serversDir2,
         playbooksDir: playbooksDir2,
         todosDir: todosDir2,
-        dbPath: resolve46(syntaurRoot(), "syntaur.db"),
-        configPath: resolve46(syntaurRoot(), "config.md"),
+        dbPath: resolve48(syntaurRoot(), "syntaur.db"),
+        configPath: resolve48(syntaurRoot(), "config.md"),
         onMessage: broadcast,
         onAssignmentChanged: (projectSlug, assignmentSlug) => {
           void recomputeOne(projectSlug, assignmentSlug);
@@ -26412,7 +27289,7 @@ function createDashboardServer(options) {
           }
         });
         server.listen(port, () => {
-          const portFile = resolve46(syntaurRoot(), "dashboard-port");
+          const portFile = resolve48(syntaurRoot(), "dashboard-port");
           writeFile8(portFile, String(port), "utf-8").catch(() => {
           });
           resolvePromise();
@@ -26436,7 +27313,7 @@ function createDashboardServer(options) {
         client.terminate();
       }
       clients.clear();
-      const portFile = resolve46(syntaurRoot(), "dashboard-port");
+      const portFile = resolve48(syntaurRoot(), "dashboard-port");
       await unlink9(portFile).catch(() => {
       });
       server.closeAllConnections?.();