sidekick-shared 0.27.5 → 0.28.0

package/dist/sessionPromptHistory.d.ts

@@ -13,7 +13,7 @@
  * `sessionIds` continues. Scope fails closed as in `collectPromptHistory()`,
  * and replies or signals that belong to an out-of-scope prompt are dropped.
  */
-import { type PromptHistoryEntry, type PromptHistoryExclusion, type PromptHistoryProvider } from './promptHistory';
+import { type PromptHistoryEntry, type PromptHistoryExclusion, type PromptHistoryProvider, type PromptHistorySessionRef } from './promptHistory';
 import { type PromptHistoryReply, type PromptHistorySignal } from './sessionPromptSignals';
 export interface SessionPromptHistoryInclude {
     /** Interrupts, rejected and failed tool calls, compactions, API errors, rollbacks. */
@@ -40,8 +40,14 @@ export interface CollectSessionPromptHistoryOptions {
     includeWorktrees?: boolean;
     /** Default both. */
     providers?: PromptHistoryProvider[];
-    /** Only these sessions (exact ids). */
+    /** Only these sessions (exact ids, any provider). */
     sessionIds?: string[];
+    /**
+     * Only these sessions, matched on provider and id, or on the exact file
+     * when `sessionKey` is given. Combined with `sessionIds`, a session that
+     * matches either is read.
+     */
+    sessionRefs?: PromptHistorySessionRef[];
     /** Only sessions whose file changed at or after this. Each comes back whole. */
     since?: Date;
     /** Return at most this many sessions, most recently modified first. */
@@ -51,7 +57,7 @@ export interface CollectSessionPromptHistoryOptions {
     bounds?: SessionPromptHistoryBounds;
     signal?: AbortSignal;
 }
-export interface PromptHistorySessionPrompt extends Omit<PromptHistoryEntry, 'provider' | 'sessionId'> {
+export interface PromptHistorySessionPrompt extends Omit<PromptHistoryEntry, 'provider' | 'sessionId' | 'sessionKey'> {
     /** With `include.replies`: the agent's last text for this prompt's turn. */
     reply?: PromptHistoryReply;
 }
@@ -80,11 +86,10 @@ export interface PromptHistorySession {
     droppedPrompts: number;
     /** Records left out as oversized or malformed (see `exclusions`). */
     excludedRecords: number;
+    /** Opaque key of the session file; tells apart two files with one session id. */
+    sessionKey?: string;
 }
-export interface PromptHistorySessionRef {
-    provider: PromptHistoryProvider;
-    sessionId: string;
-}
+export type { PromptHistorySessionRef };
 export type SessionPromptHistoryBound = 'maxSessions' | 'maxSessionBytes' | 'maxTotalBytes' | 'deadline' | 'aborted';
 export interface SessionPromptHistoryStats {
     /** Session files that matched the provider, id, and `since` filters. */

package/dist/sessionPromptHistory.js

@@ -117,6 +117,7 @@ async function collectSessionPromptHistory(options) {
     const refOf = ({ candidate }) => ({
         provider: candidate.provider,
         sessionId: candidate.sessionId,
+        sessionKey: candidate.key,
     });
     let totalBytes = 0;
     for (let index = 0; index < selected.length && sessions.length < limit; index++) {
@@ -224,9 +225,19 @@ async function selectCandidates(options, listingRoots) {
     const sinceMs = options.since ? options.since.getTime() : null;
     const providers = options.providers ?? ['claude-code', 'codex'];
     let candidates = await (0, promptHistory_1.listCandidates)(providers, listingRoots, sinceMs);
-    if (options.sessionIds) {
-        const wanted = new Set(options.sessionIds);
-        candidates = candidates.filter((candidate) => wanted.has(candidate.sessionId));
+    if (options.sessionIds || options.sessionRefs) {
+        const ids = new Set(options.sessionIds ?? []);
+        const keys = new Set();
+        const refs = new Set();
+        for (const ref of options.sessionRefs ?? []) {
+            if (ref.sessionKey)
+                keys.add(ref.sessionKey);
+            else
+                refs.add(`${ref.provider}:${ref.sessionId}`);
+        }
+        candidates = candidates.filter((candidate) => ids.has(candidate.sessionId) ||
+            keys.has(candidate.key) ||
+            refs.has(`${candidate.provider}:${candidate.sessionId}`));
     }
     const selected = [];
     for (const candidate of candidates) {
@@ -251,6 +262,7 @@ function buildSession(candidate, entries, lastOrdinal, extraction, include, read
     const session = {
         provider: candidate.provider,
         sessionId: candidate.sessionId,
+        sessionKey: candidate.key,
         startedAt: extraction.firstTimestamp ?? ordered[0].timestamp,
         lastActivityAt: extraction.lastTimestamp ?? ordered[ordered.length - 1].timestamp,
         cwds: distinct(ordered.map((entry) => entry.cwd)),

package/dist/sessionPromptSignals.d.ts

@@ -9,6 +9,7 @@
  * ordinals of `collectPromptHistory()`.
  */
 import type { PromptHistoryProvider } from './promptHistory';
+import { type ToolCategory } from './toolCategory';
 export type PromptHistorySignalKind = 'interrupt' | 'toolRejected' | 'toolError' | 'compaction' | 'apiError' | 'rollback';
 export interface PromptHistorySignal {
     kind: PromptHistorySignalKind;
@@ -18,6 +19,14 @@ export interface PromptHistorySignal {
     afterOrdinal: number;
     /** The tool involved, for `toolRejected` and `toolError`, when the log names it. */
     tool?: string;
+    /** What `tool` does (`shell`, `file_edit`, `mcp`, …), from `classifyTool()`. */
+    toolCategory?: ToolCategory;
+    /**
+     * The MCP server of an MCP tool call: from `mcp__<server>__<tool>` names
+     * (Claude Code) or the call's own server field (Codex, whose `tool` is the
+     * bare tool name).
+     */
+    mcpServer?: string;
     /**
      * `toolRejected`: the reason the person typed, untruncated. `toolError` and
      * `apiError`: the error text, cut to 1024 characters (`textTruncated`).

package/dist/sessionPromptSignals.js

@@ -12,6 +12,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SIGNAL_TEXT_CHARS = void 0;
 exports.createSessionRecordExtractor = createSessionRecordExtractor;
+const mcpToolName_1 = require("./parsers/mcpToolName");
+const toolCategory_1 = require("./toolCategory");
 /** Error text kept on a signal; tool output can be arbitrarily long. */
 exports.SIGNAL_TEXT_CHARS = 1024;
 const CLAUDE_REJECTED_PREFIX = "The user doesn't want to proceed with this tool use";
@@ -64,6 +66,13 @@ class RecordExtractor {
         const signal = { kind, timestamp, afterOrdinal: ordinal };
         if (detail.tool)
             signal.tool = detail.tool;
+        if (detail.tool || detail.mcp) {
+            const mcpServer = detail.mcpServer || (detail.tool ? (0, mcpToolName_1.parseMcpToolName)(detail.tool)?.serverName : undefined);
+            signal.toolCategory =
+                detail.mcp || !detail.tool ? 'mcp' : (0, toolCategory_1.classifyTool)(detail.tool, { mcpServer });
+            if (mcpServer)
+                signal.mcpServer = mcpServer;
+        }
         if (detail.fullText) {
             signal.text = detail.fullText;
         }
@@ -234,6 +243,8 @@ class CodexRecordExtractor extends RecordExtractor {
                 if (failure !== null) {
                     this.signal('toolError', timestamp, ordinal, {
                         tool: invocation ? stringValue(invocation.tool) : undefined,
+                        mcp: true,
+                        mcpServer: invocation ? stringValue(invocation.server) : undefined,
                         text: failure,
                     });
                 }
@@ -273,6 +284,8 @@ class CodexRecordExtractor extends RecordExtractor {
                 if (failed) {
                     this.signal('toolError', timestamp, ordinal, {
                         tool: stringValue(row.tool),
+                        mcp: true,
+                        mcpServer: stringValue(row.server),
                         text: row.error !== undefined && row.error !== null
                             ? errorText(row.error)
                             : (mcpFailure(row.result) ?? undefined),

package/dist/terminalSync.d.ts

@@ -1,7 +1,17 @@
 import type { AccountProviderId } from './accountRegistry';
 /**
- * Write a POSIX launcher script that runs the provider CLI against a profile
- * home. Unix only; on Windows use `sidekick accounts env --shell powershell`.
+ * Write a POSIX launcher script that runs the provider CLI as a saved account.
+ * The script defers to `sidekick accounts shell` at run time, which resolves
+ * the right home then: the account's profile home while it is inactive, the
+ * live home while it is the live login (a session pinned to the profile home
+ * would otherwise be a second copy of the live login). Unix only; on Windows
+ * use `sidekick accounts env --shell powershell`.
+ */
+export declare function writeAccountLauncher(name: string, provider: AccountProviderId, accountId: string): void;
+/**
+ * @deprecated Pins a launcher to one profile home; when that account becomes
+ * the live login the launcher runs a second copy of it. Use
+ * {@link writeAccountLauncher}.
  */
 export declare function writeLauncher(name: string, provider: AccountProviderId, profileHome: string): void;
 export declare function removeLauncher(name: string): void;

package/dist/terminalSync.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAccountLauncher = writeAccountLauncher;
 exports.writeLauncher = writeLauncher;
 exports.removeLauncher = removeLauncher;
 const fs = __importStar(require("fs"));
@@ -79,9 +80,33 @@ function assertNoLauncherCollision(name, targetPath) {
         }
     }
 }
+function shellSingleQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Write a POSIX launcher script that runs the provider CLI as a saved account.
+ * The script defers to `sidekick accounts shell` at run time, which resolves
+ * the right home then: the account's profile home while it is inactive, the
+ * live home while it is the live login (a session pinned to the profile home
+ * would otherwise be a second copy of the live login). Unix only; on Windows
+ * use `sidekick accounts env --shell powershell`.
+ */
+function writeAccountLauncher(name, provider, accountId) {
+    assertValidLauncherName(name);
+    const launcherPath = getLauncherPath(name);
+    assertNoLauncherCollision(name, launcherPath);
+    const script = [
+        '#!/bin/sh',
+        LAUNCHER_MARKER,
+        `exec sidekick accounts shell --provider ${provider} ${shellSingleQuote(accountId)} -- ${providerBinary(provider)} "$@"`,
+        '',
+    ].join('\n');
+    (0, atomic_1.atomicWriteFileSync)(launcherPath, script, 0o755);
+}
 /**
- * Write a POSIX launcher script that runs the provider CLI against a profile
- * home. Unix only; on Windows use `sidekick accounts env --shell powershell`.
+ * @deprecated Pins a launcher to one profile home; when that account becomes
+ * the live login the launcher runs a second copy of it. Use
+ * {@link writeAccountLauncher}.
  */
 function writeLauncher(name, provider, profileHome) {
     assertValidLauncherName(name);

package/dist/testing/credentialGuard.d.ts

@@ -0,0 +1,23 @@
+export interface CredentialGuard {
+    /** The developer's real home, from the passwd entry. */
+    readonly realHome: string;
+    /** The temp directory `HOME` now points at. */
+    readonly testHome: string;
+    /** Violations recorded since the last `take()`. */
+    readonly violations: string[];
+    /** Drain and return the recorded violations. */
+    take(): string[];
+    /** Throw when anything reached real credentials or homes since the last check. */
+    assertNoViolations(): void;
+}
+export interface CredentialGuardOptions {
+    /** Binaries no child process may run (default `security`, `claude`, `codex`). */
+    blockedBinaries?: string[];
+    /** Extra real paths to protect, besides the Claude, Codex, and Sidekick homes. */
+    protectedPaths?: string[];
+}
+/**
+ * Installs the guard once per process and returns it; later calls return the
+ * same guard and ignore their options.
+ */
+export declare function installCredentialGuard(options?: CredentialGuardOptions): CredentialGuard;

package/dist/testing/credentialGuard.js

@@ -0,0 +1,233 @@
+"use strict";
+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.installCredentialGuard = installCredentialGuard;
+/**
+ * Credential guard for test runners, published as `sidekick-shared/testing`.
+ *
+ * No test may reach the real macOS `security` binary, the real `claude` /
+ * `codex` CLIs, or the developer's real Claude, Codex, or Sidekick homes: a
+ * stray keychain write copies a live refresh token, and Claude Code rotates
+ * that token on every refresh, so a second copy is a login waiting to die.
+ *
+ * Three layers:
+ * - `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;
+ * - 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
+ *   replace the module and never get here;
+ * - the real `fs` module refuses writes under the real homes and records reads.
+ *
+ * Production code swallows most errors, so violations are also recorded;
+ * call `assertNoViolations()` after each test (see `credentialGuard.setup.ts`
+ * for a vitest wiring). Framework-free; the real modules come from
+ * `process.getBuiltinModule` (Node 20.16+), or `require` in CommonJS.
+ *
+ * @module testing/credentialGuard
+ */
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const GUARD_KEY = '__sidekickCredentialGuard';
+const DEFAULT_BLOCKED_BINARIES = ['security', 'claude', 'codex'];
+const CHILD_PROCESS_FUNCTIONS = [
+    'spawn',
+    'spawnSync',
+    'execFile',
+    'execFileSync',
+    'exec',
+    'execSync',
+];
+const FS_WRITE_FUNCTIONS = [
+    'writeFileSync',
+    'appendFileSync',
+    'mkdirSync',
+    'rmSync',
+    'rmdirSync',
+    'unlinkSync',
+    'renameSync',
+    'copyFileSync',
+    'cpSync',
+    'chmodSync',
+    'symlinkSync',
+];
+const FS_READ_FUNCTIONS = [
+    'readFileSync',
+    'existsSync',
+    'statSync',
+    'lstatSync',
+    'readdirSync',
+    'openSync',
+    'watch',
+];
+/**
+ * Installs the guard once per process and returns it; later calls return the
+ * same guard and ignore their options.
+ */
+function installCredentialGuard(options = {}) {
+    const existing = globalThis[GUARD_KEY];
+    if (existing)
+        return existing;
+    const childProcess = builtin('node:child_process');
+    const realFs = builtin('node:fs');
+    const fs = realFs;
+    const { syncBuiltinESMExports } = builtin('node:module');
+    const blockedBinaries = new Set((options.blockedBinaries ?? DEFAULT_BLOCKED_BINARIES).map((name) => name.toLowerCase()));
+    // os.userInfo() reads the passwd entry, so it still names the real home
+    // after HOME is redirected below.
+    const realHome = os.userInfo().homedir;
+    const testHome = realFs.mkdtempSync(path.join(os.tmpdir(), 'sidekick-test-home-'));
+    const removeTestHome = realFs.rmSync.bind(realFs);
+    process.once('exit', () => {
+        try {
+            removeTestHome(testHome, { recursive: true, force: true });
+        }
+        catch {
+            /* best effort */
+        }
+    });
+    const state = {
+        realHome,
+        testHome,
+        violations: [],
+        take() {
+            return state.violations.splice(0, state.violations.length);
+        },
+        assertNoViolations() {
+            const violations = state.take();
+            if (violations.length > 0) {
+                throw new Error(`Credential guard: this test reached real credentials or homes:\n- ${violations.join('\n- ')}`);
+            }
+        },
+    };
+    process.env.HOME = testHome;
+    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;
+    const protectedRoots = path.resolve(realHome) === path.resolve(testHome)
+        ? []
+        : [
+            path.join(realHome, '.claude'),
+            path.join(realHome, '.claude.json'),
+            path.join(realHome, '.codex'),
+            path.join(realHome, '.config', 'sidekick'),
+            ...(options.protectedPaths ?? []),
+        ];
+    const isProtected = (target) => {
+        let candidate = null;
+        if (typeof target === 'string')
+            candidate = target;
+        else if (target instanceof URL && target.protocol === 'file:')
+            candidate = target.pathname;
+        if (!candidate)
+            return null;
+        const resolved = path.resolve(candidate);
+        return protectedRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
+            ? resolved
+            : null;
+    };
+    const binaryName = (command) => {
+        if (typeof command !== 'string')
+            return '';
+        const first = command.trim().split(/\s+/)[0] ?? '';
+        return path
+            .basename(first.replace(/^["']|["']$/g, ''))
+            .replace(/\.(exe|cmd|bat)$/i, '')
+            .toLowerCase();
+    };
+    const record = (message) => {
+        state.violations.push(message);
+        throw new Error(`[credential guard] ${message}`);
+    };
+    for (const name of CHILD_PROCESS_FUNCTIONS) {
+        const original = childProcess[name];
+        if (typeof original !== 'function')
+            continue;
+        childProcess[name] = function guarded(...args) {
+            const binary = binaryName(args[0]);
+            if (blockedBinaries.has(binary)) {
+                record(`child_process.${name}('${binary}') reached the real binary; mock child_process or inject a runner`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_WRITE_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            for (const arg of args.slice(0, 2)) {
+                const hit = isProtected(arg);
+                if (hit)
+                    record(`fs.${name}(${hit}) would write inside the real home`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_READ_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            const hit = isProtected(args[0]);
+            // Reads are recorded rather than thrown so existsSync keeps its
+            // never-throws contract; the afterEach below still fails the test.
+            if (hit)
+                state.violations.push(`fs.${name}(${hit}) read the real home`);
+            return original.apply(this, args);
+        };
+    }
+    syncBuiltinESMExports();
+    globalThis[GUARD_KEY] = state;
+    return state;
+}
+/**
+ * The real module object of a Node built-in: `process.getBuiltinModule`
+ * (Node 20.16+), or `require` in CommonJS on older Node.
+ */
+function builtin(id) {
+    if (typeof process.getBuiltinModule === 'function')
+        return process.getBuiltinModule(id);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- CommonJS fallback for Node < 20.16
+    if (typeof require === 'function')
+        return require(id);
+    throw new Error('installCredentialGuard() needs Node 20.16+ outside CommonJS.');
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Testing entry (`sidekick-shared/testing`): helpers for test suites that
+ * exercise sidekick-shared against Claude Code and Codex session data.
+ *
+ * - `installCredentialGuard()` keeps tests away from the real `security`,
+ *   `claude`, and `codex` binaries and the real Claude, Codex, and Sidekick
+ *   homes.
+ * - The session-log builders write Claude Code and Codex logs in the shapes
+ *   the readers parse.
+ */
+export { installCredentialGuard } from './credentialGuard';
+export type { CredentialGuard, CredentialGuardOptions } from './credentialGuard';
+export { appendJsonl, claudeFiller, codexFiller, createSessionLogFixtures, ts, writeJsonl, } from './sessionLogFixtures';
+export type { Row, SessionLogFixtureContext } from './sessionLogFixtures';

package/dist/testing/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeJsonl = exports.ts = exports.createSessionLogFixtures = exports.codexFiller = exports.claudeFiller = exports.appendJsonl = exports.installCredentialGuard = void 0;
+/**
+ * Testing entry (`sidekick-shared/testing`): helpers for test suites that
+ * exercise sidekick-shared against Claude Code and Codex session data.
+ *
+ * - `installCredentialGuard()` keeps tests away from the real `security`,
+ *   `claude`, and `codex` binaries and the real Claude, Codex, and Sidekick
+ *   homes.
+ * - The session-log builders write Claude Code and Codex logs in the shapes
+ *   the readers parse.
+ */
+var credentialGuard_1 = require("./credentialGuard");
+Object.defineProperty(exports, "installCredentialGuard", { enumerable: true, get: function () { return credentialGuard_1.installCredentialGuard; } });
+var sessionLogFixtures_1 = require("./sessionLogFixtures");
+Object.defineProperty(exports, "appendJsonl", { enumerable: true, get: function () { return sessionLogFixtures_1.appendJsonl; } });
+Object.defineProperty(exports, "claudeFiller", { enumerable: true, get: function () { return sessionLogFixtures_1.claudeFiller; } });
+Object.defineProperty(exports, "codexFiller", { enumerable: true, get: function () { return sessionLogFixtures_1.codexFiller; } });
+Object.defineProperty(exports, "createSessionLogFixtures", { enumerable: true, get: function () { return sessionLogFixtures_1.createSessionLogFixtures; } });
+Object.defineProperty(exports, "ts", { enumerable: true, get: function () { return sessionLogFixtures_1.ts; } });
+Object.defineProperty(exports, "writeJsonl", { enumerable: true, get: function () { return sessionLogFixtures_1.writeJsonl; } });

package/dist/testing/sessionLogFixtures.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Claude Code and Codex session-log builders shared by the prompt-history
+ * tests, published through `sidekick-shared/testing`.
+ */
+export type Row = Record<string, unknown>;
+export declare function ts(second: number): string;
+export declare function writeJsonl(file: string, rows: Row[]): void;
+export declare function appendJsonl(file: string, rows: Row[]): void;
+/** A Claude Code line with no message: read and ignored, like progress records. */
+export declare function claudeFiller(bytes: number, second: number): Row;
+/** A Codex line that is neither a prompt nor usage. */
+export declare function codexFiller(bytes: number, second: number): Row;
+export interface SessionLogFixtureContext {
+    /** The mocked home directory holding `.claude/` and `.codex/`. */
+    home: string;
+    /** Default working directory recorded on Claude lines. */
+    repo: string;
+}
+/** Builders that read the per-test home and repo lazily from `context`. */
+export declare function createSessionLogFixtures(context: () => SessionLogFixtureContext): {
+    claudeFile: (workspace: string, sessionId: string) => string;
+    claudeUser: (content: unknown, second: number, extra?: Row) => Row;
+    claudeAssistant: (id: string, second: number, extra?: Row, message?: Row) => Row;
+    codexFile: () => string;
+    codexMeta: (cwd: string | undefined, source?: unknown, extra?: Row) => Row;
+    codexUser: (texts: string[], second: number) => Row;
+    codexTokenCount: (second: number) => Row;
+};