@phnx-labs/agents-cli 1.20.74 → 1.20.76

package/dist/lib/session/fork.js

@@ -19,6 +19,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { upsertSession } from './db.js';
 import { recordRunName } from './run-names.js';
+import { deriveShortId } from './short-id.js';
 /** Agents that `fork` can branch today (see the module doc for why). */
 export const FORKABLE_AGENTS = ['claude'];
 /** Whether a session's agent can be forked by {@link forkSession}. */
@@ -68,7 +69,7 @@ export function forkSession(source, opts = {}) {
         throw new Error(`transcript not found for session ${source.shortId}: ${source.filePath}`);
     }
     const newId = randomUUID();
-    const shortId = newId.slice(0, 8);
+    const shortId = deriveShortId(newId);
     const dir = path.dirname(source.filePath);
     const filePath = path.join(dir, `${newId}.jsonl`);
     const transcript = fs.readFileSync(source.filePath, 'utf-8');

package/dist/lib/session/hook-sessions.d.ts

@@ -0,0 +1,43 @@
+/** The subset of the hook's on-disk record this reader relies on. Extra fields are ignored. */
+export interface HookSessionRecord {
+    session_id: string;
+    agent?: string;
+    cwd?: string;
+    pid: number;
+    launch_id?: string;
+    terminal_id?: string;
+    ts?: number;
+}
+/** Pre-built lookup maps over one scan of the hook state dir. */
+export interface HookSessionIndex {
+    byLaunchId: Map<string, HookSessionRecord>;
+    byTerminalId: Map<string, HookSessionRecord>;
+    byPid: Map<number, HookSessionRecord>;
+}
+/**
+ * Scan the hook state dir once and index every record by launch_id, terminal_id,
+ * and pid. Returns empty maps if the dir is absent. Newest-by-`ts` wins a key
+ * collision (pid reuse, or a launch id lingering from a since-dead process).
+ */
+export declare function loadHookSessionIndex(): HookSessionIndex;
+export interface ResolveOpts {
+    pid: number;
+    kind: string;
+    launchId?: string;
+    terminalId?: string;
+    /** Immediate child pids of `pid` — the hook records under the agent pid, which
+     *  for a wrapper/shell pid we recorded is a child. */
+    childPids?: number[];
+}
+/**
+ * Resolve an agent's OWN authoritative session id from the hook index. Priority
+ * mirrors the session-tracker's getLiveSession: launchId join (survives pid
+ * divergence — the hook runs under the agent pid, our registry entry may sit on a
+ * tmux pane leaf or cmd.exe wrapper) → terminalId join → direct pid → children.
+ * Every hit is kind-guarded so a stale file at a reused pid can't cross agents.
+ * Undefined until the hook lands (it can lag the spawn) or for hookless harnesses.
+ */
+export declare function resolveHookSessionRecord(index: HookSessionIndex, opts: ResolveOpts): HookSessionRecord | undefined;
+/** The session id alone — see {@link resolveHookSessionRecord} for the full record
+ *  (which also carries the SessionStart `ts` used to stamp `startedAtMs`). */
+export declare function resolveHookSessionId(index: HookSessionIndex, opts: ResolveOpts): string | undefined;

package/dist/lib/session/hook-sessions.js

@@ -0,0 +1,135 @@
+/**
+ * Read-only view of the SessionStart hook's live-session state files.
+ *
+ * The `@agents/session-tracker` hook (installed into each agent's own config)
+ * writes `~/.agents/.cache/terminals/sessions/<pid>.json` AFTER an agent boots,
+ * carrying the agent's OWN authoritative session id (from its SessionStart
+ * payload) plus the join keys `launch_id` / `terminal_id`. It is the only writer
+ * that sees agents `ag run` did NOT launch (you typing `claude` in a terminal),
+ * and the only source of an exact id for non-Claude agents (whose id we can't
+ * know at spawn).
+ *
+ * This module lets `sessions --active` reconcile a `ps`-discovered pid to that
+ * authoritative id. It is deliberately a small hand-rolled reader — the CLI does
+ * NOT import the session-tracker package (a separate, workspace-less package;
+ * see packages/session-tracker/CLAUDE.md) — mirroring the Factory extension's own
+ * hand-copied reader in apps/factory/src/core/liveSession.ts. It only READS the
+ * existing dir/schema; it never writes or moves anything, so it is safe across a
+ * fleet where old hooks and a new CLI coexist.
+ *
+ * The whole state dir is scanned ONCE per active-scan into an index (the listing
+ * path polls every ~3s), and every lookup keys the pre-built maps — never a
+ * re-scan per candidate.
+ */
+import fs from 'fs';
+import path from 'path';
+import { getTerminalsDir } from '../state.js';
+function hookSessionsDir() {
+    // Sibling of the pid-registry's by-pid/ dir. The hook hardcodes this same path
+    // (packages/session-tracker/src/hook.sh); we read it, never move it.
+    return path.join(getTerminalsDir(), 'sessions');
+}
+function parseRecord(raw) {
+    try {
+        const o = JSON.parse(raw);
+        if (o && typeof o === 'object' && typeof o.session_id === 'string' && o.session_id) {
+            return o;
+        }
+    }
+    catch {
+        /* unparseable — treat as absent */
+    }
+    return undefined;
+}
+/** Keep the newest record (by `ts`) when two collide on the same key. Uses the
+ *  same strict `>` tie-break as the session-tracker's own reader (reader.ts). */
+function keepNewest(map, key, rec) {
+    const prev = map.get(key);
+    if (!prev || (rec.ts ?? 0) > (prev.ts ?? 0))
+        map.set(key, rec);
+}
+/**
+ * Scan the hook state dir once and index every record by launch_id, terminal_id,
+ * and pid. Returns empty maps if the dir is absent. Newest-by-`ts` wins a key
+ * collision (pid reuse, or a launch id lingering from a since-dead process).
+ */
+export function loadHookSessionIndex() {
+    const byLaunchId = new Map();
+    const byTerminalId = new Map();
+    const byPid = new Map();
+    let files;
+    try {
+        files = fs.readdirSync(hookSessionsDir()).filter(f => f.endsWith('.json'));
+    }
+    catch {
+        return { byLaunchId, byTerminalId, byPid };
+    }
+    for (const f of files) {
+        let rec;
+        try {
+            rec = parseRecord(fs.readFileSync(path.join(hookSessionsDir(), f), 'utf8'));
+        }
+        catch {
+            /* raced with the hook / pruner — skip */
+        }
+        if (!rec)
+            continue;
+        if (typeof rec.pid === 'number')
+            keepNewest(byPid, rec.pid, rec);
+        if (rec.launch_id)
+            keepNewest(byLaunchId, rec.launch_id, rec);
+        if (rec.terminal_id)
+            keepNewest(byTerminalId, rec.terminal_id, rec);
+    }
+    return { byLaunchId, byTerminalId, byPid };
+}
+/**
+ * True if a hook record's `agent` is compatible with a `ps`-detected kind. Guards
+ * the weak pid/children lookups against a STALE file at a reused pid (a dead
+ * hooked agent's `<pid>.json` inherited by a live hookless agent at the same pid).
+ * Permissive when the record's agent is absent/legacy-`unknown` (never reject on
+ * missing metadata). Normalizes the one known naming gap: `ps` reports Cursor as
+ * `cursor-agent`, the hook records it as `cursor`.
+ */
+function kindMatches(recordAgent, kind) {
+    if (!recordAgent || recordAgent === 'unknown')
+        return true;
+    const norm = (k) => (k === 'cursor-agent' ? 'cursor' : k);
+    return norm(recordAgent) === norm(kind);
+}
+/**
+ * Resolve an agent's OWN authoritative session id from the hook index. Priority
+ * mirrors the session-tracker's getLiveSession: launchId join (survives pid
+ * divergence — the hook runs under the agent pid, our registry entry may sit on a
+ * tmux pane leaf or cmd.exe wrapper) → terminalId join → direct pid → children.
+ * Every hit is kind-guarded so a stale file at a reused pid can't cross agents.
+ * Undefined until the hook lands (it can lag the spawn) or for hookless harnesses.
+ */
+export function resolveHookSessionRecord(index, opts) {
+    const { pid, kind, launchId, terminalId, childPids } = opts;
+    const take = (rec) => rec?.session_id && kindMatches(rec.agent, kind) ? rec : undefined;
+    if (launchId) {
+        const hit = take(index.byLaunchId.get(launchId));
+        if (hit)
+            return hit;
+    }
+    if (terminalId) {
+        const hit = take(index.byTerminalId.get(terminalId));
+        if (hit)
+            return hit;
+    }
+    const direct = take(index.byPid.get(pid));
+    if (direct)
+        return direct;
+    for (const c of childPids ?? []) {
+        const hit = take(index.byPid.get(c));
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+/** The session id alone — see {@link resolveHookSessionRecord} for the full record
+ *  (which also carries the SessionStart `ts` used to stamp `startedAtMs`). */
+export function resolveHookSessionId(index, opts) {
+    return resolveHookSessionRecord(index, opts)?.session_id;
+}

package/dist/lib/session/linear.d.ts

@@ -0,0 +1,6 @@
+/** The configured Linear workspace slug, or undefined when unknown. Cached per process. */
+export declare function linearWorkspace(): string | undefined;
+/** Canonical Linear issue URL for a tracker key, or undefined if unresolvable. */
+export declare function linearIssueUrl(ticketId?: string): string | undefined;
+/** Clear the cached workspace lookup. Tests only. */
+export declare function _resetLinearWorkspaceCache(): void;

package/dist/lib/session/linear.js

@@ -0,0 +1,55 @@
+/**
+ * Resolve a clickable Linear issue URL for a tracker key (e.g. `RUSH-1234`).
+ *
+ * Linear issue URLs are workspace-scoped — `https://linear.app/<workspace>/issue/<KEY>`
+ * — so a bare key can't be linked without knowing the workspace slug (Linear's
+ * `organization.urlKey`). That slug is resolved config-first, never hardcoded:
+ *
+ *   1. `LINEAR_WORKSPACE` env var — explicit override, else
+ *   2. `workspaceUrlKey` in the linear-cli config (`~/.linear-cli/config.json`).
+ *
+ * When neither is set the ticket stays plain text — it's still shown, just not
+ * linked. This keeps the OSS CLI free of any Rush/workspace-specific string.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** A Linear tracker key: `TEAM-N`, e.g. `RUSH-1234`. Mirrors the detector's shape. */
+const LINEAR_KEY_RE = /^[A-Z]{2,6}-\d{1,6}$/;
+// `undefined` = not yet resolved; `null` = resolved-but-unknown (skip re-reading).
+let workspaceCache;
+/** The configured Linear workspace slug, or undefined when unknown. Cached per process. */
+export function linearWorkspace() {
+    if (workspaceCache !== undefined)
+        return workspaceCache ?? undefined;
+    const env = process.env.LINEAR_WORKSPACE?.trim();
+    if (env) {
+        workspaceCache = env;
+        return env;
+    }
+    try {
+        const cfgPath = path.join(os.homedir(), '.linear-cli', 'config.json');
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+        const ws = cfg.workspaceUrlKey?.trim();
+        if (ws) {
+            workspaceCache = ws;
+            return ws;
+        }
+    }
+    catch {
+        // no linear-cli config (or unreadable) — leave tickets unlinked
+    }
+    workspaceCache = null;
+    return undefined;
+}
+/** Canonical Linear issue URL for a tracker key, or undefined if unresolvable. */
+export function linearIssueUrl(ticketId) {
+    if (!ticketId || !LINEAR_KEY_RE.test(ticketId))
+        return undefined;
+    const ws = linearWorkspace();
+    return ws ? `https://linear.app/${ws}/issue/${ticketId}` : undefined;
+}
+/** Clear the cached workspace lookup. Tests only. */
+export function _resetLinearWorkspaceCache() {
+    workspaceCache = undefined;
+}

package/dist/lib/session/migrate-targets.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Target enumeration + `--auto` scorer for `agents sessions migrate` (RUSH-1977).
+ *
+ * `sessions migrate` relocates a running session onto another machine. This
+ * module is the pure decision layer: given the fleet (enrolled hosts + devices
+ * from `listAllHosts()`), their live headroom ({@link Headroom} buckets derived
+ * from `probeFleetStats()` / the disk stats-cache), and the reusable ephemeral
+ * crabbox boxes (`reusableBoxes()`), it enumerates eligible {@link MigrateTarget}s
+ * and ranks them for `--auto`.
+ *
+ * Kept side-effect-free (no ssh, no disk, no clock) so the ranking is a unit test
+ * against synthetic Host[]/DeviceStats — the command layer does the probing and
+ * hands the results in. The one genuine-bug guard the test pins: the source and
+ * the interactive machine (os.hostname()) are never offered as targets.
+ */
+import type { Host } from '../hosts/types.js';
+import type { DeviceStats, Headroom } from '../devices/health.js';
+import type { CrabboxBox } from '../crabbox/cli.js';
+/** A machine the current session could be relocated onto. */
+export interface MigrateTarget {
+    /** The `--host` value: a host/device name, or a warm box slug for ephemeral. */
+    name: string;
+    /** Where the target comes from — a fleet host/device, or a warm crabbox box. */
+    kind: 'fleet' | 'ephemeral';
+    /** Captured OS string ('darwin'/'linux'/'windows'/…) when known, for platform-match ranking. */
+    os?: string;
+    /** Live headroom bucket ('idle' is best); 'unknown' when no stats resolved. */
+    headroom: Headroom;
+    /** The underlying host (fleet targets only). */
+    host?: Host;
+    /** The underlying warm box (ephemeral targets only). */
+    box?: CrabboxBox;
+}
+/** Inputs the scorer needs about the session being moved and this machine. */
+export interface MigrateContext {
+    /** os.hostname() of the interactive machine — never a valid target. */
+    selfHostname: string;
+    /** The source session's host (machine it currently runs on) — never a valid target. */
+    sourceHostname?: string;
+    /** The source session's OS, for the platform-match bonus. */
+    sourceOs?: string;
+}
+/**
+ * Enumerate the fleet + ephemeral targets a session could move to, excluding the
+ * interactive machine and the source. A fleet host is eligible only when it is
+ * dispatchable and not obviously offline; ephemeral (warm) boxes are always
+ * eligible (already provisioned and reachable). `statsByName` supplies live
+ * headroom — a missing entry yields 'unknown' (still eligible, just ranked lower).
+ */
+export declare function enumerateTargets(hosts: Host[], warmBoxes: CrabboxBox[], statsByName: Map<string, DeviceStats>, ctx: MigrateContext): MigrateTarget[];
+/**
+ * Rank targets for `--auto`. Order:
+ *   1. Platform match with the source (a faithful --resume wants the same OS family).
+ *   2. Fleet before ephemeral (prefer a warm worker over spinning a box).
+ *   3. Headroom (idle > light > busy > loaded > unknown).
+ *   4. Name, for a stable tie-break.
+ * Returns a new sorted array; does not mutate the input.
+ */
+export declare function rankTargets(targets: MigrateTarget[], ctx: MigrateContext): MigrateTarget[];
+/**
+ * Pick the single best `--auto` target, or null when nothing is eligible. A
+ * fully-loaded ('loaded') fleet is still returned (better than failing the
+ * migrate); the command layer can offer `--lease` when this is null.
+ */
+export declare function pickBestTarget(hosts: Host[], warmBoxes: CrabboxBox[], statsByName: Map<string, DeviceStats>, ctx: MigrateContext): MigrateTarget | null;

package/dist/lib/session/migrate-targets.js

@@ -0,0 +1,94 @@
+import { headroom } from '../devices/health.js';
+/** Headroom rank: lower is better (idle preferred). 'unknown' sorts last among reachable. */
+const HEADROOM_ORDER = {
+    idle: 0,
+    light: 1,
+    busy: 2,
+    loaded: 3,
+    unknown: 4,
+};
+/** Normalize an os string to a coarse platform token for match comparison. */
+function platformOf(os) {
+    if (!os)
+        return undefined;
+    const s = os.toLowerCase();
+    if (s.includes('darwin') || s.includes('mac'))
+        return 'darwin';
+    if (s.includes('win'))
+        return 'windows';
+    if (s.includes('linux'))
+        return 'linux';
+    return s;
+}
+/**
+ * Enumerate the fleet + ephemeral targets a session could move to, excluding the
+ * interactive machine and the source. A fleet host is eligible only when it is
+ * dispatchable and not obviously offline; ephemeral (warm) boxes are always
+ * eligible (already provisioned and reachable). `statsByName` supplies live
+ * headroom — a missing entry yields 'unknown' (still eligible, just ranked lower).
+ */
+export function enumerateTargets(hosts, warmBoxes, statsByName, ctx) {
+    const excluded = new Set([ctx.selfHostname, ctx.sourceHostname].filter((n) => !!n).map((n) => n.toLowerCase()));
+    const fleet = [];
+    for (const host of hosts) {
+        if (excluded.has(host.name.toLowerCase()))
+            continue;
+        // dispatchable is absent-means-yes; only an explicit false is disqualifying.
+        if (host.dispatchable === false)
+            continue;
+        if (host.status === 'offline')
+            continue;
+        fleet.push({
+            name: host.name,
+            kind: 'fleet',
+            os: host.os,
+            headroom: headroom(statsByName.get(host.name)),
+            host,
+        });
+    }
+    const ephemeral = warmBoxes.map((box) => ({
+        name: box.slug,
+        kind: 'ephemeral',
+        // crabbox boxes are Linux; the address is resolved at use time.
+        os: 'linux',
+        headroom: headroom(statsByName.get(box.slug)),
+        box,
+    }));
+    return [...fleet, ...ephemeral];
+}
+/**
+ * Rank targets for `--auto`. Order:
+ *   1. Platform match with the source (a faithful --resume wants the same OS family).
+ *   2. Fleet before ephemeral (prefer a warm worker over spinning a box).
+ *   3. Headroom (idle > light > busy > loaded > unknown).
+ *   4. Name, for a stable tie-break.
+ * Returns a new sorted array; does not mutate the input.
+ */
+export function rankTargets(targets, ctx) {
+    const srcPlatform = platformOf(ctx.sourceOs);
+    const score = (t) => {
+        const platformMatch = srcPlatform && platformOf(t.os) === srcPlatform ? 0 : 1;
+        const kindRank = t.kind === 'fleet' ? 0 : 1;
+        return { platformMatch, kindRank, headroomRank: HEADROOM_ORDER[t.headroom], name: t.name };
+    };
+    return [...targets].sort((a, b) => {
+        const sa = score(a);
+        const sb = score(b);
+        if (sa.platformMatch !== sb.platformMatch)
+            return sa.platformMatch - sb.platformMatch;
+        if (sa.kindRank !== sb.kindRank)
+            return sa.kindRank - sb.kindRank;
+        if (sa.headroomRank !== sb.headroomRank)
+            return sa.headroomRank - sb.headroomRank;
+        return sa.name.localeCompare(sb.name);
+    });
+}
+/**
+ * Pick the single best `--auto` target, or null when nothing is eligible. A
+ * fully-loaded ('loaded') fleet is still returned (better than failing the
+ * migrate); the command layer can offer `--lease` when this is null.
+ */
+export function pickBestTarget(hosts, warmBoxes, statsByName, ctx) {
+    const ranked = rankTargets(enumerateTargets(hosts, warmBoxes, statsByName, ctx), ctx);
+    return ranked[0] ?? null;
+}

package/dist/lib/session/migrations.d.ts

@@ -0,0 +1,37 @@
+export type MigrationMode = 'resume' | 'rehydrate';
+export interface MigrationEndpoint {
+    host: string;
+    cwd?: string;
+    /** tmux pane on the source; ephemeral box slug on the target. */
+    pane?: string;
+    box?: string;
+}
+export interface MigrationRecord {
+    sessionId: string;
+    shortId: string;
+    agent: string;
+    mode: MigrationMode;
+    /** true = move (the source was stopped); false = copy (--keep). */
+    move: boolean;
+    from: MigrationEndpoint;
+    to: MigrationEndpoint;
+    /** WIP branch the working tree was committed to before the move, if any. */
+    branch?: string;
+    /** Draft PR opened for that branch, if any. */
+    wipPr?: string;
+    /** ISO timestamp — passed in by the caller (the CLI has a real clock). */
+    at: string;
+    status: 'completed' | 'failed';
+    error?: string;
+}
+export declare function migrationsLedgerPath(): string;
+/**
+ * Append one migration event. A ledger write must never break a migration that
+ * otherwise succeeded, so a write failure is a visible warning, not a throw.
+ * `file` is injectable for tests; production uses the default ledger path.
+ */
+export declare function recordMigration(rec: MigrationRecord, file?: string): void;
+/** Read the whole ledger, oldest first. Blank/corrupt JSONL lines are skipped. */
+export declare function readMigrations(file?: string): MigrationRecord[];
+/** The most recent completed migration for a session id, or undefined. */
+export declare function latestForSession(sessionId: string, file?: string): MigrationRecord | undefined;

package/dist/lib/session/migrations.js

@@ -0,0 +1,60 @@
+/**
+ * Migration ledger (RUSH-1977) — an append-only record of every
+ * `agents sessions migrate`, so a session handed off to another machine stays
+ * trackable: where it went, when, in which mode, move vs copy, and the WIP
+ * branch/PR its working tree was parked on.
+ *
+ * Append-only JSONL under the already-synced `~/.agents/.history`, so the source
+ * and target machines converge on the same trail. One line per event; a session
+ * that hops A→B→C leaves three lines — that ordered history IS the lineage, which
+ * is why this is an event log, not a mutable field on the session.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { homeDir } from '../platform/paths.js';
+export function migrationsLedgerPath() {
+    return path.join(homeDir(), '.agents', '.history', 'migrations.jsonl');
+}
+/**
+ * Append one migration event. A ledger write must never break a migration that
+ * otherwise succeeded, so a write failure is a visible warning, not a throw.
+ * `file` is injectable for tests; production uses the default ledger path.
+ */
+export function recordMigration(rec, file = migrationsLedgerPath()) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify(rec) + '\n');
+    }
+    catch (err) {
+        console.error(chalk.yellow(`  Could not write the migration ledger (${err.message}).`));
+    }
+}
+/** Read the whole ledger, oldest first. Blank/corrupt JSONL lines are skipped. */
+export function readMigrations(file = migrationsLedgerPath()) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return []; // no ledger yet
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            out.push(JSON.parse(s));
+        }
+        catch {
+            // A single partial line (interrupted append) must not sink the whole read.
+        }
+    }
+    return out;
+}
+/** The most recent completed migration for a session id, or undefined. */
+export function latestForSession(sessionId, file = migrationsLedgerPath()) {
+    const recs = readMigrations(file).filter((r) => r.sessionId === sessionId && r.status === 'completed');
+    return recs.length ? recs[recs.length - 1] : undefined;
+}

package/dist/lib/session/parse.d.ts

@@ -72,6 +72,24 @@ export declare function parseAntigravity(dbPath: string): SessionEvent[];
  * Messages have role (user/assistant) and metadata.
  * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
  */
+/**
+ * Parse a Grok (xAI CLI) session into normalized events.
+ *
+ * A Grok session dir holds several files; the conversation transcript is
+ * `chat_history.jsonl`, one JSON object per line with a `type`:
+ *   - `system`       — the system prompt (skipped; not conversational)
+ *   - `user`         — `content` is an array of `{ type: 'text', text }` blocks
+ *   - `assistant`    — `content` is a string, plus a `tool_calls[]` array of
+ *                      `{ id, name, arguments }` (arguments is a JSON string)
+ *   - `reasoning`    — chain-of-thought; text (when present) lives in `summary`
+ *   - `tool_result`  — `{ tool_call_id, content }`, correlated back to the call
+ *
+ * The scanner records `summary.json` as the session's filePath (see
+ * `readGrokMeta` in discover.ts), so resolve `chat_history.jsonl` from the same
+ * dir; also accept being handed the transcript file directly. Per-line
+ * timestamps aren't stored, so every event carries the session's `created_at`
+ * (from summary.json), falling back to the transcript's mtime.
+ */
 export declare function parseGrok(filePath: string): SessionEvent[];
 export declare function parseOpenCode(filePath: string): SessionEvent[];
 /** Parse a Rush JSONL session file into normalized events. */