@oh-my-pi/pi-agent-core 18.4.12 → 18.5.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [18.5.1] - 2026-10-03
+
+### Added
+
+- Added provider-reported usage cost, the unnormalized provider ID, and the requested model ID to CostEstimatorContext, allowing cost estimators to use the cost already recorded for a request instead of recomputing it from token counts.
+
+### Changed
+
+- Improved tool-result supersession so path reads with selectors are tracked independently from bare-path reads, while failed results supersede only earlier failed results for the same key.
+
+### Fixed
+
+- Fixed parallel tool calls with reused or empty IDs executing with another call’s arguments or merging results; each call now executes and reports its own payload.
+- Fixed completed tool calls being retried after a transient provider-stream read error; incomplete calls from the affected turn are now discarded.
+- Fixed previously read code being removed from context when a subsequent read returned a summary, truncated content, or an error.
+- Fixed intent tracing for tools that define i as a real argument, preserving the argument and its declared schema order.
+
 ## [18.4.11] - 2026-10-02
 
 ### Fixed

package/dist/types/compaction/pruning.d.ts

@@ -1,6 +1,7 @@
 /**
  * Tool output pruning utilities for compaction.
  */
+import type { ToolResultMessage } from "@oh-my-pi/pi-ai";
 import type { Tokenizer } from "../tokenizer.js";
 import type { SessionEntry } from "./entries.js";
 import { type ProtectedToolMatcher } from "./tool-protection.js";
@@ -18,6 +19,8 @@ export interface PruneConfig {
      * unchanged.
      */
     supersedeKey?: SupersedeKeyFn;
+    /** Whether a keyed result shows its whole target (see {@link SupersedePruneConfig.supersedeComplete}). */
+    supersedeComplete?: SupersedeCompleteFn;
     /** Useless-flagged results bypass the protect window (see {@link USELESS_NOTICE}). Default true. */
     pruneUseless?: boolean;
     /**
@@ -56,15 +59,35 @@ export declare const SUPERSEDED_NOTICE = "[Superseded by a newer read of this fi
 export declare const USELESS_NOTICE = "[Uneventful result elided]";
 /**
  * Maps a tool call to a supersede key. Results sharing a key form a group in
- * which every result except the newest is a supersede candidate. A key `K`
- * additionally supersedes keys with prefix `K + "\u0000"` (selector-free read
- * supersedes selector-carrying reads of the same base path). Return
- * `undefined` to exempt a call from supersede grouping.
+ * which a newer successful result supersedes every older one. A key `K` also
+ * covers keys with prefix `K + "\u0000"`: they are superseded only when the
+ * newest successful result for `K` is complete (see
+ * {@link SupersedeCompleteFn}). Return `undefined` to exempt a call from
+ * supersede grouping.
  */
 export type SupersedeKeyFn = (toolName: string, args: Record<string, unknown>) => string | undefined;
+/**
+ * Whether a successful keyed result shows its whole target, so a result for a
+ * parent key (e.g. a selector-free read) may supersede child-key results (e.g.
+ * range reads). A summary, truncated page, or notice is not complete.
+ */
+export type SupersedeCompleteFn = (message: ToolResultMessage) => boolean;
 export interface SupersedePruneConfig {
-    /** Supersede key function; results sharing a key supersede older ones. */
+    /** Supersede key function; a newer successful result with the same key supersedes older ones (see {@link SupersedeKeyFn}). */
     supersedeKey?: SupersedeKeyFn;
+    /**
+     * Whether a successful keyed result is complete. Absent, every successful
+     * result is complete. Child-key results are superseded only when the parent
+     * key's newest successful result is complete; same-key results follow
+     * newest-wins, since a same-key re-read that shows a different view means
+     * the target changed. A failed result supersedes only older failed results.
+     *
+     * Trade-off, by design: after `read foo.ts:50-200` → edit → a bare
+     * `read foo.ts` that returns a summary, the pre-edit range stays in context
+     * until a complete bare read or a same-range re-read. Keeping possibly stale
+     * detail is preferred over losing detail the summary does not show.
+     */
+    supersedeComplete?: SupersedeCompleteFn;
     /** Also prune results flagged useless by their tool. Default false. */
     pruneUseless?: boolean;
     /** Prune a candidate now when all messages after it total at most this many estimated tokens. Default 8 000. */
@@ -113,9 +136,10 @@ export declare function pruneToolOutputs(entries: SessionEntry[], tokenizer: Tok
  * selector stripped (the read tool's own splitter grammar via
  * {@link splitReadSelector}, e.g. `src/foo.ts:50-200`, `:2-4:raw`).
  * Internal/URL-scheme paths (`skill://…`, `https://…`) are exempt.
- * Selector-free reads key on the bare path; selector-carrying reads key on
- * `path + "\u0000" + selector`, so two reads collide only when the newer is
- * selector-free or the selectors are identical (the pass's prefix rule lets a
- * bare-path read supersede selector-carrying reads of the same file).
+ * Selector-free reads key on the bare path; line-range reads key on
+ * `path + "\u0000" + selector`, so a complete bare-path read can supersede them.
+ * `raw` and `conflicts` reads show a different form than a plain read (e.g. raw
+ * notebook JSON vs converted notebook text), so they key on
+ * `path + "\u0001" + selector` and are superseded only by the same selector.
  */
 export declare function readToolSupersedeKey(toolName: string, args: Record<string, unknown>): string | undefined;

package/dist/types/compaction/utils.d.ts

@@ -26,6 +26,11 @@ export declare function splitReadSelector(path: string): {
  * and matches its write/edit path when computing Read/Write/RW markers.
  */
 export declare function stripReadSelector(path: string): string;
+/**
+ * Whether a selector from {@link splitReadSelector} shows the file in a form other
+ * than its plain lines: verbatim `raw` bytes or the merge `conflicts` view.
+ */
+export declare function isAlternateFormReadSelector(sel: string): boolean;
 /**
  * Whether `path` references a `scheme://` URL (internal URI or web URL) rather
  * than a filesystem path that belongs in the compaction `<files>` summary.

package/dist/types/telemetry.d.ts

@@ -145,10 +145,18 @@ export interface ChatUsageSnapshot {
 }
 /** Context passed to the cost estimator. */
 export interface CostEstimatorContext {
+    /** OTel provider label (`gen_ai.provider.name`). */
     readonly provider: string;
+    /** Provider id before OTel normalization (e.g. `openai-codex` for the `openai` label). */
+    readonly providerId: string | undefined;
+    /** Model id reported on the response; a provider may report a served model instead of the requested one. */
     readonly model: string;
+    /** Requested model id, when the caller knows it. */
+    readonly modelId: string | undefined;
     readonly serviceTier: ServiceTier | undefined;
     readonly usage: ChatUsageSnapshot;
+    /** Cost the provider already computed for this request; the value persisted with the message. */
+    readonly usageCost: Usage["cost"];
 }
 /**
  * Cost estimator result.
@@ -390,6 +398,8 @@ export interface ChatRequestSnapshot {
  */
 export declare function finishChatSpan(telemetry: AgentTelemetry | undefined, span: Span | undefined, message: AssistantMessage, options: {
     readonly stepNumber: number;
+    /** Requested model id; `message.model` may name a served fallback model instead. */
+    readonly modelId?: string;
     readonly serviceTier?: ServiceTier;
     readonly responseHeaders?: Readonly<Record<string, string>>;
     readonly baseUrl?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.4.12",
+	"version": "18.5.1",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -38,16 +38,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.4.12",
-		"@oh-my-pi/pi-catalog": "18.4.12",
-		"@oh-my-pi/pi-natives": "18.4.12",
-		"@oh-my-pi/pi-utils": "18.4.12",
-		"@oh-my-pi/pi-wire": "18.4.12",
-		"@oh-my-pi/snapcompact": "18.4.12",
+		"@oh-my-pi/pi-ai": "18.5.1",
+		"@oh-my-pi/pi-catalog": "18.5.1",
+		"@oh-my-pi/pi-natives": "18.5.1",
+		"@oh-my-pi/pi-utils": "18.5.1",
+		"@oh-my-pi/pi-wire": "18.5.1",
+		"@oh-my-pi/snapcompact": "18.5.1",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.4.12",
+		"@oh-my-pi/omptype": "18.5.1",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent-loop.ts

@@ -28,11 +28,13 @@ import {
 import {
 	type Dialect,
 	encodeInbandToolHistory,
+	mintToolCallId,
 	renderInbandToolPrompt,
 	renderToolExamples,
 	wrapInbandToolStream,
 } from "@oh-my-pi/pi-ai/dialect";
 import * as AIError from "@oh-my-pi/pi-ai/error";
+import { appendDuplicateSuffix, MAX_TOOL_CALL_ID_LENGTH } from "@oh-my-pi/pi-ai/providers/transform-messages";
 import {
 	type CursorExecResolvedCarrier,
 	copyCursorExecResolved,
@@ -998,7 +1000,8 @@ export function normalizeTools(tools: AgentContext["tools"], options: NormalizeT
 	const injectIntent = options.injectIntent && Bun.env.PI_NO_INTENT !== "1";
 	return tools?.map(t => {
 		const intentMode = resolveIntentMode(t.intent);
-		const doInjectIntent = injectIntent && intentMode !== "omit";
+		const doInjectIntent =
+			injectIntent && intentMode !== "omit" && !schemaDefinesProperty(toolWireSchema(t), INTENT_FIELD);
 		// When the full catalog is rendered into the system prompt, ship the tool
 		// specs without their descriptions (top-level + nested schema annotations)
 		// so they are not duplicated on the wire. Strip the STABLE wire schema (the
@@ -1479,6 +1482,15 @@ async function runLoopBody(
 					}
 				}
 				if (recovered) {
+					// Mint/repair ids before any snapshot: the recovered message skipped
+					// the streamed prepare (the leak interruption landed first), and the
+					// `message_start`/`message_end` copies below are what persistence and
+					// every consumer retain. Repairing only at executeToolCalls would
+					// leave those copies under a never-materialized id while the result
+					// carries the minted one. The later prepare stays idempotent — the
+					// repaired mark rides the snapshot (object spread), and the minted
+					// ids are already claimed at run scope.
+					ensureUniqueToolCallIds(message, toolCallIdsDispatchedUnder(currentContext));
 					message = snapshotAssistantMessage(message);
 					currentContext.messages.push(message);
 					stream.push({ type: "message_start", message: snapshotAssistantMessage(message) });
@@ -2031,6 +2043,7 @@ async function streamAssistantResponse(
 	const finishChat = async (message: AssistantMessage): Promise<void> => {
 		await finishChatSpan(telemetry, chatSpan, message, {
 			stepNumber: chatStepNumber,
+			modelId: model.id,
 			serviceTier: effectiveServiceTier,
 			responseHeaders: capturedHeaders,
 			baseUrl: model.baseUrl,
@@ -2447,7 +2460,10 @@ async function streamAssistantResponse(
 			}
 
 			try {
-				let trailing = await response.result();
+				let trailing = recoverTransientErrorToolTurn(
+					retainCompletedToolCalls(await response.result(), completedToolCallIds),
+					context.tools ?? [],
+				);
 				if (harmonyMitigationEnabled) {
 					const detection = detectHarmonyLeakInAssistantMessage(trailing);
 					if (detection) {
@@ -2839,15 +2855,110 @@ function formatToolNotFoundMessage(
 	return `Tool ${name} not found. Closest available: ${suggestions.slice(0, MAX_TOOL_NAME_SUGGESTIONS).join(", ")}`;
 }
 
+/**
+ * Enforce the invariant every downstream matcher keys on: `toolCall.id` is
+ * unique and non-empty across the whole run — not just within one assistant
+ * message. Providers can deliver a reused id (wire length truncation, Responses
+ * `callId|itemId` composite collapse) or an id that never materialized (`""`) —
+ * the same occurrences the replay pipeline repairs or drops
+ * (`deduplicateToolCallIds` / `sanitizeMalformedToolCalls`). Id-keyed per-call
+ * state — the prepare map below, every UI and persistence matcher — would
+ * otherwise merge sibling calls: the later call's prepared entry overwrites the
+ * earlier's, both calls execute the sibling's payload, and colliding result ids
+ * merge or drop one sibling's output in every consumer. Message-scope
+ * uniqueness is not enough for the session-wide consumers
+ * (`formatSessionHistoryMarkdown`'s last-entry-wins map, the advisor delta
+ * split, `EventController.#toolTimelineComponents`, persistence keys): a second
+ * assistant turn whose ids never materialized used to re-mint `call_1`,
+ * `call_2`, … and re-derive the same `_dup` suffixes, so those consumers merged
+ * the cross-turn collisions. Every id kept or minted here is therefore claimed
+ * in the run-scoped registry (`toolCallIdsDispatchedUnder`) and every candidate
+ * is generated until unused at run scope. Never-materialized is the sanitizer's
+ * trim test (`isMalformedToolCallId`): a whitespace-only id is minted like an
+ * empty one, never kept — it would be dropped from provider replay together
+ * with its result, the live/replay divergence this repair exists to close.
+ * Cursor server-resolved blocks are never re-keyed (the provider correlates
+ * their results out-of-band under its own ids) but their ids still join the
+ * registry so no minted candidate collides with one. Idempotent: the message is
+ * marked repaired and re-entry is a no-op, so the Harmony path can repair
+ * before its snapshots while the dispatch-time prepare sees the already-minted
+ * ids and leaves them alone.
+ */
+const kToolCallIdsRepaired = Symbol("agent-loop.toolCallIdsRepaired");
+
+/** Assistant message optionally carrying the {@link kToolCallIdsRepaired} mark. */
+type ToolCallIdsRepairedCarrier = AssistantMessage & { [kToolCallIdsRepaired]?: true };
+
+/**
+ * Run-scoped registry of every tool-call id {@link ensureUniqueToolCallIds} has
+ * kept, minted, or seen on a server-resolved block under one
+ * {@link AgentContext}. Keyed by the dispatch context (the same object every
+ * `prepareToolCallDispatch` receives) so the uniqueness window spans every
+ * assistant turn of the run rather than resetting per message. Each run gets a
+ * fresh loop context, so minted ids use the process-unique `mintToolCallId`.
+ */
+const dispatchedToolCallIdsByContext = new WeakMap<AgentContext, Set<string>>();
+
+function toolCallIdsDispatchedUnder(context: AgentContext): Set<string> {
+	let dispatched = dispatchedToolCallIdsByContext.get(context);
+	if (!dispatched) {
+		dispatched = new Set();
+		dispatchedToolCallIdsByContext.set(context, dispatched);
+	}
+	return dispatched;
+}
+
+function ensureUniqueToolCallIds(message: ToolCallIdsRepairedCarrier, dispatchedIds: Set<string>): void {
+	if (message[kToolCallIdsRepaired] === true) return;
+	const content = message.content;
+	const reserved = new Set<string>();
+	for (const block of content) {
+		if (block.type === "toolCall" && block.id) reserved.add(block.id);
+	}
+	const seen = new Set<string>();
+	for (const block of content) {
+		if (block.type !== "toolCall") continue;
+		if ((block as CursorExecResolvedCarrier)[kCursorExecResolved] === true) {
+			if (block.id?.trim()) dispatchedIds.add(block.id);
+			continue;
+		}
+		if (block.id?.trim() && !seen.has(block.id) && !dispatchedIds.has(block.id)) {
+			seen.add(block.id);
+			dispatchedIds.add(block.id);
+			continue;
+		}
+		let candidate: string;
+		if (block.id?.trim()) {
+			let suffix = 1;
+			candidate = appendDuplicateSuffix(block.id, `_dup${suffix}`, MAX_TOOL_CALL_ID_LENGTH);
+			while (seen.has(candidate) || reserved.has(candidate) || dispatchedIds.has(candidate)) {
+				suffix += 1;
+				candidate = appendDuplicateSuffix(block.id, `_dup${suffix}`, MAX_TOOL_CALL_ID_LENGTH);
+			}
+		} else {
+			// Process-unique minter: a per-run counter would re-mint `call_1` in
+			// every run and collide with earlier runs' calls in session history.
+			do {
+				candidate = mintToolCallId();
+			} while (seen.has(candidate) || reserved.has(candidate) || dispatchedIds.has(candidate));
+		}
+		block.id = candidate;
+		seen.add(candidate);
+		dispatchedIds.add(candidate);
+	}
+	message[kToolCallIdsRepaired] = true;
+}
+
 /**
  * Pre-dispatch phase for every pending tool call on `assistantMessage`, run in
- * call order: intent extraction, argument validation, and the `beforeToolCall`
- * hook. A hook `args` revision is revalidated against the tool schema and
- * written back to `toolCall.arguments`; run before `message_start`/`message_end`
- * (the streamed path) that makes the revision the single source of truth —
- * history, execution events, persistence, provider replay, concurrency
- * scheduling, and `tool.execute` all agree. Failures are recorded per call and
- * surfaced by `executeToolCalls` at the record's scheduled slot.
+ * call order: tool-call id repair, intent extraction, argument validation, and
+ * the `beforeToolCall` hook. A hook `args` revision is revalidated against the
+ * tool schema and written back to `toolCall.arguments`; run before
+ * `message_start`/`message_end` (the streamed path) that makes the revision the
+ * single source of truth — history, execution events, persistence, provider
+ * replay, concurrency scheduling, and `tool.execute` all agree. Id repair in
+ * {@link ensureUniqueToolCallIds} follows the same rule. Failures are recorded
+ * per call and surfaced by `executeToolCalls` at the record's scheduled slot.
  */
 async function prepareToolCallDispatch(
 	assistantMessage: AssistantMessage,
@@ -2856,6 +2967,9 @@ async function prepareToolCallDispatch(
 	signal: AbortSignal | undefined,
 ): Promise<Map<string, PreparedToolCall>> {
 	const { resolveFallbackTool, suggestFallbackToolNames, intentTracing, beforeToolCall } = config;
+	// Unique, non-empty ids first: everything below and every consumer of this
+	// message keys per-call state on `toolCall.id`.
+	ensureUniqueToolCallIds(assistantMessage, toolCallIdsDispatchedUnder(context));
 	const prepared = new Map<string, PreparedToolCall>();
 	for (const toolCall of assistantMessage.content) {
 		if (toolCall.type !== "toolCall") continue;
@@ -2872,17 +2986,13 @@ async function prepareToolCallDispatch(
 		prepared.set(toolCall.id, entry);
 		let argsForExecution = toolCall.arguments as Record<string, unknown>;
 		if (intentTracing) {
-			const { intent, strippedArgs } = extractIntent(toolCall.arguments);
+			// A schema-owned `i` is a tool argument, never a harness intent.
+			const ownsIntent = tool !== undefined && schemaDefinesProperty(toolWireSchema(tool), INTENT_FIELD);
+			const { intent, strippedArgs } = ownsIntent
+				? { intent: undefined, strippedArgs: argsForExecution }
+				: extractIntent(toolCall.arguments);
 			argsForExecution = strippedArgs;
-			// A payload in `i` would be stripped and the tool run with the leftover
-			// args. Unknown tools fall through to the not-found error; a tool that
-			// owns `i` as a real parameter has nowhere else to put the value.
-			if (
-				intent !== undefined &&
-				intent.length > MAX_INTENT_LENGTH &&
-				tool &&
-				!schemaDefinesProperty(toolWireSchema(tool), INTENT_FIELD)
-			) {
+			if (intent !== undefined && intent.length > MAX_INTENT_LENGTH && tool) {
 				entry.args = strippedArgs;
 				entry.validationErrorMessage = `\`${INTENT_FIELD}\` is a short intent label (at most ${MAX_INTENT_LENGTH} chars); the value you sent is ${intent.length} chars. The tool was not run. Put that content in the tool's own parameters and retry with a brief \`${INTENT_FIELD}\`.`;
 				continue;

package/src/compaction/pruning.ts

@@ -14,7 +14,7 @@ import {
 	isSkillReadToolResult,
 	type ProtectedToolMatcher,
 } from "./tool-protection";
-import { splitReadSelector } from "./utils";
+import { isAlternateFormReadSelector, splitReadSelector } from "./utils";
 
 export interface PruneConfig {
 	/** Keep the most recent tool output tokens intact. */
@@ -30,6 +30,8 @@ export interface PruneConfig {
 	 * unchanged.
 	 */
 	supersedeKey?: SupersedeKeyFn;
+	/** Whether a keyed result shows its whole target (see {@link SupersedePruneConfig.supersedeComplete}). */
+	supersedeComplete?: SupersedeCompleteFn;
 	/** Useless-flagged results bypass the protect window (see {@link USELESS_NOTICE}). Default true. */
 	pruneUseless?: boolean;
 	/**
@@ -100,16 +102,37 @@ export const USELESS_NOTICE = "[Uneventful result elided]";
 
 /**
  * Maps a tool call to a supersede key. Results sharing a key form a group in
- * which every result except the newest is a supersede candidate. A key `K`
- * additionally supersedes keys with prefix `K + "\u0000"` (selector-free read
- * supersedes selector-carrying reads of the same base path). Return
- * `undefined` to exempt a call from supersede grouping.
+ * which a newer successful result supersedes every older one. A key `K` also
+ * covers keys with prefix `K + "\u0000"`: they are superseded only when the
+ * newest successful result for `K` is complete (see
+ * {@link SupersedeCompleteFn}). Return `undefined` to exempt a call from
+ * supersede grouping.
  */
 export type SupersedeKeyFn = (toolName: string, args: Record<string, unknown>) => string | undefined;
 
+/**
+ * Whether a successful keyed result shows its whole target, so a result for a
+ * parent key (e.g. a selector-free read) may supersede child-key results (e.g.
+ * range reads). A summary, truncated page, or notice is not complete.
+ */
+export type SupersedeCompleteFn = (message: ToolResultMessage) => boolean;
+
 export interface SupersedePruneConfig {
-	/** Supersede key function; results sharing a key supersede older ones. */
+	/** Supersede key function; a newer successful result with the same key supersedes older ones (see {@link SupersedeKeyFn}). */
 	supersedeKey?: SupersedeKeyFn;
+	/**
+	 * Whether a successful keyed result is complete. Absent, every successful
+	 * result is complete. Child-key results are superseded only when the parent
+	 * key's newest successful result is complete; same-key results follow
+	 * newest-wins, since a same-key re-read that shows a different view means
+	 * the target changed. A failed result supersedes only older failed results.
+	 *
+	 * Trade-off, by design: after `read foo.ts:50-200` → edit → a bare
+	 * `read foo.ts` that returns a summary, the pre-edit range stays in context
+	 * until a complete bare read or a same-range re-read. Keeping possibly stale
+	 * detail is preferred over losing detail the summary does not show.
+	 */
+	supersedeComplete?: SupersedeCompleteFn;
 	/** Also prune results flagged useless by their tool. Default false. */
 	pruneUseless?: boolean;
 	/** Prune a candidate now when all messages after it total at most this many estimated tokens. Default 8 000. */
@@ -196,21 +219,35 @@ interface SupersedeCandidate {
 	notice: string;
 }
 
+/**
+ * Newer results of one key. An entry exists once any newer result (even a
+ * failed one) was seen. `complete` describes the newest successful result
+ * only: older successes of the key are superseded, so they cannot vouch for
+ * child keys.
+ */
+interface NewerResults {
+	success: boolean;
+	complete: boolean;
+}
+
 /**
  * Collect superseded tool results: for every unpruned, unprotected tool result
- * whose paired call resolves a supersede key, a LATER result with the same key
- * — or with a key that is the `"\u0000"`-prefix parent of this one — marks it
- * superseded. Returned in message order.
+ * whose paired call resolves a supersede key, a LATER successful result of the
+ * same key supersedes it, as does its `"\u0000"`-prefix parent key when that
+ * key's newest successful result is complete. A failed result supersedes only
+ * older failed results; an older failed result is superseded by any later
+ * result of its key or a later successful result of its parent key.
  */
 function collectSupersededResults(
 	entries: readonly SessionEntry[],
 	tokenizer: Tokenizer,
 	toolCallsById: ReadonlyMap<string, AgentToolCall>,
 	supersedeKey: SupersedeKeyFn,
+	supersedeComplete: SupersedeCompleteFn | undefined,
 	protectedTools: readonly ProtectedToolMatcher[],
 ): SupersedeCandidate[] {
 	const candidates: SupersedeCandidate[] = [];
-	const seenKeys = new Set<string>();
+	const newerByKey = new Map<string, NewerResults>();
 	for (let i = entries.length - 1; i >= 0; i--) {
 		const entry = entries[i];
 		const message = getToolResultMessage(entry);
@@ -221,8 +258,17 @@ function collectSupersededResults(
 		const key = supersedeKey(toolCall.name, toolCall.arguments as Record<string, unknown>);
 		if (key === undefined) continue;
 		const separator = key.indexOf("\u0000");
-		const superseded = seenKeys.has(key) || (separator >= 0 && seenKeys.has(key.slice(0, separator)));
-		seenKeys.add(key);
+		const sameKey = newerByKey.get(key);
+		const parent = separator >= 0 ? newerByKey.get(key.slice(0, separator)) : undefined;
+		const superseded = message.isError
+			? sameKey !== undefined || parent?.success === true
+			: sameKey?.success === true || parent?.complete === true;
+		const newer = sameKey ?? { success: false, complete: false };
+		if (!message.isError && !newer.success) {
+			newer.success = true;
+			newer.complete = supersedeComplete?.(message) ?? true;
+		}
+		newerByKey.set(key, newer);
 		if (!superseded) continue;
 		candidates.push({
 			entry: entry as SessionMessageEntry,
@@ -278,7 +324,14 @@ export function pruneSupersededToolResults(
 ): PruneResult {
 	const toolCallsById = collectToolCallsById(entries);
 	const candidates = config.supersedeKey
-		? collectSupersededResults(entries, tokenizer, toolCallsById, config.supersedeKey, config.protectedTools)
+		? collectSupersededResults(
+				entries,
+				tokenizer,
+				toolCallsById,
+				config.supersedeKey,
+				config.supersedeComplete,
+				config.protectedTools,
+			)
 		: [];
 	if (config.pruneUseless) {
 		const exclude = new Set(candidates.map(candidate => candidate.message));
@@ -341,9 +394,14 @@ export function pruneToolOutputs(
 	const toolCallsById = collectToolCallsById(entries);
 	const supersededMessages = config.supersedeKey
 		? new Set(
-				collectSupersededResults(entries, tokenizer, toolCallsById, config.supersedeKey, config.protectedTools).map(
-					candidate => candidate.message,
-				),
+				collectSupersededResults(
+					entries,
+					tokenizer,
+					toolCallsById,
+					config.supersedeKey,
+					config.supersedeComplete,
+					config.protectedTools,
+				).map(candidate => candidate.message),
 			)
 		: undefined;
 	const uselessMessages =
@@ -440,10 +498,11 @@ export function pruneToolOutputs(
  * selector stripped (the read tool's own splitter grammar via
  * {@link splitReadSelector}, e.g. `src/foo.ts:50-200`, `:2-4:raw`).
  * Internal/URL-scheme paths (`skill://…`, `https://…`) are exempt.
- * Selector-free reads key on the bare path; selector-carrying reads key on
- * `path + "\u0000" + selector`, so two reads collide only when the newer is
- * selector-free or the selectors are identical (the pass's prefix rule lets a
- * bare-path read supersede selector-carrying reads of the same file).
+ * Selector-free reads key on the bare path; line-range reads key on
+ * `path + "\u0000" + selector`, so a complete bare-path read can supersede them.
+ * `raw` and `conflicts` reads show a different form than a plain read (e.g. raw
+ * notebook JSON vs converted notebook text), so they key on
+ * `path + "\u0001" + selector` and are superseded only by the same selector.
  */
 export function readToolSupersedeKey(toolName: string, args: Record<string, unknown>): string | undefined {
 	if (toolName !== "read") return undefined;
@@ -451,5 +510,6 @@ export function readToolSupersedeKey(toolName: string, args: Record<string, unkn
 	if (typeof path !== "string" || path.length === 0) return undefined;
 	if (path.includes("://")) return undefined;
 	const { path: base, sel } = splitReadSelector(path);
-	return sel === undefined ? base : `${base}\u0000${sel}`;
+	if (sel === undefined) return base;
+	return `${base}${isAlternateFormReadSelector(sel) ? "\u0001" : "\u0000"}${sel}`;
 }

package/src/compaction/utils.ts

@@ -38,6 +38,7 @@ const RANGE_LIST_SRC = `${RANGE_CHUNK_SRC}(?:,${RANGE_CHUNK_SRC})*`;
 const READ_SELECTOR_RE = new RegExp(`^(?:${RANGE_LIST_SRC}|raw|conflicts)$`, "i");
 const READ_RANGE_ONLY_RE = new RegExp(`^${RANGE_LIST_SRC}$`, "i");
 const READ_RAW_ONLY_RE = /^raw$/i;
+const READ_ALTERNATE_FORM_RE = /^(?:raw|conflicts)$/i;
 
 /**
  * Split a read-tool path into its base path and trailing selector, mirroring the
@@ -77,6 +78,14 @@ export function stripReadSelector(path: string): string {
 	return splitReadSelector(path).path;
 }
 
+/**
+ * Whether a selector from {@link splitReadSelector} shows the file in a form other
+ * than its plain lines: verbatim `raw` bytes or the merge `conflicts` view.
+ */
+export function isAlternateFormReadSelector(sel: string): boolean {
+	return sel.split(":").some(part => READ_ALTERNATE_FORM_RE.test(part));
+}
+
 /**
  * A real filesystem path never contains a `scheme://` URL. Tool-call paths that
  * do — `conflict://1`, `artifact://3`, `local://ctx.md`, `history://…`,

package/src/telemetry.ts

@@ -204,10 +204,18 @@ export interface ChatUsageSnapshot {
 
 /** Context passed to the cost estimator. */
 export interface CostEstimatorContext {
+	/** OTel provider label (`gen_ai.provider.name`). */
 	readonly provider: string;
+	/** Provider id before OTel normalization (e.g. `openai-codex` for the `openai` label). */
+	readonly providerId: string | undefined;
+	/** Model id reported on the response; a provider may report a served model instead of the requested one. */
 	readonly model: string;
+	/** Requested model id, when the caller knows it. */
+	readonly modelId: string | undefined;
 	readonly serviceTier: ServiceTier | undefined;
 	readonly usage: ChatUsageSnapshot;
+	/** Cost the provider already computed for this request; the value persisted with the message. */
+	readonly usageCost: Usage["cost"];
 }
 
 /**
@@ -1138,6 +1146,8 @@ export async function finishChatSpan(
 	message: AssistantMessage,
 	options: {
 		readonly stepNumber: number;
+		/** Requested model id; `message.model` may name a served fallback model instead. */
+		readonly modelId?: string;
 		readonly serviceTier?: ServiceTier;
 		readonly responseHeaders?: Readonly<Record<string, string>>;
 		readonly baseUrl?: string;
@@ -1147,7 +1157,7 @@ export async function finishChatSpan(
 	applyChatResponseAttributes(span, message);
 	applyUsageAttributes(span, message.usage);
 	applyGatewayAttributes(span, options.responseHeaders, options.baseUrl);
-	const cost = applyCostEstimate(telemetry, span, message, options.serviceTier, options.stepNumber);
+	const cost = applyCostEstimate(telemetry, span, message, options.serviceTier, options.stepNumber, options.modelId);
 	if (telemetry) {
 		await emitChatUsage(telemetry, span, {
 			operation: GenAIOperation.Chat,
@@ -1367,10 +1377,12 @@ function applyCostEstimate(
 	message: AssistantMessage,
 	serviceTier: ServiceTier | undefined,
 	stepNumber: number | undefined,
+	modelId: string | undefined,
 ): AppliedCostEstimate {
 	if (!telemetry) return EMPTY_COST;
 	return applyCostEstimateForUsage(telemetry, span, {
 		model: message.model,
+		modelId,
 		provider: message.provider,
 		serviceTier,
 		stepNumber,
@@ -1383,6 +1395,7 @@ function applyCostEstimateForUsage(
 	span: Span,
 	input: {
 		readonly model: string;
+		readonly modelId: string | undefined;
 		readonly provider: string | undefined;
 		readonly serviceTier: ServiceTier | undefined;
 		readonly stepNumber: number | undefined;
@@ -1398,9 +1411,12 @@ function applyCostEstimateForUsage(
 	try {
 		result = estimator({
 			provider,
+			providerId: input.provider,
 			model: input.model,
+			modelId: input.modelId,
 			serviceTier: input.serviceTier,
 			usage,
+			usageCost: input.usage.cost,
 		});
 	} catch (err) {
 		emitTelemetryWarning(telemetry, {
@@ -1620,6 +1636,7 @@ export async function recordManualChatTelemetry(
 	if (telemetry) {
 		const applied = applyCostEstimateForUsage(telemetry, span, {
 			model: options.responseModel ?? options.model.id,
+			modelId: options.model.id,
 			provider: options.model.provider,
 			serviceTier: options.serviceTier,
 			stepNumber: options.stepNumber,
@@ -1889,6 +1906,7 @@ export async function instrumentedCompleteSimple<TApi extends Api>(
 				: await runOnce();
 			await finishChatSpan(telemetry, chatSpan, message, {
 				stepNumber,
+				modelId: model.id,
 				serviceTier: options.serviceTier,
 				responseHeaders: capturedHeaders,
 				baseUrl: model.baseUrl,