sidekick-shared 0.28.3 → 0.29.1

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>>;

package/dist/toolCallOrigins.js

@@ -0,0 +1,346 @@
+"use strict";
+/**
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findToolCallOrigins = findToolCallOrigins;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const promptHistory_1 = require("./promptHistory");
+const codexRolloutOrigin_1 = require("./parsers/codexRolloutOrigin");
+const workspaceRoots_1 = require("./workspaceRoots");
+/**
+ * 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.
+ */
+async function findToolCallOrigins(options) {
+    const wanted = new Set([...options.ids].filter((id) => typeof id === 'string' && id.length > 0));
+    const found = new Map();
+    if (wanted.size === 0)
+        return found;
+    throwIfAborted(options.signal);
+    const realpaths = new Map();
+    const { roots, listingRoots } = (0, promptHistory_1.resolveRoots)(options.workspacePaths, options.includeWorktrees !== false, realpaths);
+    if (roots.length === 0)
+        return found;
+    const providers = options.providers ?? ['claude-code', 'codex'];
+    const sinceMs = options.since ? options.since.getTime() : null;
+    const candidates = await (0, promptHistory_1.listCandidates)(providers, listingRoots, sinceMs);
+    const byProviderSession = new Map();
+    for (const candidate of candidates) {
+        byProviderSession.set(`${candidate.provider}:${candidate.sessionId}`, candidate);
+    }
+    const marksCache = new Map();
+    const marksFor = (candidate) => {
+        let marks = marksCache.get(candidate.key);
+        if (!marks) {
+            marks = (0, promptHistory_1.readPromptOrdinalMarks)(candidate.provider, candidate.sessionId, candidate.filePath).catch(() => []);
+            marksCache.set(candidate.key, marks);
+        }
+        return marks;
+    };
+    const remaining = new Set(wanted);
+    // Best timestamp seen per id, to prefer the earliest record across files.
+    const bestMs = new Map();
+    for (const candidate of candidates) {
+        if (remaining.size === 0)
+            break;
+        throwIfAborted(options.signal);
+        const targets = [{ candidate, filePath: candidate.filePath }];
+        if (candidate.provider === 'claude-code') {
+            for (const sub of claudeSubagentTranscripts(candidate.filePath, candidate.sessionId)) {
+                targets.push({ candidate, filePath: sub.filePath, agentId: sub.agentId });
+            }
+        }
+        // A Codex fork or spawned subagent answers its parent's prompts.
+        let codexParent;
+        if (candidate.provider === 'codex') {
+            const origin = (0, codexRolloutOrigin_1.codexRolloutOrigin)(await readFirstRecord(candidate.filePath));
+            if (origin.parentId)
+                codexParent = { id: origin.parentId, fork: !origin.isSubagent };
+        }
+        for (const target of targets) {
+            const hits = await scanForIds(target.filePath, candidate.provider, remaining, roots, realpaths, options.signal);
+            for (const hit of hits) {
+                const isFork = codexParent?.fork === true;
+                const previous = bestMs.get(hit.id);
+                if (previous &&
+                    (previous.ms < hit.timestampMs ||
+                        (previous.ms === hit.timestampMs && (!previous.fork || isFork)))) {
+                    continue;
+                }
+                bestMs.set(hit.id, { ms: hit.timestampMs, fork: isFork });
+                let subagent;
+                if (target.agentId) {
+                    subagent = { agentId: target.agentId, parentSessionId: candidate.sessionId };
+                }
+                else if (codexParent && !codexParent.fork) {
+                    subagent = { agentId: candidate.sessionId, parentSessionId: codexParent.id };
+                }
+                // Ordinals come from the session whose prompts the call answered: a
+                // Codex fork or subagent has none of its own, so its parent's count.
+                const parentSession = codexParent
+                    ? byProviderSession.get(`codex:${codexParent.id}`)
+                    : undefined;
+                const session = parentSession ?? candidate;
+                const afterOrdinal = !codexParent || parentSession
+                    ? ordinalAt(await marksFor(session), hit.timestampMs)
+                    : null;
+                found.set(hit.id, {
+                    provider: candidate.provider,
+                    sessionId: session.sessionId,
+                    sessionKey: session.key,
+                    filePath: target.filePath,
+                    timestamp: hit.timestamp,
+                    afterOrdinal,
+                    ...(hit.toolName ? { toolName: hit.toolName } : {}),
+                    ...(subagent ? { subagent } : {}),
+                });
+                // A fork's copy might be replaced by the original later; keep looking.
+                if (!isFork)
+                    remaining.delete(hit.id);
+            }
+            if (remaining.size === 0)
+                break;
+        }
+    }
+    return found;
+}
+/** Highest ordinal among prompts at or before `ms`; marks are in file order. */
+function ordinalAt(marks, ms) {
+    let best = null;
+    for (const mark of marks) {
+        if (Number.isFinite(mark.timestampMs) && mark.timestampMs <= ms) {
+            if (best === null || mark.ordinal > best)
+                best = mark.ordinal;
+        }
+    }
+    return best;
+}
+function claudeSubagentTranscripts(sessionFile, sessionId) {
+    const dir = path.join(path.dirname(sessionFile), sessionId, 'subagents');
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter((name) => name.endsWith('.jsonl'))
+        .sort()
+        .map((name) => ({
+        filePath: path.join(dir, name),
+        agentId: path.basename(name, '.jsonl').replace(/^agent-/, ''),
+    }));
+}
+async function readFirstRecord(filePath) {
+    let handle;
+    try {
+        handle = await fs.promises.open(filePath, 'r');
+        const buffer = Buffer.alloc(256 * 1024);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        const text = buffer.subarray(0, bytesRead).toString('utf8');
+        const newline = text.indexOf('\n');
+        return JSON.parse(newline === -1 ? text : text.slice(0, newline));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+/** Fail-closed scope check on a recorded working directory. */
+function inScope(cwd, roots, realpaths) {
+    if (typeof cwd !== 'string' || cwd.length === 0)
+        return false;
+    const real = (0, workspaceRoots_1.realpathOrNull)(cwd, realpaths);
+    if (!real)
+        return false;
+    return roots.some((root) => {
+        if (real === root)
+            return true;
+        const prefix = root.endsWith(path.sep) ? root : root + path.sep;
+        return real.startsWith(prefix);
+    });
+}
+const ID_PATTERN = /"(?:id|call_id)"\s*:\s*"([^"\\]{1,256})"/g;
+async function scanForIds(filePath, provider, wanted, roots, realpaths, signal) {
+    const hits = [];
+    let stream;
+    try {
+        stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+    }
+    catch {
+        return hits;
+    }
+    const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    // Codex records a working directory per session/turn, not per line.
+    let codexCwd;
+    try {
+        for await (const line of lines) {
+            throwIfAborted(signal);
+            if (provider === 'codex' && line.includes('"cwd"')) {
+                const cwd = codexCwdOf(line);
+                if (cwd !== undefined)
+                    codexCwd = cwd;
+            }
+            let match = false;
+            for (const found of line.matchAll(ID_PATTERN)) {
+                if (wanted.has(found[1])) {
+                    match = true;
+                    break;
+                }
+            }
+            if (!match)
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const lineHits = provider === 'claude-code' ? claudeToolUses(record, wanted) : codexToolCall(record, wanted);
+            if (lineHits.length === 0)
+                continue;
+            const cwd = provider === 'claude-code' ? record.cwd : codexCwd;
+            if (!inScope(cwd, roots, realpaths))
+                continue;
+            hits.push(...lineHits);
+        }
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        // Unreadable or vanished file: keep what was found.
+    }
+    finally {
+        lines.close();
+        stream.destroy();
+    }
+    return hits;
+}
+function codexCwdOf(line) {
+    try {
+        const record = JSON.parse(line);
+        if (record.type === 'session_meta' || record.type === 'turn_context') {
+            return record.payload?.cwd;
+        }
+    }
+    catch {
+        // Not a complete record.
+    }
+    return undefined;
+}
+function timeOf(record) {
+    const timestamp = record.timestamp;
+    if (typeof timestamp !== 'string')
+        return null;
+    const timestampMs = Date.parse(timestamp);
+    return Number.isFinite(timestampMs) ? { timestamp, timestampMs } : null;
+}
+function claudeToolUses(record, wanted) {
+    const row = record;
+    if (row?.type !== 'assistant' || !Array.isArray(row.message?.content))
+        return [];
+    const time = timeOf(record);
+    if (!time)
+        return [];
+    const hits = [];
+    for (const block of row.message.content) {
+        const item = block;
+        if ((item?.type === 'tool_use' || item?.type === 'server_tool_use') &&
+            typeof item.id === 'string' &&
+            wanted.has(item.id)) {
+            hits.push({
+                id: item.id,
+                ...time,
+                ...(typeof item.name === 'string' ? { toolName: item.name } : {}),
+            });
+        }
+    }
+    return hits;
+}
+function codexToolCall(record, wanted) {
+    const row = record;
+    const payloadType = row?.payload?.type;
+    if (row?.type !== 'response_item' ||
+        typeof payloadType !== 'string' ||
+        !payloadType.endsWith('_call')) {
+        return [];
+    }
+    const callId = row.payload?.call_id;
+    if (typeof callId !== 'string' || !wanted.has(callId))
+        return [];
+    const time = timeOf(record);
+    if (!time)
+        return [];
+    const name = row.payload?.name;
+    return [
+        {
+            id: callId,
+            ...time,
+            toolName: typeof name === 'string' ? name : payloadType.replace(/_call$/, ''),
+        },
+    ];
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw (signal.reason ?? Object.assign(new Error('The operation was aborted'), { name: 'AbortError' }));
+    }
+}

package/dist/transcript.d.ts

@@ -32,6 +32,13 @@ export interface CanonicalTranscriptBlock {
     command?: string;
     truncated?: boolean;
     raw?: unknown;
+    /**
+     * The provider's own tool name before normalization (for example Codex
+     * `exec_command` behind `Bash`), when the parser recorded one.
+     */
+    rawToolName?: string;
+    /** The MCP server that served this tool call, when the parser recorded one. */
+    mcpServerName?: string;
 }
 export interface CanonicalTranscriptMessage {
     id?: string;
@@ -51,10 +58,15 @@ export interface CanonicalToolCall {
     id?: string;
     name: string;
     timestamp: string;
+    /** Tool input without the parsers' internal `_sidekick*` bookkeeping keys. */
     input?: unknown;
     output?: unknown;
     isError?: boolean;
     command?: string;
+    /** The provider's own tool name before normalization, when recorded. */
+    rawToolName?: string;
+    /** The MCP server that served this tool call, when recorded. */
+    mcpServerName?: string;
     source: TranscriptSourceProvenance;
 }
 export interface CanonicalTranscriptUsageTotals {

package/dist/transcript.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectSessionTranscript = projectSessionTranscript;
 const usageNormalization_1 = require("./usageNormalization");
+const subagentSpawn_1 = require("./subagentSpawn");
 const EMPTY_TOTALS = {
     uncachedInputTokens: 0,
     cacheReadTokens: 0,
@@ -28,6 +29,9 @@ function projectSessionTranscript(events, options = {}) {
     let cwd;
     let gitBranch;
     events.forEach((event, eventIndex) => {
+        // A reader's synthetic notice that a background task finished, not a message.
+        if ((0, subagentSpawn_1.isTaskNotificationSystemEvent)(event))
+            return;
         if (nonEmpty(event.cwd))
             cwd = event.cwd;
         if (nonEmpty(event.gitBranch))
@@ -66,10 +70,12 @@ function projectSessionTranscript(events, options = {}) {
             blocks.push({ type: 'text', ...boundedText(event.summary, fidelity, maxContentChars) });
         }
         if (event.type === 'tool_use') {
+            const projected = projectToolInput(event.tool.input);
             blocks.push({
                 type: 'tool_use',
                 toolName: event.tool.name,
-                input: boundedValue(event.tool.input, fidelity, maxContentChars),
+                input: boundedValue(projected.input, fidelity, maxContentChars),
+                ...toolIdentity(projected),
             });
         }
         if (event.type === 'tool_result') {
@@ -90,6 +96,7 @@ function projectSessionTranscript(events, options = {}) {
                     timestamp: event.timestamp,
                     input: block.input,
                     command,
+                    ...toolIdentity(block),
                     source,
                 };
                 tools.push(call);
@@ -186,12 +193,14 @@ function contentBlocks(content, fidelity, maxChars, includeUnknown = false) {
             });
         }
         else if (block.type === 'tool_use' && typeof block.name === 'string') {
+            const projected = projectToolInput(block.input);
             result.push({
                 type: 'tool_use',
                 toolName: block.name,
                 toolUseId: typeof block.id === 'string' ? block.id : undefined,
-                input: boundedValue(block.input, fidelity, maxChars),
-                command: commandFromTool(block.name, block.input),
+                input: boundedValue(projected.input, fidelity, maxChars),
+                command: commandFromTool(block.name, projected.input),
+                ...toolIdentity(projected),
             });
         }
         else if (block.type === 'tool_result') {
@@ -215,6 +224,40 @@ function contentBlocks(content, fidelity, maxChars, includeUnknown = false) {
     }
     return result;
 }
+/** Prefix of the bookkeeping keys session parsers stash inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
+/**
+ * Lifts the parsers' `_sidekickRawToolName` / `_sidekickMcpServerName` out of
+ * a tool input and drops every other top-level `_sidekick*` key. Returns a
+ * copy when anything is removed; the source event is never modified.
+ */
+function projectToolInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return { input };
+    const source = input;
+    const keys = Object.keys(source);
+    if (!keys.some((key) => key.startsWith(SIDEKICK_INPUT_KEY_PREFIX)))
+        return { input };
+    const clean = {};
+    for (const key of keys) {
+        if (!key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+            clean[key] = source[key];
+    }
+    return {
+        input: clean,
+        rawToolName: nonEmptyString(source._sidekickRawToolName),
+        mcpServerName: nonEmptyString(source._sidekickMcpServerName),
+    };
+}
+function toolIdentity(value) {
+    return {
+        ...(value.rawToolName ? { rawToolName: value.rawToolName } : {}),
+        ...(value.mcpServerName ? { mcpServerName: value.mcpServerName } : {}),
+    };
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
 function boundedText(text, fidelity, maxChars) {
     if (fidelity === 'full' || text.length <= maxChars)
         return { text, truncated: false };

package/dist/turns/assistantTurn.d.ts

@@ -70,6 +70,7 @@ export interface ReasoningSummary {
     body: string;
 }
 export declare function reasoningSummary(text: string): ReasoningSummary;
+/** Whether a tool call spawns a subagent (`Agent`, or its earlier name `Task`). */
 export declare function isAssistantTurnSubagentTool(toolName: string | undefined): boolean;
 export declare function segmentAssistantTurn(events: readonly AssistantTurnEvent[], options?: SegmentAssistantTurnOptions): AssistantTurnProjection;
 export declare function assistantTurnEventsFromSessionEvents(events: readonly SessionEvent[]): AssistantTurnEvent[];