@phnx-labs/agents-cli 1.22.56 → 1.22.58

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

@@ -54,14 +54,7 @@ export interface DiscoverOptions {
     idExact?: string;
     /** Session id prefix — a targeted indexed lookup with no scan (RUSH-2477). */
     idPrefix?: string;
-    /**
-     * Cold-miss repair: when another live process already holds the scan claim,
-     * wait (bounded) for that in-flight scan to finish before reading the index,
-     * instead of returning the pre-scan snapshot (RUSH-2682). A caller repairing a
-     * "not indexed yet" miss wants the fresh result the concurrent scan is about to
-     * write, not the stale read that just missed. Ignored when THIS process wins
-     * the claim (it scans itself) or no scan is in progress.
-     */
+    /** On a cold miss, briefly await the scan already holding the single-flight claim. */
     waitForScan?: boolean;
 }
 /** Progress report emitted during incremental scanning. */
@@ -181,41 +174,15 @@ export declare function discoverSessions(options?: DiscoverOptions): Promise<Ses
 interface IncrementalScanResult {
     /** True when this process won the single-flight claim and ran the scan. */
     claimed: boolean;
-    /**
-     * Transcripts parsed this scan — i.e. those whose (mtime, size) changed. Zero
-     * is the steady state on an idle box and does NOT mean the scan was skipped;
-     * read `claimed` for that.
-     *
-     * Twelve of the 13 SESSION_AGENTS contribute, including OpenCode, whose
-     * scanner filters to sessions whose own per-session stamp changed and reports
-     * that batch — so a tick whose only changed sessions live there no longer
-     * reports 0 (RUSH-2691). OpenClaw is the exception and contributes nothing:
-     * its scanner has no change detection to report (a TTL gate, a fresh stamp
-     * every run, and an entry list rebuilt as the current inventory), so counting
-     * it would overstate rather than measure. See `scanOpenClawIncremental`.
-     */
+    /** Changed transcripts parsed; zero with `claimed: true` is a successful no-op scan. */
     scanned: number;
 }
-/**
- * The write half of {@link discoverSessions}: claim the single-flight scan slot,
- * incrementally index this host's transcript dirs, and report what was parsed.
- *
- * Split out so a caller that only wants the index refreshed — the daemon's warm
- * tick — can run it WITHOUT the listing query `discoverSessions` ends with. That
- * query is not free: it applies a cwd filter, runs the `archived_at`-writing
- * existence check, and can issue a Linear fetch, none of which index anything
- * (RUSH-2691). Keeping one implementation here is also what stops the tick and
- * the foreground path from drifting apart.
- */
+/** Separate write half so daemon warming does not pay for listing or external enrichment. */
 export declare function scanSessionsIncremental(options?: {
     agent?: SessionAgentId;
     onProgress?: (p: ScanProgress) => void;
 }): Promise<IncrementalScanResult>;
-/**
- * Poll until no live process holds the scan claim, or the bound elapses
- * (RUSH-2682). Bounded so a wedged/slow scan can never hang a foreground preview.
- * Exported for the cold-miss repair test.
- */
+/** Bounded wait so a wedged scan cannot hang a foreground cold-miss repair. */
 export declare function waitForScanToSettle(timeoutMs?: number, pollMs?: number): Promise<boolean>;
 /** Read the current SQLite snapshot without scanning or parsing transcript files. */
 export declare function queryIndexedSessions(options?: DiscoverOptions, indexedOptions?: {
@@ -223,27 +190,8 @@ export declare function queryIndexedSessions(options?: DiscoverOptions, indexedO
     skipExistenceCheck?: boolean;
 }): Promise<SessionMeta[]>;
 /**
- * Resolve a full-or-partial session id against the LOCAL SQLite index only.
- *
- * A plain WAL read through `queryIndexedSessions` — same origin-machine
- * attribution and managed scoping every indexed read gets — with NO incremental
- * discovery scan (so none of `tryClaimScan`/`releaseScan`'s `BEGIN IMMEDIATE`
- * writer lock) and NO fleet SSH fan-out. This is the crash-restart storm path
- * (RUSH-2477): dozens of `sessions resume <id>` at once for a known local id must
- * each be a cheap read, never a writer-lock contender or a dial into the
- * not-yet-up tailnet. Exact id first, then prefix (matching `findSessionsById`),
- * so a complete id never also drags in its prefix siblings. Returns `[]` on a
- * genuine local miss, leaving the caller to fall back to the fleet resolver.
- *
- * The existence check is left ON (`skipExistenceCheck: false`), exactly as the old
- * `discoverSessions` path and `findSessionsById` do (RUSH-2436): it KEEPS a
- * file-gone session whose user turns still live in `session_text` (flagged
- * archived) and SUPPRESSES a contentless phantom — so a phantom id misses here and
- * falls through to the fleet resolver, instead of resolving to a row with no real
- * transcript to resume. For a present transcript — the storm's actual case, since
- * the crashed tabs' files are on disk — the check does no writes, so the lock-free
- * guarantee holds; it only writes to (un)archive a genuinely missing or resurrected
- * file, which is not the 20-at-once resume path.
+ * Resolve locally without scanning or fleet I/O, keeping concurrent crash recovery lock-light.
+ * The existence check preserves archived content while rejecting transcriptless phantoms.
  */
 export declare function resolveIndexedSessionById(idQuery: string): Promise<SessionMeta[]>;
 /**

package/dist/lib/session/discover.js

@@ -131,12 +131,7 @@ async function applyJsonlAppend(filePath, fromOffset, wasDroppingOversizedLine,
  * between `agents sessions` calls but is still being written to.
  */
 const HOT_FILE_WINDOW_MS = 600_000;
-/**
- * Kill-switch: set `AGENTS_SESSIONS_NO_DIR_LEDGER=1` to force the old full-walk
- * path (readdir + per-file stat every dir, every run — the pre-A-2 behavior),
- * skipping the dir_ledger short-circuit entirely. One env var reverts a field
- * regression to today's behavior.
- */
+/** Emergency kill-switch for the directory-ledger optimization. */
 function dirLedgerDisabled() {
     const v = process.env.AGENTS_SESSIONS_NO_DIR_LEDGER;
     return v === '1' || v === 'true';
@@ -175,17 +170,7 @@ export async function discoverSessions(options) {
         skipExistenceCheck: options?.skipExistenceCheck ?? false,
     });
 }
-/**
- * The write half of {@link discoverSessions}: claim the single-flight scan slot,
- * incrementally index this host's transcript dirs, and report what was parsed.
- *
- * Split out so a caller that only wants the index refreshed — the daemon's warm
- * tick — can run it WITHOUT the listing query `discoverSessions` ends with. That
- * query is not free: it applies a cwd filter, runs the `archived_at`-writing
- * existence check, and can issue a Linear fetch, none of which index anything
- * (RUSH-2691). Keeping one implementation here is also what stops the tick and
- * the foreground path from drifting apart.
- */
+/** Separate write half so daemon warming does not pay for listing or external enrichment. */
 export async function scanSessionsIncremental(options) {
     // Touch the DB so the schema is ready and connection is cached for this run.
     getDB();
@@ -222,11 +207,7 @@ export async function scanSessionsIncremental(options) {
         scanned += n;
     return { claimed: true, scanned };
 }
-/**
- * Poll until no live process holds the scan claim, or the bound elapses
- * (RUSH-2682). Bounded so a wedged/slow scan can never hang a foreground preview.
- * Exported for the cold-miss repair test.
- */
+/** Bounded wait so a wedged scan cannot hang a foreground cold-miss repair. */
 export async function waitForScanToSettle(timeoutMs = WAIT_FOR_SCAN_TIMEOUT_MS, pollMs = WAIT_FOR_SCAN_POLL_MS) {
     const deadline = Date.now() + timeoutMs;
     while (scanInProgressByLivePid()) {
@@ -259,27 +240,8 @@ export async function queryIndexedSessions(options, indexedOptions = {}) {
     return scopeToManaged(sessions, agents, options);
 }
 /**
- * Resolve a full-or-partial session id against the LOCAL SQLite index only.
- *
- * A plain WAL read through `queryIndexedSessions` — same origin-machine
- * attribution and managed scoping every indexed read gets — with NO incremental
- * discovery scan (so none of `tryClaimScan`/`releaseScan`'s `BEGIN IMMEDIATE`
- * writer lock) and NO fleet SSH fan-out. This is the crash-restart storm path
- * (RUSH-2477): dozens of `sessions resume <id>` at once for a known local id must
- * each be a cheap read, never a writer-lock contender or a dial into the
- * not-yet-up tailnet. Exact id first, then prefix (matching `findSessionsById`),
- * so a complete id never also drags in its prefix siblings. Returns `[]` on a
- * genuine local miss, leaving the caller to fall back to the fleet resolver.
- *
- * The existence check is left ON (`skipExistenceCheck: false`), exactly as the old
- * `discoverSessions` path and `findSessionsById` do (RUSH-2436): it KEEPS a
- * file-gone session whose user turns still live in `session_text` (flagged
- * archived) and SUPPRESSES a contentless phantom — so a phantom id misses here and
- * falls through to the fleet resolver, instead of resolving to a row with no real
- * transcript to resume. For a present transcript — the storm's actual case, since
- * the crashed tabs' files are on disk — the check does no writes, so the lock-free
- * guarantee holds; it only writes to (un)archive a genuinely missing or resurrected
- * file, which is not the 20-at-once resume path.
+ * Resolve locally without scanning or fleet I/O, keeping concurrent crash recovery lock-light.
+ * The existence check preserves archived content while rejecting transcriptless phantoms.
  */
 export async function resolveIndexedSessionById(idQuery) {
     const q = idQuery.trim();

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

@@ -1,32 +1,51 @@
+/**
+ * Session forking — branch an existing conversation into a new, independent
+ * sibling that continues the work, leaving the original untouched.
+ *
+ * `resume` continues the SAME conversation (same id, same file — it appends).
+ * `fork` launches a NEW same-harness session, load-balanced, seeded with a
+ * recap of the source so it picks up where the original left off. This is the
+ * "git branch" of conversations.
+ *
+ * The recap — not a transcript copy — is what makes fork work across every
+ * device and every REPL harness: the sibling is handed plain text as its opening
+ * input, so it never has to reach a transcript that may live on another box. The
+ * source is resolved cross-fleet by the same resolver `preview` uses; this module
+ * owns only the pure recap text the resolved data folds into.
+ */
 import type { SessionMeta } from './types.js';
-/** Agents that `fork` can branch today (see the module doc for why). */
-export declare const FORKABLE_AGENTS: readonly ["claude"];
-/** Whether a session's agent can be forked by {@link forkSession}. */
-export declare function isForkableAgent(agent: string): boolean;
-/** Outcome of a successful fork. */
-export interface ForkResult {
-    /** The new session's full id. */
-    newId: string;
-    /** The new session's short id (first 8 chars), for display/resume. */
-    shortId: string;
-    /** Absolute path of the copied transcript. */
-    filePath: string;
-    /** The label applied to the fork. */
+/** File-change tally as `sessions preview --json` serializes it (digest.changes). */
+export interface ForkRecapChanges {
+    created: number;
+    modified: number;
+    deleted: number;
+}
+/** Everything the recap seed is built from — resolved cross-fleet before launch. */
+export interface ForkRecapInput {
+    /** Source harness id — the sibling launches the same one. */
+    agent: string;
+    /** Display label for the source (label → topic → short id, resolved by the caller). */
     label: string;
+    /** Source working directory, so the sibling re-roots itself. */
+    cwd?: string;
+    /** Linear/GitHub ticket the source was bound to, if any. */
+    ticketId?: string;
+    /** Device that owns the source transcript, for the `/continue` escape hatch. */
+    machine?: string;
+    /** Short + full id, so the sibling can pull full history with `/continue <id>`. */
+    shortId: string;
+    id: string;
+    /** The source's last assistant line — the single best "where it left off" signal. */
+    lastAssistant?: string;
+    /** Changed-files tally so far. */
+    changes?: ForkRecapChanges;
 }
+/** Resolve the human display label the caller passes in from a raw SessionMeta. */
+export declare function forkLabelFor(session: Pick<SessionMeta, 'label' | 'topic' | 'shortId'>): string;
 /**
- * Fork a Claude session into a new, independent one.
- *
- * Copies `source.filePath` to a new `<uuid>.jsonl` beside it, rewrites the
- * embedded session id, registers the new session in the index, and records a
- * `--name`-style label. Returns the new ids/path. Throws if the source
- * transcript is missing.
+ * Build the recap-seed prompt handed to the forked sibling as its opening input.
  *
- * @param source  The resolved metadata of the session being forked.
- * @param opts.name  Optional explicit label; defaults to `fork of <original>`.
- * @param now  ISO timestamp to stamp the fork with (injectable for tests).
+ * Pure and deterministic (unit-tested) — no filesystem, no spawn — so the launch
+ * orchestration in `commands/fork.ts` stays the only side-effecting layer.
  */
-export declare function forkSession(source: SessionMeta, opts?: {
-    name?: string;
-    now?: string;
-}): ForkResult;
+export declare function buildForkRecap(input: ForkRecapInput): string;

package/dist/lib/session/fork.js

@@ -1,102 +1,39 @@
-/**
- * Session forking — branch an existing conversation into a new, independent
- * session that can be continued separately, leaving the original untouched.
- *
- * `resume` continues the SAME conversation (same id, same file — it appends).
- * `fork` copies the transcript under a FRESH session id, so continuing the fork
- * diverges from the original instead of mutating it. This is the "git branch"
- * of conversations.
- *
- * v1 supports Claude, whose session id IS its `<id>.jsonl` filename and which
- * resumes natively via `--resume`. A fork is therefore: copy the transcript to
- * a new-uuid filename in the same directory, rewrite the embedded `sessionId`
- * on each line, register the new session in the index, and label it. Other
- * agents (codex single-file; grok/kimi multi-file; opencode DB-only) are a
- * natural follow-up and are refused up front for now.
- */
-import { randomUUID } from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-import { upsertSession } from './db.js';
-import { recordRunName } from './run-names.js';
-import { deriveShortId } from '../text/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}. */
-export function isForkableAgent(agent) {
-    return FORKABLE_AGENTS.includes(agent);
+/** Longest last-assistant excerpt carried into the seed — enough to convey intent
+ * without pasting a wall of text (decision: Recap, not Full digest). */
+const LAST_LINE_CAP = 400;
+/** Collapse whitespace and cap length so a multi-paragraph final message becomes
+ * one scannable recap line. */
+function trimLastLine(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    if (collapsed.length <= LAST_LINE_CAP)
+        return collapsed;
+    return `${collapsed.slice(0, LAST_LINE_CAP).trimEnd()}…`;
 }
-/**
- * Rewrite the per-line `sessionId` field of a Claude JSONL transcript to a new
- * id. Claude resolves a conversation by its filename, so this is belt-and-braces
- * (keeps the in-file id consistent with the new filename); malformed lines are
- * passed through untouched.
- */
-function rewriteSessionId(transcript, newId) {
-    return transcript
-        .split('\n')
-        .map((line) => {
-        if (!line.trim())
-            return line;
-        try {
-            const obj = JSON.parse(line);
-            if (typeof obj.sessionId === 'string') {
-                obj.sessionId = newId;
-                return JSON.stringify(obj);
-            }
-            return line;
-        }
-        catch {
-            return line;
-        }
-    })
-        .join('\n');
+/** Resolve the human display label the caller passes in from a raw SessionMeta. */
+export function forkLabelFor(session) {
+    return session.label || session.topic || session.shortId;
 }
 /**
- * Fork a Claude session into a new, independent one.
- *
- * Copies `source.filePath` to a new `<uuid>.jsonl` beside it, rewrites the
- * embedded session id, registers the new session in the index, and records a
- * `--name`-style label. Returns the new ids/path. Throws if the source
- * transcript is missing.
+ * Build the recap-seed prompt handed to the forked sibling as its opening input.
  *
- * @param source  The resolved metadata of the session being forked.
- * @param opts.name  Optional explicit label; defaults to `fork of <original>`.
- * @param now  ISO timestamp to stamp the fork with (injectable for tests).
+ * Pure and deterministic (unit-tested) — no filesystem, no spawn — so the launch
+ * orchestration in `commands/fork.ts` stays the only side-effecting layer.
  */
-export function forkSession(source, opts = {}) {
-    if (!fs.existsSync(source.filePath)) {
-        throw new Error(`transcript not found for session ${source.shortId}: ${source.filePath}`);
+export function buildForkRecap(input) {
+    const lines = [];
+    lines.push(`Continue a prior ${input.agent} session ("${input.label}"). Pick up where it left off — do not restart it.`);
+    if (input.cwd)
+        lines.push(`Working directory: ${input.cwd}`);
+    if (input.ticketId)
+        lines.push(`Ticket: ${input.ticketId}`);
+    const last = input.lastAssistant ? trimLastLine(input.lastAssistant) : '';
+    if (last)
+        lines.push(`It last said: "${last}"`);
+    const chg = input.changes;
+    if (chg && (chg.created || chg.modified || chg.deleted)) {
+        lines.push(`Changes so far: +${chg.created} ~${chg.modified} -${chg.deleted}.`);
     }
-    const newId = randomUUID();
-    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');
-    const rewritten = rewriteSessionId(transcript, newId);
-    fs.writeFileSync(filePath, rewritten);
-    const original = source.label || source.topic || source.shortId;
-    const label = opts.name || `fork of ${original}`;
-    // Label sidecar (seeds the DB label; survives rescans until an agent title
-    // supersedes it), mirroring `agents run --name`.
-    recordRunName({ sessionId: newId, name: label, agent: source.agent, cwd: source.cwd });
-    // Register the new session so it resolves immediately (by `agents sessions resume`,
-    // `agents sessions`, etc.) without waiting for the next scan.
-    const stamp = opts.now ?? new Date().toISOString();
-    const meta = {
-        ...source,
-        id: newId,
-        shortId,
-        filePath,
-        label,
-        timestamp: stamp,
-        lastActivity: stamp,
-        // The fork has not opened its own PR / team; drop origin-specific refs.
-        prUrl: undefined,
-        prNumber: undefined,
-        teamOrigin: undefined,
-        spawnedTeam: undefined,
-    };
-    upsertSession(meta, rewritten);
-    return { newId, shortId, filePath, label };
+    const origin = input.machine ? ` on ${input.machine}` : '';
+    lines.push(`Source session ${input.shortId}${origin} — run \`/continue ${input.id}\` if you need the full transcript.`);
+    return lines.join('\n');
 }

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

@@ -28,28 +28,10 @@ export declare function sanitizeEvents(events: SessionEvent[]): void;
  * ERR_STRING_TOO_LONG ceiling.
  */
 export declare function safeReadSessionFile(filePath: string, maxBytes?: number): string;
-/**
- * Auto-detect agent type from file path and parse the session.
- */
 export interface ParseSessionOptions {
     /** Keep normalized tool results compact by default; renderers can request full output. */
     maxToolOutputChars?: number;
-    /**
-     * Emit an `interrupt` event where the transcript records `[Request interrupted`.
-     *
-     * OFF by default, deliberately. That marker is not a user message, and the default
-     * event array is a versioned consumer contract: `agents sessions <id> --json`
-     * serializes it verbatim (see render.ts, issue #743), `computeSummaryStats` folds
-     * every event's timestamp into the session duration, and the live-state reader and
-     * tail renderer inspect fixed-size windows of the last N events. Emitting it
-     * unconditionally changed all four — a measured 12x duration swing on one real
-     * transcript, a new object in a published payload, and an eviction from the
-     * 12-event rate-limit window whose trigger shape (a trailing interrupt) is exactly
-     * a session the user just cancelled.
-     *
-     * `agents insights` opts in: an interruption is a real friction signal, and dropping
-     * it outright is what made it unrecoverable.
-     */
+    /** Opt-in because interrupts are not user messages and would change the published event stream. */
     includeInterrupts?: boolean;
 }
 export declare function parseSession(filePath: string, agent?: SessionAgentId, opts?: ParseSessionOptions): SessionEvent[];

package/dist/lib/session/parse.js

@@ -117,14 +117,7 @@ function truncateNormalizedToolOutput(output, maxChars) {
         return output;
     return `${output.slice(0, maxChars)}\n\n[Output truncated: ${output.length - maxChars} characters omitted.]`;
 }
-/**
- * Registry-dispatch table: each `SessionAgentId` to its offline transcript
- * parser. Replaces the per-harness `switch` — the harness axis of Move 3. Kept
- * as its own table (not on the HarnessAdapter registry) because its id domain is
- * `SessionAgentId`: `rush` is a session agent with no `AgentId`, and the offline
- * transcript reader is a deliberately separate concern from live team events.
- * The `Record` is total, so a new session harness must add an entry here.
- */
+/** Separate from HarnessAdapter because offline transcripts include session-only agents such as Rush. */
 const TRANSCRIPT_PARSERS = {
     claude: (filePath, opts) => parseClaude(filePath, opts),
     codex: (filePath) => parseCodex(filePath),
@@ -146,13 +139,7 @@ export function parseSession(filePath, agent, opts = {}) {
         throw new Error(`Cannot detect agent type from path: ${filePath}`);
     }
     const events = TRANSCRIPT_PARSERS[detected](filePath, opts);
-    // Chokepoint: every string field that originated in an untrusted session
-    // file gets stripped of terminal escapes here, so renderers downstream can
-    // safely splat values into chalk/console output. Same pass flags
-    // harness-injected `role=user` scaffolding (Claude `<bash-input>`/`<bash-stdout>`
-    // from `!`-prefix runs, `<system-reminder>`, etc.) as `_synthetic` so turn
-    // slicing and `--include user` count only genuine user intent — one place,
-    // every harness, instead of per-consumer regex.
+    // Sanitize untrusted strings and identify synthetic user scaffolding once for every consumer.
     const maxToolOutputChars = opts.maxToolOutputChars ?? 500;
     for (const e of events) {
         if (e.type === 'tool_result' && e.output) {

package/dist/lib/session/tool-calls.d.ts

@@ -10,12 +10,21 @@ export declare const TOOL_CHANGED_MAX_CALLS = 10000;
 export declare const TOOL_INDEX_LIMIT_ORDINAL: number;
 export declare const TOOL_TEXT_PROCESSING_MAX_BYTES: number;
 export declare const TOOL_SHELL_PARSE_MAX_BYTES: number;
-export declare const TOOL_INDEX_VERSION = 7;
+export declare const TOOL_INDEX_VERSION = 8;
 export type ToolCallOutcome = 'ok' | 'error' | 'unknown';
 export interface IndexedToolCall {
     ordinal: number;
     sourceCallId?: string;
     timestamp: string;
+    /**
+     * When the call's RESULT record arrived — the call's own end time, taken from
+     * the tool_result transcript record at `finish()` (PHNX-3437). `timestamp` is
+     * the start; `endTimestamp - timestamp` is the call's own blocking duration,
+     * which the traces insight engine attributes as a failed call's wasted time.
+     * Undefined for a call that never produced a result (still pending at scan end)
+     * and for rows produced by an older extractor.
+     */
+    endTimestamp?: string;
     tool: string;
     programs: string[];
     programOccurrences: ShellProgramOccurrence[];
@@ -81,6 +90,39 @@ export declare class ToolCallCollector {
     private removePending;
     private markChanged;
 }
+/** The prior scan's resume point for an append-only event stream. */
+export interface EventToolScanResumePoint {
+    /** ToolCallCollector snapshot after folding `eventCount` events. */
+    snapshot: ToolCallCollectorSnapshot;
+    /** How many events had been folded when the snapshot was taken. */
+    eventCount: number;
+}
+export interface EventToolScanResult {
+    /** The CHANGED calls — an append-safe upsert set, not the whole history. */
+    calls: IndexedToolCall[];
+    /** Serialized-ready snapshot to persist for the next incremental scan. */
+    snapshot: ToolCallCollectorSnapshot;
+    /** Events folded so far — the next scan's resume offset into `events`. */
+    eventCount: number;
+}
+/**
+ * Derive tool calls from a full-file harness's normalized events, optionally
+ * RESUMING from a prior scan of the same append-only stream.
+ *
+ * Without `prior` this is a full parse from event 0 (identical to the legacy
+ * {@link toolCallsFromEvents}). With `prior`, the collector is seeded from the
+ * prior snapshot and only events at or after `prior.eventCount` are folded — so
+ * an active session that grew by a few turns re-derives (and re-redacts) only
+ * those new tool calls instead of re-sanitizing its entire history on every
+ * daemon warm tick (PHNX-3411). The ordinals continue deterministically from the
+ * snapshot, so folding [0..k) then [k..n) yields the same index as folding
+ * [0..n) once, and the CHANGED set is safe to persist with `mode: 'append'`.
+ *
+ * The caller is responsible for only supplying `prior` when the stream is still
+ * an append of what was scanned before (same source, un-truncated,
+ * `prior.eventCount <= events.length`); anything else must full-scan.
+ */
+export declare function scanEventToolCalls(events: SessionEvent[], prior?: EventToolScanResumePoint): EventToolScanResult;
 /** Build indexed calls from the normalized parser contract used by full-file harnesses. */
 export declare function toolCallsFromEvents(events: SessionEvent[]): IndexedToolCall[];
 export declare function toolCallKey(sessionId: string, ordinal: number): string;

package/dist/lib/session/tool-calls.js

@@ -12,7 +12,10 @@ export const TOOL_CHANGED_MAX_CALLS = 10_000;
 export const TOOL_INDEX_LIMIT_ORDINAL = Number.MAX_SAFE_INTEGER;
 export const TOOL_TEXT_PROCESSING_MAX_BYTES = 64 * 1024;
 export const TOOL_SHELL_PARSE_MAX_BYTES = 64 * 1024;
-export const TOOL_INDEX_VERSION = 7;
+// Bumped to 8 for the per-call end timestamp (PHNX-3437): the extractor now
+// records when a call's result arrived, so a re-index re-derives it for rows
+// stored by an older extractor.
+export const TOOL_INDEX_VERSION = 8;
 const BASE64_BLOCK = /(?:[A-Za-z0-9+/]{256,}={0,2})/g;
 const SECRET_FIELD = /(?:token|secret|password|authorization|cookie|api[_-]?key|private[_-]?key)$/i;
 const KNOWN_SECRET_VALUES = knownSecretValuesFromEnv();
@@ -310,7 +313,7 @@ function buildCall(ordinal, timestamp, tool, args, command, sourceCallId) {
 }
 export function toolCallEvidenceBytes(call) {
     return Buffer.byteLength([
-        call.sourceCallId, call.timestamp, call.tool, call.input, call.errorCode,
+        call.sourceCallId, call.timestamp, call.endTimestamp, call.tool, call.input, call.errorCode,
         call.output, call.error, call.parseError, ...call.programs,
         ...call.programOccurrences.map((occurrence) => `${occurrence.role}:${occurrence.program}`),
     ].filter((value) => typeof value === 'string').join('\0'));
@@ -363,6 +366,9 @@ export class ToolCallCollector {
         const call = this.takePending(args.sourceCallId, tool);
         if (!call)
             return undefined;
+        if (typeof args.timestamp === 'string' && args.timestamp.length > 0) {
+            call.endTimestamp = sanitizeToolEvidenceText(args.timestamp, 128);
+        }
         const outcome = args.outcome === 'ok' || args.outcome === 'error' || args.outcome === 'unknown'
             ? args.outcome
             : undefined;
@@ -471,50 +477,74 @@ export class ToolCallCollector {
         return true;
     }
 }
+/** Fold one normalized event into a collector (the full-file harness contract). */
+function foldEventIntoCollector(collector, event) {
+    if (event.type === 'tool_use') {
+        collector.start({
+            timestamp: event.timestamp,
+            tool: event.tool || 'unknown',
+            input: event.args,
+            command: event.command,
+            sourceCallId: event.callId,
+        });
+    }
+    else if (event.type === 'tool_result') {
+        collector.finish({
+            timestamp: event.timestamp,
+            sourceCallId: event.callId,
+            tool: event.tool,
+            success: event.success,
+            outcome: event.outcome,
+            exitCode: event.exitCode,
+            statusCode: event.statusCode,
+            errorCode: event.errorCode,
+            output: event.output,
+        });
+    }
+    else if (event.type === 'error' && event.tool) {
+        const structuredError = event.outcome === 'error' || event.success === false;
+        const evidence = event.content || event.output || 'Tool execution failed';
+        collector.finish({
+            timestamp: event.timestamp,
+            sourceCallId: event.callId,
+            tool: event.tool,
+            success: structuredError ? false : undefined,
+            outcome: event.outcome,
+            exitCode: event.exitCode,
+            statusCode: event.statusCode,
+            errorCode: event.errorCode,
+            error: structuredError ? evidence : undefined,
+            output: structuredError ? undefined : evidence,
+        });
+    }
+}
+/**
+ * Derive tool calls from a full-file harness's normalized events, optionally
+ * RESUMING from a prior scan of the same append-only stream.
+ *
+ * Without `prior` this is a full parse from event 0 (identical to the legacy
+ * {@link toolCallsFromEvents}). With `prior`, the collector is seeded from the
+ * prior snapshot and only events at or after `prior.eventCount` are folded — so
+ * an active session that grew by a few turns re-derives (and re-redacts) only
+ * those new tool calls instead of re-sanitizing its entire history on every
+ * daemon warm tick (PHNX-3411). The ordinals continue deterministically from the
+ * snapshot, so folding [0..k) then [k..n) yields the same index as folding
+ * [0..n) once, and the CHANGED set is safe to persist with `mode: 'append'`.
+ *
+ * The caller is responsible for only supplying `prior` when the stream is still
+ * an append of what was scanned before (same source, un-truncated,
+ * `prior.eventCount <= events.length`); anything else must full-scan.
+ */
+export function scanEventToolCalls(events, prior) {
+    const startIndex = prior ? Math.min(prior.eventCount, events.length) : 0;
+    const collector = new ToolCallCollector(prior?.snapshot);
+    for (let i = startIndex; i < events.length; i++)
+        foldEventIntoCollector(collector, events[i]);
+    return { calls: collector.drainChanged(), snapshot: collector.snapshot(), eventCount: events.length };
+}
 /** Build indexed calls from the normalized parser contract used by full-file harnesses. */
 export function toolCallsFromEvents(events) {
-    const collector = new ToolCallCollector();
-    for (const event of events) {
-        if (event.type === 'tool_use') {
-            collector.start({
-                timestamp: event.timestamp,
-                tool: event.tool || 'unknown',
-                input: event.args,
-                command: event.command,
-                sourceCallId: event.callId,
-            });
-        }
-        else if (event.type === 'tool_result') {
-            collector.finish({
-                timestamp: event.timestamp,
-                sourceCallId: event.callId,
-                tool: event.tool,
-                success: event.success,
-                outcome: event.outcome,
-                exitCode: event.exitCode,
-                statusCode: event.statusCode,
-                errorCode: event.errorCode,
-                output: event.output,
-            });
-        }
-        else if (event.type === 'error' && event.tool) {
-            const structuredError = event.outcome === 'error' || event.success === false;
-            const evidence = event.content || event.output || 'Tool execution failed';
-            collector.finish({
-                timestamp: event.timestamp,
-                sourceCallId: event.callId,
-                tool: event.tool,
-                success: structuredError ? false : undefined,
-                outcome: event.outcome,
-                exitCode: event.exitCode,
-                statusCode: event.statusCode,
-                errorCode: event.errorCode,
-                error: structuredError ? evidence : undefined,
-                output: structuredError ? undefined : evidence,
-            });
-        }
-    }
-    return collector.drainChanged();
+    return scanEventToolCalls(events).calls;
 }
 export function toolCallKey(sessionId, ordinal) {
     return createHash('sha256').update(`${sessionId}\0${ordinal}`).digest('hex').slice(0, 20);