syntaur 0.45.0 → 0.47.0

package/dist/launch/index.js

@@ -1989,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 ? {
@@ -3338,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"],
@@ -3437,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";
@@ -3503,6 +3509,9 @@ var init_config2 = __esm({
         autoApprove: false,
         autoCreateWorktree: "ask"
       },
+      session: {
+        autoTrack: "all"
+      },
       integrations: {
         claudePluginDir: null,
         codexPluginDir: null,
@@ -3523,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 = {
@@ -3946,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(
@@ -3957,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) {
@@ -3984,19 +4259,155 @@ function rowToSession(row) {
     transcriptPath: row.transcript_path ?? null,
     pid: row.pid ?? null,
     pidStartedAt: row.pid_started_at ?? null,
-    originalHeadSha: row.original_head_sha ?? null
+    originalHeadSha: row.original_head_sha ?? null,
+    updatedAt: row.updated_at ?? null
   };
 }
+async function 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"]);
   }
 });
 
@@ -5720,13 +6131,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";
@@ -5798,6 +6212,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;
@@ -5841,7 +6301,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 = () => {
@@ -5851,7 +6311,7 @@ async function executeLaunchPlan(plan, spawnFn = realSpawn) {
         child.unref();
       } catch {
       }
-      resolve15();
+      resolve16();
     };
     const finishErr = (remediation) => {
       if (settled) return;
@@ -5887,6 +6347,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;
@@ -6036,8 +6547,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(?:\/|$)/ },
@@ -6062,7 +6573,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) {
@@ -6078,14 +6589,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;
@@ -6097,7 +6608,7 @@ function detectInstallKind(scriptUrl, opts = {}) {
       }
     } catch {
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6115,20 +6626,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 {