@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/session/state.js

@@ -15,6 +15,7 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import * as path from 'path';
+import { Lexer } from 'marked';
 import { isCompletedTodoStatus, SNAPSHOT_TODO_TOOLS, summarizeToolUse } from './parse.js';
 import { isShellExecTool } from './shell-programs.js';
 import { classifyFileChanges } from './digest.js';
@@ -367,7 +368,7 @@ export function extractCreatedTicket(text) {
  * lifts `input` onto `event.args`. Returns undefined for a missing/empty plan
  * so consumers can rely on `plan?: string` truthiness.
  */
-export function extractPlanText(args) {
+function extractPlanText(args) {
     const plan = args?.plan;
     if (typeof plan !== 'string')
         return undefined;
@@ -432,13 +433,110 @@ function eventStampMs(e, mtimeMs) {
     return ms;
 }
 /** Does an assistant message read as a question directed at the user? */
-function looksLikeQuestion(text) {
-    const t = text.trim();
-    if (!t)
-        return false;
-    // Only weigh the final line — a long answer that ends with a question is a question.
-    const lastLine = t.split('\n').filter(Boolean).pop() ?? t;
-    return QUESTION_TRAILING.test(lastLine) || QUESTION_PHRASE.test(lastLine);
+/** Strip inline-code spans so a `?` living only inside `code` never reads as a question. */
+function stripInlineCode(s) {
+    return s.replace(/`[^`]*`/g, '');
+}
+/** Whether one line's prose ENDS an ask (trailing '?' or an interrogative phrase). */
+function lineIsQuestion(line) {
+    const probe = stripInlineCode(line.trim());
+    return QUESTION_TRAILING.test(probe) || QUESTION_PHRASE.test(probe);
+}
+/**
+ * Split a run of prose into its trailing QUESTION and the CONTEXT before it,
+ * instead of flattening a whole report into one line (the old `oneLine(content)`
+ * that copied a merged report and lost its Markdown). Returns undefined when the
+ * text has no real trailing ask.
+ *
+ * Rules, each pinned by a test:
+ *   - The ask must be TRAILING: the last eligible non-empty line is the question,
+ *     or the search stops (a report line after the question means it isn't the ask).
+ *   - A `?` that lives ONLY inside a fenced code block, an inline `code` span, or a
+ *     `>` blockquote does NOT count — those lines are ineligible to end the ask
+ *     (they still ride along in `context`).
+ *   - Multiple/multiline related asks are kept together (a contiguous run of
+ *     question / list-item / `:`-lead-in lines), never dropped.
+ *   - When the ask shares ONE line with preceding prose, the leading non-question
+ *     sentences peel into `context` and only the trailing question sentence(s) stay
+ *     in `text`.
+ *   - Both fields preserve newlines and Markdown.
+ */
+export function extractProseQuestion(raw) {
+    const content = (raw ?? '').replace(/\r\n/g, '\n');
+    if (!content.trim())
+        return undefined;
+    const lines = content.split('\n');
+    // Mark lines that may NOT end the ask: fenced-code (delimiters + body) and
+    // blockquotes. They remain part of context; they just can't BE the question.
+    const eligible = [];
+    let fence;
+    for (const line of lines) {
+        const t = line.trim();
+        const delimiter = /^(`{3,}|~{3,})(.*)$/.exec(t);
+        if (fence) {
+            if (delimiter && delimiter[1][0] === fence.marker && delimiter[1].length >= fence.length && !delimiter[2].trim())
+                fence = undefined;
+            eligible.push(false);
+            continue;
+        }
+        if (delimiter) {
+            fence = { marker: delimiter[1][0], length: delimiter[1].length };
+            eligible.push(false);
+            continue;
+        }
+        eligible.push(!/^>/.test(t)); // blockquote line is ineligible
+    }
+    // The trailing ask: the last eligible non-empty line must itself be a question.
+    let qEnd = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (!eligible[i] || !lines[i].trim())
+            continue;
+        if (lineIsQuestion(lines[i]))
+            qEnd = i;
+        break; // first eligible non-empty line from the end decides it
+    }
+    if (qEnd === -1)
+        return undefined;
+    // Expand upward over contiguous eligible non-empty ask/lead-in lines so a
+    // multi-line ask ("Questions:\n- A?\n- B?") stays whole.
+    let blockStart = qEnd;
+    for (let i = qEnd - 1; i >= 0; i--) {
+        if (!eligible[i])
+            break;
+        if (!lines[i].trim())
+            break; // blank line ends the paragraph/block
+        blockStart = i;
+    }
+    const contextAbove = lines.slice(0, blockStart).join('\n').trim();
+    let block = lines.slice(blockStart, qEnd + 1).join('\n').trim();
+    // Only plain text can contribute a sentence boundary. Code, links and other
+    // inline Markdown remain whole, even when their content contains punctuation.
+    let inlineContext = '';
+    if (!/^\s*(?:[-*]|\d+[.)])\s/m.test(block)) {
+        const boundaries = [];
+        let offset = 0;
+        for (const token of Lexer.lexInline(block)) {
+            if (token.type === 'text') {
+                for (const match of token.raw.matchAll(/(?<=[.!?])\s+/g))
+                    boundaries.push(offset + match.index + match[0].length);
+            }
+            offset += token.raw.length;
+        }
+        const starts = [0, ...boundaries];
+        const sentences = starts.map((start, i) => block.slice(start, starts[i + 1] ?? block.length));
+        let firstQ = sentences.length - 1;
+        for (let i = sentences.length - 1; i >= 0; i--) {
+            if (lineIsQuestion(sentences[i]))
+                firstQ = i;
+            else
+                break;
+        }
+        inlineContext = sentences.slice(0, firstQ).join('').trim();
+        block = sentences.slice(firstQ).join('').trim();
+    }
+    const trailingContext = lines.slice(qEnd + 1).join('\n').trim();
+    const context = [contextAbove, inlineContext, trailingContext].filter(Boolean).join('\n\n').trim() || undefined;
+    return { text: block, context };
 }
 /** Human-readable one-liner for the latest event (message text or tool action). */
 function describeEvent(e) {
@@ -559,9 +657,12 @@ export function inferActivity(events, ctx = {}) {
         // kept the question forever).
         const askedAtMs = eventStampMs(last, ctx.mtimeMs) ?? ctx.mtimeMs;
         const questionFresh = askedAtMs != null && nowMs - askedAtMs < PROSE_QUESTION_FRESH_MS;
-        if (questionFresh && looksLikeQuestion(last.content ?? '')) {
-            const text = oneLine(last.content ?? '');
-            return { ...base, activity: 'waiting_input', awaitingReason: 'question', question: { text, reason: 'question' } };
+        const prose = questionFresh ? extractProseQuestion(last.content ?? '') : undefined;
+        if (prose) {
+            const question = { text: prose.text, reason: 'question' };
+            if (prose.context)
+                question.context = prose.context;
+            return { ...base, activity: 'waiting_input', awaitingReason: 'question', question };
         }
         return { ...base, activity: 'idle' };
     }

package/dist/lib/session/stream-render.d.ts

@@ -1,3 +1,4 @@
 import type { SessionAgentId } from './types.js';
-export type StreamLineRenderer = (line: string) => string | null;
+type StreamLineRenderer = (line: string) => string | null;
 export declare function makeStreamRenderer(agent: SessionAgentId, cwd?: string): StreamLineRenderer;
+export {};

package/dist/lib/session/sync/agents.d.ts

@@ -67,8 +67,6 @@ export declare const SYNC_AGENTS: SyncAgentSpec[];
  * by session id so a session present in multiple version homes is uploaded once.
  */
 export declare function listLocalTranscripts(spec: SyncAgentSpec): LocalTranscript[];
-/** Session ids this machine holds locally (live home), used to skip mirror writes. */
-export declare function localSessionIds(spec: SyncAgentSpec): Set<string>;
 /**
  * Absolute mirror path for a remote machine's transcript — lands in a scan root.
  *
@@ -90,7 +88,5 @@ export declare function mirrorPath(spec: SyncAgentSpec, machine: string, relKey:
  *    one object per constituent file of the session directory.
  */
 export declare function objectKey(machine: string, agentId: string, sessionId: string, relKey?: string): string;
-/** R2 object key for a machine's manifest. */
-export declare function manifestKey(machine: string): string;
 /** Prefix under which all machine manifests live (for discovery). */
 export declare const SESSIONS_PREFIX = "sessions/";

package/dist/lib/session/sync/backend.d.ts

@@ -18,16 +18,15 @@
  * MANAGED-FIRST — the mere PRESENCE of an r2.backups bundle is NOT a BYO
  * override. A signed-in user with a stale r2.backups bundle still backs up to
  * managed unless they opt out explicitly: `--byo`, `AGENTS_SESSIONS_BACKEND=byo`,
- * or a DI write token. This mirrors `lib/share/backend.ts` (a persisted BYO
- * config is deliberately not an override) so the product's managed-first
- * contract is identical across surfaces.
+ * or a DI write token. This mirrors the artifact-share backend contract (a
+ * persisted BYO config is deliberately not an override) so the product's
+ * managed-first contract is identical across surfaces.
  */
 import { type PhoenixSession } from '../../identity/client.js';
 import { type R2Config } from './config.js';
-export type SessionsBackendKind = 'managed' | 'byo';
 /** Env var that forces the BYO path. Value must be exactly `byo`. */
 export declare const SESSIONS_BACKEND_ENV = "AGENTS_SESSIONS_BACKEND";
-export interface ManagedSessionsBackend {
+interface ManagedSessionsBackend {
     kind: 'managed';
     /** Public base URL of the managed sessions Worker, no trailing slash. */
     baseUrl: string;
@@ -36,13 +35,13 @@ export interface ManagedSessionsBackend {
     /** Phoenix userId — the object-store namespace prefix (path segment 0). */
     userId: string;
 }
-export interface ByoSessionsBackend {
+interface ByoSessionsBackend {
     kind: 'byo';
     /** The resolved r2.backups credentials for the S3-compatible client. */
     r2: R2Config;
 }
-export type SessionsBackend = ManagedSessionsBackend | ByoSessionsBackend;
-export interface ResolveSessionsBackendOpts {
+type SessionsBackend = ManagedSessionsBackend | ByoSessionsBackend;
+interface ResolveSessionsBackendOpts {
     /** Force the BYO r2.backups path even when signed in. */
     byo?: boolean;
     /** DI seam — a static write token selects BYO (tests / self-host). */
@@ -59,3 +58,4 @@ export declare function shouldUseManagedSessions(opts?: ResolveSessionsBackendOp
  * lives here, not in the shared policy.
  */
 export declare function resolveSessionsBackend(opts?: ResolveSessionsBackendOpts): SessionsBackend;
+export {};

package/dist/lib/session/sync/backend.js

@@ -18,9 +18,9 @@
  * MANAGED-FIRST — the mere PRESENCE of an r2.backups bundle is NOT a BYO
  * override. A signed-in user with a stale r2.backups bundle still backs up to
  * managed unless they opt out explicitly: `--byo`, `AGENTS_SESSIONS_BACKEND=byo`,
- * or a DI write token. This mirrors `lib/share/backend.ts` (a persisted BYO
- * config is deliberately not an override) so the product's managed-first
- * contract is identical across surfaces.
+ * or a DI write token. This mirrors the artifact-share backend contract (a
+ * persisted BYO config is deliberately not an override) so the product's
+ * managed-first contract is identical across surfaces.
  */
 import { readSession } from '../../identity/client.js';
 import { selectStorageBackendKind } from '../../storage/selection.js';

package/dist/lib/session/sync/managed-config.d.ts

@@ -17,13 +17,5 @@ export declare const DEFAULT_SESSIONS_DOMAIN = "sessions.agents-cli.sh";
 export declare const DEFAULT_SESSIONS_WORKER_NAME = "agents-sessions";
 /** R2 bucket name backing the managed sessions Worker. */
 export declare const DEFAULT_SESSIONS_BUCKET_NAME = "agents-sessions";
-/** Isolated Cloudflare resources for the managed session-backup store. */
-export interface SessionsConfig {
-    baseUrl: string;
-    accountId: string;
-    workerName: string;
-    bucketName: string;
-    domain?: string;
-}
 /** Public base URL of the managed sessions Worker, no trailing slash. */
 export declare function managedSessionsBaseUrl(): string;

package/dist/lib/session/sync/managed-key.d.ts

@@ -31,8 +31,6 @@ export declare const ESCROW_REL_KEY = "__key/backup-dek";
 export declare function backupKeyCachePath(): string;
 /** The DEK cached locally for this Phoenix user, or null. */
 export declare function readCachedBackupKey(userId: string): Buffer | null;
-/** Persist a DEK (base64) for this Phoenix user in the local 0600 cache. */
-export declare function cacheBackupKey(userId: string, b64: string): void;
 /**
  * Resolve the managed backup DEK for `userId`, minting + escrowing one on first
  * use. NEVER returns null — the managed path must not upload plaintext.

package/dist/lib/session/sync/managed-key.js

@@ -66,7 +66,7 @@ export function readCachedBackupKey(userId) {
     return decodeDek(readCache()[userId]);
 }
 /** Persist a DEK (base64) for this Phoenix user in the local 0600 cache. */
-export function cacheBackupKey(userId, b64) {
+function cacheBackupKey(userId, b64) {
     const file = backupKeyCachePath();
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
     ensureLockTarget(file, '{}', 0o700);

package/dist/lib/session/sync/provision.d.ts

@@ -1,4 +1,4 @@
-import { type CloudflareRequester } from '../../share/provision.js';
+import { type CloudflareRequester } from '../../cloudflare/provision.js';
 interface ProvisionOptions {
     request?: CloudflareRequester;
 }

package/dist/lib/session/sync/provision.js

@@ -1,11 +1,11 @@
 // Cloudflare orchestration for the managed session-backup store. The generic
-// request primitives live in share/provision; only the isolated sessions
+// request primitives live in cloudflare/provision; only the isolated sessions
 // resource choices and Worker template belong here. Mirrors lib/traces/provision.ts.
 //
 // This is the OPERATOR provisioning path — cutting the `agents-sessions` Worker +
 // bucket + custom domain once. Product traffic never runs it; a signed-in user
 // talks to the already-deployed Worker through `SessionsHttpClient`.
-import { addCustomDomain, createBucket, deployWorker, enableWorkersDev, findZoneId, putWorkerSecret, } from '../../share/provision.js';
+import { addCustomDomain, createBucket, deployWorker, enableWorkersDev, findZoneId, putWorkerSecret, } from '../../cloudflare/provision.js';
 import { DEFAULT_SESSIONS_BUCKET_NAME, DEFAULT_SESSIONS_DOMAIN, DEFAULT_SESSIONS_WORKER_NAME, } from './managed-config.js';
 import { renderSessionsWorkerScript } from './worker-template.js';
 /** Bind the Phoenix identity base URL used to verify every session read and write. */

package/dist/lib/session/sync/r2.d.ts

@@ -10,7 +10,7 @@
  * Linux-only; rclone-mount needs macFUSE).
  */
 import type { R2Config } from './config.js';
-export interface HeadResult {
+interface HeadResult {
     size: number;
     etag: string;
 }
@@ -35,3 +35,6 @@ export declare class R2Client {
      *  {@link SessionsBackupClient} interface (managed lists with no prefix). */
     list(prefix?: string): Promise<string[]>;
 }
+/** Single pass: sequential replaces would double-decode `&amp;lt;` into `<`. */
+export declare function decodeXml(s: string): string;
+export {};

package/dist/lib/session/sync/r2.js

@@ -108,13 +108,10 @@ export class R2Client {
         return keys;
     }
 }
-function decodeXml(s) {
-    return s
-        .replace(/&/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&apos;/g, "'");
+const XML_ENTITIES = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'" };
+/** Single pass: sequential replaces would double-decode `&amp;lt;` into `<`. */
+export function decodeXml(s) {
+    return s.replace(/&(?:amp|lt|gt|quot|apos);/g, (entity) => XML_ENTITIES[entity] ?? entity);
 }
 async function safeText(res) {
     try {

package/dist/lib/session/sync/transcript-crypto.d.ts

@@ -25,7 +25,7 @@
  */
 import type { R2Config } from './config.js';
 /** Serialized envelope stored as the R2 object body when encryption is on. */
-export interface TranscriptEnvelope {
+interface TranscriptEnvelope {
     /** Envelope format version. */
     v: 1;
     alg: 'aes-256-gcm';
@@ -75,3 +75,4 @@ export declare function decryptEnvelope(envelope: TranscriptEnvelope, key: Buffe
  *  - Plaintext body  → returned verbatim (legacy/unencrypted object).
  */
 export declare function decryptTranscriptBody(body: string, key: Buffer | null): string;
+export {};

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

@@ -9,7 +9,7 @@
  */
 import type { SessionAgentId, SessionEvent } from './types.js';
 /** A tail read: the last few normalized events plus the raw text they came from. */
-export interface SessionTail {
+interface SessionTail {
     events: SessionEvent[];
     /** The raw JSONL chunk (leading partial line dropped), for content-level math. */
     content: string;
@@ -35,3 +35,4 @@ export declare function readSessionTailWithRaw(filePath: string, agent: SessionA
  * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
  */
 export declare function readSessionTail(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionEvent[];
+export {};

package/dist/lib/session/team-filter.d.ts

@@ -40,7 +40,7 @@ export declare function _resetTeamOriginIndex(): void;
  */
 export declare function enrichTeamOrigins(sessions: SessionMeta[]): SessionMeta[];
 /** Result of splitting sessions into visible and hidden (team-origin) groups. */
-export interface FilterResult {
+interface FilterResult {
     visible: SessionMeta[];
     hiddenCount: number;
 }

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

@@ -8,9 +8,7 @@
  * straight off `agents sessions --active --json` instead (issue #741).
  */
 /** Agents whose transcript formats report per-turn output-token usage. */
-export type ThroughputAgent = 'claude' | 'codex' | 'gemini';
-/** Rolling window (seconds) the throughput average is computed over. */
-export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+type ThroughputAgent = 'claude' | 'codex' | 'gemini';
 /**
  * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
  *
@@ -28,3 +26,4 @@ export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
  *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
  */
 export declare function computeTokPerSec(sessionContent: string, agent: ThroughputAgent, windowSec?: number, now?: number): number;
+export {};

package/dist/lib/session/throughput.js

@@ -8,7 +8,7 @@
  * straight off `agents sessions --active --json` instead (issue #741).
  */
 /** Rolling window (seconds) the throughput average is computed over. */
-export const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
 /**
  * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
  *

package/dist/lib/session/timeline-pass.d.ts

@@ -19,30 +19,15 @@
  *     picks it up whole.
  */
 import type { ActiveSession } from './active.js';
-import { type SessionTimelineCacheRow, type SessionTimelineEntry } from './db.js';
 import type { SessionAgentId, SessionEvent } from './types.js';
-/** Sessions folded per tick. The tick's own deadline is 30 s; this stays well inside it. */
-export declare const TIMELINE_PASS_MAX_PER_TICK = 8;
 /** Bytes one session may consume in one tick. A bigger backlog catches up over ticks. */
 export declare const TIMELINE_PASS_MAX_BYTES_PER_SESSION: number;
-/**
- * Bytes the whole pass may consume in one tick, across every session.
- *
- * The per-session cap alone is not a bound on the TICK: on a cold cache eight
- * live sessions each fold from offset 0, and eight multi-megabyte transcripts
- * parsed back to back is what blew the 30 s `session-state` deadline and parked
- * the service on this fleet (observed 2026-09-06). A tick budget makes a cold
- * start catch up over a few ticks instead of stalling one.
- */
-export declare const TIMELINE_PASS_MAX_BYTES_PER_TICK: number;
 /**
  * Ceiling on a whole-file re-parse for a harness with no resumable reader.
  * Beyond it the timeline is reported `partial` rather than wedging the tick —
  * the same honesty rule the tool index applies at its own in-memory limit.
  */
 export declare const TIMELINE_PASS_MAX_WHOLE_FILE_BYTES: number;
-/** Events folded from one non-resumable whole-file parse before reporting `partial`. */
-export declare const TIMELINE_PASS_MAX_EVENTS = 20000;
 /**
  * How long a non-resumable harness's timeline may go stale before the pass
  * re-parses its transcript whole.
@@ -56,7 +41,7 @@ export declare const TIMELINE_PASS_MAX_EVENTS = 20000;
  * quarter of the cost.
  */
 export declare const TIMELINE_PASS_NON_RESUMABLE_MIN_INTERVAL_MS = 60000;
-export interface TimelinePassResult {
+interface TimelinePassResult {
     /** Sessions whose timeline was folded and written this tick. */
     computed: number;
     /** Sessions whose cached timeline already matched the transcript bytes. */
@@ -64,7 +49,7 @@ export interface TimelinePassResult {
     /** Sessions skipped: unreadable transcript, no id/file, or no parseable transcript. */
     skipped: number;
 }
-export interface TimelinePassOptions {
+interface TimelinePassOptions {
     /** Live rows to fold. Defaults to the local active-sessions cache. */
     sessions?: ActiveSession[];
     budget?: number;
@@ -88,31 +73,6 @@ export interface TimelinePassOptions {
  * fold two different event streams for the same session.
  */
 export declare function parseTimelineEvents(filePath: string, agent: SessionAgentId): SessionEvent[];
-/** One session's fold: the entry to cache, and what it actually cost to produce. */
-export interface SessionTimelineFold {
-    entry: SessionTimelineEntry;
-    /**
-     * Bytes this fold READ off disk — what the tick's byte budget is debited by.
-     *
-     * Not the transcript's growth delta: a non-resumable harness re-parses the
-     * WHOLE file every time, so eight 3 MiB sessions grown by 10 KB each read
-     * 24 MiB, not 80 KB. Charging the delta is what let a tick overrun its budget
-     * by an order of magnitude.
-     */
-    bytesRead: number;
-}
-/**
- * Fold one session's new transcript bytes and return the entry to cache.
- * Exported for tests: this is where the resume decision and the whole-file
- * fallback live, and both are worth pinning without a daemon.
- *
- * `byteBudget` is the TICK's remaining allowance. Each branch derives its own
- * ceiling from it — the resumable chunk read is additionally capped per session,
- * while a whole-file re-parse is gated on a budget that can actually reach a
- * real transcript. A session that genuinely does not fit gets a `partial` row
- * stating why, never silence.
- */
-export declare function foldSessionTimeline(session: ActiveSession, filePath: string, fileSize: number, prior: SessionTimelineCacheRow | undefined, nowMs?: number, byteBudget?: number): SessionTimelineFold | undefined;
 /**
  * Fold the timelines of the live local sessions, bounded, once per tick.
  * Returns what it did so the daemon tick can log it like every other pass.
@@ -127,3 +87,4 @@ export declare function runTimelinePass(opts?: TimelinePassOptions): Promise<Tim
 export declare function runTimelinePassSync(opts: TimelinePassOptions & {
     sessions: ActiveSession[];
 }): TimelinePassResult;
+export {};

package/dist/lib/session/timeline-pass.js

@@ -24,7 +24,7 @@ import { parseClaudeContent, parseCodexItemsContent, parseSession } from './pars
 import { toolEvidenceSourcePath } from './tool-store.js';
 import { compactTimelineState, emptyTimelineState, foldTimeline, projectSessionFiles, projectTimeline, unavailableTimeline, TIMELINE_EXTRACTOR_VERSION, } from './timeline.js';
 /** Sessions folded per tick. The tick's own deadline is 30 s; this stays well inside it. */
-export const TIMELINE_PASS_MAX_PER_TICK = 8;
+const TIMELINE_PASS_MAX_PER_TICK = 8;
 /** Bytes one session may consume in one tick. A bigger backlog catches up over ticks. */
 export const TIMELINE_PASS_MAX_BYTES_PER_SESSION = 4 * 1024 * 1024;
 /**
@@ -36,7 +36,7 @@ export const TIMELINE_PASS_MAX_BYTES_PER_SESSION = 4 * 1024 * 1024;
  * the service on this fleet (observed 2026-09-06). A tick budget makes a cold
  * start catch up over a few ticks instead of stalling one.
  */
-export const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
+const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
 /**
  * Ceiling on a whole-file re-parse for a harness with no resumable reader.
  * Beyond it the timeline is reported `partial` rather than wedging the tick —
@@ -44,7 +44,7 @@ export const TIMELINE_PASS_MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
  */
 export const TIMELINE_PASS_MAX_WHOLE_FILE_BYTES = 16 * 1024 * 1024;
 /** Events folded from one non-resumable whole-file parse before reporting `partial`. */
-export const TIMELINE_PASS_MAX_EVENTS = 20_000;
+const TIMELINE_PASS_MAX_EVENTS = 20_000;
 /**
  * How long a non-resumable harness's timeline may go stale before the pass
  * re-parses its transcript whole.
@@ -139,7 +139,7 @@ function mib(bytes) {
  * real transcript. A session that genuinely does not fit gets a `partial` row
  * stating why, never silence.
  */
-export function foldSessionTimeline(session, filePath, fileSize, prior, nowMs = Date.now(), byteBudget = TIMELINE_PASS_MAX_BYTES_PER_TICK) {
+function foldSessionTimeline(session, filePath, fileSize, prior, nowMs = Date.now(), byteBudget = TIMELINE_PASS_MAX_BYTES_PER_TICK) {
     const agent = (session.kind ?? 'claude');
     // A settled state stamped at the file's current size, so an unavailable or
     // over-limit session is recognized as up to date next tick instead of being

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

@@ -33,16 +33,6 @@ import type { SessionEvent, SessionFileChange, SessionFiles, SessionRequest, Ses
 export declare const TIMELINE_EXTRACTOR_VERSION = 1;
 /** Steps carried on the row in full; everything older folds into a counter. */
 export declare const TIMELINE_KEEP_STEPS = 8;
-/** File rows carried on the row in full; `total` still reports the real count. */
-export declare const TIMELINE_KEEP_FILES = 8;
-/**
- * Steps kept in the persisted resume state. A long session narrates for hours,
- * and the state is re-read every tick, so the fold rolls everything past this
- * into {@link TimelineState.dropped} — exact totals, bounded bytes.
- */
-export declare const TIMELINE_STATE_MAX_STEPS = 200;
-/** Paths kept in the persisted resume state; older ones roll into `filesDropped`. */
-export declare const TIMELINE_STATE_MAX_FILES = 200;
 /** One file the session touched, as accumulated during the fold. */
 interface TimelineFileEntry {
     op: SessionFileChange['op'];
@@ -115,7 +105,7 @@ export declare function classifyCommandVerb(command: string | undefined): Sessio
 /** The verb class for one tool call: the harness's own if it classified it, else derived. */
 export declare function verbClassForEvent(event: SessionEvent): SessionVerbClass;
 /** Options the fold needs that are not on the events themselves. */
-export interface FoldTimelineOptions {
+interface FoldTimelineOptions {
     /** Row attachments, so an image the prose never named still rides the request. */
     attachments?: import('./types.js').SessionAttachment[];
     /** Stop after this many events and mark the state `truncated` (the projection reads `partial`). */
@@ -135,9 +125,9 @@ export interface FoldTimelineOptions {
  */
 export declare function foldTimeline(events: SessionEvent[], prior?: TimelineState, opts?: FoldTimelineOptions): TimelineState;
 /** The activity values that mean the agent is mid-step, so the newest step is live. */
-export type TimelineActivity = string | undefined;
+type TimelineActivity = string | undefined;
 /** How {@link projectTimeline} scrubs the transcript text it is about to ship. */
-export interface ProjectTimelineOptions {
+interface ProjectTimelineOptions {
     /** Redact secrets from every projected string. Default true — see below. */
     redact?: boolean;
     /** Known credential values to mask verbatim; defaults to {@link knownSecretValuesFromEnv}. */

package/dist/lib/session/timeline.js

@@ -36,15 +36,15 @@ export const TIMELINE_EXTRACTOR_VERSION = 1;
 /** Steps carried on the row in full; everything older folds into a counter. */
 export const TIMELINE_KEEP_STEPS = 8;
 /** File rows carried on the row in full; `total` still reports the real count. */
-export const TIMELINE_KEEP_FILES = 8;
+const TIMELINE_KEEP_FILES = 8;
 /**
  * Steps kept in the persisted resume state. A long session narrates for hours,
  * and the state is re-read every tick, so the fold rolls everything past this
  * into {@link TimelineState.dropped} — exact totals, bounded bytes.
  */
-export const TIMELINE_STATE_MAX_STEPS = 200;
+const TIMELINE_STATE_MAX_STEPS = 200;
 /** Paths kept in the persisted resume state; older ones roll into `filesDropped`. */
-export const TIMELINE_STATE_MAX_FILES = 200;
+const TIMELINE_STATE_MAX_FILES = 200;
 /** A narration beat that said nothing and ran nothing merges into the next one within this window. */
 const NARRATION_MERGE_MS = 2_000;
 /** A thinking block shorter than this is a fragment, not a beat worth showing. */

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

@@ -8,7 +8,6 @@ export declare const TOOL_PENDING_MAX_BYTES: number;
 export declare const TOOL_PENDING_MAX_CALLS = 256;
 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 = 9;
 export type ToolCallOutcome = 'ok' | 'error' | 'unknown';
@@ -97,7 +96,7 @@ export interface EventToolScanResumePoint {
     /** How many events had been folded when the snapshot was taken. */
     eventCount: number;
 }
-export interface EventToolScanResult {
+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. */
@@ -130,3 +129,4 @@ export declare function toolCallKey(sessionId: string, ordinal: number): string;
 export declare function collectClaudeToolCalls(collector: ToolCallCollector, parsed: any): void;
 /** Fold one raw Codex rollout record into the resumable call collector. */
 export declare function collectCodexToolCalls(collector: ToolCallCollector, parsed: any): void;
+export {};

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

@@ -10,7 +10,7 @@ export const TOOL_PENDING_MAX_BYTES = 1024 * 1024;
 export const TOOL_PENDING_MAX_CALLS = 256;
 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;
+const TOOL_TEXT_PROCESSING_MAX_BYTES = 64 * 1024;
 export const TOOL_SHELL_PARSE_MAX_BYTES = 64 * 1024;
 // Bumped to 9 for Codex tool-outcome classification (PHNX-3761): Codex results
 // arrive as a string or input_text[] rather than an object, so every one used to

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

@@ -6,7 +6,6 @@ export declare const TOOL_PROGRAM_COUNT_SCHEMA_VERSION = 1;
 export declare const TOOL_QUERY_MAX_CLAUSES = 32;
 export declare const TOOL_QUERY_MAX_CLAUSE_BYTES = 4096;
 export declare const TOOL_QUERY_MAX_CALL_ROWS = 50000;
-export declare const TOOL_QUERY_MAX_RESULT_BYTES: number;
 export declare const TOOL_QUERY_MAX_RESULT_SESSIONS = 1000;
 export declare const TOOL_QUERY_MAX_SERIALIZED_BYTES: number;
 export declare const TOOL_QUERY_MERGE_OVERHEAD_BYTES: number;
@@ -90,16 +89,9 @@ export declare function ensureToolIndex(sessions: SessionMeta[], limits?: {
     maxBytes?: number;
     verifySourceStamps?: boolean;
 }): Promise<ToolIndexCoverage>;
-interface QueryTerm {
-    field?: 'tool' | 'program' | 'input' | 'output' | 'status' | 'exit' | 'error';
-    value: string;
-}
-/** Parse one same-call clause. Unprefixed terms search every evidence field. */
-export declare function parseToolQueryClause(source: string): QueryTerm[];
 /** A count has one unambiguous subject: one exact `program:<name>` term. */
 export declare function parseToolProgramCountClause(source: string): string;
 /** Count exact, pre-indexed static program sites without reading transcripts. */
 export declare function countToolProgramOccurrences(sessions: SessionMeta[], program: string, coverage: ToolIndexCoverage, machine: string): ToolProgramCountEnvelope;
 /** Query cached evidence; every repeated clause must select a distinct call. */
 export declare function searchToolCalls(sessions: SessionMeta[], clauseSources: string[], coverage: ToolIndexCoverage, resultLimit?: number): ToolSearchEnvelope;
-export {};