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

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

@@ -33,7 +33,7 @@ import { composeRequestProjection, } from './request-projection.js';
 import { decodePlaintextResponsesReasoningState, responsesReasoningItemId, } from './responses-reasoning-state.js';
 import { finitePositive } from './context-budget-helpers.js';
 import { contextDiagnosticsCompactionOf, } from './context-diagnostics.js';
-import { hasActiveToolResultPruneDiagnosticPatch, hasBlockingReplayDiagnostics, } from './ai-sdk-compaction.js';
+import { hasBlockingReplayDiagnostics } from './ai-sdk-compaction.js';
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
@@ -42,7 +42,7 @@ import { toolAvailabilityHash } from './tool-availability.js';
 import { renderSwarmModePrompt } from './swarm-mode.js';
 import { renderGraphModePrompt } from './graph-mode.js';
 import { modelUsesNativeOpenAiResponses } from './model-runtime.js';
-import { applyRuntimeEventContextBudget, buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, mergeContextBudgetDiagnosticPatches, minimalContextBudgetDiagnostic, shouldAppendContextCompactedNote, shouldAppendContextCompactionFailedOpenNote, } from './context-budget.js';
+import { applyRuntimeEventContextBudget, buildContextBudgetDiagnosticShell, mergeContextBudgetDiagnostic, addToolResultPruneStats, minimalContextBudgetDiagnostic, shouldAppendContextCompactedNote, shouldAppendContextCompactionFailedOpenNote, } from './context-budget.js';
 import { isHistoryCompactContentEvent } from './history-compaction.js';
 import { canContinueHistoryCompactCheckpointForModel, historyCompactSourceDigest, isProviderHistoryCompactCheckpoint, matchHistoryCompactCheckpointPrefix, projectHistoryCompactCheckpointReplay, } from './history-compact-checkpoint.js';
 import { resolveSelectedModelContextWindow } from './context-budget-policy.js';
@@ -834,8 +834,6 @@ export class AiSdkTurn {
             return { plan, providerTools: plan.providerTools, modelTools, nestedTools };
         };
         let { plan, providerTools, modelTools, nestedTools } = snapshotStepTools();
-        let activeToolResultPruneDiagnosticPatch = {};
-        let midTurnCompactDiagnosticPatch;
         // Tool names the repair path matches a mis-cased call against — follows the
         // current step's snapshot so a tool activated mid-turn is repairable on the
         // step it becomes active, not routed to `invalid`.
@@ -979,6 +977,12 @@ export class AiSdkTurn {
                 };
                 const loadDurableTurnProjection = async () => {
                     const turnEvents = await loadDurableTurnEvents();
+                    const pruned = await this.deps.compaction.pruneToolResults(turnEvents, turnId);
+                    if (pruned.stats) {
+                        if (pruned.stats.prunedToolResults > 0)
+                            pruneAppliedAtStep = runtimeSteps;
+                        contextBudgetForTelemetry = addToolResultPruneStats(contextBudgetForTelemetry ?? minimalContextBudgetDiagnostic(), pruned.stats);
+                    }
                     const projectionCheckpoint = midTurnState?.projectionCheckpoint;
                     const rawProjectionEvents = projectionCheckpoint
                         ? [
@@ -999,7 +1003,7 @@ export class AiSdkTurn {
                         // built from. Replay without the stale block — the provider
                         // decides fit and overflow recovery re-folds (#4845 review).
                         const pinnedEffectiveDigest = projectionCheckpoint.coverage.effectiveSourceDigest;
-                        const coveredEffective = await this.deps.compaction.foldEffectiveModelHistory(checkpointMatch.coveredRuntimeEvents);
+                        const coveredEffective = await this.deps.compaction.foldEffectiveModelHistory(checkpointMatch.coveredRuntimeEvents, pruned.projectionSnapshot);
                         if (pinnedEffectiveDigest === undefined ||
                             historyCompactSourceDigest(coveredEffective) !== pinnedEffectiveDigest) {
                             effectiveProjectionCheckpoint = undefined;
@@ -1016,7 +1020,7 @@ export class AiSdkTurn {
                     // folded through the same reducer before it becomes messages. Without
                     // this, a result archived at step N is rebuilt in full at step N+1 and
                     // the ledger's account of what the model sees stops being true.
-                    const foldedReplayEvents = await this.deps.compaction.foldEffectiveModelHistory(replayEvents);
+                    const foldedReplayEvents = await this.deps.compaction.foldEffectiveModelHistory(replayEvents, pruned.projectionSnapshot);
                     const replayPlan = buildRuntimeEventModelReplayPlan(foldedReplayEvents, {
                         toolActivityTurnIds: collectToolActivityTurnIds([
                             ...(input.runtimeContext ?? []),
@@ -1049,7 +1053,7 @@ export class AiSdkTurn {
                     ...(priorReplay.contextBudget ? { contextBudget: priorReplay.contextBudget } : {}),
                 });
                 const onMidTurnDiagnosticPatch = (patch) => {
-                    midTurnCompactDiagnosticPatch = mergeContextBudgetDiagnosticPatches(midTurnCompactDiagnosticPatch, patch);
+                    contextBudgetForTelemetry = mergeContextBudgetDiagnostic(contextBudgetForTelemetry ?? minimalContextBudgetDiagnostic(), patch);
                 };
                 const capacityProviderTools = [...providerTools];
                 const midTurnCapacityHook = this.deps.compaction.buildMidTurnCapacityCompactProjection(turnId, midTurnState, queue, capacityProviderTools, onMidTurnDiagnosticPatch, this, this.automaticMemoryCompactionSupported()
@@ -1057,15 +1061,8 @@ export class AiSdkTurn {
                     : undefined, this.automaticMemoryCompactionSupported()
                     ? (dispatch) => this.dispatchAutomaticMemoryCompaction(dispatch)
                     : undefined, turnAbortController.signal);
-                // When mid-turn capacity compaction is active, the prune must also cover
-                // the newest completed step; see collectPrunableCompletedStepToolCallIds.
-                const activeToolResultPruneIncludesNewestStep = midTurnState !== undefined;
-                const activeToolResultPruneHook = this.deps.compaction.buildActiveToolResultPruneProjection(turnId, activeToolResultPruneIncludesNewestStep, (patch) => {
-                    pruneAppliedAtStep = runtimeSteps;
-                    activeToolResultPruneDiagnosticPatch = mergeActiveToolResultPruneDiagnosticPatches(activeToolResultPruneDiagnosticPatch, patch);
-                });
                 const projectCurrentToolAvailability = (options) => plan.projectActiveTools?.(options);
-                const shapedProjection = composeRequestProjection(projectCurrentToolAvailability, midTurnCapacityHook, activeToolResultPruneHook);
+                const shapedProjection = composeRequestProjection(projectCurrentToolAvailability, midTurnCapacityHook);
                 // Hooks shape; nothing measures the final payload. Whether it fits is
                 // the provider's answer (#4559).
                 const requestProjection = shapedProjection;
@@ -1655,21 +1652,7 @@ export class AiSdkTurn {
                                 : undefined;
                             if (recovered) {
                                 overflowRetryUsed = true;
-                                // Recovery rebuilds the request from the durable ledger, whose
-                                // tool results intentionally retain their full bodies. Re-enter
-                                // the active-result projection before dispatch so an archived
-                                // result cannot reappear in provider context on the retry.
-                                const recoveredProjection = activeToolResultPruneHook
-                                    ? await activeToolResultPruneHook({
-                                        completedSteps: completedProviderSteps,
-                                        stepNumber: runtimeSteps,
-                                        model,
-                                        messages: recovered.messages,
-                                        activeTools: activeToolsForRequest,
-                                        resolveDispatch,
-                                    })
-                                    : undefined;
-                                attemptMessages = recoveredProjection?.messages ?? recovered.messages;
+                                attemptMessages = recovered.messages;
                                 continue;
                             }
                             // Window suggestion (#4559): the provider rejected a request and
@@ -2006,7 +1989,7 @@ export class AiSdkTurn {
                     tokenUsage = sawUnusableStepUsage ? undefined : (completedStepUsage ?? attemptTotalUsage);
                     if (tokenUsage) {
                         tokenUsageCostUsd = this.deps.providerTelemetry.normalizedUsageCostUsd(tokenUsage);
-                        const contextBudgetForUsage = contextBudgetWithRequestProjectionDiagnostics(contextBudgetForTelemetry, activeToolResultPruneDiagnosticPatch, midTurnCompactDiagnosticPatch);
+                        const contextBudgetForUsage = contextBudgetForTelemetry;
                         // Persisted alongside the live event so transcript rebuilds from
                         // stored messages keep the TUI ctx segment instead of degrading to
                         // `?/<window>` (#4019). Computed once; both writers share it.
@@ -2169,7 +2152,6 @@ export class AiSdkTurn {
                 watchdogState.current?.stop();
                 if (this.watchdog === watchdogState.current)
                     this.watchdog = null;
-                contextBudgetForTelemetry = contextBudgetWithRequestProjectionDiagnostics(contextBudgetForTelemetry, activeToolResultPruneDiagnosticPatch, midTurnCompactDiagnosticPatch);
                 // `tokenUsage` still backfills from the completed steps when the send
                 // ended without a final `usage`: the terminal outcome and the
                 // `token_usage` SessionEvent below both read it. An unusable sample in
@@ -2393,7 +2375,7 @@ export class AiSdkTurn {
         // transition reducer before it becomes messages, so a committed
         // transition still cannot resurrect content for the model (#4283).
         const budgeted = applyRuntimeEventContextBudget(rawPriorRuntimeContext, contextBudget);
-        let runtimeContext = await this.deps.compaction.foldEffectiveModelHistory(budgeted?.events ?? rawPriorRuntimeContext);
+        let runtimeContext = await this.deps.compaction.foldEffectiveModelHistory(budgeted?.events ?? rawPriorRuntimeContext, preparedContextBudget.projectionSnapshot);
         let contextBudgetDiagnostic = budgeted?.diagnostic;
         let projectedHistoryCompactCheckpoint = budgeted?.historyCompactCheckpoint;
         if (preparedContextBudget.diagnosticPatch) {
@@ -2656,15 +2638,6 @@ class ContinuationReplayEmptyError extends Error {
         this.name = 'ContinuationReplayEmptyError';
     }
 }
-function mergeActiveToolResultPruneDiagnosticPatches(left, right) {
-    return {
-        ...sumOptionalCounts('activePrunedToolResults', left, right),
-        ...sumOptionalCounts('activeSupersededToolResults', left, right),
-        ...sumOptionalCounts('activeDuplicateToolResults', left, right),
-        ...sumOptionalCounts('activeArchiveFailures', left, right),
-        ...sumOptionalCounts('activeEstimatedTokensSaved', left, right),
-    };
-}
 function mergeNormalizedUsage(current, next) {
     if (!current)
         return next;
@@ -2685,17 +2658,6 @@ function mergeNormalizedUsage(current, next) {
         cachedInputTokens: cacheHitInputTokens,
     };
 }
-function sumOptionalCounts(key, left, right) {
-    const total = (left[key] ?? 0) + (right[key] ?? 0);
-    return total > 0 ? { [key]: total } : {};
-}
-function contextBudgetWithRequestProjectionDiagnostics(base, patch, compactionPatch) {
-    const prunePatch = hasActiveToolResultPruneDiagnosticPatch(patch) ? patch : undefined;
-    const mergedPatch = mergeContextBudgetDiagnosticPatches(prunePatch, compactionPatch);
-    if (!mergedPatch)
-        return base;
-    return mergeContextBudgetDiagnostic(base ?? minimalContextBudgetDiagnostic(), mergedPatch);
-}
 function projectMemoryConversationPrefix(messages, eventMessagePositions) {
     // Context visibility and durable evidence authority are separate boundaries.
     // Keep the exact source prefix so the auxiliary request preserves referents

package/node_modules/@maka/runtime/dist/bash-model-output.js

@@ -32,5 +32,11 @@ export function projectBashToolResultForModel(output) {
     return projected;
 }
 export function bashToolResultToModelOutput(output) {
-    return toolResultOutput(projectBashToolResultForModel(output), false);
+    const isError = output !== null &&
+        typeof output === 'object' &&
+        'kind' in output &&
+        output.kind === 'terminal' &&
+        'status' in output &&
+        output.status !== 'completed';
+    return toolResultOutput(projectBashToolResultForModel(output), isError);
 }

package/node_modules/@maka/runtime/dist/bash-tail-buffer.js

@@ -21,48 +21,17 @@
 // Memory-bounded tail accumulator for streaming shell output. A runaway command
 // must not be able to grow the captured result without limit (the old Bash path
 // instead discarded ALL output past a hard cap), so we retain only the last
-// `cap` characters.
-//
-// SECURITY: the retained tail is later passed through redactSecrets before it
-// reaches the model / UI. redactSecrets matches on full tokens and their
-// prefixes (e.g. `Authorization: Bearer …`, `sk-…`), so a tail that begins in
-// the MIDDLE of a secret-bearing line would defeat redaction and leak the
-// suffix. To prevent that, when the buffer actually drops content it also drops
-// the (partial) leading line, so the retained tail always starts at a line
-// boundary and redaction sees whole lines.
+// `cap` characters. Trimming avoids splitting a UTF-16 surrogate pair.
 export class BashTailBuffer {
     cap;
     chunks = [];
     retained = 0;
-    // True when we dropped an unterminated oversized line: subsequent chunks are
-    // still part of that compromised line and must be discarded until the next
-    // newline, otherwise a continuation chunk (a secret's severed suffix) would
-    // be retained as if it were a clean line and defeat downstream redaction.
-    insideDroppedLine = false;
-    // Latches true once we drop an oversized no-newline line entirely (the case
-    // above). Callers surface a marker so a result that looks empty is not
-    // mistaken for "the command produced nothing" — content existed but could not
-    // be safely truncated.
-    droppedUnsafe = false;
     constructor(cap) {
         this.cap = cap;
     }
-    /** Whether an oversized, unsafe-to-truncate line was dropped from the tail. */
-    hasDroppedUnsafe() {
-        return this.droppedUnsafe;
-    }
     push(chunk) {
         if (!chunk)
             return;
-        if (this.insideDroppedLine) {
-            const nl = chunk.indexOf('\n');
-            if (nl < 0)
-                return; // whole chunk is still the dropped line — discard it
-            this.insideDroppedLine = false;
-            chunk = chunk.slice(nl + 1); // resume from the first clean line boundary
-            if (!chunk)
-                return;
-        }
         this.chunks.push(chunk);
         this.retained += chunk.length;
         // Amortize: allow growth to 2x cap before compacting back to cap so appends
@@ -78,28 +47,20 @@ export class BashTailBuffer {
         if (this.chunks.length <= 1 && this.retained <= this.cap)
             return;
         const joined = this.chunks.join('');
-        let kept = joined.length > this.cap ? joined.slice(joined.length - this.cap) : joined;
-        if (kept.length < joined.length) {
-            // We sliced mid-stream. Drop the partial leading line so the retained tail
-            // starts at a line boundary and downstream redaction never sees a secret
-            // whose prefix was cut off (see SECURITY note above). With no newline the
-            // whole tail is one partial line we cannot make safe — drop it entirely
-            // rather than risk leaking a severed secret. (A single line larger than
-            // the cap is pathological; the common single-line case is <= cap and is
-            // never sliced here.)
-            const nl = kept.indexOf('\n');
-            if (nl >= 0) {
-                kept = kept.slice(nl + 1);
-            }
-            else {
-                // No line boundary in the retained tail: drop it and stay "inside" the
-                // dropped line so its continuation chunks are discarded until a newline.
-                kept = '';
-                this.insideDroppedLine = true;
-                this.droppedUnsafe = true;
-            }
+        let start = Math.max(0, joined.length - this.cap);
+        if (start > 0 &&
+            isLowSurrogate(joined.charCodeAt(start)) &&
+            isHighSurrogate(joined.charCodeAt(start - 1))) {
+            start += 1;
         }
+        const kept = joined.slice(start);
         this.chunks = kept ? [kept] : [];
         this.retained = kept.length;
     }
 }
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}

package/node_modules/@maka/runtime/dist/builtin-tools.js

@@ -21,7 +21,7 @@
 // execution facts, while the active session ExecutionBoundary constrains local
 // filesystem, shell, and network effects.
 import { z } from 'zod';
-import { jsonSchema, zodSchema } from 'ai';
+import { READ_DESCRIPTION, readParameters, readToolResultPage, resolveReadInput, } from './read-page.js';
 import { closeSync, constants, fstatSync, futimesSync, lstatSync, openSync, realpathSync, unlinkSync, } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname } from 'node:path';
@@ -30,6 +30,8 @@ import { parseAttachmentResourceRef } from '@maka/core/attachments';
 import { isStorageRef } from '@maka/core/events';
 import { bashToolResultToModelOutput } from './bash-model-output.js';
 import { fileWriteToolResultToModelOutput } from './file-tool-model-output.js';
+import { toolResultOutput } from './tool-result-output.js';
+import { GREP_MAX_LINES, GREP_MAX_LINES_PER_FILE, GREP_MAX_MATCH_BYTES } from './grep-search.js';
 import { openAiApplyPatchInputSchema } from './openai-apply-patch.js';
 import { parseCodexV4aPatch } from './codex-v4a-patch.js';
 import { executeApplyPatchOperations } from './apply-patch-batch.js';
@@ -104,87 +106,6 @@ export function buildBuiltinTools(options = {}) {
         ...(options.permissionProfile ? { permissionProfile: options.permissionProfile } : {}),
     });
     const executionFacts = executor.facts;
-    const acceptsResourceRefs = Boolean(options.runtimeResources || options.attachmentResources);
-    const readDescription = `Read a text file${options.snapshotImage ? ' or supported image' : ''} from disk${acceptsResourceRefs ? ', or read a whole runtime resource using ref' : ''}.`;
-    const pathField = z
-        .string()
-        .describe('A file path; relative paths are resolved from the session cwd');
-    const offsetField = z
-        .number()
-        .int()
-        .nonnegative()
-        .describe('Zero-based text file line offset')
-        .optional();
-    const limitField = z
-        .number()
-        .int()
-        .positive()
-        .describe('Maximum text file lines to read')
-        .optional();
-    const refField = z
-        .string()
-        .describe('A runtime resource ref provided in the conversation or returned by another tool');
-    const fileReadParameters = z
-        .object({
-        path: pathField,
-        offset: offsetField,
-        limit: limitField,
-    })
-        .strict();
-    const runtimeResourceReadParameters = z
-        .object({
-        ref: refField,
-    })
-        .strict();
-    // Some providers serialize every optional field with a default. Normalize
-    // only empty fields that cannot carry intent, then let the strict union keep
-    // rejecting genuinely ambiguous file-and-resource requests.
-    const normalizeProviderReadInput = (value) => {
-        if (typeof value !== 'object' || value === null || Array.isArray(value))
-            return value;
-        const input = value;
-        const ref = input.ref;
-        const path = input.path;
-        if (typeof ref === 'string' && ref.trim() !== '') {
-            if (typeof path !== 'string' || path.trim() !== '')
-                return value;
-            return Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'path' && key !== 'offset' && key !== 'limit'));
-        }
-        if (typeof ref !== 'string' || ref.trim() !== '')
-            return value;
-        return Object.fromEntries(Object.entries(input).filter(([key]) => key !== 'ref'));
-    };
-    const strictReadParameters = z.preprocess(normalizeProviderReadInput, z
-        .union([fileReadParameters, runtimeResourceReadParameters])
-        .describe('Read a file with path, or a whole runtime resource with ref; provide exactly one'));
-    // Provider-facing schema: a single top-level object with every field optional.
-    // Anthropic rejects a tool definition whose input schema carries a top-level
-    // `anyOf`, so the file-vs-ref exclusivity is stated in the field descriptions
-    // here and enforced authoritatively by the strict union in `validate` below
-    // (see #1228 — a union-generated `anyOf` had been leaking onto the wire).
-    const providerReadParameters = z
-        .object({
-        path: pathField
-            .describe('A file path; relative paths are resolved from the session cwd. Provide either path (optionally with offset/limit) or ref, never both.')
-            .optional(),
-        offset: offsetField,
-        limit: limitField,
-        ref: refField
-            .describe('A runtime resource ref provided in the conversation or returned by another tool. Provide ref on its own, without path/offset/limit; omit it (or leave it empty) when reading a file.')
-            .optional(),
-    })
-        .describe('Read a file with path (optionally offset/limit), or a whole runtime resource with ref; provide exactly one of path or ref.');
-    const providerReadSchema = zodSchema(providerReadParameters);
-    const readParameters = acceptsResourceRefs
-        ? jsonSchema(async () => await providerReadSchema.jsonSchema, {
-            validate: async (value) => {
-                const result = await strictReadParameters.safeParseAsync(value);
-                return result.success
-                    ? { success: true, value: result.data }
-                    : { success: false, error: result.error };
-            },
-        })
-        : fileReadParameters;
     const shell = options.shell ?? { plan: defaultShellPlan() };
     const sandboxPlatform = options.sandboxPlatform ?? process.platform;
     const bashTools = options.shellRuns
@@ -253,9 +174,29 @@ export function buildBuiltinTools(options = {}) {
         {
             name: 'Read',
             activityKind: 'read',
-            description: readDescription,
+            description: READ_DESCRIPTION,
             parameters: readParameters,
             executionFacts,
+            toModelOutput: ({ input, output }) => {
+                const args = input;
+                const { path } = resolveReadInput(args);
+                if (classifyRuntimeResourceRef(path) !== 'runtime' ||
+                    path.startsWith('maka://runtime/tool-results/'))
+                    return undefined;
+                if (output && typeof output === 'object' && 'kind' in output && output.kind === 'image')
+                    return undefined;
+                try {
+                    return toolResultOutput(readToolResultPage(JSON.stringify(output), args), false);
+                }
+                catch (error) {
+                    return {
+                        type: 'error-text',
+                        value: error instanceof Error
+                            ? error.message
+                            : 'This Read page could not be generated. Read the original path again.',
+                    };
+                }
+            },
             ...(options.releaseImageSnapshot
                 ? {
                     compensateDurableOutcomeCommitFailure: async (input) => {
@@ -280,35 +221,35 @@ export function buildBuiltinTools(options = {}) {
                 : {}),
             impl: async (input, ctx) => {
                 const { cwd, sessionId, abortSignal } = ctx;
-                if ('ref' in input) {
-                    const { ref } = input;
-                    if (classifyRuntimeResourceRef(ref) !== 'runtime') {
-                        throw new Error(`Unsupported runtime resource ref: ${ref}`);
-                    }
-                    const attachment = parseAttachmentResourceRef(ref);
+                const resolved = resolveReadInput(input);
+                const path = resolved.path;
+                const runtimeRef = classifyRuntimeResourceRef(path);
+                if (runtimeRef === 'unsupported')
+                    throw new Error(`Unsupported Maka address: ${path}. Use a path returned by a tool.`);
+                if (runtimeRef === 'runtime') {
+                    const attachment = parseAttachmentResourceRef(path);
                     if (attachment) {
-                        if (!options.attachmentResources) {
+                        if (!options.attachmentResources)
                             throw new Error('Attachment resources are not available in this toolset');
-                        }
-                        return await options.attachmentResources.readAttachmentResource(sessionId, attachment.artifactId, abortSignal);
+                        const result = await options.attachmentResources.readAttachmentResource(sessionId, attachment.artifactId, abortSignal);
+                        return result;
                     }
                     if (!options.runtimeResources)
                         throw new Error('Runtime resources are not available in this toolset');
-                    return await options.runtimeResources.readRuntimeResource(sessionId, ref, abortSignal);
-                }
-                const { path, offset, limit } = input;
-                const runtimeRef = classifyRuntimeResourceRef(path);
-                if (runtimeRef === 'unsupported')
-                    throw new Error(`Unsupported runtime resource ref: ${path}`);
-                if (runtimeRef === 'runtime') {
-                    throw new Error('Runtime resources must be read with the ref parameter, not path');
+                    const result = await options.runtimeResources.readRuntimeResource(sessionId, path, abortSignal);
+                    return result;
                 }
                 const result = await filesystem.execute({
                     operation: {
                         kind: 'read',
                         path,
-                        ...(offset !== undefined ? { offset } : {}),
-                        ...(limit !== undefined ? { limit } : {}),
+                        ...(input.offset === undefined ? {} : { offset: input.offset }),
+                        ...(input.limit === undefined ? {} : { limit: input.limit }),
+                        ...(resolved.position === undefined
+                            ? {}
+                            : {
+                                continuation: { position: resolved.position, digest: resolved.digest },
+                            }),
                     },
                     ...filesystemCall(ctx),
                 });
@@ -328,7 +269,8 @@ export function buildBuiltinTools(options = {}) {
                 }
                 if (result.kind !== 'read')
                     throw internalFilesystemReadFailure('Read', 'no file content came back', 'the file is empty or missing');
-                return { content: result.content };
+                const { kind: _kind, ...page } = result;
+                return page;
             },
         },
         ...(executor.applyPatch ? [applyPatchTool] : []),
@@ -461,11 +403,16 @@ export function buildBuiltinTools(options = {}) {
         {
             name: 'Grep',
             activityKind: 'search',
-            description: 'Search file contents with a regex via ripgrep.',
+            description: `Search file contents with a ripgrep regex. Scans files as text, including binary files; directory traversal respects ripgrep ignore rules and glob filters. Returns path:line:content matches and exact matchedLines, returnedLines, omittedLines, and truncated from one completed search. Keeps at most ${GREP_MAX_LINES_PER_FILE} lines per file, ${GREP_MAX_LINES} total, and ${GREP_MAX_MATCH_BYTES / 1024} KiB of JSON matches; oversized or non-UTF8 lines/paths may be omitted. Narrow path, glob, or pattern for more matches, or use Read to inspect a file. Failed searches have unknown totals.`,
             parameters: z.object({
-                pattern: z.string(),
-                path: z.string().optional(),
-                glob: z.string().optional(),
+                pattern: z
+                    .string()
+                    .describe('Ripgrep regular expression; use an empty pattern to match every line.'),
+                path: z
+                    .string()
+                    .optional()
+                    .describe('File or directory to search; defaults to the session working directory.'),
+                glob: z.string().optional().describe('Optional ripgrep file glob, for example **/*.ts.'),
             }),
             executionFacts,
             impl: async ({ pattern, path, glob }, ctx) => {
@@ -476,18 +423,19 @@ export function buildBuiltinTools(options = {}) {
                 const result = await filesystem.execute({
                     operation: {
                         kind: 'grep',
-                        path: path ?? '.',
+                        path: path || '.',
                         pattern,
                         ...(glob ? { glob } : {}),
-                        maxCountPerFile: 50,
-                        limit: 200,
+                        maxCountPerFile: GREP_MAX_LINES_PER_FILE,
+                        limit: GREP_MAX_LINES,
                         timeoutMs: GREP_TIMEOUT_MS,
                     },
                     ...filesystemCall(ctx),
                 });
                 if (result.kind !== 'grep')
                     throw internalFilesystemReadFailure('Grep', 'no search result came back', 'the pattern is absent');
-                return { matches: result.matches };
+                const { kind: _kind, ...searchResult } = result;
+                return searchResult;
             },
         },
     ];

package/node_modules/@maka/runtime/dist/child-fd-input.js

@@ -17,11 +17,12 @@
  * under the License.
  */
 import { closeSync } from 'node:fs';
+export const MAX_CHILD_FD = 64;
 export function buildSpawnStdio(fdInputs, stdin = 'ignore') {
     const stdio = [stdin, 'pipe', 'pipe'];
     for (const input of fdInputs ?? []) {
-        if (!Number.isInteger(input.fd) || input.fd < 3 || input.fd > 64) {
-            throw new Error(`Child fd input must use an integer fd between 3 and 64; received ${input.fd}`);
+        if (!Number.isInteger(input.fd) || input.fd < 3 || input.fd > MAX_CHILD_FD) {
+            throw new Error(`Child fd input must use an integer fd between 3 and ${MAX_CHILD_FD}; received ${input.fd}`);
         }
         if ('sourceFd' in input && (!Number.isInteger(input.sourceFd) || input.sourceFd < 0)) {
             throw new Error(`Child fd input source must be a non-negative integer; received ${input.sourceFd}`);

package/node_modules/@maka/runtime/dist/context-budget-policy.js

@@ -29,22 +29,12 @@ export function buildDefaultContextBudgetPolicy(options = {}) {
     const surfaceName = (options.name ?? 'default-history-budget').replace(/-default-history-budget$/, '');
     return {
         name: options.name ?? 'default-history-budget',
-        staleToolResultPrune: {
-            enabled: true,
-            maxResultEstimatedTokens: 2_048,
-            minRecentTurnsFull: 2,
-        },
+        toolResultPrune: { enabled: true },
         historyCompact: {
             enabled: true,
             highWaterName: `${surfaceName}-history-compact`,
             midTurn: { enabled: true },
         },
-        activeToolResultPrune: {
-            enabled: true,
-            maxCurrentResultEstimatedTokens: 2_048,
-            minSupersededResultEstimatedTokens: 256,
-            minStepNumber: 1,
-        },
     };
 }
 /**

package/node_modules/@maka/runtime/dist/context-budget.js

@@ -24,7 +24,7 @@ export { estimateRuntimeEventsTokens } from './model-history.js';
 export { ARCHIVED_TOOL_RESULT_PLACEHOLDER_KIND, ARCHIVED_TOOL_RESULT_REWRITE_VERSION, isArchivedToolResultPlaceholder, deserializeToolResultArchive, serializeToolResultForArchive, } from './tool-result-archive.js';
 import { applyRuntimeEventHistoryCompact as applyRuntimeEventHistoryCompactNarrow, } from './history-compaction.js';
 export function applyRuntimeEventContextBudget(events, policy) {
-    const prunePolicy = policy?.staleToolResultPrune;
+    const prunePolicy = policy?.toolResultPrune;
     const pruneEnabled = prunePolicy?.enabled === true;
     const historyCompactEnabled = policy?.historyCompact?.enabled === true;
     const enabled = pruneEnabled || historyCompactEnabled;
@@ -110,6 +110,17 @@ export function mergeContextBudgetDiagnostic(base, patch) {
         ...mergeCompactionDecisionDiagnostics(base.compactionDecisions, patch.compactionDecisions),
     };
 }
+export function addToolResultPruneStats(snapshot, delta) {
+    return {
+        ...snapshot,
+        prunedToolResults: (snapshot.prunedToolResults ?? 0) + delta.prunedToolResults,
+        archiveWriteFailures: (snapshot.archiveWriteFailures ?? 0) + delta.archiveWriteFailures,
+        prunedToolResultEstimatedTokensBefore: (snapshot.prunedToolResultEstimatedTokensBefore ?? 0) +
+            delta.prunedToolResultEstimatedTokensBefore,
+        prunedToolResultEstimatedTokensAfter: (snapshot.prunedToolResultEstimatedTokensAfter ?? 0) +
+            delta.prunedToolResultEstimatedTokensAfter,
+    };
+}
 export function mergeContextBudgetDiagnosticPatches(left, right) {
     if (!left && !right)
         return undefined;