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

package/node_modules/@maka/runtime/dist/tool-result-archive-transition.js

@@ -16,37 +16,15 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * The one writer that turns a Tool Result prune decision into durable truth
- * (#4283).
- *
- * Both prune paths — the current Turn's active prune before the next provider
- * step, and the prior Turn's stale prune before compaction — come through here.
- * They used to keep their replacement in a Turn-local map and a policy-carried
- * ref table respectively, so each owned a private recovery contract and neither
- * survived a restart. Now each records one `ModelProjectionTransition`, and the
- * Session reducer is the only thing that decides what the model sees.
- *
- * Write order is the whole safety argument:
- *
- * 1. Archive the replaced body. A failure here leaves the projection untouched.
- * 2. Append the transition. A failure here leaves an artifact nothing points
- *    at — unreachable by the reducer, so safe to reclaim once something does —
- *    and again leaves the projection untouched.
- * 3. Only then may a caller show the replacement.
- *
- * There is no state in which the model has lost content the ledger cannot
- * explain, and none in which a completed tool effect is repeated.
- */
 import { MATERIALIZED_IMAGE_TOKENS } from '@maka/core/attachments';
 import { DURABLE_TOOL_RESULT_PROJECTION_VERSION } from '@maka/core/durable-tool-result-projection';
 import { buildModelProjectionTransition, durableToolResultProjectionDigest, } from '@maka/core/model-projection-transition';
-import { estimateTokens, finitePositive, sha256, turnKey, utf8ByteLength, } from './context-budget-helpers.js';
+import { estimateTokens, sha256, utf8ByteLength } from './context-budget-helpers.js';
 import { projectionArtifactMedia } from './durable-tool-result-projection.js';
-import { baseToolResultProjection, nextInChain } from './model-projection-transition-ledger.js';
+import { baseToolResultProjection } from './model-projection-transition-ledger.js';
 import { ARCHIVED_TOOL_RESULT_REWRITE_VERSION, buildArchivedToolResultPlaceholder, buildLedgerArchivedToolResultPlaceholder, isArchivedToolResultPlaceholder, } from './tool-result-archive.js';
 import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
-const DEFAULT_MAX_TOOL_RESULT_ESTIMATED_TOKENS = 2048;
+import { READ_PAGE_MAX_CHARS, readToolResultPage } from './read-page.js';
 /**
  * What the model actually reads for one Tool Result, as bytes.
  *
@@ -59,19 +37,19 @@ export function serializedToolResultProjection(projection) {
     return serializeToolResultProjectionV1(projection);
 }
 /** The replacement a pruned Tool Result projects to. */
-export function archivedToolResultProjection(placeholder) {
+export function archivedToolResultProjection(placeholder, source) {
     return {
         version: DURABLE_TOOL_RESULT_PROJECTION_VERSION,
         kind: 'json',
         value: placeholder,
+        ...(source && 'isError' in source && source.isError ? { isError: true } : {}),
     };
 }
 /**
  * Archive one body and commit the transition that replaces its projection.
  *
- * Returns `undefined` when either durable step fails: the caller then leaves
- * the model-visible content exactly as it was, which is the only outcome that
- * keeps "visible history is append-only" true under partial failure.
+ * This is a write attempt, not a projection decision. The caller must read
+ * the durable ledger afterwards, including after a failed or uncertain write.
  */
 export async function archiveToolResultAsTransition(services, request) {
     const bodySha256 = sha256(request.serializedResult);
@@ -112,7 +90,6 @@ export async function archiveToolResultAsTransition(services, request) {
         originalEstimatedTokens: request.originalEstimatedTokens,
         originalBytes: request.originalBytes,
         reason: request.reason,
-        ...(request.supersession ? { supersession: request.supersession } : {}),
     };
     let placeholder;
     try {
@@ -126,6 +103,7 @@ export async function archiveToolResultAsTransition(services, request) {
                     : {}),
             })
             : buildArchivedToolResultPlaceholder({ ...common, artifactId: archived.artifactId });
+        placeholder.page = readToolResultPage(request.serializedResult, { path: placeholder.resourceRef }, READ_PAGE_MAX_CHARS - JSON.stringify(placeholder).length - 32);
     }
     catch {
         return undefined;
@@ -144,7 +122,7 @@ export async function archiveToolResultAsTransition(services, request) {
             // The placeholder inside the replacement is the whole archive record:
             // artifact id, body digest and original size. The transition does not
             // repeat them — one fact, one place.
-            replacement: archivedToolResultProjection(placeholder),
+            replacement: archivedToolResultProjection(placeholder, request.sourceProjection),
             ...(request.previousTransitionId
                 ? { previousTransitionId: request.previousTransitionId }
                 : {}),
@@ -160,77 +138,35 @@ export async function archiveToolResultAsTransition(services, request) {
         else {
             await services.recordTransition(transition);
         }
-        const winner = await winningTransition(services, transition);
-        if (winner && winner.transitionId !== transition.transitionId) {
-            // The rival won. Show what the ledger says, not what this writer wrote;
-            // its own record stays durable and inert, and the body it archived is
-            // unreachable exactly as a refused transition's archive should be.
-            const replaced = winner.replacement.kind === 'json' ? winner.replacement.value : undefined;
-            if (!isArchivedToolResultPlaceholder(replaced))
-                return undefined;
-            return { placeholder: replaced, transition: winner };
-        }
     }
     catch {
-        // The archive artifact is now unreferenced: nothing in the effective
-        // history names it, which is what reducer-derived reachability reports. It
-        // is content-addressed, so a retry of the same decision reuses it rather
-        // than publishing a second one. No cleanup pass consumes that reachability
-        // yet, so such an artifact is retained until one does — it cannot break
-        // replay, but it is not reclaimed either (#4283).
+        // A storage failure does not prove that no transition committed. Only the
+        // caller's subsequent authoritative read can decide what is effective.
         return undefined;
     }
-    return { placeholder, transition };
-}
-/** The transition the durable fold accepts for this target, after an append. */
-async function winningTransition(services, appended) {
-    if (!services.loadTransitions)
-        return appended;
-    const { transitions } = await services.loadTransitions();
-    return nextInChain(transitions, appended.previousTransitionId, appended.sourceProjectionDigest, {
-        id: appended.target.toolCallId,
-        name: appended.target.toolName,
-    });
 }
-/**
- * Prior-Turn results large enough to archive before compaction.
- *
- * Collection reads events the transition reducer has already folded, so a
- * result an earlier transition replaced is measured at its replacement size and
- * simply falls below the threshold — there is no second "already pruned?"
- * predicate to keep in step with the fold.
- */
-export function collectStaleToolResultArchiveCandidates(events, prunePolicy, charsPerToken) {
+export function collectToolResultArchiveCandidates(events, prunePolicy, charsPerToken) {
     if (prunePolicy?.enabled !== true)
         return [];
-    const maxResultEstimatedTokens = finitePositive(prunePolicy.maxResultEstimatedTokens) ??
-        DEFAULT_MAX_TOOL_RESULT_ESTIMATED_TOKENS;
-    const minRecentTurnsFull = Math.max(0, Math.floor(prunePolicy.minRecentTurnsFull ?? 1));
-    const protectedTurnIds = recentTurnIds(events, minRecentTurnsFull);
     const candidates = [];
     for (const event of events) {
         const content = event.content;
         if (event.partial ||
             event.modelVisibility === 'hidden' ||
             content?.kind !== 'function_response' ||
-            protectedTurnIds.has(turnKey(event))) {
+            content.providerExecuted) {
             continue;
         }
         const sourceProjection = baseToolResultProjection(event);
-        if (!sourceProjection)
+        if (!sourceProjection ||
+            (sourceProjection.kind === 'json' && isArchivedToolResultPlaceholder(sourceProjection.value)))
             continue;
         const serializedResult = serializedToolResultProjection(sourceProjection);
         const originalBytes = utf8ByteLength(serializedResult);
         const media = projectionArtifactMedia(sourceProjection);
-        // An artifact serializes to a short reference and materializes to real
-        // image bytes, so the string alone would price a screenshot at nothing.
         const originalEstimatedTokens = estimateTokens(serializedResult.length, charsPerToken) +
             media.length * MATERIALIZED_IMAGE_TOKENS;
-        // A result that carries media is always a candidate: archiving it drops
-        // whole images from the request, which is worth doing whatever the
-        // reference text around them happens to weigh. The size gate is there to
-        // spare small text results, so it only decides those.
-        if (media.length === 0 && originalEstimatedTokens <= maxResultEstimatedTokens)
+        if (media.length > 0 || serializedResult.length <= READ_PAGE_MAX_CHARS)
             continue;
         candidates.push({
             runtimeEventId: event.id,
@@ -243,46 +179,8 @@ export function collectStaleToolResultArchiveCandidates(events, prunePolicy, cha
             originalEstimatedTokens,
             originalBytes,
             rewriteVersion: ARCHIVED_TOOL_RESULT_REWRITE_VERSION,
-            reason: 'stale_tool_result_pruned_before_compact',
+            reason: 'tool_result_pruned',
         });
     }
     return candidates;
 }
-/**
- * Archive artifacts the effective history still needs.
- *
- * Derived from the folded events, never from a parallel bookkeeping table: an
- * artifact is reachable exactly when a placeholder the model can still see names
- * it. An archive whose transition was refused is therefore unreachable by
- * construction.
- *
- * This is the reachability authority a reclaiming pass must ask; no such pass
- * exists yet, so nothing here is reclaimed today (#4283). Adding one is what
- * makes an unreferenced archive temporary rather than retained.
- */
-export function collectReachableArchiveArtifactIds(events) {
-    const reachable = new Set();
-    for (const event of events) {
-        const content = event.content;
-        if (content?.kind !== 'function_response')
-            continue;
-        if (isArchivedToolResultPlaceholder(content.result) && content.result.rewriteVersion === 1) {
-            reachable.add(content.result.artifactId);
-        }
-    }
-    return reachable;
-}
-function recentTurnIds(events, count) {
-    if (count <= 0)
-        return new Set();
-    const order = [];
-    const seen = new Set();
-    for (const event of events) {
-        const key = turnKey(event);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        order.push(key);
-    }
-    return new Set(order.slice(Math.max(0, order.length - count)));
-}

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

@@ -32,11 +32,11 @@ export function buildLedgerArchivedToolResultPlaceholder(input) {
         originalBytes: input.originalBytes,
         originalEstimatedTokens: input.originalEstimatedTokens,
         reason: input.reason,
-        ...(input.supersession ? { supersession: input.supersession } : {}),
         kind: ARCHIVED_TOOL_RESULT_PLACEHOLDER_KIND,
         rewriteVersion: 2,
-        resourceRef: buildToolResultArchiveResourceRef(input),
-        readInstructions: TOOL_RESULT_ARCHIVE_READ_INSTRUCTIONS,
+        resourceRef: `maka://runtime/tool-results/${encodeURIComponent(input.runtimeEventId)}`,
+        readInstructions: 'Use Read with the next parameters to continue this result.',
+        ...(input.page ? { page: input.page } : {}),
     };
 }
 export function stableToolResultArchiveArtifactId(event) {
@@ -96,28 +96,11 @@ export function isArchivedToolResultPlaceholder(value) {
         typeof candidate.originalBytes === 'number' &&
         Number.isFinite(candidate.originalBytes) &&
         candidate.originalBytes > 0 &&
-        (candidate.reason === 'stale_tool_result_pruned_before_compact' ||
-            candidate.reason === 'active_current_turn_tool_result_pruned_before_next_step') &&
-        isValidSupersession(candidate.supersession));
-}
-function isValidSupersession(value) {
-    if (value === undefined)
-        return true;
-    if (!value || typeof value !== 'object')
-        return false;
-    const candidate = value;
-    return ((candidate.reason === 'exact_duplicate' ||
-        candidate.reason === 'newer_read_covers_range' ||
-        candidate.reason === 'newer_snapshot' ||
-        candidate.reason === 'failure_resolved') &&
-        typeof candidate.supersededByToolCallId === 'string' &&
-        candidate.supersededByToolCallId.length > 0 &&
-        (candidate.reason === 'failure_resolved'
-            ? typeof candidate.failureBodySha256 === 'string' &&
-                /^[a-f0-9]{64}$/.test(candidate.failureBodySha256)
-            : candidate.failureBodySha256 === undefined));
+        (candidate.reason === 'tool_result_pruned' ||
+            candidate.reason === 'stale_tool_result_pruned_before_compact' ||
+            candidate.reason === 'active_current_turn_tool_result_pruned_before_next_step'));
 }
-/** Add the canonical ArchiveRead address to persisted v1 placeholders. */
+/** Normalize persisted archive metadata without expanding the body. */
 export function withToolResultArchiveResourceRef(value) {
     if (!isArchivedToolResultPlaceholder(value))
         return value;
@@ -151,6 +134,5 @@ export function buildArchivedToolResultPlaceholder(input) {
         originalEstimatedTokens: input.originalEstimatedTokens,
         originalBytes: input.originalBytes,
         reason: input.reason,
-        ...(input.supersession ? { supersession: input.supersession } : {}),
     };
 }

package/node_modules/@maka/runtime/dist/tool-runtime.js

@@ -372,6 +372,8 @@ export class ToolRuntime {
                 return encodeDefaultDurableToolResultOutput(result, this.input.sessionId);
             }
             const output = tool.toModelOutput({ toolCallId, input, output: result });
+            if (output === undefined)
+                return encodeDefaultDurableToolResultOutput(result, this.input.sessionId);
             // Projection is deliberately synchronous and total at the tool boundary.
             // Fail closed for untyped/plugin implementations that violate the
             // contract so a completed effect can never be stranded before T2.
@@ -1319,7 +1321,7 @@ export class ToolRuntime {
                 }
                 const durationMs = Math.max(0, this.input.now() - startedAt);
                 const terminalResult = this.errorReturn(terminalFailure.message);
-                const projected = this.projectToolResult(tool, turnId, toolUseId, executionArgs, terminalResult);
+                const projected = this.projectToolResult(tool, turnId, toolUseId, executionArgs, terminalFailure.content);
                 const modelProjection = isPromiseLike(projected) ? await projected : projected;
                 const durableOutcome = await durableAttempt?.commitOutcome(terminalFailure.content, true, modelProjection, durationMs);
                 queue.push({
@@ -2830,14 +2832,14 @@ function coerceTerminalFailure(tool, cwd, args, err) {
     const command = args && typeof args === 'object' && typeof args.command === 'string'
         ? args.command
         : '';
-    const stdout = redactSecrets(String(error.stdout ?? ''));
-    const stderr = redactSecrets(String(error.stderr ?? ''));
+    const stdout = String(error.stdout ?? '');
+    const stderr = String(error.stderr ?? '');
     const sandboxDenied = error.reason === 'sandbox_denial' && error.sandboxed === true;
     return {
         content: {
             kind: 'terminal',
             cwd,
-            cmd: redactSecrets(command),
+            cmd: command,
             status: error.code === 124 ? 'timed_out' : error.code === 130 ? 'cancelled' : 'failed',
             exitCode: error.code,
             output: {
@@ -2846,7 +2848,7 @@ function coerceTerminalFailure(tool, cwd, args, err) {
                 stderr,
                 stdoutTruncated: error.stdoutTruncated === true,
                 stderrTruncated: error.stderrTruncated === true,
-                redacted: stdout !== String(error.stdout ?? '') || stderr !== String(error.stderr ?? ''),
+                redacted: false,
             },
             ...(sandboxDenied
                 ? {