maka-agent 0.2.0-dev.30.20260912 → 0.2.0-dev.31.20260913

package/node_modules/@maka/core/dist/runtime-logical-execution.js

@@ -20,7 +20,8 @@ import { continuationStartEventMatchesClaim, createRuntimeBoundaryCursor, invoca
 import { readRunInvocation, } from './runtime-event-store.js';
 import { assertHandoffClaimSource, runtimeHandoffPause, } from './runtime-handoff.js';
 /** All logical snapshot and command routing paths share these edge checks. */
-export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
+export async function readLogicalRuntimeExecution(store, identity, knownRoot, options) {
+    const membership = options?.mode === 'membership';
     const root = knownRoot ?? (await readRunInvocation(store, identity.sessionId, identity.runId));
     if (!root)
         return undefined;
@@ -37,17 +38,25 @@ export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
         if (seen.has(tip.runId) || seen.size >= 64)
             throw new Error('Invalid logical execution handoff lineage');
         seen.add(tip.runId);
-        const events = await store.readImmutableRuntimeEvents(identity.sessionId, tip.runId);
-        const last = events.at(-1);
+        const events = membership
+            ? undefined
+            : await store.readImmutableRuntimeEvents(identity.sessionId, tip.runId);
+        const last = membership ? tip.terminalEvent : events?.at(-1);
         const pause = last && runtimeHandoffPause(last);
         if (!pause)
-            return { root, tip, events, runIds: [...seen] };
+            return logicalExecutionResult(root, tip, [...seen], events);
         if (pause.rootRunId !== root.runId)
             throw new Error('Handoff seal changes the logical root');
-        const prefix = await store.readImmutableRuntimePrefix({
-            sessionId: identity.sessionId,
-            runId: tip.runId,
-        });
+        const prefix = membership
+            ? await store.readImmutableRuntimePrefixProof({
+                sessionId: identity.sessionId,
+                runId: tip.runId,
+            })
+            : await store.readImmutableRuntimePrefix({
+                sessionId: identity.sessionId,
+                runId: tip.runId,
+            });
+        const segment = runtimePrefixSegment(prefix);
         if (prefix.position.lastEventId !== last.id)
             throw new Error('Handoff source changed after its seal');
         if (!segments) {
@@ -59,9 +68,9 @@ export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
                     throw new Error('Handoff requires authenticated source lineage');
                 const initial = await store.readContinuationClaimStateByBoundary(source.boundaryDigest);
                 if (!initial ||
-                    initial.startEventId !== prefix.events[0]?.id ||
+                    initial.startEventId !== prefixFirstEvent(prefix).id ||
                     !invocationMatchesClaimTarget(root, initial.claim) ||
-                    !continuationStartEventMatchesClaim(prefix.events[0], initial.claim, initial.startKind)) {
+                    !continuationStartEventMatchesClaim(prefixFirstEvent(prefix), initial.claim, initial.startKind)) {
                     throw new Error('Handoff root continuation is not authenticated');
                 }
                 segments = [...initial.claim.boundary.segments];
@@ -69,7 +78,7 @@ export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
             else
                 segments = [];
         }
-        segments.push(runtimePrefixSegment(prefix));
+        segments.push(segment);
         const boundary = createRuntimeBoundaryCursor(segments);
         let state = await store.readContinuationClaimStateByBoundary(boundary.manifestDigest);
         const next = await readRunInvocation(store, identity.sessionId, pause.successorRunId);
@@ -81,15 +90,21 @@ export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
         if (!state) {
             if (next)
                 throw new Error('Handoff successor opened without its continuation claim');
-            return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+            return logicalExecutionResult(root, tip, [...seen], events, pause);
         }
         assertHandoffClaimSource(state.claim, prefix);
         if (!next) {
             if (state.startEventId)
                 throw new Error('Handoff successor opening is missing');
-            return { root, tip, events, runIds: [...seen], pendingHandoff: pause };
+            return logicalExecutionResult(root, tip, [...seen], events, pause);
         }
-        const first = (await store.readImmutableRuntimeEvents(identity.sessionId, next.runId))[0];
+        const first = membership
+            ? prefixFirstEvent(await store.readImmutableRuntimePrefixProof({
+                sessionId: identity.sessionId,
+                runId: next.runId,
+                upToEventSeq: 1,
+            }))
+            : (await store.readImmutableRuntimeEvents(identity.sessionId, next.runId))[0];
         if (state.startEventId !== first?.id ||
             !invocationMatchesClaimTarget(next, state.claim) ||
             !continuationStartEventMatchesClaim(first, state.claim, state.startKind)) {
@@ -98,6 +113,16 @@ export async function readLogicalRuntimeExecution(store, identity, knownRoot) {
         tip = next;
     }
 }
+function prefixFirstEvent(prefix) {
+    const first = prefix.protocol === 'immutable_runtime_prefix_v1' ? prefix.events[0] : prefix.firstEvent;
+    if (!first)
+        throw new Error('immutable RuntimeEvent prefix is empty');
+    return first;
+}
+function logicalExecutionResult(root, tip, runIds, events, pendingHandoff) {
+    const result = { root, tip, runIds, ...(pendingHandoff ? { pendingHandoff } : {}) };
+    return events ? { ...result, events } : result;
+}
 /** Resolve a durable physical proof back to its root, then authenticate membership. */
 export async function readLogicalRuntimeExecutionForRun(store, identity) {
     const run = await readRunInvocation(store, identity.sessionId, identity.runId);

package/node_modules/@maka/core/dist/tool-result-archive-evidence.js

@@ -16,5 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES } from './durable-tool-result-projection.js';
 export const TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_TRANSITIONS = 64;
-export const TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES = 2 * 1024 * 1024;
+// Include event identity and transition overhead around the stored projection.
+export const TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES = DURABLE_TOOL_RESULT_PROJECTION_MAX_BYTES + 128 * 1024;

package/node_modules/@maka/core/dist/tool-result-record-schema.js

@@ -162,7 +162,8 @@ function isNonShellToolResultContent(value) {
                 isFiniteNumber(value.originalEstimatedTokens) &&
                 isFiniteNumber(value.originalBytes) &&
                 isFiniteNumber(value.rewriteVersion) &&
-                (value.reason === 'stale_tool_result_pruned_before_compact' ||
+                (value.reason === 'tool_result_pruned' ||
+                    value.reason === 'stale_tool_result_pruned_before_compact' ||
                     value.reason === 'active_current_turn_tool_result_pruned_before_next_step'));
         case 'image':
             return (hasExactShape(value, IMAGE_SHAPE) &&

package/node_modules/@maka/core/dist/unified-diff.js

@@ -26,39 +26,57 @@ const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
  * structure — degrades to unnumbered meta rows.
  */
 export function parseUnifiedDiffRows(diff) {
-    const lines = diff.split('\n');
-    // A trailing newline terminates the diff rather than starting an empty row.
-    if (lines.length > 1 && lines[lines.length - 1] === '')
-        lines.pop();
     const rows = [];
+    scanUnifiedDiff(diff, rows);
+    return rows;
+}
+/** Green `+N` / red `-N` counts, without materializing display rows or body text. */
+export function countDiffLineStats(diff) {
+    return scanUnifiedDiff(diff);
+}
+/**
+ * One structural scan for both consumers. The optional output array keeps
+ * display objects and body substrings out of the count-only path.
+ */
+function scanUnifiedDiff(diff, rows) {
+    let additions = 0;
+    let deletions = 0;
     let oldLine = 0;
     let newLine = 0;
     let remainingOld = 0;
     let remainingNew = 0;
     let inHunk = false;
-    for (const line of lines) {
+    let offset = 0;
+    // Visit an empty input once, but do not invent a row after a trailing newline.
+    do {
+        const start = offset;
+        const newline = diff.indexOf('\n', start);
+        const end = newline === -1 ? diff.length : newline;
+        offset = end + 1;
         if (inHunk && remainingOld + remainingNew > 0) {
-            const marker = line.charAt(0);
+            const marker = diff.charAt(start);
             if (marker === '\\') {
                 // `` annotates the previous row without
                 // consuming a line on either side.
-                rows.push({ kind: 'meta', text: line });
+                rows?.push({ kind: 'meta', text: diff.slice(start, end) });
                 continue;
             }
             if (marker === '-') {
-                rows.push({ kind: 'del', text: line, oldLine });
+                rows?.push({ kind: 'del', text: diff.slice(start, end), oldLine });
+                deletions += 1;
                 oldLine += 1;
                 remainingOld -= 1;
                 continue;
             }
             if (marker === '+') {
-                rows.push({ kind: 'add', text: line, newLine });
+                rows?.push({ kind: 'add', text: diff.slice(start, end), newLine });
+                additions += 1;
                 newLine += 1;
                 remainingNew -= 1;
                 continue;
             }
             // ' ' context, and the bare empty line some generators emit for one.
-            rows.push({ kind: 'ctx', text: line, oldLine, newLine });
+            rows?.push({ kind: 'ctx', text: diff.slice(start, end), oldLine, newLine });
             oldLine += 1;
             newLine += 1;
             remainingOld -= 1;
@@ -66,6 +84,7 @@ export function parseUnifiedDiffRows(diff) {
             continue;
         }
         inHunk = false;
+        const line = diff.slice(start, end);
         const hunk = HUNK_HEADER.exec(line);
         if (hunk) {
             oldLine = Number(hunk[1]);
@@ -73,29 +92,17 @@ export function parseUnifiedDiffRows(diff) {
             remainingOld = hunk[2] === undefined ? 1 : Number(hunk[2]);
             remainingNew = hunk[4] === undefined ? 1 : Number(hunk[4]);
             inHunk = true;
-            rows.push({ kind: 'hunk', text: line });
+            rows?.push({ kind: 'hunk', text: line });
             continue;
         }
         if (line.startsWith('diff ')) {
-            rows.push({ kind: 'meta', text: line });
+            rows?.push({ kind: 'meta', text: line });
             continue;
         }
         if (line.startsWith('--- ') || line.startsWith('+++ ') || line.startsWith('index ')) {
             continue;
         }
-        rows.push({ kind: 'meta', text: line });
-    }
-    return rows;
-}
-/** Green `+N` / red `-N` counts, from the structural parse. */
-export function countDiffLineStats(diff) {
-    let additions = 0;
-    let deletions = 0;
-    for (const row of parseUnifiedDiffRows(diff)) {
-        if (row.kind === 'add')
-            additions += 1;
-        else if (row.kind === 'del')
-            deletions += 1;
-    }
+        rows?.push({ kind: 'meta', text: line });
+    } while (offset < diff.length);
     return { additions, deletions };
 }

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -22,10 +22,9 @@ import { isHistoryCompactContentEvent } from './history-compaction.js';
 import { canContinueHistoryCompactCheckpointForModel, canReplayHistoryCompactCheckpointForModel, historyCompactSourceDigest, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { HistoryCompactSummarizerError, isMalformedHistoryCompactSummaryReason, } from './history-compact-error.js';
 import { createHash } from 'node:crypto';
-import { rewriteActiveToolResultsInMessages, } from './active-tool-result-prune.js';
-import { archiveToolResultAsTransition, collectStaleToolResultArchiveCandidates, serializedToolResultProjection, } from './tool-result-archive-transition.js';
+import { archiveToolResultAsTransition, collectToolResultArchiveCandidates, serializedToolResultProjection, } from './tool-result-archive-transition.js';
 import { estimateTokens } from './context-budget-helpers.js';
-import { baseToolResultProjection, reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
+import { reduceEffectiveModelProjections, } from './model-projection-transition-ledger.js';
 import { buildRuntimeEventModelReplayPlan, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, } from './model-history.js';
 import { planHistoryCompaction } from './history-compaction.js';
 import { resolveDeclaredContextWindow } from './context-budget-policy.js';
@@ -98,7 +97,6 @@ export class AiSdkCompaction {
             sessionId: this.sessionId,
             archiveToolResult: (candidate) => archive(candidate),
             recordTransition: (transition) => record(transition, turnId),
-            loadTransitions: () => this.loadModelProjectionTransitions(),
             now: this.now,
         };
     }
@@ -335,11 +333,11 @@ export class AiSdkCompaction {
      *
      * The current Turn's own events go through here on every provider step, for
      * the same reason prior Turns do: what the model sees is the folded ledger,
-     * not the raw one. A ledger this build cannot read in full leaves the slice
-     * untouched — the content is then merely unpruned, never wrongly replaced.
+     * not the raw one. Checkpoint validation and replay pass the same snapshot;
+     * standalone callers read one here. Unreadable targets remain withheld.
      */
-    async foldEffectiveModelHistory(events) {
-        const loaded = await this.loadModelProjectionTransitions();
+    async foldEffectiveModelHistory(events, snapshot) {
+        const loaded = snapshot ?? (await this.loadModelProjectionTransitions());
         if (loaded.transitions.length === 0 && loaded.unreadableTargets.size === 0) {
             return [...events];
         }
@@ -371,39 +369,32 @@ export class AiSdkCompaction {
         return historyCompactSourceDigest(covered) === pinned;
     }
     /**
-     * Fold the durable transition ledger onto this session's prior history, and
-     * commit any new stale-result transition the prune policy calls for.
+     * Apply the same bounded-result rule to current and prior events.
      *
      * This is the one seam where raw RuntimeEvents become effective model
      * history: the caller uses the returned events for replay, budgeting and
      * compaction alike, so no later stage can read content a transition removed.
      */
-    async prepareContextBudgetPolicy(runtimeContext, turnId) {
+    async pruneToolResults(runtimeContext, turnId) {
         const policy = this.input.contextBudget;
-        const loaded = await this.loadModelProjectionTransitions();
-        let transitions = loaded.transitions;
-        let effective = reduceEffectiveModelProjections(runtimeContext, transitions, loaded.unreadableTargets);
+        let loaded = await this.loadModelProjectionTransitions();
+        let effective = reduceEffectiveModelProjections(runtimeContext, loaded.transitions, loaded.unreadableTargets);
         if (!policy)
-            return { policy, events: effective.events };
-        let nextPolicy = policy;
-        let diagnosticPatch;
+            return { events: effective.events, projectionSnapshot: loaded };
+        let stats;
         // A chain this reader cannot see in full is a chain it must not extend: a
         // successor built on a partly known state would name the wrong predecessor
         // and be permanently inert, losing the content it archived.
         const services = loaded.unreadableTargets.size === 0
             ? this.toolResultArchiveTransitionServices(turnId)
             : undefined;
-        if (policy.staleToolResultPrune?.enabled === true && services) {
+        if (policy.toolResultPrune?.enabled === true && services) {
             // The decision is taken over EFFECTIVE history, so a result an earlier
             // Turn already replaced is never re-measured — or re-archived — at the
             // size it used to have.
-            const candidates = collectStaleToolResultArchiveCandidates(effective.events, policy.staleToolResultPrune, policy.charsPerToken ?? 4);
-            const committed = [];
-            let archiveFailures = 0;
-            let estimatedTokensBefore = 0;
-            let estimatedTokensAfter = 0;
+            const candidates = collectToolResultArchiveCandidates(effective.events, policy.toolResultPrune, policy.charsPerToken ?? 4);
             for (const candidate of candidates) {
-                const outcome = await archiveToolResultAsTransition(services, {
+                await archiveToolResultAsTransition(services, {
                     runtimeEventId: candidate.runtimeEventId,
                     turnId: candidate.turnId,
                     toolCallId: candidate.toolCallId,
@@ -415,37 +406,41 @@ export class AiSdkCompaction {
                     reason: candidate.reason,
                     result: candidate.result,
                 });
-                if (!outcome) {
-                    archiveFailures += 1;
-                    continue;
-                }
-                committed.push(outcome.transition);
-                estimatedTokensBefore += candidate.originalEstimatedTokens;
-                estimatedTokensAfter += estimateTokens(serializedToolResultProjection(outcome.transition.replacement).length, policy.charsPerToken ?? 4);
             }
-            if (committed.length > 0) {
-                transitions = [...transitions, ...committed];
-                effective = reduceEffectiveModelProjections(runtimeContext, transitions, loaded.unreadableTargets);
-            }
-            if (committed.length > 0 || archiveFailures > 0) {
-                diagnosticPatch = {
-                    ...(committed.length > 0
-                        ? {
-                            prunedToolResults: committed.length,
-                            prunedToolResultEstimatedTokensBefore: estimatedTokensBefore,
-                            prunedToolResultEstimatedTokensAfter: estimatedTokensAfter,
-                            archivePlaceholders: committed.length,
-                            archivePlaceholderReasonCounts: {
-                                stale_tool_result_pruned_before_compact: committed.length,
-                            },
-                        }
-                        : {}),
-                    ...(archiveFailures > 0
-                        ? { archiveWriteFailures: archiveFailures, unarchivedToolResults: archiveFailures }
-                        : {}),
+            if (candidates.length > 0) {
+                // Writes (including a rival winner or an uncertain commit) cannot tell
+                // us what the model sees. Read once after the batch and use this same
+                // snapshot for checkpoint validation, replay, and diagnostics.
+                loaded = await this.loadModelProjectionTransitions();
+                effective = reduceEffectiveModelProjections(runtimeContext, loaded.transitions, loaded.unreadableTargets);
+                stats = {
+                    prunedToolResults: 0,
+                    prunedToolResultEstimatedTokensBefore: 0,
+                    prunedToolResultEstimatedTokensAfter: 0,
+                    archiveWriteFailures: 0,
                 };
+                for (const candidate of candidates) {
+                    const applied = effective.applied.find((transition) => transition.target.runtimeEventId === candidate.runtimeEventId);
+                    if (!applied) {
+                        stats.archiveWriteFailures++;
+                        continue;
+                    }
+                    stats.prunedToolResults++;
+                    stats.prunedToolResultEstimatedTokensBefore += candidate.originalEstimatedTokens;
+                    stats.prunedToolResultEstimatedTokensAfter += estimateTokens(serializedToolResultProjection(applied.replacement).length, policy.charsPerToken ?? 4);
+                }
             }
         }
+        return { events: effective.events, projectionSnapshot: loaded, ...(stats ? { stats } : {}) };
+    }
+    async prepareContextBudgetPolicy(runtimeContext, turnId) {
+        const policy = this.input.contextBudget;
+        const prepared = await this.pruneToolResults(runtimeContext, turnId);
+        const effective = { events: prepared.events };
+        if (!policy)
+            return { policy, events: effective.events, projectionSnapshot: prepared.projectionSnapshot };
+        let nextPolicy = policy;
+        let diagnosticPatch = prepared.stats;
         let loadedCheckpoint;
         try {
             loadedCheckpoint = await Promise.resolve(this.input.loadHistoryCompactCheckpoint?.());
@@ -492,93 +487,10 @@ export class AiSdkCompaction {
         return {
             policy: nextPolicy,
             events: effective.events,
+            projectionSnapshot: prepared.projectionSnapshot,
             ...(diagnosticPatch ? { diagnosticPatch } : {}),
         };
     }
-    buildActiveToolResultPruneProjection(turnId, includeNewestStep, onDiagnosticPatch) {
-        const policy = this.input.contextBudget?.activeToolResultPrune;
-        if (policy?.enabled !== true)
-            return undefined;
-        const services = this.toolResultArchiveTransitionServices(turnId);
-        // No durable ledger, no lossy rewrite. The old per-Turn placeholder map let
-        // this run prune content that the NEXT request would have shown again.
-        if (!services || !this.input.loadTurnRuntimeEvents)
-            return undefined;
-        // The current Turn reads the same folded history as every other consumer.
-        // Nothing here remembers what this run already archived: the ledger says it,
-        // and a step that measures the raw body again would archive it again.
-        let effective;
-        const loadEffectiveTurnEvents = async () => {
-            if (effective)
-                return effective;
-            const loaded = await this.loadModelProjectionTransitions();
-            if (loaded.unreadableTargets.size > 0)
-                return undefined;
-            let turnEvents;
-            try {
-                turnEvents = await this.input.loadTurnRuntimeEvents(turnId);
-            }
-            catch {
-                return undefined;
-            }
-            const reduction = reduceEffectiveModelProjections(turnEvents, loaded.transitions);
-            const lastApplied = new Map();
-            for (const transition of reduction.applied) {
-                lastApplied.set(transition.target.runtimeEventId, transition.transitionId);
-            }
-            effective = { events: reduction.events, lastApplied };
-            return effective;
-        };
-        const resolveProjection = async (toolCallId) => {
-            const current = await loadEffectiveTurnEvents();
-            if (!current)
-                return undefined;
-            const event = current.events.find((candidate) => candidate.partial !== true &&
-                candidate.content?.kind === 'function_response' &&
-                candidate.content.id === toolCallId);
-            if (!event || event.content?.kind !== 'function_response')
-                return undefined;
-            const projection = baseToolResultProjection(event);
-            if (!projection)
-                return undefined;
-            const previousTransitionId = current.lastApplied.get(event.id);
-            return {
-                runtimeEventId: event.id,
-                turnId: event.turnId,
-                toolName: event.content.name,
-                projection,
-                ...(previousTransitionId ? { previousTransitionId } : {}),
-            };
-        };
-        return async (options) => {
-            const eligibleToolCallIds = collectPrunableCompletedStepToolCallIds(options.completedSteps, includeNewestStep);
-            if (eligibleToolCallIds.size === 0)
-                return undefined;
-            // Each provider step rebuilds its messages from the durable Turn ledger,
-            // so each step must re-fold it too.
-            effective = undefined;
-            const rewritten = await rewriteActiveToolResultsInMessages({
-                messages: options.messages,
-                policy,
-                stepNumber: options.stepNumber,
-                turnId,
-                charsPerToken: this.input.contextBudget?.charsPerToken,
-                eligibleToolCallIds,
-                completedToolCalls: options.completedSteps.flatMap((step, stepNumber) => (step.toolCalls ?? []).map((call) => ({
-                    toolCallId: call.toolCallId,
-                    toolName: call.toolName,
-                    input: call.input,
-                    stepNumber,
-                }))),
-                resolveProjection,
-                transitions: services,
-            });
-            if (hasActiveToolResultPruneDiagnosticPatch(rewritten.diagnosticPatch)) {
-                onDiagnosticPatch?.(rewritten.diagnosticPatch);
-            }
-            return rewritten.rewritten > 0 ? { messages: rewritten.messages } : undefined;
-        };
-    }
     /**
      * Mid-turn capacity compaction eligibility (issue #882 PR 1). Explicit
      * opt-in via `historyCompact.midTurn.enabled`; requires the checkpoint
@@ -907,7 +819,8 @@ export class AiSdkCompaction {
         // materializable and replay-admissible. A checkpoint that fails either
         // check must never be persisted because it would poison every later
         // projection.
-        const replayPlan = buildRuntimeEventModelReplayPlan(plan.replacementEvents, {
+        const effectiveReplacement = await this.foldEffectiveModelHistory(plan.replacementEvents);
+        const replayPlan = buildRuntimeEventModelReplayPlan(effectiveReplacement, {
             toolActivityTurnIds: collectToolActivityTurnIds(orderedEvents),
         });
         if (replayPlan.items.length === 0 ||
@@ -1035,41 +948,6 @@ export class AiSdkCompaction {
         return { messages: outcome.replacementMessages };
     }
 }
-// -- moved helpers (defined in ai-sdk-backend, used only by cache write) -------
-function incrementRecord(counts, key) {
-    counts[key] = (counts[key] ?? 0) + 1;
-}
-function mergeCountsInto(target, source) {
-    for (const [key, value] of Object.entries(source ?? {})) {
-        target[key] = (target[key] ?? 0) + value;
-    }
-}
-// -- moved helpers (prepare-step / signature / prune) ------------------------
-/**
- * Tool results from the newest completed step have not crossed the provider
- * boundary yet: projection is invoked immediately before the first request
- * that could show those results to the model. By default active pruning defers
- * the newest step and archives only older completed steps, after the model has
- * had one request in which to consume their exact output.
- *
- * `includeNewestStep` widens eligibility to every completed step, including the
- * newest. The caller sets it when mid-turn capacity compaction is active: the
- * final-payload verdict may need an oversized newest result pruned to a
- * placeholder before declaring exhaustion, and capacity/recovery rebuilds
- * re-materialize raw bodies from the ledger that must be re-archived.
- */
-function collectPrunableCompletedStepToolCallIds(steps, includeNewestStep) {
-    const out = new Set();
-    const prunableSteps = includeNewestStep ? steps : steps.slice(0, -1);
-    for (const step of prunableSteps) {
-        for (const call of step.toolCalls ?? []) {
-            if (typeof call.toolCallId === 'string' && call.toolCallId.length > 0) {
-                out.add(call.toolCallId);
-            }
-        }
-    }
-    return out;
-}
 function projectHistoricalImageOmissions(messages, omittedImageToolResults) {
     if (omittedImageToolResults.size === 0)
         return undefined;
@@ -1110,13 +988,6 @@ function stableStringifyForSignature(value) {
         .map((key) => `${JSON.stringify(key)}:${stableStringifyForSignature(object[key])}`)
         .join(',')}}`;
 }
-export function hasActiveToolResultPruneDiagnosticPatch(patch) {
-    return ((patch.activePrunedToolResults ?? 0) > 0 ||
-        (patch.activeSupersededToolResults ?? 0) > 0 ||
-        (patch.activeDuplicateToolResults ?? 0) > 0 ||
-        (patch.activeArchiveFailures ?? 0) > 0 ||
-        (patch.activeEstimatedTokensSaved ?? 0) > 0);
-}
 /**
  * Per-send() state for the mid-turn capacity invariant. The coverage pool is
  * NOT mirrored here: every trigger reads the current turn's persisted

package/node_modules/@maka/runtime/dist/ai-sdk-message-projection.js

@@ -444,18 +444,23 @@ export class AiSdkMessageProjection {
     }
     async materializeRuntimeReplayItem(budget, item) {
         if (item.role === 'user') {
+            // Both ordinary and steered replay materialize image attachments through
+            // the same path the original request used — a steering replay that kept
+            // only the envelope text would hand a recovery turn references without
+            // the native images the first request received.
+            const content = await this.appendImageParts(budget, item.content, item.attachments, item.steering ? `steering:${item.steering.eventId}` : `runtime-event:${item.eventId}`);
             if (item.steering) {
                 // Already envelope-wrapped by the plan; carry the structured identity
                 // so injection dedupe recognizes the replayed message.
                 return {
                     role: 'user',
-                    content: item.content,
+                    content,
                     providerOptions: steeringProviderOptions(item.steering.eventId),
                 };
             }
             return {
                 role: 'user',
-                content: await this.appendImageParts(budget, item.content, item.attachments, `runtime-event:${item.eventId}`),
+                content,
             };
         }
         return {