syntaur 0.44.1 → 0.46.0

package/dist/launch/index.js

@@ -1028,7 +1028,11 @@ var init_fields = __esm({
       tags: { kind: "list" },
       archived: { kind: "bool" },
       title: { kind: "substring" },
-      search: { kind: "substring", get: (i) => i["title"] },
+      // `search` reads a dedicated `searchText` haystack when the item provides one
+      // (so the dashboard can match title + slug + project like its filter box),
+      // falling back to `title` when absent. Backward-compatible: title-only when no
+      // searchText. The `title` field stays title-only.
+      search: { kind: "substring", get: (i) => i["searchText"] ?? i["title"] },
       created: { kind: "timestamp" },
       updated: { kind: "timestamp" },
       completedat: { kind: "timestamp", get: (i) => i["completedAt"] },
@@ -1663,17 +1667,7 @@ var init_query = __esm({
   }
 });
 
-// src/lifecycle/derive.ts
-var derive_exports = {};
-__export(derive_exports, {
-  DERIVE_FIELDS: () => DERIVE_FIELDS,
-  acceptFactDeclarations: () => acceptFactDeclarations,
-  buildDeriveRegistry: () => buildDeriveRegistry,
-  buildQueryRegistry: () => buildQueryRegistry,
-  deriveDimensions: () => deriveDimensions,
-  factFieldNames: () => factFieldNames,
-  validateDeriveCondition: () => validateDeriveCondition
-});
+// src/utils/fact-registry.ts
 function factFieldNames(decl) {
   const name = decl.name;
   const exportNames = {
@@ -1740,85 +1734,63 @@ function buildQueryRegistry(accepted) {
   for (const decl of accepted) addFactFields(registry, decl);
   return registry;
 }
-function validateDeriveCondition(when, registry = DERIVE_FIELDS) {
-  if (when === "*") return null;
-  const parsed = parseQuery(when);
-  if (!parsed.ast) return parsed.errors[0]?.message ?? "unparseable condition";
-  try {
-    compileNode(parsed.ast, registry);
-    return null;
-  } catch (err) {
-    if (err instanceof CompileError) return err.errors[0]?.message ?? "invalid condition";
-    throw err;
-  }
-}
-function compiledWhen(registry, when) {
-  let cache = conditionCache.get(registry);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    conditionCache.set(registry, cache);
-  }
-  let pred = cache.get(when);
-  if (!pred) {
-    if (when === "*") {
-      pred = () => true;
+function queryFieldNames(declarations) {
+  const builtins = [
+    "status",
+    "priority",
+    "type",
+    "assignee",
+    "project",
+    "tag",
+    "tags",
+    "archived",
+    "title",
+    "search",
+    "created",
+    "updated",
+    "completedAt",
+    "statusAge",
+    "phase",
+    "disposition",
+    "phaseAge",
+    "hasRealObjective",
+    "acRealTotal",
+    "acRealChecked",
+    "acAllChecked",
+    "planExists",
+    "planApproved",
+    "workspaceSet",
+    "implementationStarted",
+    "depsSatisfied",
+    "unresolvedQuestions",
+    "progressStaleDays",
+    "blocked",
+    "parked",
+    "reviewRequested",
+    "pinned"
+  ];
+  const custom = [];
+  for (const decl of declarations) {
+    const names = factFieldNames(decl);
+    if (decl.type === "attestation") {
+      custom.push(
+        names.exports.fact,
+        names.exports.approved,
+        names.exports.changesRequested,
+        names.exports.by,
+        names.exports.approvedBy
+      );
     } else {
-      const parsed = parseQuery(when);
-      if (!parsed.ast) {
-        throw new CompileError(parsed.errors);
-      }
-      pred = compileNode(parsed.ast, registry);
+      custom.push(names.exports.fact);
     }
-    cache.set(when, pred);
   }
-  return pred;
+  return [...builtins, ...custom];
 }
-function deriveDimensions(input) {
-  const { facts, derive, currentStatus, terminalStatuses, knownStatusIds, override } = input;
-  const registry = input.registry ?? DERIVE_FIELDS;
-  if (terminalStatuses.has(currentStatus)) return null;
-  const ctx = { now: 0 };
-  const item = facts;
-  let phase = derive.phaseLadder[0]?.phase ?? currentStatus;
-  let nextAction = derive.phaseLadder[0]?.next ?? null;
-  for (let i = derive.phaseLadder.length - 1; i >= 0; i--) {
-    const rung = derive.phaseLadder[i];
-    if (compiledWhen(registry, rung.when)(item, ctx)) {
-      phase = rung.phase;
-      nextAction = rung.next ?? null;
-      break;
-    }
-  }
-  let disposition = "active";
-  for (const rule of derive.disposition) {
-    if (rule.when === null || compiledWhen(registry, rule.when)(item, ctx)) {
-      disposition = rule.is;
-      break;
-    }
-  }
-  let derivedStatus;
-  switch (disposition) {
-    case "parked":
-      derivedStatus = knownStatusIds.has(derive.headline.parked) ? derive.headline.parked : phase;
-      break;
-    case "blocked":
-      derivedStatus = knownStatusIds.has(derive.headline.blocked) ? derive.headline.blocked : phase;
-      break;
-    default:
-      derivedStatus = phase;
-  }
-  let status = derivedStatus;
-  if (override && override.status && !terminalStatuses.has(override.status) && knownStatusIds.has(override.status)) {
-    status = override.status;
-  }
-  return { phase, disposition, derivedStatus, status, nextAction };
-}
-var DERIVE_FIELDS, conditionCache;
-var init_derive = __esm({
-  "src/lifecycle/derive.ts"() {
+var DERIVE_FIELDS;
+var init_fact_registry = __esm({
+  "src/utils/fact-registry.ts"() {
     "use strict";
     init_query();
-    init_query();
     DERIVE_FIELDS = {
       hasrealobjective: { kind: "bool", get: (i) => i["hasRealObjective"] },
       acrealtotal: { kind: "number", get: (i) => i["acRealTotal"] },
@@ -1835,7 +1807,6 @@ var init_derive = __esm({
       reviewrequested: { kind: "bool", get: (i) => i["reviewRequested"] },
       pinned: { kind: "bool" }
     };
-    conditionCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -2018,6 +1989,7 @@ function cloneDefaultConfig() {
     ...DEFAULT_CONFIG,
     onboarding: { ...DEFAULT_CONFIG.onboarding },
     agentDefaults: { ...DEFAULT_CONFIG.agentDefaults },
+    session: { ...DEFAULT_CONFIG.session },
     integrations: { ...DEFAULT_CONFIG.integrations },
     backup: DEFAULT_CONFIG.backup ? { ...DEFAULT_CONFIG.backup } : null,
     statuses: DEFAULT_CONFIG.statuses ? {
@@ -3367,6 +3339,11 @@ async function readConfig() {
         fm["agentDefaults.autoCreateWorktree"]
       ) ? fm["agentDefaults.autoCreateWorktree"] : DEFAULT_CONFIG.agentDefaults.autoCreateWorktree
     },
+    session: {
+      autoTrack: SESSION_AUTO_TRACK_VALUES.includes(
+        fm["session.autoTrack"]
+      ) ? fm["session.autoTrack"] : DEFAULT_CONFIG.session.autoTrack
+    },
     integrations: {
       claudePluginDir: parseOptionalAbsolutePath(
         fm["integrations.claudePluginDir"],
@@ -3466,7 +3443,7 @@ async function updateAgentsConfig(mutation, options = {}) {
   await writeAgentsConfig(next);
   return { previous, next, written: true };
 }
-var DEFAULT_DERIVE_CONFIG, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
+var DEFAULT_DERIVE_CONFIG, DEFAULT_ASSIGNMENT_TYPES, DEFAULT_CONFIG, AUTO_CREATE_WORKTREE_VALUES, SESSION_AUTO_TRACK_VALUES, AgentConfigError, DEFAULT_STATUS_COLORS, KNOWN_AGENT_SCALAR_FIELDS, migratedConfigPaths, TerminalConfigError;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -3478,7 +3455,7 @@ var init_config2 = __esm({
     init_hotkeysCatalog();
     init_agents_schema();
     init_slug();
-    init_derive();
+    init_fact_registry();
     init_query();
     init_terminal_schema();
     init_workspace_visibility_schema();
@@ -3532,6 +3509,9 @@ var init_config2 = __esm({
         autoApprove: false,
         autoCreateWorktree: "ask"
       },
+      session: {
+        autoTrack: "all"
+      },
       integrations: {
         claudePluginDir: null,
         codexPluginDir: null,
@@ -3552,6 +3532,7 @@ var init_config2 = __esm({
       }
     };
     AUTO_CREATE_WORKTREE_VALUES = ["skip", "ask", "always"];
+    SESSION_AUTO_TRACK_VALUES = ["all", "workspaces-only", "off"];
     AgentConfigError = class extends Error {
     };
     DEFAULT_STATUS_COLORS = {
@@ -3656,6 +3637,103 @@ var init_assignment_resolver = __esm({
   }
 });
 
+// src/lifecycle/derive.ts
+var derive_exports = {};
+__export(derive_exports, {
+  DERIVE_FIELDS: () => DERIVE_FIELDS,
+  acceptFactDeclarations: () => acceptFactDeclarations,
+  addFactFields: () => addFactFields,
+  buildDeriveRegistry: () => buildDeriveRegistry,
+  buildQueryRegistry: () => buildQueryRegistry,
+  deriveDimensions: () => deriveDimensions,
+  factFieldNames: () => factFieldNames,
+  queryFieldNames: () => queryFieldNames,
+  validateDeriveCondition: () => validateDeriveCondition
+});
+function validateDeriveCondition(when, registry = DERIVE_FIELDS) {
+  if (when === "*") return null;
+  const parsed = parseQuery(when);
+  if (!parsed.ast) return parsed.errors[0]?.message ?? "unparseable condition";
+  try {
+    compileNode(parsed.ast, registry);
+    return null;
+  } catch (err) {
+    if (err instanceof CompileError) return err.errors[0]?.message ?? "invalid condition";
+    throw err;
+  }
+}
+function compiledWhen(registry, when) {
+  let cache = conditionCache.get(registry);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    conditionCache.set(registry, cache);
+  }
+  let pred = cache.get(when);
+  if (!pred) {
+    if (when === "*") {
+      pred = () => true;
+    } else {
+      const parsed = parseQuery(when);
+      if (!parsed.ast) {
+        throw new CompileError(parsed.errors);
+      }
+      pred = compileNode(parsed.ast, registry);
+    }
+    cache.set(when, pred);
+  }
+  return pred;
+}
+function deriveDimensions(input) {
+  const { facts, derive, currentStatus, terminalStatuses, knownStatusIds, override } = input;
+  const registry = input.registry ?? DERIVE_FIELDS;
+  if (terminalStatuses.has(currentStatus)) return null;
+  const ctx = { now: 0 };
+  const item = facts;
+  let phase = derive.phaseLadder[0]?.phase ?? currentStatus;
+  let nextAction = derive.phaseLadder[0]?.next ?? null;
+  for (let i = derive.phaseLadder.length - 1; i >= 0; i--) {
+    const rung = derive.phaseLadder[i];
+    if (compiledWhen(registry, rung.when)(item, ctx)) {
+      phase = rung.phase;
+      nextAction = rung.next ?? null;
+      break;
+    }
+  }
+  let disposition = "active";
+  for (const rule of derive.disposition) {
+    if (rule.when === null || compiledWhen(registry, rule.when)(item, ctx)) {
+      disposition = rule.is;
+      break;
+    }
+  }
+  let derivedStatus;
+  switch (disposition) {
+    case "parked":
+      derivedStatus = knownStatusIds.has(derive.headline.parked) ? derive.headline.parked : phase;
+      break;
+    case "blocked":
+      derivedStatus = knownStatusIds.has(derive.headline.blocked) ? derive.headline.blocked : phase;
+      break;
+    default:
+      derivedStatus = phase;
+  }
+  let status = derivedStatus;
+  if (override && override.status && !terminalStatuses.has(override.status) && knownStatusIds.has(override.status)) {
+    status = override.status;
+  }
+  return { phase, disposition, derivedStatus, status, nextAction };
+}
+var conditionCache;
+var init_derive = __esm({
+  "src/lifecycle/derive.ts"() {
+    "use strict";
+    init_query();
+    init_fact_registry();
+    init_fact_registry();
+    conditionCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/utils/playbooks.ts
 import { resolve as resolve8 } from "path";
 import { readdir as readdir4, readFile as readFile7, unlink } from "fs/promises";
@@ -3878,9 +3956,162 @@ var init_help = __esm({
 });
 
 // src/dashboard/session-db.ts
+var session_db_exports = {};
+__export(session_db_exports, {
+  closeSessionDb: () => closeSessionDb,
+  getSessionDb: () => getSessionDb,
+  initSessionDb: () => initSessionDb,
+  isSessionDbInitialized: () => isSessionDbInitialized,
+  migrateFromMarkdown: () => migrateFromMarkdown,
+  resetSessionDb: () => resetSessionDb
+});
 import Database from "better-sqlite3";
 import { resolve as resolve9 } from "path";
 import { readdir as readdir5 } from "fs/promises";
+function initSessionDb(dbPath) {
+  if (db) return db;
+  const finalPath = dbPath ?? resolve9(syntaurRoot(), "syntaur.db");
+  db = new Database(finalPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(SCHEMA_SQL);
+  db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)").run(
+    "schema_version",
+    SCHEMA_VERSION
+  );
+  const database = db;
+  const runMigrations = database.transaction(() => {
+    const vBeforeV2 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV2 === "1") {
+      database.exec(`
+        CREATE TABLE sessions_v2 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v2 SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, NULL, created_at, updated_at FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v2 RENAME TO sessions;
+        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);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '2' WHERE key = 'schema_version';
+      `);
+    }
+    const vBeforeV3 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV3 === "2") {
+      const v2Columns = database.prepare("PRAGMA table_info(sessions)").all();
+      const v2ColNames = v2Columns.map((c) => c.name);
+      const hasProject = v2ColNames.includes("project_slug");
+      const hasMission = v2ColNames.includes("mission_slug");
+      const projectSlugExpr = hasProject && hasMission ? "COALESCE(project_slug, mission_slug)" : hasProject ? "project_slug" : hasMission ? "mission_slug" : null;
+      if (!projectSlugExpr) {
+        throw new Error(
+          "sessions table has neither project_slug nor mission_slug; cannot migrate from v2 to v3"
+        );
+      }
+      database.exec(`
+        CREATE TABLE sessions_v3 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          agent TEXT NOT NULL,
+          started TEXT NOT NULL,
+          ended TEXT,
+          status TEXT NOT NULL DEFAULT 'active',
+          path TEXT,
+          description TEXT,
+          transcript_path TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v3
+          SELECT session_id, ${projectSlugExpr}, assignment_slug, agent, started, ended, status, path, description, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v3 RENAME TO sessions;
+        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);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '3' WHERE key = 'schema_version';
+      `);
+    }
+    const vBeforeV4 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV4 === "3") {
+      database.exec(`
+        CREATE TABLE sessions_v4 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          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,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v4
+          SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, transcript_path, NULL, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v4 RENAME TO sessions;
+        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);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '4' WHERE key = 'schema_version';
+      `);
+    }
+    const vBeforeV5 = database.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get()?.value;
+    if (vBeforeV5 === "4") {
+      database.exec(`
+        CREATE TABLE sessions_v5 (
+          session_id TEXT PRIMARY KEY,
+          project_slug TEXT,
+          assignment_slug TEXT,
+          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,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        INSERT INTO sessions_v5
+          SELECT session_id, project_slug, assignment_slug, agent, started, ended, status, path, description, transcript_path, pid, pid_started_at, NULL, created_at, updated_at
+          FROM sessions;
+        DROP TABLE sessions;
+        ALTER TABLE sessions_v5 RENAME TO sessions;
+        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);
+        CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+        UPDATE meta SET value = '5' WHERE key = 'schema_version';
+      `);
+    }
+  });
+  runMigrations.exclusive();
+  db.exec(POST_MIGRATION_INDEXES_SQL);
+  return db;
+}
+function isSessionDbInitialized() {
+  return db !== null;
+}
 function getSessionDb() {
   if (!db) {
     throw new Error(
@@ -3889,17 +4120,129 @@ function getSessionDb() {
   }
   return db;
 }
-var db;
+function closeSessionDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+function resetSessionDb() {
+  db = null;
+}
+async function migrateFromMarkdown(projectsDir) {
+  const database = getSessionDb();
+  const count = database.prepare("SELECT COUNT(*) as count FROM sessions").get();
+  if (count.count > 0) return 0;
+  if (!await fileExists(projectsDir)) return 0;
+  const entries = await readdir5(projectsDir, { withFileTypes: true });
+  const allSessions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const projectDir = resolve9(projectsDir, entry.name);
+    const indexPath = resolve9(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 (?, ?, ?, ?, ?, ?, ?)
+  `);
+  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);
+    }
+  });
+  insertAll(allSessions);
+  console.log(`Migrated ${allSessions.length} sessions from markdown to SQLite.`);
+  return allSessions.length;
+}
+async function parseMarkdownSessionsIndex(filePath, projectSlug) {
+  const { readFile: readFile12 } = await import("fs/promises");
+  const raw = await readFile12(filePath, "utf-8");
+  const sessions = [];
+  const lines = raw.split("\n");
+  let inTable = false;
+  let headerSeen = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("| Assignment") || trimmed.startsWith("|Assignment")) {
+      inTable = true;
+      headerSeen = false;
+      continue;
+    }
+    if (inTable && !headerSeen && trimmed.match(/^\|[-\s|]+\|$/)) {
+      headerSeen = true;
+      continue;
+    }
+    if (inTable && headerSeen && trimmed.startsWith("|")) {
+      const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+      if (cells.length >= 6) {
+        sessions.push({
+          assignmentSlug: cells[0],
+          agent: cells[1],
+          sessionId: cells[2],
+          started: cells[3],
+          status: cells[4] || "active",
+          path: cells[5],
+          projectSlug
+        });
+      }
+    }
+  }
+  return sessions;
+}
+var db, SCHEMA_VERSION, SCHEMA_SQL, POST_MIGRATION_INDEXES_SQL;
 var init_session_db = __esm({
   "src/dashboard/session-db.ts"() {
     "use strict";
     init_paths();
     init_fs();
     db = null;
+    SCHEMA_VERSION = "5";
+    SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+  session_id TEXT PRIMARY KEY,
+  project_slug TEXT,
+  assignment_slug TEXT,
+  agent TEXT NOT NULL,
+  started TEXT NOT NULL,
+  ended TEXT,
+  status TEXT NOT NULL DEFAULT 'active',
+  path TEXT,
+  description TEXT,
+  transcript_path TEXT,
+  pid INTEGER,
+  pid_started_at TEXT,
+  original_head_sha 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/dashboard/agent-sessions.ts
+var agent_sessions_exports = {};
+__export(agent_sessions_exports, {
+  appendSession: () => appendSession,
+  deleteSessions: () => deleteSessions,
+  getSessionById: () => getSessionById,
+  listAllSessions: () => listAllSessions,
+  listProjectSessions: () => listProjectSessions,
+  listSessionsByAssignment: () => listSessionsByAssignment,
+  parseSessionsIndex: () => parseSessionsIndex,
+  reconcileActiveSessions: () => reconcileActiveSessions,
+  updateSessionStatus: () => updateSessionStatus
+});
 import { readFile as readFile8 } from "fs/promises";
 import { resolve as resolve10 } from "path";
 function rowToSession(row) {
@@ -3919,16 +4262,151 @@ function rowToSession(row) {
     originalHeadSha: row.original_head_sha ?? null
   };
 }
+async function parseSessionsIndex(_projectDir, projectSlug) {
+  const db2 = getSessionDb();
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  return rows.map(rowToSession);
+}
+async function appendSession(_projectDir, session, opts) {
+  const db2 = getSessionDb();
+  db2.prepare(`
+    INSERT INTO sessions (session_id, project_slug, assignment_slug, agent, started, status, path, description, transcript_path, pid, pid_started_at, original_head_sha)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    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,
+      path              = COALESCE(NULLIF(excluded.path, ''),              path),
+      description       = COALESCE(NULLIF(excluded.description, ''),       description),
+      transcript_path   = COALESCE(NULLIF(excluded.transcript_path, ''),   transcript_path),
+      pid               = COALESCE(excluded.pid,                           pid),
+      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
+  );
+}
+async function updateSessionStatus(_projectDir, sessionId, status, endedAt) {
+  const db2 = getSessionDb();
+  const isTerminal = status === "completed" || status === "stopped";
+  const result = isTerminal ? db2.prepare(
+    "UPDATE sessions SET status = ?, ended = COALESCE(?, datetime('now')), updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, endedAt ?? null, sessionId) : db2.prepare(
+    "UPDATE sessions SET status = ?, updated_at = datetime('now') WHERE session_id = ?"
+  ).run(status, sessionId);
+  return result.changes > 0;
+}
+async function listAllSessions(_projectsDir) {
+  const db2 = getSessionDb();
+  const rows = db2.prepare("SELECT * FROM sessions ORDER BY started DESC").all();
+  return rows.map(rowToSession);
+}
 function getSessionById(sessionId) {
   const db2 = getSessionDb();
   const row = db2.prepare("SELECT * FROM sessions WHERE session_id = ? LIMIT 1").get(sessionId);
   return row ? rowToSession(row) : null;
 }
+async function listProjectSessions(_projectsDir, projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  if (assignmentSlug) {
+    const rows2 = db2.prepare(
+      "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+    ).all(projectSlug, assignmentSlug);
+    return rows2.map(rowToSession);
+  }
+  const rows = db2.prepare("SELECT * FROM sessions WHERE project_slug = ? ORDER BY started DESC").all(projectSlug);
+  return rows.map(rowToSession);
+}
+async function deleteSessions(sessionIds) {
+  if (sessionIds.length === 0) return 0;
+  const db2 = getSessionDb();
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const result = db2.prepare(`DELETE FROM sessions WHERE session_id IN (${placeholders})`).run(...sessionIds);
+  return result.changes;
+}
+async function readAssignmentStatusFromPath(assignmentMdPath) {
+  if (!await fileExists(assignmentMdPath)) return null;
+  const raw = await readFile8(assignmentMdPath, "utf-8");
+  const match = raw.match(/^status:\s*(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+async function readAssignmentStatus(projectDir, assignmentSlug) {
+  return readAssignmentStatusFromPath(
+    resolve10(projectDir, "assignments", assignmentSlug, "assignment.md")
+  );
+}
+async function reconcileActiveSessions(projectsDir, assignmentsDir) {
+  const db2 = getSessionDb();
+  const activeSessions = db2.prepare("SELECT * FROM sessions WHERE status = 'active' AND assignment_slug IS NOT NULL").all();
+  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}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (session.project_slug) {
+      const status = await readAssignmentStatus(
+        resolve10(projectsDir, session.project_slug),
+        aslug
+      );
+      if (status) assignmentStatuses.set(key, status);
+    } else if (assignmentsDir) {
+      const status = await readAssignmentStatusFromPath(
+        resolve10(assignmentsDir, aslug, "assignment.md")
+      );
+      if (status) assignmentStatuses.set(key, status);
+    }
+  }
+  let totalUpdated = 0;
+  for (const session of activeSessions) {
+    const projectKey = session.project_slug ?? "__standalone__";
+    const key = `${projectKey}/${session.assignment_slug}`;
+    const assignmentStatus = assignmentStatuses.get(key);
+    if (!assignmentStatus || !DONE_ASSIGNMENT_STATUSES.has(assignmentStatus)) continue;
+    const newStatus = assignmentStatus === "failed" ? "stopped" : "completed";
+    await updateSessionStatus("", session.session_id, newStatus);
+    totalUpdated++;
+  }
+  return totalUpdated;
+}
+async function listSessionsByAssignment(projectSlug, assignmentSlug) {
+  const db2 = getSessionDb();
+  const rows = projectSlug === null ? db2.prepare(
+    "SELECT * FROM sessions WHERE assignment_slug = ? AND project_slug IS NULL ORDER BY started DESC"
+  ).all(assignmentSlug) : db2.prepare(
+    "SELECT * FROM sessions WHERE project_slug = ? AND assignment_slug = ? ORDER BY started DESC"
+  ).all(projectSlug, assignmentSlug);
+  return rows.map(rowToSession);
+}
+var DONE_ASSIGNMENT_STATUSES;
 var init_agent_sessions = __esm({
   "src/dashboard/agent-sessions.ts"() {
     "use strict";
     init_fs();
     init_session_db();
+    DONE_ASSIGNMENT_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "review"]);
   }
 });
 
@@ -4315,7 +4793,8 @@ async function getStatusConfig() {
       derive: config.statuses.derive ?? null,
       facts: config.statuses.facts ?? null,
       factDeclarations: accepted,
-      deriveRegistry: buildDeriveRegistry(accepted)
+      deriveRegistry: buildDeriveRegistry(accepted),
+      queryRegistry: buildQueryRegistry(accepted)
     };
   } else {
     const def = buildDefaultStatusConfig();
@@ -4329,7 +4808,8 @@ async function getStatusConfig() {
       derive: null,
       facts: null,
       factDeclarations: [],
-      deriveRegistry: buildDeriveRegistry([])
+      deriveRegistry: buildDeriveRegistry([]),
+      queryRegistry: buildQueryRegistry([])
     };
   }
   return _cachedConfig;
@@ -5285,12 +5765,6 @@ function parseOpenUrl(input) {
   let prompt;
   if (promptVals.length === 1) {
     const value = promptVals[0];
-    if (/[\r\n]/.test(value)) {
-      throw new OpenUrlError(
-        "invalid-prompt",
-        "`prompt` query param must be a single line (no newlines)"
-      );
-    }
     if (value.length > MAX_OPEN_PROMPT_LENGTH) {
       throw new OpenUrlError(
         "invalid-prompt",
@@ -5656,13 +6130,16 @@ async function resolveSessionPlan(input, terminal) {
     env: process.env,
     agentId: agent.id,
     fallbackWarning,
-    shellFallbackWarning
+    shellFallbackWarning,
+    // Resume continues the SAME session id; fork mints a new one in-agent.
+    session: { sessionId: (input.mode ?? "resume") === "resume" ? session.sessionId : null }
   };
 }
 
 // src/launch/execute.ts
 import { spawn as spawn3 } from "child_process";
-import { basename as basename2 } from "path";
+import { homedir as homedir5 } from "os";
+import { basename as basename2, join as join5, resolve as resolve14 } from "path";
 
 // src/utils/terminal-probe.ts
 import { spawnSync as spawnSync2 } from "child_process";
@@ -5734,6 +6211,52 @@ function resolveCmuxCli(applicationsDirsOverride, cliDirsOverride, lsappinfoRunn
   return null;
 }
 
+// src/launch/execute.ts
+init_fs();
+init_config2();
+
+// src/utils/session-id.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { mkdirSync, readFileSync, statSync as statSync2, writeFileSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+
+// src/utils/process-info.ts
+import { execFileSync } from "child_process";
+function captureProcessStartedAt(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  try {
+    const out = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = out.trim();
+    return trimmed === "" ? null : trimmed;
+  } catch {
+    return null;
+  }
+}
+
+// src/usage/cwd-extractor.ts
+init_paths();
+import { open as open2, readdir as readdir8, stat } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/utils/transcript.ts
+import { open } from "fs/promises";
+
+// src/usage/cwd-extractor.ts
+var TAIL_READ_BYTES = 8 * 1024;
+var TAIL_READ_BYTES_MAX = 64 * 1024;
+
+// src/utils/session-id.ts
+function writeRuntimeMarker(pid, marker, dir) {
+  const path = join4(dir, `${pid}.json`);
+  mkdirSync(dirname3(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(marker));
+}
+
 // src/launch/execute.ts
 var TerminalNotFoundError = class extends Error {
   terminal;
@@ -5777,7 +6300,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       `Spawn failed: ${msg}. Verify the terminal is installed and on PATH.`
     );
   }
-  await new Promise((resolve15, reject) => {
+  await new Promise((resolve16, reject) => {
     let settled = false;
     let stderr = "";
     const finishOk = () => {
@@ -5787,7 +6310,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve15();
+      resolve16();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -5823,6 +6346,57 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
       });
     }
   });
+  await registerLaunchAtBirth(plan, child);
+}
+async function registerLaunchAtBirth(plan, child) {
+  try {
+    const pid = child.pid;
+    if (!pid) return;
+    const autoTrack = (await readConfig()).session.autoTrack;
+    if (autoTrack === "off") return;
+    const sessionId = plan.session?.sessionId ?? null;
+    const procStart = captureProcessStartedAt(pid);
+    const envDir = process.env.SYNTAUR_RUNTIME_SESSIONS_DIR;
+    const markerDir = envDir && envDir.length > 0 ? envDir : join5(homedir5(), ".syntaur", "runtime", "sessions");
+    writeRuntimeMarker(
+      pid,
+      {
+        ...sessionId ? { sessionId } : {},
+        agent: plan.agentId,
+        cwd: plan.cwd,
+        ...procStart ? { procStart } : {},
+        writtenAt: Date.now()
+      },
+      markerDir
+    );
+    if (!sessionId) return;
+    if (autoTrack === "workspaces-only" && !await fileExists(resolve14(plan.cwd, ".syntaur", "context.json"))) {
+      return;
+    }
+    const { initSessionDb: initSessionDb2 } = await Promise.resolve().then(() => (init_session_db(), session_db_exports));
+    const { appendSession: appendSession2 } = await Promise.resolve().then(() => (init_agent_sessions(), agent_sessions_exports));
+    initSessionDb2();
+    await appendSession2(
+      "",
+      {
+        sessionId,
+        projectSlug: null,
+        assignmentSlug: null,
+        agent: plan.agentId,
+        started: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active",
+        path: plan.cwd,
+        description: null,
+        transcriptPath: null,
+        pid,
+        pidStartedAt: procStart,
+        originalHeadSha: null
+      },
+      // Resuming a stopped session IS live-process evidence — we just spawned it.
+      { reviveStopped: true }
+    );
+  } catch {
+  }
 }
 var CMUX_BUNDLE_ID = "com.cmuxterm.app";
 var CMUX_READINESS_MAX_MS = 20 * 250;
@@ -5972,8 +6546,8 @@ function appleScriptString(value) {
 init_paths();
 init_fs();
 import { fileURLToPath } from "url";
-import { dirname as dirname3, resolve as resolve14, join as join3 } from "path";
-import { realpathSync, readFileSync, mkdirSync } from "fs";
+import { dirname as dirname4, resolve as resolve15, join as join6 } from "path";
+import { realpathSync, readFileSync as readFileSync2, mkdirSync as mkdirSync2 } from "fs";
 var NPX_PATTERNS = [
   { kind: "npm", re: /\/_npx\/([^/]+)\/node_modules(?:\/|$)/ },
   { kind: "pnpm", re: /\/pnpm\/dlx\/([^/]+)\/node_modules(?:\/|$)/ },
@@ -5998,7 +6572,7 @@ function normalizeSlashes(p) {
 }
 function detectInstallKind(scriptUrl, opts = {}) {
   const realpath = opts.realpath ?? realpathSync.native;
-  const readFile12 = opts.readFile ?? ((p) => readFileSync(p, "utf-8"));
+  const readFile12 = opts.readFile ?? ((p) => readFileSync2(p, "utf-8"));
   const ua = opts.envUserAgent !== void 0 ? opts.envUserAgent : process.env.npm_config_user_agent ?? "";
   const resolved = resolveScriptPath(scriptUrl, realpath);
   if (resolved === null) {
@@ -6014,14 +6588,14 @@ function detectInstallKind(scriptUrl, opts = {}) {
   if (GLOBAL_PATTERN.test(norm)) {
     return "global";
   }
-  let dir = dirname3(resolved);
+  let dir = dirname4(resolved);
   for (let depth = 0; depth < 8; depth++) {
-    const pkgJsonPath = join3(dir, "package.json");
+    const pkgJsonPath = join6(dir, "package.json");
     let raw;
     try {
       raw = readFile12(pkgJsonPath);
     } catch {
-      const parent2 = dirname3(dir);
+      const parent2 = dirname4(dir);
       if (parent2 === dir) break;
       dir = parent2;
       continue;
@@ -6033,7 +6607,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
       }
     } catch {
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6051,20 +6625,20 @@ function extractNpxHash(scriptUrl, opts = {}) {
   return null;
 }
 function nudgeStampDir() {
-  return resolve14(syntaurRoot(), "npx-handler-nudge");
+  return resolve15(syntaurRoot(), "npx-handler-nudge");
 }
 function sanitizeHash(hash) {
   return hash.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
 }
 function nudgeStampPath(hash) {
-  return join3(nudgeStampDir(), sanitizeHash(hash));
+  return join6(nudgeStampDir(), sanitizeHash(hash));
 }
 async function hasNudgedHash(hash) {
   return fileExists(nudgeStampPath(hash));
 }
 async function recordNudge(hash) {
   try {
-    mkdirSync(nudgeStampDir(), { recursive: true });
+    mkdirSync2(nudgeStampDir(), { recursive: true });
   } catch {
   }
   try {