@phnx-labs/agents-cli 1.22.83 → 1.22.85

package/dist/lib/session/mirror.js

@@ -30,6 +30,43 @@ export const SESSION_MIRROR_MAX_ROWS = 200;
 export const SESSION_MIRROR_SNIPPET_MAX = 280;
 /** Mirror rows older than this since their last sync are pruned (staleness/size ceiling). */
 export const SESSION_MIRROR_MAX_AGE_MS = 14 * 24 * 60 * 60_000;
+/** Caps for the timeline block on a published mirror row. */
+export const SESSION_MIRROR_MAX_STEPS = 8;
+export const SESSION_MIRROR_STEP_TEXT_MAX = 160;
+export const SESSION_MIRROR_REQUEST_MAX = 2_000;
+export const SESSION_MIRROR_MAX_FILES = 8;
+function cap(value, max) {
+    return value.length > max ? value.slice(0, max) : value;
+}
+/** Bound the tidied request: prose capped, chips capped, never re-derived. */
+function boundedRequest(request) {
+    return {
+        ...request,
+        text: cap(request.text, SESSION_MIRROR_REQUEST_MAX),
+        headline: cap(request.headline, SESSION_MIRROR_STEP_TEXT_MAX),
+        ...(request.command ? { command: cap(request.command, 120) } : {}),
+        attachments: request.attachments.slice(0, SESSION_MIRROR_MAX_FILES)
+            .map((a) => ({ kind: a.kind, name: cap(a.name, 120) })),
+    };
+}
+/** Bound the step list. Counters are kept exact — only text is truncated. */
+function boundedTimeline(timeline) {
+    const steps = timeline.steps.slice(-SESSION_MIRROR_MAX_STEPS).map((step) => ({
+        ...step,
+        text: cap(step.text, SESSION_MIRROR_STEP_TEXT_MAX),
+        ...(step.now ? { now: cap(step.now, SESSION_MIRROR_STEP_TEXT_MAX) } : {}),
+        ...(step.marks ? { marks: step.marks.slice(0, 4).map((mark) => cap(mark, 40)) } : {}),
+    }));
+    return { ...timeline, steps, ...(timeline.reason ? { reason: cap(timeline.reason, 200) } : {}) };
+}
+/** Bound the file rows; `total` still reports the real count. */
+function boundedFiles(files) {
+    return {
+        ...files,
+        changes: files.changes.slice(0, SESSION_MIRROR_MAX_FILES)
+            .map((change) => ({ ...change, path: cap(change.path, 400) })),
+    };
+}
 function snippet(value, max = SESSION_MIRROR_SNIPPET_MAX) {
     if (!value)
         return undefined;
@@ -83,6 +120,12 @@ export async function publishSessionMirrorToSharedStore(options = {}) {
             }
             : {}),
         ...(s.summary?.summaryState ? { summaryState: s.summary.summaryState } : {}),
+        // Same bound-on-publish discipline as the summary above: the fleet state file
+        // is git-synced, so the request text, the step list, and the file rows are
+        // capped here rather than shipped raw (PHNX-3939).
+        ...(s.timeline?.request ? { request: boundedRequest(s.timeline.request) } : {}),
+        ...(s.timeline?.timeline ? { timeline: boundedTimeline(s.timeline.timeline) } : {}),
+        ...(s.timeline?.files ? { files: boundedFiles(s.timeline.files) } : {}),
         capturedAt,
     }));
     try {
@@ -133,8 +176,131 @@ function toUpsert(raw) {
         ticketId: cap(r.ticketId, 64),
         prUrl: cap(r.prUrl, 512),
         summary: toMirrorSummary(r),
+        timeline: toMirrorTimeline(r),
     };
 }
+/**
+ * Validate an untrusted peer's published request/timeline/files into the bounded
+ * projection the local cache stores (PHNX-3939). Bounds mirror the publish side,
+ * so a hostile or oversized peer cannot bloat this box's cache. Only a row that
+ * carries a well-formed timeline is kept; a malformed one is dropped whole
+ * rather than partially trusted.
+ */
+function toMirrorTimeline(r) {
+    const timeline = toMirrorTimelineBlock(r.timeline);
+    if (!timeline)
+        return undefined;
+    return {
+        timeline,
+        ...(toMirrorRequest(r.request) ? { request: toMirrorRequest(r.request) } : {}),
+        ...(toMirrorFiles(r.files) ? { files: toMirrorFiles(r.files) } : {}),
+    };
+}
+function isRecord(v) {
+    return Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+}
+function count(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.floor(v) : 0;
+}
+/** The verb keys a peer's `mix` may carry — anything else is dropped, not trusted. */
+const MIRROR_VERB_CLASSES = [
+    'read', 'edit', 'run', 'git', 'test', 'browser', 'agent', 'other',
+];
+/** A peer's per-verb breakdown, whitelisted by key and clamped by value. */
+function toMirrorMix(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const mix = {};
+    for (const verb of MIRROR_VERB_CLASSES) {
+        const n = count(raw[verb]);
+        if (n > 0)
+            mix[verb] = n;
+    }
+    return Object.keys(mix).length ? mix : undefined;
+}
+function toMirrorTimelineBlock(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const state = raw.state;
+    if (state !== 'ready' && state !== 'partial' && state !== 'unavailable')
+        return undefined;
+    const steps = (Array.isArray(raw.steps) ? raw.steps : [])
+        .filter(isRecord)
+        .filter((step) => isString(step.text) && isString(step.at))
+        .slice(0, SESSION_MIRROR_MAX_STEPS)
+        .map((step) => ({
+        text: String(step.text).slice(0, SESSION_MIRROR_STEP_TEXT_MAX),
+        at: String(step.at).slice(0, 40),
+        ...(isString(step.endedAt) ? { endedAt: step.endedAt.slice(0, 40) } : {}),
+        source: (step.source === 'thinking' || step.source === 'derived' || step.source === 'user'
+            ? step.source : 'narration'),
+        tools: count(step.tools),
+        failed: count(step.failed),
+        blocked: count(step.blocked),
+        ...(isString(step.now) ? { now: step.now.slice(0, SESSION_MIRROR_STEP_TEXT_MAX) } : {}),
+        // `mix` and `live` are what the sidebar renders a step WITH ("6 run ·
+        // 2 blocked", the amber now-line). Dropping them here made a remote row
+        // disagree with the local one about what a live step even is, while `now`
+        // survived — so they ride through, whitelisted like every other field.
+        ...(step.live === true ? { live: true } : {}),
+        ...(() => {
+            const mix = toMirrorMix(step.mix);
+            return mix ? { mix } : {};
+        })(),
+        ...(Array.isArray(step.marks)
+            ? { marks: step.marks.filter(isString).slice(0, 4).map((mark) => mark.slice(0, 40)) }
+            : {}),
+    }));
+    const earlier = isRecord(raw.earlier) ? raw.earlier : {};
+    return {
+        steps,
+        earlier: { steps: count(earlier.steps), tools: count(earlier.tools), failed: count(earlier.failed) },
+        tools: count(raw.tools),
+        failed: count(raw.failed),
+        blocked: count(raw.blocked),
+        spanMs: count(raw.spanMs),
+        state,
+        ...(isString(raw.reason) ? { reason: raw.reason.slice(0, 200) } : {}),
+    };
+}
+function toMirrorRequest(raw) {
+    if (!isRecord(raw) || !isString(raw.headline))
+        return undefined;
+    const kind = raw.kind;
+    return {
+        text: isString(raw.text) ? raw.text.slice(0, SESSION_MIRROR_REQUEST_MAX) : '',
+        headline: raw.headline.slice(0, SESSION_MIRROR_STEP_TEXT_MAX),
+        kind: kind === 'image' || kind === 'command' || kind === 'skill' ? kind : 'text',
+        ...(isString(raw.command) ? { command: raw.command.slice(0, 120) } : {}),
+        attachments: (Array.isArray(raw.attachments) ? raw.attachments : [])
+            .filter(isRecord)
+            .filter((a) => isString(a.name))
+            .slice(0, SESSION_MIRROR_MAX_FILES)
+            .map((a) => ({
+            kind: a.kind === 'image' || a.kind === 'dir' ? a.kind : 'file',
+            name: String(a.name).slice(0, 120),
+        })),
+        pastedLines: count(raw.pastedLines),
+        ...(typeof raw.turns === 'number' ? { turns: count(raw.turns) } : {}),
+    };
+}
+function toMirrorFiles(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const changes = (Array.isArray(raw.changes) ? raw.changes : [])
+        .filter(isRecord)
+        .filter((change) => isString(change.path))
+        .slice(0, SESSION_MIRROR_MAX_FILES)
+        .map((change) => ({
+        path: String(change.path).slice(0, 400),
+        op: (change.op === 'created' || change.op === 'deleted' ? change.op : 'modified'),
+        edits: count(change.edits),
+        at: isString(change.at) ? change.at.slice(0, 40) : '',
+    }));
+    if (!changes.length)
+        return undefined;
+    return { changes, total: count(raw.total) || changes.length, source: raw.source === 'harness' ? 'harness' : 'tools' };
+}
 /** One published summary state, validated back into the union or undefined. */
 function toSummaryState(v) {
     return v === 'pending' || v === 'ready' || v === 'skipped' ? v : undefined;

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

@@ -33,6 +33,14 @@ export interface ParseSessionOptions {
     maxToolOutputChars?: number;
     /** Opt-in because interrupts are not user messages and would change the published event stream. */
     includeInterrupts?: boolean;
+    /**
+     * Opt-in `file_change` events from the harness's own file ledger (Claude
+     * `file-history-delta`). Opt-in for the same reason as
+     * {@link includeInterrupts}: they are not tool calls, and emitting them by
+     * default would change every published event stream (message counts, digests,
+     * trajectories) for a signal only the timeline fold consumes.
+     */
+    includeFileHistory?: boolean;
 }
 export declare function parseSession(filePath: string, agent?: SessionAgentId, opts?: ParseSessionOptions): SessionEvent[];
 /** Infer the agent type from a session file path using known directory conventions. */
@@ -75,6 +83,28 @@ export declare function applyPatchTargets(input: string): Array<{
     op: 'Add' | 'Update' | 'Delete';
 }>;
 export declare function applyPatchTargetPaths(input: string): string[];
+/**
+ * Codex writes its turn TWICE in one rollout: the raw `response_item` records
+ * the model exchanged, and a parallel `event_msg` / `item_completed` stream of
+ * typed, already-classified items. The two overlap — on a 6,244-line rollout on
+ * zion (2026-09-06) the same turn appears as 648 `custom_tool_call` +
+ * 60 `function_call` records AND as 1,038 `CommandExecution` items — so the two
+ * MUST NOT be merged into one event list: every consumer that counts tool calls
+ * (digest, trajectory, insights, the tool index) would double-count.
+ *
+ * {@link parseCodexContent} therefore keeps reading `response_item` and this is
+ * a SEPARATE reader over the item stream, for consumers that want the harness's
+ * own classification instead of re-deriving it: the command as Codex parsed it
+ * (`parsed_cmd.type`), its `exit_code`/`status`, the per-path `FileChange`
+ * ledger, `AgentMessage.phase` (`commentary` is the narration between calls),
+ * web searches, sub-agent activity and compactions. The timeline fold is the
+ * consumer; `parseSession` is untouched.
+ *
+ * Version-tolerant by construction: an item type this does not know folds to a
+ * generic `other` tool_use rather than throwing, so a Codex release that adds an
+ * item type degrades to a counted step instead of an empty timeline.
+ */
+export declare function parseCodexItemsContent(content: string): SessionEvent[];
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -142,6 +172,25 @@ export declare function sessionFilePathContainer(filePath: string): string;
  * timestamps aren't stored, so every event carries the session's `created_at`
  * (from summary.json), falling back to the transcript's mtime.
  */
+/**
+ * Counters Grok writes beside its transcript in `signals.json` — the only place
+ * a Grok session records milestones and failures, since `chat_history.jsonl`
+ * carries no timestamps and no exit codes. Read by the timeline fold to mark a
+ * session that committed / opened / merged a PR and to report a tool-failure
+ * count the event stream cannot supply.
+ */
+export interface GrokSessionSignals {
+    gitCommitCount: number;
+    prCreatedCount: number;
+    prMergedCount: number;
+    toolFailureCount: number;
+}
+/**
+ * Read `signals.json` next to a Grok transcript. Returns `undefined` when the
+ * file is absent or unreadable — a Grok session simply has no signals then, and
+ * the fold reports what it does have rather than inventing zeros.
+ */
+export declare function readGrokSignals(filePath: string): GrokSessionSignals | undefined;
 export declare function parseGrok(filePath: string): SessionEvent[];
 /**
  * The transcript query {@link parseOpenCode} runs, exported so a test can assert