sidekick-shared 0.28.3 → 0.29.0

package/dist/report/htmlReportGenerator.js

@@ -599,14 +599,51 @@ function renderContentBlock(block, includeThinking, includeToolDetail) {
             return '';
     }
 }
-function renderToolUse(block, includeDetail) {
+/** Prefix of the bookkeeping keys session parsers stash inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
+/**
+ * The tool's display identity and user-facing input. Entries built outside
+ * the canonical projection may still carry the parsers' `_sidekick*` keys in
+ * `toolInput`; those are hidden here and read as the raw identity.
+ */
+function toolDisplay(block) {
     const name = block.toolName || 'unknown';
+    const raw = block.toolInput;
+    let input = raw;
+    let rawToolName = block.rawToolName;
+    let mcpServerName = block.mcpServerName;
+    if (raw && Object.keys(raw).some((key) => key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))) {
+        const clean = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (!key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+                clean[key] = value;
+        }
+        input = clean;
+        if (!rawToolName && typeof raw._sidekickRawToolName === 'string') {
+            rawToolName = raw._sidekickRawToolName;
+        }
+        if (!mcpServerName && typeof raw._sidekickMcpServerName === 'string') {
+            mcpServerName = raw._sidekickMcpServerName;
+        }
+    }
+    const parts = [];
+    if (rawToolName && rawToolName.trim() && rawToolName !== name)
+        parts.push(rawToolName);
+    if (mcpServerName && mcpServerName.trim())
+        parts.push(`MCP: ${mcpServerName}`);
+    const hint = parts.length
+        ? ` <span class="tool-raw-name" style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(parts.join(' · '))}</span>`
+        : '';
+    return { name, hint, input };
+}
+function renderToolUse(block, includeDetail) {
+    const { name, hint, input } = toolDisplay(block);
     if (!includeDetail) {
-        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${(0, htmlHelpers_1.escapeHtml)(name)}</div></div>`;
+        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${(0, htmlHelpers_1.escapeHtml)(name)}${hint}</div></div>`;
     }
     let inputHtml = '';
-    if (block.toolInput && Object.keys(block.toolInput).length > 0) {
-        const inputJson = JSON.stringify(block.toolInput, null, 2);
+    if (input && Object.keys(input).length > 0) {
+        const inputJson = JSON.stringify(input, null, 2);
         const highlighted = (0, htmlHelpers_1.highlightCodeBlock)(inputJson, 'json');
         inputHtml = `<div class="tool-io">
     <div class="tool-label">Input</div>
@@ -614,7 +651,7 @@ function renderToolUse(block, includeDetail) {
   </div>`;
     }
     return `<details class="tool-block" data-block-type="tool">
-  <summary>${(0, htmlHelpers_1.escapeHtml)(name)}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(block.toolUseId)}</span>` : ''}</summary>
+  <summary>${(0, htmlHelpers_1.escapeHtml)(name)}${hint}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(block.toolUseId)}</span>` : ''}</summary>
   <div class="tool-content">
     ${inputHtml}
   </div>

package/dist/report/transcriptParser.d.ts

@@ -1,6 +1,15 @@
 /** Report compatibility adapters over the canonical transcript projection. */
 import type { SessionEvent } from '../types/sessionEvent';
-import type { TranscriptEntry } from './types';
+import type { TranscriptEntry, TranscriptContentBlock } from './types';
+/**
+ * A report tool block that also names the provider's raw tool and MCP
+ * server. Internal: the extra fields are optional and read only by the HTML
+ * renderer.
+ */
+export type ReportToolUseBlock = TranscriptContentBlock & {
+    rawToolName?: string;
+    mcpServerName?: string;
+};
 /** Parse a Claude Code JSONL session through the canonical provider reader. */
 export declare function parseTranscript(sessionPath: string): TranscriptEntry[];
 /** Project canonical provider events into the legacy report transcript shape. */

package/dist/report/transcriptParser.js

@@ -79,17 +79,19 @@ function toReportBlock(block) {
             return block.text ? [{ type: 'text', text: block.text }] : [];
         case 'thinking':
             return block.text ? [{ type: 'thinking', text: block.text }] : [];
-        case 'tool_use':
-            return [
-                {
-                    type: 'tool_use',
-                    toolName: block.toolName ?? 'unknown',
-                    toolInput: block.input && typeof block.input === 'object'
-                        ? block.input
-                        : {},
-                    toolUseId: block.toolUseId,
-                },
-            ];
+        case 'tool_use': {
+            const toolBlock = {
+                type: 'tool_use',
+                toolName: block.toolName ?? 'unknown',
+                toolInput: block.input && typeof block.input === 'object'
+                    ? block.input
+                    : {},
+                toolUseId: block.toolUseId,
+                ...(block.rawToolName ? { rawToolName: block.rawToolName } : {}),
+                ...(block.mcpServerName ? { mcpServerName: block.mcpServerName } : {}),
+            };
+            return [toolBlock];
+        }
         case 'tool_result':
             return [
                 {

package/dist/schemas/providerFailure.d.ts

@@ -52,6 +52,25 @@ export declare const providerFailureEvidenceSchema: z.ZodObject<{
         context_overflow: "context_overflow";
     }>;
     checkedAt: z.ZodOptional<z.ZodString>;
+    codexErrorInfo: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        contextWindowExceeded: "contextWindowExceeded";
+        sessionBudgetExceeded: "sessionBudgetExceeded";
+        usageLimitExceeded: "usageLimitExceeded";
+        rateLimitExceeded: "rateLimitExceeded";
+        serverOverloaded: "serverOverloaded";
+        cyberPolicy: "cyberPolicy";
+        httpConnectionFailed: "httpConnectionFailed";
+        responseStreamConnectionFailed: "responseStreamConnectionFailed";
+        internalServerError: "internalServerError";
+        unauthorized: "unauthorized";
+        badRequest: "badRequest";
+        threadRollbackFailed: "threadRollbackFailed";
+        sandboxError: "sandboxError";
+        responseStreamDisconnected: "responseStreamDisconnected";
+        responseTooManyFailedAttempts: "responseTooManyFailedAttempts";
+        activeTurnNotSteerable: "activeTurnNotSteerable";
+    }>>;
 }, z.core.$strip>;
 export declare const providerRetryAfterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"delay">;
@@ -98,6 +117,7 @@ export declare const providerFailureDiagnosisSchema: z.ZodObject<{
         reduce_context: "reduce_context";
         inspect_error: "inspect_error";
     }>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
     evidence: z.ZodArray<z.ZodObject<{
         source: z.ZodEnum<{
             message: "message";
@@ -122,6 +142,25 @@ export declare const providerFailureDiagnosisSchema: z.ZodObject<{
             context_overflow: "context_overflow";
         }>;
         checkedAt: z.ZodOptional<z.ZodString>;
+        codexErrorInfo: z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            contextWindowExceeded: "contextWindowExceeded";
+            sessionBudgetExceeded: "sessionBudgetExceeded";
+            usageLimitExceeded: "usageLimitExceeded";
+            rateLimitExceeded: "rateLimitExceeded";
+            serverOverloaded: "serverOverloaded";
+            cyberPolicy: "cyberPolicy";
+            httpConnectionFailed: "httpConnectionFailed";
+            responseStreamConnectionFailed: "responseStreamConnectionFailed";
+            internalServerError: "internalServerError";
+            unauthorized: "unauthorized";
+            badRequest: "badRequest";
+            threadRollbackFailed: "threadRollbackFailed";
+            sandboxError: "sandboxError";
+            responseStreamDisconnected: "responseStreamDisconnected";
+            responseTooManyFailedAttempts: "responseTooManyFailedAttempts";
+            activeTurnNotSteerable: "activeTurnNotSteerable";
+        }>>;
     }, z.core.$strip>>;
     authentication: z.ZodOptional<z.ZodObject<{
         credentialKind: z.ZodEnum<{

package/dist/schemas/providerFailure.js

@@ -23,6 +23,7 @@ exports.providerFailureEvidenceSchema = zod_1.z.object({
     source: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_EVIDENCE_SOURCES),
     rule: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_CODES),
     checkedAt: zod_1.z.string().optional(),
+    codexErrorInfo: zod_1.z.enum(providerFailure_1.CODEX_ERROR_INFO_KINDS).optional(),
 });
 exports.providerRetryAfterSchema = zod_1.z.discriminatedUnion('kind', [
     zod_1.z.object({ kind: zod_1.z.literal('delay'), delayMs: zod_1.z.number() }),
@@ -33,6 +34,7 @@ exports.providerFailureDiagnosisSchema = zod_1.z.object({
     credentialKind: zod_1.z.enum(providerFailure_1.PROVIDER_CREDENTIAL_KINDS),
     diagnosis: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_CODES),
     recovery: zod_1.z.enum(providerFailure_1.PROVIDER_RECOVERY_ACTIONS),
+    retryable: zod_1.z.boolean().optional(),
     evidence: zod_1.z.array(exports.providerFailureEvidenceSchema),
     authentication: exports.providerAuthenticationEvidenceSchema.optional(),
     httpStatus: zod_1.z.number().optional(),

package/dist/schemas/transcript.d.ts

@@ -12,6 +12,8 @@ export declare const canonicalTranscriptBlockSchema: z.ZodObject<{
     }>;
     text: z.ZodOptional<z.ZodString>;
     toolName: z.ZodOptional<z.ZodString>;
+    rawToolName: z.ZodOptional<z.ZodString>;
+    mcpServerName: z.ZodOptional<z.ZodString>;
     toolUseId: z.ZodOptional<z.ZodString>;
     input: z.ZodOptional<z.ZodUnknown>;
     output: z.ZodOptional<z.ZodUnknown>;

package/dist/schemas/transcript.js

@@ -20,6 +20,8 @@ exports.canonicalTranscriptBlockSchema = zod_1.z.object({
     type: zod_1.z.enum(['text', 'thinking', 'tool_use', 'tool_result', 'image', 'unknown']),
     text: zod_1.z.string().optional(),
     toolName: zod_1.z.string().optional(),
+    rawToolName: zod_1.z.string().optional(),
+    mcpServerName: zod_1.z.string().optional(),
     toolUseId: zod_1.z.string().optional(),
     input: zod_1.z.unknown().optional(),
     output: zod_1.z.unknown().optional(),
@@ -31,6 +33,8 @@ exports.canonicalTranscriptBlockSchema = zod_1.z.object({
 exports.canonicalToolCallSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
     name: zod_1.z.string(),
+    rawToolName: zod_1.z.string().optional(),
+    mcpServerName: zod_1.z.string().optional(),
     timestamp: zod_1.z.string(),
     input: zod_1.z.unknown().optional(),
     output: zod_1.z.unknown().optional(),

package/dist/sessionPromptHistory.d.ts

@@ -28,7 +28,13 @@ export interface SessionPromptHistoryBounds {
     maxSessionBytes?: number;
     /** Bytes read across all sessions in one call. Default 256 MiB. */
     maxTotalBytes?: number;
-    /** Largest single log record that is parsed. Default 16 MiB. */
+    /**
+     * Largest single log record that is parsed. Default 16 MiB
+     * (`PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES`). A prompt inside a longer
+     * record is never seen, so later ordinals do not count it: ordinals match
+     * `collectPromptHistory()` (and usage events' `promptOrdinal`) only when
+     * both use the default.
+     */
     maxRecordBytes?: number;
     /** Wall-clock budget for the call. Default 60 000 ms. */
     deadlineMs?: number;

package/dist/sessionPromptHistory.js

@@ -56,7 +56,7 @@ const DEFAULT_SESSION_BOUNDS = {
     maxSessions: 1000,
     maxSessionBytes: 256 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
-    maxRecordBytes: promptHistory_1.DEFAULT_BOUNDS.maxRecordBytes,
+    maxRecordBytes: promptHistory_1.PROMPT_HISTORY_ORDINAL_MAX_RECORD_BYTES,
     deadlineMs: 60_000,
 };
 const MAX_EXCLUSIONS = 1000;

package/dist/statusline/payload.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `sidekick-shared/statusline/payload` — the pure Claude Code status-line
+ * stdin parser on its own, for hosts with a tight bundle budget that render
+ * their own line. Loads no account, credential, quota-snapshot, or network
+ * code (the full `sidekick-shared/statusline` entry does).
+ *
+ * @module statusline/payload
+ */
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';
+export type { ClaudeStatuslinePayload, ClaudeStatuslineRateLimitWindow, QuotaFromStatuslineOptions, } from './claudeStatuslinePayload';

package/dist/statusline/payload.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * `sidekick-shared/statusline/payload` — the pure Claude Code status-line
+ * stdin parser on its own, for hosts with a tight bundle budget that render
+ * their own line. Loads no account, credential, quota-snapshot, or network
+ * code (the full `sidekick-shared/statusline` entry does).
+ *
+ * @module statusline/payload
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quotaFromStatuslinePayload = exports.parseClaudeStatuslinePayload = void 0;
+var claudeStatuslinePayload_1 = require("./claudeStatuslinePayload");
+Object.defineProperty(exports, "parseClaudeStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.parseClaudeStatuslinePayload; } });
+Object.defineProperty(exports, "quotaFromStatuslinePayload", { enumerable: true, get: function () { return claudeStatuslinePayload_1.quotaFromStatuslinePayload; } });

package/dist/testing/credentialGuard.d.ts

@@ -15,6 +15,20 @@ export interface CredentialGuardOptions {
     blockedBinaries?: string[];
     /** Extra real paths to protect, besides the Claude, Codex, and Sidekick homes. */
     protectedPaths?: string[];
+    /**
+     * Home overrides to keep instead of unsetting, for a suite that points one
+     * at its own fixture before the guard installs. Accepts only the variables
+     * the guard unsets: `CLAUDE_CONFIG_DIR`, `CLAUDE_SECURESTORAGE_CONFIG_DIR`,
+     * `CODEX_HOME`, and `SIDEKICK_CONFIG_DIR`.
+     *
+     * Install throws, before changing anything, for any other name, or when a
+     * preserved value is, contains, or lies inside a real protected location:
+     * the real home's `.claude`, `.claude.json`, and `.codex`, the default
+     * Sidekick config dir, or a `protectedPaths` entry. Symlinks are resolved
+     * first. The guard cannot tell a real store kept elsewhere from a fixture,
+     * so preserve only paths the suite created. Blank values are kept unchecked.
+     */
+    preserveEnv?: readonly string[];
 }
 /**
  * Installs the guard once per process and returns it; later calls return the

package/dist/testing/credentialGuard.js

@@ -46,7 +46,8 @@ exports.installCredentialGuard = installCredentialGuard;
  * - `HOME` (and the Windows equivalents) point at a per-process temp dir,
  *   removed on exit, and the home overrides (`CLAUDE_CONFIG_DIR`,
  *   `CLAUDE_SECURESTORAGE_CONFIG_DIR`, `CODEX_HOME`, `SIDEKICK_CONFIG_DIR`)
- *   are unset, so every `os.homedir()`-derived path is isolated structurally;
+ *   are unset (unless named in `preserveEnv` and pointed at a fixture), so
+ *   every `os.homedir()`-derived path is isolated structurally;
  * - the real `child_process` module object is patched, which reaches both ESM
  *   named imports (after `syncBuiltinESMExports`) and CommonJS code loaded
  *   through native `require`; per-file `vi.mock('child_process')` factories
@@ -64,6 +65,13 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const GUARD_KEY = '__sidekickCredentialGuard';
 const DEFAULT_BLOCKED_BINARIES = ['security', 'claude', 'codex'];
+/** Home overrides the guard unsets; only these can be preserved. */
+const SCRUBBED_ENV = [
+    'CLAUDE_CONFIG_DIR',
+    'CLAUDE_SECURESTORAGE_CONFIG_DIR',
+    'CODEX_HOME',
+    'SIDEKICK_CONFIG_DIR',
+];
 const CHILD_PROCESS_FUNCTIONS = [
     'spawn',
     'spawnSync',
@@ -111,6 +119,8 @@ function installCredentialGuard(options = {}) {
     // os.userInfo() reads the passwd entry, so it still names the real home
     // after HOME is redirected below.
     const realHome = os.userInfo().homedir;
+    // Validated before any side effect, so a refused install changes nothing.
+    const preserved = checkPreservedEnv(options, realHome, realFs);
     const testHome = realFs.mkdtempSync(path.join(os.tmpdir(), 'sidekick-test-home-'));
     const removeTestHome = realFs.rmSync.bind(realFs);
     process.once('exit', () => {
@@ -139,10 +149,9 @@ function installCredentialGuard(options = {}) {
     process.env.USERPROFILE = testHome;
     process.env.APPDATA = path.join(testHome, 'AppData', 'Roaming');
     process.env.LOCALAPPDATA = path.join(testHome, 'AppData', 'Local');
-    delete process.env.CLAUDE_CONFIG_DIR;
-    delete process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
-    delete process.env.CODEX_HOME;
-    delete process.env.SIDEKICK_CONFIG_DIR;
+    for (const name of SCRUBBED_ENV)
+        if (!preserved.has(name))
+            delete process.env[name];
     const protectedRoots = path.resolve(realHome) === path.resolve(testHome)
         ? []
         : [
@@ -244,6 +253,79 @@ function installCredentialGuard(options = {}) {
     globalThis[GUARD_KEY] = state;
     return state;
 }
+/** The `preserveEnv` names, after refusing unknown names and unsafe values. */
+function checkPreservedEnv(options, realHome, realFs) {
+    const preserved = new Set();
+    for (const name of options.preserveEnv ?? []) {
+        if (!SCRUBBED_ENV.includes(name)) {
+            throw new Error(`installCredentialGuard: preserveEnv accepts only ${SCRUBBED_ENV.join(', ')}; got ${JSON.stringify(name)}.`);
+        }
+        preserved.add(name);
+    }
+    if (preserved.size === 0)
+        return preserved;
+    const roots = [
+        path.join(realHome, '.claude'),
+        path.join(realHome, '.claude.json'),
+        path.join(realHome, '.codex'),
+        path.join(realHome, '.config', 'sidekick'),
+        // The Windows default config dir, read before HOME and APPDATA move.
+        ...(process.platform === 'win32' && process.env.APPDATA
+            ? [path.join(process.env.APPDATA, 'sidekick')]
+            : []),
+        ...(options.protectedPaths ?? []),
+    ];
+    for (const name of preserved) {
+        const value = process.env[name]?.trim();
+        if (!value)
+            continue;
+        const hit = protectedLocation(value, roots, realFs);
+        if (hit) {
+            throw new Error(`installCredentialGuard: preserveEnv ${name}=${value} reaches the real protected location ${hit}. Point it at a temporary fixture instead.`);
+        }
+    }
+    return preserved;
+}
+/** The root `target` equals, contains, or lies inside, comparing plain and symlink-resolved paths. */
+function protectedLocation(target, roots, realFs) {
+    // Case-insensitive by default on macOS and Windows; folding can only over-refuse.
+    const fold = process.platform === 'darwin' || process.platform === 'win32';
+    const normal = (value) => {
+        const resolved = path.resolve(value);
+        return fold ? resolved.toLowerCase() : resolved;
+    };
+    const within = (parent, child) => child === parent || child.startsWith(parent.endsWith(path.sep) ? parent : parent + path.sep);
+    const related = (a, b) => within(a, b) || within(b, a);
+    // Plain paths first, so an obviously unsafe value never reaches the filesystem.
+    const plain = normal(target);
+    for (const root of roots)
+        if (related(normal(root), plain))
+            return root;
+    const real = normal(realpathOfNearest(target, realFs));
+    for (const root of roots) {
+        const realRoot = normal(realpathOfNearest(root, realFs));
+        if (related(realRoot, real) || related(normal(root), real) || related(realRoot, plain))
+            return root;
+    }
+    return null;
+}
+/** `realpath` of the nearest existing ancestor, with the missing tail re-appended. */
+function realpathOfNearest(target, realFs) {
+    let current = path.resolve(target);
+    let tail = [];
+    for (;;) {
+        try {
+            return path.join(realFs.realpathSync.native(current), ...tail);
+        }
+        catch {
+            const parent = path.dirname(current);
+            if (parent === current)
+                return path.resolve(target);
+            tail = [path.basename(current), ...tail];
+            current = parent;
+        }
+    }
+}
 /**
  * The real module object of a Node built-in: `process.getBuiltinModule`
  * (Node 20.16+), or `require` in CommonJS on older Node.

package/dist/toolCallOrigins.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Locates the session record that issued each of a set of tool calls, by id.
+ *
+ * Given Claude Code `tool_use` ids (`toolu_…`) and/or Codex `call_id`s, finds
+ * the session file, session id and time of each call, plus the ordinal of the
+ * human prompt the call answered, so a downstream record (an edit, a commit)
+ * can be tied back to the prompt that caused it. Scope, listing, session keys
+ * and ordinals are the ones `collectPromptHistory()` uses, so results join
+ * directly with prompt-history entries.
+ *
+ * Cost: one listing of the workspace-scoped session files (`since` prunes by
+ * modification time), then a streaming pass over each candidate file in which
+ * a line is only parsed when it contains one of the wanted ids. Claude Code
+ * subagent transcripts of each session are searched too. Stops as soon as
+ * every id is found. Prompt ordinals are read only for files that matched.
+ *
+ * Node-only: reads session files.
+ *
+ * @module toolCallOrigins
+ */
+import { type PromptHistoryProvider } from './promptHistory';
+export interface FindToolCallOriginsOptions {
+    /** Tool-call ids to locate: Claude `tool_use` ids and/or Codex `call_id`s. */
+    ids: Iterable<string>;
+    /** Workspace roots that scope the search (as for `collectPromptHistory`). */
+    workspacePaths: string[];
+    /** Also search the roots' git worktree siblings. Default true. */
+    includeWorktrees?: boolean;
+    /** Only session files modified at or after this instant. */
+    since?: Date;
+    /** Default both. */
+    providers?: PromptHistoryProvider[];
+    /** Stops between files and lines; the promise rejects with the signal's reason. */
+    signal?: AbortSignal;
+}
+export interface ToolCallOrigin {
+    provider: PromptHistoryProvider;
+    /**
+     * Session whose prompt history `afterOrdinal` counts in: the session itself,
+     * or its parent for a subagent or fork (Claude subagent transcripts live
+     * under the parent; a Codex subagent or fork has its own rollout, named in
+     * `subagent.agentId` / `filePath`, and no prompts of its own).
+     */
+    sessionId: string;
+    /** Same key `collectPromptHistory()` reports for that session's file. */
+    sessionKey: string;
+    /** File the call was recorded in (a subagent transcript for subagent calls). */
+    filePath: string;
+    /** ISO timestamp of the record that issued the call. */
+    timestamp: string;
+    /**
+     * Ordinal of the last human prompt at or before the call, in the session's
+     * prompt history; null when the call precedes every prompt or the session
+     * has none (e.g. a Codex subagent whose parent was not found in scope).
+     */
+    afterOrdinal: number | null;
+    toolName?: string;
+    /** Set when a subagent issued the call. */
+    subagent?: {
+        agentId: string;
+        parentSessionId: string;
+    };
+}
+/**
+ * Finds where each tool call was issued. Ids that are not found are absent
+ * from the result. When an id appears more than once (a forked or resumed
+ * session can replay history), the earliest record wins, and a session's own
+ * record wins over a fork's copy at the same instant.
+ */
+export declare function findToolCallOrigins(options: FindToolCallOriginsOptions): Promise<Map<string, ToolCallOrigin>>;