@paraharness/claude 0.0.0-stage → 0.2.0

package/dist/driver/claude-model-driver.d.ts

@@ -0,0 +1,71 @@
+import type { AppendToolResultNotesOptions, ClaudeModelNode, ForkContext, ModelDriver, ModelTurnRequest, ModelTurnResponse, PrepareForkTarget, RuntimeDriverContext, WireFrameRecord } from '@paraharness/core';
+import type { ClaudeHttpTransport } from './claude-http-transport.js';
+/**
+ * Runtime `ModelDriver` implementation for the Anthropic `/v1/messages` HTTP protocol (`@paraharness/claude`).
+ *
+ * Resolves CLI subscription `configDir` OAuth tokens and `EnvRef` API keys at turn invocation time,
+ * preserves `thinking` blocks and cryptographic `signature` fields in `rawWireFrame`, enforces native
+ * `output_config.format` JSON-schema structured output, and prepares KV-cache-preserving forks.
+ */
+export declare class ClaudeModelDriver implements ModelDriver {
+    /** Primary vendor identifier (`'anthropic'`). */
+    readonly vendorId: "anthropic";
+    /** Vendor alias matching `vendorId` (`'anthropic'`). */
+    readonly vendor: "anthropic";
+    /** Underlying HTTP transport used to dispatch `/v1/messages` requests. */
+    private readonly transport;
+    /** Optional passive `ClaudeModelNode` bound to this driver instance. */
+    private readonly modelNode;
+    /** Optional runtime driver context providing `resolveEnv` for symbolic `EnvRef` keys. */
+    private readonly driverCtx;
+    /**
+     * Initializes a `ClaudeModelDriver` with an HTTP transport, optional `ClaudeModelNode`, and runtime context.
+     *
+     * Defers all credential and environment variable lookups until `invokeTurn()` is executed.
+     *
+     * @param {ClaudeHttpTransport}              [transport=defaultClaudeHttpTransport] - HTTP transport for `/v1/messages`.
+     * @param {ClaudeModelNode | undefined}      [modelNode]                            - Optional bound `ClaudeModelNode`.
+     * @param {RuntimeDriverContext | undefined} [driverCtx]                            - Optional runtime driver context.
+     */
+    constructor(transport?: ClaudeHttpTransport, modelNode?: ClaudeModelNode, driverCtx?: RuntimeDriverContext);
+    /**
+     * Invokes a single Anthropic `/v1/messages` turn over `req.history` and returns the raw wire frame and canonical projection.
+     *
+     * Validates HTTP status codes before parsing `bodyText` so non-JSON error payloads (`502 Bad Gateway`) never crash
+     * with `SyntaxError`, and propagates HTTP `429` rate-limit responses with `{ status: 429, resetAtMs }`.
+     *
+     * @param {ModelTurnRequest} req - Turn request payload, wire prefix, and structured output schema.
+     *
+     * @returns {Promise<ModelTurnResponse>} Raw wire response, canonical message, structured output, and usage metrics.
+     *
+     * @throws {Error} On HTTP `429` rate limits, non-2xx statuses, aborted signals, or `outputSchema` validation failures.
+     */
+    invokeTurn(req: ModelTurnRequest): Promise<ModelTurnResponse>;
+    /**
+     * Synthesizes the initial `WireFrameRecord[]` chain for a downward fork or cross-model escalation.
+     *
+     * Preserves byte-identical `rawWireFrame` payloads with `cache_control: { type: 'ephemeral' }` when
+     * `target.substituteTombstones === false`, and re-projects `CanonicalMessage` frames with compacted
+     * tombstones when `target.substituteTombstones === true`.
+     *
+     * @param {ForkContext}       ctx    - Fork lineage, history mode, and assistant turn-batch pairing metadata.
+     * @param {PrepareForkTarget} target - Target model configuration and tombstone substitution flag.
+     *
+     * @returns {Promise<readonly WireFrameRecord[]>} Synthesized wire frame chain to persist in `LedgerStore`.
+     */
+    prepareFork(ctx: ForkContext, target: PrepareForkTarget): Promise<readonly WireFrameRecord[]>;
+    /**
+     * Appends synchronization or recovery notes in-place to an Anthropic `role: 'tool'` or `role: 'user'` frame.
+     *
+     * Updates both `rawWireFrame` and `frame.canonical` without breaking conversation role alternation.
+     *
+     * @param {WireFrameRecord}                          frame        - Existing `tool` or `user` wire frame record.
+     * @param {readonly string[]}                        notes        - Synchronization note strings to append.
+     * @param {string | undefined}                       targetCallId - Optional tool `callId` to target on a `tool` frame.
+     * @param {AppendToolResultNotesOptions | undefined} opts         - Optional error status override.
+     *
+     * @returns {Promise<WireFrameRecord>} Updated wire frame record to persist via `LedgerStore.replaceMessageFrame()`.
+     */
+    appendToolResultNotes(frame: WireFrameRecord, notes: readonly string[], targetCallId?: string, opts?: AppendToolResultNotesOptions): Promise<WireFrameRecord>;
+}
+//# sourceMappingURL=claude-model-driver.d.ts.map

package/dist/driver/claude-model-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-model-driver.d.ts","sourceRoot":"","sources":["../../src/driver/claude-model-driver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,eAAe,EACf,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AActE;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAG,WAAW,CAAU;IAEzC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAG,WAAW,CAAU;IAEvC,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAEhD,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA8B;IAExD,yFAAyF;IACzF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmC;IAE7D;;;;;;;;OAQG;gBAED,SAAS,GAAE,mBAAgD,EAC3D,SAAS,CAAC,EAAE,eAAe,EAC3B,SAAS,CAAC,EAAE,oBAAoB;IAOlC;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAwBnE;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAI7F;;;;;;;;;;;OAWG;IACH,qBAAqB,CACnB,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,YAAY,CAAC,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,4BAA4B,GAClC,OAAO,CAAC,eAAe,CAAC;CAK5B"}

package/dist/driver/claude-model-driver.js

@@ -0,0 +1,105 @@
+import { ANTHROPIC_MESSAGES_ENDPOINT, defaultClaudeHttpTransport, } from './default-claude-http-transport.constants.js';
+import { claudeAppendToolResultNotes } from './internal/claude-append-tool-result-notes.js';
+import { claudePrepareFork } from './internal/claude-prepare-fork.js';
+import { buildAnthropicMessagesRequest, parseAnthropicMessagesResponse, } from './internal/claude-wire-converter.js';
+import { extractClaudeResponseBody } from './internal/extract-claude-response-body.js';
+import { resolveClaudeSeatAuth } from './internal/resolve-claude-seat-auth.js';
+/**
+ * Runtime `ModelDriver` implementation for the Anthropic `/v1/messages` HTTP protocol (`@paraharness/claude`).
+ *
+ * Resolves CLI subscription `configDir` OAuth tokens and `EnvRef` API keys at turn invocation time,
+ * preserves `thinking` blocks and cryptographic `signature` fields in `rawWireFrame`, enforces native
+ * `output_config.format` JSON-schema structured output, and prepares KV-cache-preserving forks.
+ */
+export class ClaudeModelDriver {
+    /** Primary vendor identifier (`'anthropic'`). */
+    vendorId = 'anthropic';
+    /** Vendor alias matching `vendorId` (`'anthropic'`). */
+    vendor = 'anthropic';
+    /** Underlying HTTP transport used to dispatch `/v1/messages` requests. */
+    transport;
+    /** Optional passive `ClaudeModelNode` bound to this driver instance. */
+    modelNode;
+    /** Optional runtime driver context providing `resolveEnv` for symbolic `EnvRef` keys. */
+    driverCtx;
+    /**
+     * Initializes a `ClaudeModelDriver` with an HTTP transport, optional `ClaudeModelNode`, and runtime context.
+     *
+     * Defers all credential and environment variable lookups until `invokeTurn()` is executed.
+     *
+     * @param {ClaudeHttpTransport}              [transport=defaultClaudeHttpTransport] - HTTP transport for `/v1/messages`.
+     * @param {ClaudeModelNode | undefined}      [modelNode]                            - Optional bound `ClaudeModelNode`.
+     * @param {RuntimeDriverContext | undefined} [driverCtx]                            - Optional runtime driver context.
+     */
+    constructor(transport = defaultClaudeHttpTransport, modelNode, driverCtx) {
+        this.transport = transport;
+        this.modelNode = modelNode;
+        this.driverCtx = driverCtx;
+    }
+    /**
+     * Invokes a single Anthropic `/v1/messages` turn over `req.history` and returns the raw wire frame and canonical projection.
+     *
+     * Validates HTTP status codes before parsing `bodyText` so non-JSON error payloads (`502 Bad Gateway`) never crash
+     * with `SyntaxError`, and propagates HTTP `429` rate-limit responses with `{ status: 429, resetAtMs }`.
+     *
+     * @param {ModelTurnRequest} req - Turn request payload, wire prefix, and structured output schema.
+     *
+     * @returns {Promise<ModelTurnResponse>} Raw wire response, canonical message, structured output, and usage metrics.
+     *
+     * @throws {Error} On HTTP `429` rate limits, non-2xx statuses, aborted signals, or `outputSchema` validation failures.
+     */
+    async invokeTurn(req) {
+        req.signal?.throwIfAborted();
+        const auth = resolveClaudeSeatAuth({
+            accountConfig: req.accountConfig,
+            modelNode: this.modelNode,
+            driverCtx: this.driverCtx,
+        });
+        const body = buildAnthropicMessagesRequest(req);
+        const response = await this.transport.sendMessagesRequest({
+            url: ANTHROPIC_MESSAGES_ENDPOINT,
+            headers: auth.headers,
+            body,
+            seatId: auth.seatId,
+            authSource: auth.authSource,
+            signal: req.signal,
+        });
+        const responseBody = extractClaudeResponseBody({
+            response,
+            modelId: req.modelId,
+            seatId: auth.seatId,
+        });
+        return parseAnthropicMessagesResponse(responseBody, req);
+    }
+    /**
+     * Synthesizes the initial `WireFrameRecord[]` chain for a downward fork or cross-model escalation.
+     *
+     * Preserves byte-identical `rawWireFrame` payloads with `cache_control: { type: 'ephemeral' }` when
+     * `target.substituteTombstones === false`, and re-projects `CanonicalMessage` frames with compacted
+     * tombstones when `target.substituteTombstones === true`.
+     *
+     * @param {ForkContext}       ctx    - Fork lineage, history mode, and assistant turn-batch pairing metadata.
+     * @param {PrepareForkTarget} target - Target model configuration and tombstone substitution flag.
+     *
+     * @returns {Promise<readonly WireFrameRecord[]>} Synthesized wire frame chain to persist in `LedgerStore`.
+     */
+    prepareFork(ctx, target) {
+        return Promise.resolve(claudePrepareFork(ctx, target));
+    }
+    /**
+     * Appends synchronization or recovery notes in-place to an Anthropic `role: 'tool'` or `role: 'user'` frame.
+     *
+     * Updates both `rawWireFrame` and `frame.canonical` without breaking conversation role alternation.
+     *
+     * @param {WireFrameRecord}                          frame        - Existing `tool` or `user` wire frame record.
+     * @param {readonly string[]}                        notes        - Synchronization note strings to append.
+     * @param {string | undefined}                       targetCallId - Optional tool `callId` to target on a `tool` frame.
+     * @param {AppendToolResultNotesOptions | undefined} opts         - Optional error status override.
+     *
+     * @returns {Promise<WireFrameRecord>} Updated wire frame record to persist via `LedgerStore.replaceMessageFrame()`.
+     */
+    appendToolResultNotes(frame, notes, targetCallId, opts) {
+        return Promise.resolve(claudeAppendToolResultNotes({ frame, notes, targetCallId, opts }));
+    }
+}
+//# sourceMappingURL=claude-model-driver.js.map

package/dist/driver/claude-model-driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-model-driver.js","sourceRoot":"","sources":["../../src/driver/claude-model-driver.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+CAA+C,CAAC;AAC5F,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAE/E;;;;;;GAMG;AACH,MAAM,OAAO,iBAAiB;IAC5B,iDAAiD;IACxC,QAAQ,GAAG,WAAoB,CAAC;IAEzC,wDAAwD;IAC/C,MAAM,GAAG,WAAoB,CAAC;IAEvC,0EAA0E;IACzD,SAAS,CAAsB;IAEhD,wEAAwE;IACvD,SAAS,CAA8B;IAExD,yFAAyF;IACxE,SAAS,CAAmC;IAE7D;;;;;;;;OAQG;IACH,YACE,YAAiC,0BAA0B,EAC3D,SAA2B,EAC3B,SAAgC;QAEhC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,UAAU,CAAC,GAAqB;QACpC,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,qBAAqB,CAAC;YACjC,aAAa,EAAE,GAAG,CAAC,aAAa;YAChC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,6BAA6B,CAAC,GAAG,CAAC,CAAC;QAChD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC;YACxD,GAAG,EAAE,2BAA2B;YAChC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,IAAI;YACJ,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM,EAAE,GAAG,CAAC,MAAM;SACnB,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,yBAAyB,CAAC;YAC7C,QAAQ;YACR,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC,CAAC;QACH,OAAO,8BAA8B,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,GAAgB,EAAE,MAAyB;QACrD,OAAO,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,qBAAqB,CACnB,KAAsB,EACtB,KAAwB,EACxB,YAAqB,EACrB,IAAmC;QAEnC,OAAO,OAAO,CAAC,OAAO,CACpB,2BAA2B,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAClE,CAAC;IACJ,CAAC;CACF"}

package/dist/driver/create-claude-executors.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeExecutorRegistrySlice } from '@paraharness/core';
+import type { ClaudeHttpTransport } from './claude-http-transport.js';
+/**
+ * Creates a `RuntimeExecutorRegistrySlice` registering `ClaudeModelDriver` for `'claude:model'` AST nodes.
+ *
+ * Accepts an optional custom `ClaudeHttpTransport` for deterministic testing while defaulting to
+ * `defaultClaudeHttpTransport` in production.
+ *
+ * @param {ClaudeHttpTransport} [transport=defaultClaudeHttpTransport] - HTTP transport used by `ClaudeModelDriver`.
+ *
+ * @returns {RuntimeExecutorRegistrySlice} Frozen executor registry slice with `models['claude:model']`.
+ */
+export declare function createClaudeExecutors(transport?: ClaudeHttpTransport): RuntimeExecutorRegistrySlice;
+//# sourceMappingURL=create-claude-executors.d.ts.map

package/dist/driver/create-claude-executors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-claude-executors.d.ts","sourceRoot":"","sources":["../../src/driver/create-claude-executors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,4BAA4B,EAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAItE;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,GAAE,mBAAgD,GAC1D,4BAA4B,CAO9B"}

package/dist/driver/create-claude-executors.js

@@ -0,0 +1,20 @@
+import { ClaudeModelDriver } from './claude-model-driver.js';
+import { defaultClaudeHttpTransport } from './default-claude-http-transport.constants.js';
+/**
+ * Creates a `RuntimeExecutorRegistrySlice` registering `ClaudeModelDriver` for `'claude:model'` AST nodes.
+ *
+ * Accepts an optional custom `ClaudeHttpTransport` for deterministic testing while defaulting to
+ * `defaultClaudeHttpTransport` in production.
+ *
+ * @param {ClaudeHttpTransport} [transport=defaultClaudeHttpTransport] - HTTP transport used by `ClaudeModelDriver`.
+ *
+ * @returns {RuntimeExecutorRegistrySlice} Frozen executor registry slice with `models['claude:model']`.
+ */
+export function createClaudeExecutors(transport = defaultClaudeHttpTransport) {
+    return Object.freeze({
+        models: Object.freeze({
+            'claude:model': (node, ctx) => new ClaudeModelDriver(transport, node, ctx),
+        }),
+    });
+}
+//# sourceMappingURL=create-claude-executors.js.map

package/dist/driver/create-claude-executors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-claude-executors.js","sourceRoot":"","sources":["../../src/driver/create-claude-executors.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8CAA8C,CAAC;AAE1F;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAAiC,0BAA0B;IAE3D,OAAO,MAAM,CAAC,MAAM,CAA+B;QACjD,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;YACpB,cAAc,EAAE,CAAC,IAAqB,EAAE,GAAyB,EAAqB,EAAE,CACtF,IAAI,iBAAiB,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,CAAC;SAC9C,CAAC;KACH,CAAC,CAAC;AACL,CAAC"}

package/dist/driver/default-claude-http-transport.constants.d.ts

@@ -0,0 +1,14 @@
+import type { ClaudeHttpTransport } from './claude-http-transport.js';
+/** Default Anthropic Messages API HTTPS endpoint URL. */
+export declare const ANTHROPIC_MESSAGES_ENDPOINT = "https://api.anthropic.com/v1/messages";
+/** Default Anthropic API version header value. */
+export declare const ANTHROPIC_API_VERSION = "2023-06-01";
+/** Default `max_tokens` ceiling sent on Anthropic `/v1/messages` requests. */
+export declare const DEFAULT_CLAUDE_MAX_TOKENS = 16384;
+/** Extended thinking token budgets keyed by reasoning effort level (`'low' | 'medium' | 'high'`). */
+export declare const CLAUDE_THINKING_BUDGETS: Readonly<Record<'low' | 'medium' | 'high', number>>;
+/** Candidate credential filenames searched inside a Claude CLI `configDir`. */
+export declare const CLAUDE_CREDENTIAL_FILENAMES: readonly string[];
+/** Default `@anthropic-ai/sdk`-backed HTTP transport implementation for Anthropic `/v1/messages`. */
+export declare const defaultClaudeHttpTransport: ClaudeHttpTransport;
+//# sourceMappingURL=default-claude-http-transport.constants.d.ts.map

package/dist/driver/default-claude-http-transport.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-claude-http-transport.constants.d.ts","sourceRoot":"","sources":["../../src/driver/default-claude-http-transport.constants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,yDAAyD;AACzD,eAAO,MAAM,2BAA2B,0CAA0C,CAAC;AAEnF,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,eAAe,CAAC;AAElD,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD,qGAAqG;AACrG,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,GAAG,QAAQ,GAAG,MAAM,EAAE,MAAM,CAAC,CAKpF,CAAC;AAEL,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAKvD,CAAC;AAEH,qGAAqG;AACrG,eAAO,MAAM,0BAA0B,EAAE,mBAevC,CAAC"}

package/dist/driver/default-claude-http-transport.constants.js

@@ -0,0 +1,38 @@
+import { sendClaudeMessagesViaSdk } from './internal/send-claude-messages-via-sdk.js';
+/** Default Anthropic Messages API HTTPS endpoint URL. */
+export const ANTHROPIC_MESSAGES_ENDPOINT = 'https://api.anthropic.com/v1/messages';
+/** Default Anthropic API version header value. */
+export const ANTHROPIC_API_VERSION = '2023-06-01';
+/** Default `max_tokens` ceiling sent on Anthropic `/v1/messages` requests. */
+export const DEFAULT_CLAUDE_MAX_TOKENS = 16_384;
+/** Extended thinking token budgets keyed by reasoning effort level (`'low' | 'medium' | 'high'`). */
+export const CLAUDE_THINKING_BUDGETS = Object.freeze({
+    low: 2_048,
+    medium: 8_192,
+    high: 16_384,
+});
+/** Candidate credential filenames searched inside a Claude CLI `configDir`. */
+export const CLAUDE_CREDENTIAL_FILENAMES = Object.freeze([
+    '.credentials.json',
+    'credentials.json',
+    'oauth.json',
+    'auth.json',
+]);
+/** Default `@anthropic-ai/sdk`-backed HTTP transport implementation for Anthropic `/v1/messages`. */
+export const defaultClaudeHttpTransport = Object.freeze({
+    /**
+     * Dispatches a `/v1/messages` POST request via the official `@anthropic-ai/sdk` client.
+     *
+     * Forwards `request` directly to `sendClaudeMessagesViaSdk()`.
+     *
+     * @param {ClaudeHttpRequest} request - Wire-formatted Anthropic `/v1/messages` request.
+     *
+     * @returns {Promise<ClaudeHttpResponse>} HTTP status, parsed body, and optional `resetAtMs`.
+     *
+     * @throws {Error} If `request.signal` is aborted or a network transport exception occurs.
+     */
+    sendMessagesRequest(request) {
+        return sendClaudeMessagesViaSdk(request);
+    },
+});
+//# sourceMappingURL=default-claude-http-transport.constants.js.map

package/dist/driver/default-claude-http-transport.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-claude-http-transport.constants.js","sourceRoot":"","sources":["../../src/driver/default-claude-http-transport.constants.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAEtF,yDAAyD;AACzD,MAAM,CAAC,MAAM,2BAA2B,GAAG,uCAAuC,CAAC;AAEnF,kDAAkD;AAClD,MAAM,CAAC,MAAM,qBAAqB,GAAG,YAAY,CAAC;AAElD,8EAA8E;AAC9E,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AAEhD,qGAAqG;AACrG,MAAM,CAAC,MAAM,uBAAuB,GAClC,MAAM,CAAC,MAAM,CAAC;IACZ,GAAG,EAAE,KAAK;IACV,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,MAAM;CACb,CAAC,CAAC;AAEL,+EAA+E;AAC/E,MAAM,CAAC,MAAM,2BAA2B,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC1E,mBAAmB;IACnB,kBAAkB;IAClB,YAAY;IACZ,WAAW;CACZ,CAAC,CAAC;AAEH,qGAAqG;AACrG,MAAM,CAAC,MAAM,0BAA0B,GAAwB,MAAM,CAAC,MAAM,CAAsB;IAChG;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,OAA0B;QAC5C,OAAO,wBAAwB,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;CACF,CAAC,CAAC"}

package/dist/driver/internal/build-claude-paired-fork-tool-frame.d.ts

@@ -0,0 +1,14 @@
+import type { ForkContext, WireFrameRecord } from '@paraharness/core';
+/**
+ * Synthesizes a single `role: 'tool'` `WireFrameRecord` pairing all `1..k` `toolCalls` on `forkPointFrame`.
+ *
+ * Maps preceding `(1..m)` calls from `ctx.precedingCompletedResults`, `ctx.forkCallId` to the child role
+ * context and task prompt, and all other calls in `(1..k)` to `"[Dispatched/Deferred in parent turn]"`.
+ *
+ * @param {ForkContext}     ctx            - Fork context carrying `forkCallId` and `precedingCompletedResults`.
+ * @param {WireFrameRecord} forkPointFrame - Assistant turn frame containing `toolCalls` `(1..k)`.
+ *
+ * @returns {WireFrameRecord} Synthesized `tool_result` wire frame pairing all `1..k` tool calls.
+ */
+export declare function buildClaudePairedForkToolFrame(ctx: ForkContext, forkPointFrame: WireFrameRecord): WireFrameRecord;
+//# sourceMappingURL=build-claude-paired-fork-tool-frame.d.ts.map

package/dist/driver/internal/build-claude-paired-fork-tool-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-claude-paired-fork-tool-frame.d.ts","sourceRoot":"","sources":["../../../src/driver/internal/build-claude-paired-fork-tool-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,WAAW,EAEX,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAI3B;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,WAAW,EAChB,cAAc,EAAE,eAAe,GAC9B,eAAe,CA+CjB"}

package/dist/driver/internal/build-claude-paired-fork-tool-frame.js

@@ -0,0 +1,56 @@
+import { projectCanonicalToAnthropicMessage } from './project-canonical-to-anthropic-message.js';
+import { formatClaudeForkPromptText } from './format-claude-fork-prompt-text.js';
+/**
+ * Synthesizes a single `role: 'tool'` `WireFrameRecord` pairing all `1..k` `toolCalls` on `forkPointFrame`.
+ *
+ * Maps preceding `(1..m)` calls from `ctx.precedingCompletedResults`, `ctx.forkCallId` to the child role
+ * context and task prompt, and all other calls in `(1..k)` to `"[Dispatched/Deferred in parent turn]"`.
+ *
+ * @param {ForkContext}     ctx            - Fork context carrying `forkCallId` and `precedingCompletedResults`.
+ * @param {WireFrameRecord} forkPointFrame - Assistant turn frame containing `toolCalls` `(1..k)`.
+ *
+ * @returns {WireFrameRecord} Synthesized `tool_result` wire frame pairing all `1..k` tool calls.
+ */
+export function buildClaudePairedForkToolFrame(ctx, forkPointFrame) {
+    const precedingByCallId = new Map();
+    for (const precedingEntry of ctx.precedingCompletedResults ?? []) {
+        precedingByCallId.set(precedingEntry.callId, precedingEntry);
+    }
+    const combinedPrompt = formatClaudeForkPromptText(ctx);
+    const forkCallText = combinedPrompt.length > 0 ? combinedPrompt : '[Forked child session]';
+    const toolResults = [];
+    for (const call of forkPointFrame.canonical.toolCalls ?? []) {
+        const preceding = precedingByCallId.get(call.id);
+        if (preceding !== undefined) {
+            toolResults.push(Object.freeze({
+                callId: call.id,
+                content: preceding.content,
+                isError: Boolean(preceding.isError),
+            }));
+        }
+        else {
+            const content = call.id === ctx.forkCallId ? forkCallText : '[Dispatched/Deferred in parent turn]';
+            toolResults.push(Object.freeze({
+                callId: call.id,
+                content,
+                isError: false,
+            }));
+        }
+    }
+    const canonical = Object.freeze({
+        role: 'tool',
+        visibleText: '',
+        toolCalls: undefined,
+        toolResults: Object.freeze(toolResults),
+    });
+    return Object.freeze({
+        messageId: `${forkPointFrame.messageId}:fork-tools:${ctx.forkCallId ?? 'batch'}`,
+        parentMessageId: forkPointFrame.messageId,
+        vendorId: 'anthropic',
+        rawWireFrame: new TextEncoder().encode(JSON.stringify(projectCanonicalToAnthropicMessage(canonical))),
+        canonical,
+        prefixDigest: ctx.wirePrefix?.systemDigest ?? forkPointFrame.prefixDigest,
+        compactedTombstones: undefined,
+    });
+}
+//# sourceMappingURL=build-claude-paired-fork-tool-frame.js.map

package/dist/driver/internal/build-claude-paired-fork-tool-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-claude-paired-fork-tool-frame.js","sourceRoot":"","sources":["../../../src/driver/internal/build-claude-paired-fork-tool-frame.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AACjG,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,8BAA8B,CAC5C,GAAgB,EAChB,cAA+B;IAE/B,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAwC,CAAC;IAC1E,KAAK,MAAM,cAAc,IAAI,GAAG,CAAC,yBAAyB,IAAI,EAAE,EAAE,CAAC;QACjE,iBAAiB,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC/D,CAAC;IACD,MAAM,cAAc,GAAG,0BAA0B,CAAC,GAAG,CAAC,CAAC;IACvD,MAAM,YAAY,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,wBAAwB,CAAC;IAC3F,MAAM,WAAW,GAA0B,EAAE,CAAC;IAC9C,KAAK,MAAM,IAAI,IAAI,cAAc,CAAC,SAAS,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC;QAC5D,MAAM,SAAS,GAAG,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,WAAW,CAAC,IAAI,CACd,MAAM,CAAC,MAAM,CAAsB;gBACjC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC;aACpC,CAAC,CACH,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GACX,IAAI,CAAC,EAAE,KAAK,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,sCAAsC,CAAC;YACrF,WAAW,CAAC,IAAI,CACd,MAAM,CAAC,MAAM,CAAsB;gBACjC,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,OAAO;gBACP,OAAO,EAAE,KAAK;aACf,CAAC,CACH,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAmB;QAChD,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,EAAE;QACf,SAAS,EAAE,SAAS;QACpB,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC;KACxC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,MAAM,CAAkB;QACpC,SAAS,EAAE,GAAG,cAAc,CAAC,SAAS,eAAe,GAAG,CAAC,UAAU,IAAI,OAAO,EAAE;QAChF,eAAe,EAAE,cAAc,CAAC,SAAS;QACzC,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CACpC,IAAI,CAAC,SAAS,CAAC,kCAAkC,CAAC,SAAS,CAAC,CAAC,CAC9D;QACD,SAAS;QACT,YAAY,EAAE,GAAG,CAAC,UAAU,EAAE,YAAY,IAAI,cAAc,CAAC,YAAY;QACzE,mBAAmB,EAAE,SAAS;KAC/B,CAAC,CAAC;AACL,CAAC"}

package/dist/driver/internal/build-claude-user-frame.d.ts

@@ -0,0 +1,26 @@
+import type { WireFrameRecord } from '@paraharness/core';
+/**
+ * Parameters for constructing an Anthropic `role: 'user'` `WireFrameRecord` via `buildClaudeUserFrame()`.
+ *
+ * Supplies the message lineage identifiers and user prompt text content.
+ */
+export interface BuildClaudeUserFrameParams {
+    /** Unique message frame identifier. */
+    readonly messageId: string;
+    /** Preceding message frame identifier, or `null` for Turn 0. */
+    readonly parentMessageId: string | null;
+    /** User prompt text content. */
+    readonly text: string;
+}
+/**
+ * Constructs a `role: 'user'` `WireFrameRecord` seeded with `params.text` for Turn-0 or fork-point context injection.
+ *
+ * Encodes both the Anthropic `{ role: 'user', content: [{ type: 'text', text }] }` wire JSON and
+ * the canonical user message representation.
+ *
+ * @param {BuildClaudeUserFrameParams} params - Message ID, parent message ID, and user prompt text.
+ *
+ * @returns {WireFrameRecord} Frozen user `WireFrameRecord` for Anthropic `/v1/messages`.
+ */
+export declare function buildClaudeUserFrame(params: BuildClaudeUserFrameParams): WireFrameRecord;
+//# sourceMappingURL=build-claude-user-frame.d.ts.map

package/dist/driver/internal/build-claude-user-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-claude-user-frame.d.ts","sourceRoot":"","sources":["../../../src/driver/internal/build-claude-user-frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAG3E;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,0BAA0B,GAAG,eAAe,CAkBxF"}

package/dist/driver/internal/build-claude-user-frame.js

@@ -0,0 +1,29 @@
+import { projectCanonicalToAnthropicMessage } from './project-canonical-to-anthropic-message.js';
+/**
+ * Constructs a `role: 'user'` `WireFrameRecord` seeded with `params.text` for Turn-0 or fork-point context injection.
+ *
+ * Encodes both the Anthropic `{ role: 'user', content: [{ type: 'text', text }] }` wire JSON and
+ * the canonical user message representation.
+ *
+ * @param {BuildClaudeUserFrameParams} params - Message ID, parent message ID, and user prompt text.
+ *
+ * @returns {WireFrameRecord} Frozen user `WireFrameRecord` for Anthropic `/v1/messages`.
+ */
+export function buildClaudeUserFrame(params) {
+    const canonical = Object.freeze({
+        role: 'user',
+        visibleText: params.text,
+        toolCalls: undefined,
+        toolResults: undefined,
+    });
+    return Object.freeze({
+        messageId: params.messageId,
+        parentMessageId: params.parentMessageId,
+        vendorId: 'anthropic',
+        rawWireFrame: new TextEncoder().encode(JSON.stringify(projectCanonicalToAnthropicMessage(canonical))),
+        canonical,
+        prefixDigest: 'fork-seed',
+        compactedTombstones: undefined,
+    });
+}
+//# sourceMappingURL=build-claude-user-frame.js.map

package/dist/driver/internal/build-claude-user-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-claude-user-frame.js","sourceRoot":"","sources":["../../../src/driver/internal/build-claude-user-frame.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kCAAkC,EAAE,MAAM,6CAA6C,CAAC;AAgBjG;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAkC;IACrE,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAmB;QAChD,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,MAAM,CAAC,IAAI;QACxB,SAAS,EAAE,SAAS;QACpB,WAAW,EAAE,SAAS;KACvB,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,MAAM,CAAkB;QACpC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CACpC,IAAI,CAAC,SAAS,CAAC,kCAAkC,CAAC,SAAS,CAAC,CAAC,CAC9D;QACD,SAAS;QACT,YAAY,EAAE,WAAW;QACzB,mBAAmB,EAAE,SAAS;KAC/B,CAAC,CAAC;AACL,CAAC"}

package/dist/driver/internal/claude-append-tool-result-notes.d.ts

@@ -0,0 +1,28 @@
+import type { AppendToolResultNotesOptions, WireFrameRecord } from '@paraharness/core';
+/**
+ * Parameters for appending synchronization or recovery notes to an Anthropic `WireFrameRecord`.
+ *
+ * Supplies the target frame, note strings, optional `targetCallId`, and optional error flag override.
+ */
+export interface ClaudeAppendToolResultNotesParams {
+    /** Existing `tool` or `user` wire frame record to update. */
+    readonly frame: WireFrameRecord;
+    /** Synchronization or recovery note strings to append. */
+    readonly notes: readonly string[];
+    /** Optional tool `callId` to target on a `role: 'tool'` frame. */
+    readonly targetCallId: string | undefined;
+    /** Optional error status override (`{ isError?: boolean }`). */
+    readonly opts: AppendToolResultNotesOptions | undefined;
+}
+/**
+ * Appends synchronization or recovery notes in-place to an Anthropic `tool` or `user` `WireFrameRecord`.
+ *
+ * Updates both `frame.canonical` and `frame.rawWireFrame`, targeting `targetCallId` (or the last
+ * `tool_result` block) on `role: 'tool'` frames and setting `is_error: true` when `opts?.isError === true`.
+ *
+ * @param {ClaudeAppendToolResultNotesParams} params - Frame, notes, optional target `callId`, and options.
+ *
+ * @returns {WireFrameRecord} Updated wire frame record with appended notes.
+ */
+export declare function claudeAppendToolResultNotes(params: ClaudeAppendToolResultNotesParams): WireFrameRecord;
+//# sourceMappingURL=claude-append-tool-result-notes.d.ts.map

package/dist/driver/internal/claude-append-tool-result-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-append-tool-result-notes.d.ts","sourceRoot":"","sources":["../../../src/driver/internal/claude-append-tool-result-notes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAG5B,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAG3B;;;;GAIG;AACH,MAAM,WAAW,iCAAiC;IAChD,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,kEAAkE;IAClE,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,4BAA4B,GAAG,SAAS,CAAC;CACzD;AA2HD;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,iCAAiC,GACxC,eAAe,CAkBjB"}

package/dist/driver/internal/claude-append-tool-result-notes.js

@@ -0,0 +1,124 @@
+import { projectCanonicalToAnthropicMessage } from './project-canonical-to-anthropic-message.js';
+/**
+ * Resolves the index of the `CanonicalToolResult` entry targeted by `targetCallId` (defaulting to the last entry).
+ *
+ * Falls back to `results.length - 1` when `targetCallId` is `undefined` or does not match an entry.
+ *
+ * @param {readonly CanonicalToolResult[]} results      - Existing tool result array on the frame.
+ * @param {string | undefined}             targetCallId - Optional tool `callId` to locate.
+ *
+ * @returns {number} Target index inside `results`.
+ */
+function findClaudeTargetToolResultIndex(results, targetCallId) {
+    if (targetCallId === undefined) {
+        return results.length - 1;
+    }
+    for (let idx = 0; idx < results.length; idx += 1) {
+        if (results[idx]?.callId === targetCallId) {
+            return idx;
+        }
+    }
+    return results.length - 1;
+}
+/**
+ * Appends `suffix` to a single `CanonicalToolResult` entry and applies `opts?.isError` when present.
+ *
+ * Returns a new frozen `CanonicalToolResult` with the updated content and error flag.
+ *
+ * @param {CanonicalToolResult}                    toolResult - Original tool result entry.
+ * @param {string}                                 suffix     - Joined note string to append.
+ * @param {AppendToolResultNotesOptions | undefined} opts     - Optional error status override.
+ *
+ * @returns {CanonicalToolResult} Updated frozen tool result entry.
+ */
+function appendSuffixToClaudeToolResult(toolResult, suffix, opts) {
+    const nextContent = toolResult.content.length > 0 ? `${toolResult.content}\n${suffix}` : suffix;
+    const nextError = opts?.isError !== undefined ? opts.isError : toolResult.isError;
+    return Object.freeze({
+        callId: toolResult.callId,
+        content: nextContent,
+        isError: nextError,
+    });
+}
+/**
+ * Rebuilds a `CanonicalToolResult[]` array with `suffix` appended to the entry matching `params.targetCallId` (or the last entry).
+ *
+ * Returns a frozen `CanonicalToolResult[]` array preserving all non-targeted tool results unchanged.
+ *
+ * @param {readonly CanonicalToolResult[]}    results - Existing tool result array on the frame.
+ * @param {string}                            suffix  - Joined synchronization note string to append.
+ * @param {ClaudeAppendToolResultNotesParams} params  - Frame, notes, optional target `callId`, and options.
+ *
+ * @returns {readonly CanonicalToolResult[]} Frozen updated tool result array.
+ */
+function rebuildClaudeToolResultsWithSuffix(results, suffix, params) {
+    const targetIdx = findClaudeTargetToolResultIndex(results, params.targetCallId);
+    const updatedResults = [];
+    for (let idx = 0; idx < results.length; idx += 1) {
+        const toolResult = results[idx];
+        if (toolResult !== undefined) {
+            updatedResults.push(idx === targetIdx
+                ? appendSuffixToClaudeToolResult(toolResult, suffix, params.opts)
+                : toolResult);
+        }
+    }
+    return Object.freeze(updatedResults);
+}
+/**
+ * Projects an updated `CanonicalMessage` with `suffix` appended to either the targeted `tool` result or the `user` visible text.
+ *
+ * Preserves all non-targeted `CanonicalMessage` fields in a fixed monomorphic property order.
+ *
+ * @param {ClaudeAppendToolResultNotesParams} params - Frame, notes, optional target `callId`, and options.
+ * @param {string}                            suffix - Joined synchronization note string to append.
+ *
+ * @returns {CanonicalMessage} Frozen updated canonical message.
+ */
+function appendNotesToClaudeCanonicalMessage(params, suffix) {
+    const { frame } = params;
+    if (frame.canonical.role === 'tool' && frame.canonical.toolResults !== undefined) {
+        return Object.freeze({
+            role: frame.canonical.role,
+            visibleText: frame.canonical.visibleText,
+            toolCalls: frame.canonical.toolCalls,
+            toolResults: rebuildClaudeToolResultsWithSuffix(frame.canonical.toolResults, suffix, params),
+        });
+    }
+    const nextText = frame.canonical.visibleText.length > 0
+        ? `${frame.canonical.visibleText}\n${suffix}`
+        : suffix;
+    return Object.freeze({
+        role: 'user',
+        visibleText: nextText,
+        toolCalls: frame.canonical.toolCalls,
+        toolResults: frame.canonical.toolResults,
+    });
+}
+/**
+ * Appends synchronization or recovery notes in-place to an Anthropic `tool` or `user` `WireFrameRecord`.
+ *
+ * Updates both `frame.canonical` and `frame.rawWireFrame`, targeting `targetCallId` (or the last
+ * `tool_result` block) on `role: 'tool'` frames and setting `is_error: true` when `opts?.isError === true`.
+ *
+ * @param {ClaudeAppendToolResultNotesParams} params - Frame, notes, optional target `callId`, and options.
+ *
+ * @returns {WireFrameRecord} Updated wire frame record with appended notes.
+ */
+export function claudeAppendToolResultNotes(params) {
+    const { frame, notes } = params;
+    if (notes.length === 0) {
+        return frame;
+    }
+    const canonical = appendNotesToClaudeCanonicalMessage(params, notes.join('\n'));
+    const rawWireFrame = new TextEncoder().encode(JSON.stringify(projectCanonicalToAnthropicMessage(canonical)));
+    return Object.freeze({
+        messageId: frame.messageId,
+        parentMessageId: frame.parentMessageId,
+        vendorId: frame.vendorId,
+        rawWireFrame,
+        canonical,
+        prefixDigest: frame.prefixDigest,
+        compactedTombstones: frame.compactedTombstones,
+    });
+}
+//# sourceMappingURL=claude-append-tool-result-notes.js.map

package/dist/driver/internal/claude-append-tool-result-notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-append-tool-result-notes.js","sourceRoot":"","sources":["../../../src/driver/internal/claude-append-tool-result-notes.ts"],"names":[],"mappings":"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"}

package/dist/driver/internal/claude-prepare-fork.d.ts

@@ -0,0 +1,14 @@
+import type { ForkContext, PrepareForkTarget, WireFrameRecord } from '@paraharness/core';
+/**
+ * Synthesizes the initial `WireFrameRecord[]` chain for an Anthropic downward fork or cross-model escalation.
+ *
+ * Handles `'shared-prefix-only'` clean starts, `'clone-transcript'` with `substituteTombstones` (`false` vs `true`),
+ * and full-turn `(1..k)` `tool_result` pairing whenever `ctx.forkCallId` is set on an assistant tool-call turn.
+ *
+ * @param {ForkContext}       ctx    - Fork lineage, history mode, and assistant turn-batch metadata.
+ * @param {PrepareForkTarget} target - Target model configuration and `substituteTombstones` flag.
+ *
+ * @returns {readonly WireFrameRecord[]} Synthesized wire frame chain to persist in `LedgerStore`.
+ */
+export declare function claudePrepareFork(ctx: ForkContext, target: PrepareForkTarget): readonly WireFrameRecord[];
+//# sourceMappingURL=claude-prepare-fork.d.ts.map

package/dist/driver/internal/claude-prepare-fork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-prepare-fork.d.ts","sourceRoot":"","sources":["../../../src/driver/internal/claude-prepare-fork.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOzF;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,iBAAiB,GACxB,SAAS,eAAe,EAAE,CAgD5B"}