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

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

@@ -23,108 +23,98 @@ import { decodeLedgerTransition, reduceEffectiveModelProjections, } from './mode
 import { isArchivedToolResultPlaceholder, } from './tool-result-archive.js';
 import { serializeToolResultProjectionV1 } from './tool-result-archive-encoding.js';
 import { TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_BYTES, TOOL_RESULT_ARCHIVE_EVIDENCE_MAX_TRANSITIONS, } from '@maka/core/tool-result-archive-evidence';
-/**
- * Read-only v1 reconstruction. It never calls a live tool projector, reads an
- * Artifact, changes history, or authorizes access from a hash alone.
- * The evidence port is trusted to return the complete bounded target history.
- */
-export function createLedgerToolResultArchiveReader(evidence) {
-    return async (input) => {
-        const request = { ...input };
-        if (!isArchivedToolResultPlaceholder(request) ||
-            !/^[a-f0-9]{64}$/.test(request.bodySha256) ||
-            !Number.isSafeInteger(request.originalBytes) ||
-            request.originalBytes < 1) {
-            return { ok: false, reason: 'corrupt' };
+async function readLedgerArchive(evidence, request) {
+    const identity = 'bodySha256' in request ? request : undefined;
+    if (identity &&
+        (!/^[a-f0-9]{64}$/.test(identity.bodySha256) ||
+            !Number.isSafeInteger(identity.originalBytes) ||
+            identity.originalBytes < 1))
+        return { ok: false, reason: 'corrupt' };
+    if (!Number.isSafeInteger(request.maxBytes) ||
+        (identity && request.maxBytes < identity.originalBytes))
+        return { ok: false, reason: 'too_large' };
+    try {
+        const loaded = await evidence.read({
+            sessionId: request.sessionId,
+            runtimeEventId: request.runtimeEventId,
+        });
+        if (!loaded.ok)
+            return {
+                ok: false,
+                reason: loaded.reason === 'unavailable' ? 'read_failed' : loaded.reason,
+            };
+        const { event } = loaded;
+        const content = event.content;
+        if (event.sessionId !== request.sessionId)
+            return { ok: false, reason: 'session_mismatch' };
+        if (event.id !== request.runtimeEventId ||
+            content?.kind !== 'function_response' ||
+            (identity && (content.id !== identity.toolCallId || content.name !== identity.toolName)) ||
+            content.providerExecuted ||
+            !content.modelProjection)
+            return { ok: false, reason: 'source_mismatch' };
+        let source = decodeDurableToolResultProjection(content.modelProjection);
+        const byId = new Map();
+        for (const record of loaded.transitions) {
+            const transition = decodeLedgerTransition(record, request.sessionId);
+            if (!transition ||
+                record.sessionId !== request.sessionId ||
+                transition.target.runtimeEventId !== event.id)
+                return { ok: false, reason: 'corrupt' };
+            const previous = byId.get(transition.transitionId);
+            if (previous &&
+                JSON.stringify({ ...previous, createdAt: 0 }) !==
+                    JSON.stringify({ ...transition, createdAt: 0 })) {
+                return { ok: false, reason: 'corrupt' };
+            }
+            byId.set(transition.transitionId, transition);
         }
-        const maxBytes = request.maxBytes ?? request.originalBytes;
-        if (!Number.isSafeInteger(maxBytes) || maxBytes < request.originalBytes)
-            return { ok: false, reason: 'too_large' };
-        try {
-            const loaded = await evidence.read({
-                sessionId: request.sessionId,
-                runtimeEventId: request.runtimeEventId,
-            });
-            if (!loaded.ok)
-                return {
-                    ok: false,
-                    reason: loaded.reason === 'unavailable' ? 'read_failed' : loaded.reason,
-                };
-            const { event } = loaded;
-            const content = event.content;
-            if (event.sessionId !== request.sessionId)
-                return { ok: false, reason: 'session_mismatch' };
-            if (event.id !== request.runtimeEventId ||
-                content?.kind !== 'function_response' ||
-                content.id !== request.toolCallId ||
-                content.name !== request.toolName ||
-                content.providerExecuted ||
-                !content.modelProjection)
-                return { ok: false, reason: 'source_mismatch' };
-            let source = decodeDurableToolResultProjection(content.modelProjection);
-            const byId = new Map();
-            for (const record of loaded.transitions) {
-                const transition = decodeLedgerTransition(record, request.sessionId);
-                if (!transition ||
-                    record.sessionId !== request.sessionId ||
-                    transition.target.runtimeEventId !== event.id)
+        const reduction = reduceEffectiveModelProjections([event], [...byId.values()]);
+        for (const transition of reduction.applied) {
+            const replacement = transition.replacement;
+            const placeholder = replacement.kind === 'json' ? replacement.value : undefined;
+            if (isArchivedToolResultPlaceholder(placeholder) &&
+                ((!identity && transition === reduction.applied.at(-1)) ||
+                    (placeholder.rewriteVersion === 2 &&
+                        identity &&
+                        placeholder.sourceProjectionDigest === identity.sourceProjectionDigest &&
+                        placeholder.previousTransitionId === identity.previousTransitionId))) {
+                if (placeholder.runtimeEventId !== event.id ||
+                    placeholder.toolCallId !== content.id ||
+                    placeholder.toolName !== content.name ||
+                    (identity &&
+                        (placeholder.bodySha256 !== identity.bodySha256 ||
+                            placeholder.originalBytes !== identity.originalBytes)))
+                    return { ok: false, reason: 'source_mismatch' };
+                if (placeholder.rewriteVersion === 2 &&
+                    (placeholder.sourceProjectionDigest !== transition.sourceProjectionDigest ||
+                        placeholder.previousTransitionId !== transition.previousTransitionId))
                     return { ok: false, reason: 'corrupt' };
-                const previous = byId.get(transition.transitionId);
-                if (previous &&
-                    JSON.stringify({ ...previous, createdAt: 0 }) !==
-                        JSON.stringify({ ...transition, createdAt: 0 })) {
+                const serializedResult = serializeToolResultProjectionV1(source);
+                if (placeholder.originalBytes > request.maxBytes)
+                    return { ok: false, reason: 'too_large' };
+                if (Buffer.byteLength(serializedResult, 'utf8') !== placeholder.originalBytes)
+                    return { ok: false, reason: 'size_mismatch' };
+                if (createHash('sha256').update(serializedResult).digest('hex') !== placeholder.bodySha256)
                     return { ok: false, reason: 'corrupt' };
-                }
-                byId.set(transition.transitionId, transition);
-            }
-            const reduction = reduceEffectiveModelProjections([event], [...byId.values()]);
-            for (const transition of reduction.applied) {
-                const replacement = transition.replacement;
-                const placeholder = replacement.kind === 'json' ? replacement.value : undefined;
-                if (isArchivedToolResultPlaceholder(placeholder) &&
-                    ((placeholder.rewriteVersion === 1 &&
-                        request.rewriteVersion === 1 &&
-                        placeholder.artifactId === request.artifactId) ||
-                        (placeholder.rewriteVersion === 2 &&
-                            request.rewriteVersion === 2 &&
-                            placeholder.sourceProjectionDigest === request.sourceProjectionDigest &&
-                            placeholder.previousTransitionId === request.previousTransitionId))) {
-                    if (placeholder.runtimeEventId !== request.runtimeEventId ||
-                        placeholder.toolCallId !== request.toolCallId ||
-                        placeholder.toolName !== request.toolName ||
-                        placeholder.bodySha256 !== request.bodySha256 ||
-                        placeholder.originalBytes !== request.originalBytes ||
-                        placeholder.rewriteVersion !== request.rewriteVersion)
-                        return { ok: false, reason: 'source_mismatch' };
-                    if (placeholder.rewriteVersion === 2 &&
-                        (placeholder.sourceProjectionDigest !== transition.sourceProjectionDigest ||
-                            placeholder.previousTransitionId !== transition.previousTransitionId))
-                        return { ok: false, reason: 'corrupt' };
-                    const serializedResult = serializeToolResultProjectionV1(source);
-                    if (Buffer.byteLength(serializedResult, 'utf8') !== request.originalBytes)
-                        return { ok: false, reason: 'size_mismatch' };
-                    if (createHash('sha256').update(serializedResult).digest('hex') !== request.bodySha256)
-                        return { ok: false, reason: 'corrupt' };
-                    return { ok: true, serializedResult };
-                }
-                source = transition.replacement;
+                return { ok: true, serializedResult };
             }
-            return { ok: false, reason: 'not_found' };
+            source = transition.replacement;
         }
-        catch {
-            return { ok: false, reason: 'corrupt' };
+        if (!identity && reduction.rejected.length === 0) {
+            const serializedResult = serializeToolResultProjectionV1(source);
+            if (Buffer.byteLength(serializedResult, 'utf8') > request.maxBytes)
+                return { ok: false, reason: 'too_large' };
+            return { ok: true, serializedResult };
         }
-    };
+        return { ok: false, reason: 'not_found' };
+    }
+    catch {
+        return { ok: false, reason: 'corrupt' };
+    }
 }
 export function createLedgerArchiveResourceReader(evidence) {
-    const reader = createLedgerToolResultArchiveReader(evidence);
-    return (input) => reader({
-        ...input,
-        kind: 'maka.archived_tool_result',
-        rewriteVersion: 2,
-        originalEstimatedTokens: 1,
-        reason: 'stale_tool_result_pruned_before_compact',
-    });
+    return (input) => readLedgerArchive(evidence, input);
 }
 /** Verify reconstructibility before committing a replacement; does not write any payload. */
 export function createLedgerArchivePreparer(evidence) {

package/node_modules/@maka/runtime/dist/model-history.js

@@ -134,8 +134,30 @@ export function estimateEffectiveToolResultChars(content, sessionId) {
 export function estimateRuntimeEventChars(event) {
     let total = 0;
     const content = event.content;
-    if (content?.kind === 'text' || content?.kind === 'thinking')
+    if (content?.kind === 'text' || content?.kind === 'thinking') {
         total += content.text.length;
+        // Structured carriers are part of the event's weight: a quote- or
+        // attachment-only user message must not estimate to zero, or the
+        // history-compact gate drops a model-visible event (#4804).
+        if (content.kind === 'text') {
+            for (const quote of content.quotes ?? []) {
+                total += quote.text.length + (quote.label?.length ?? 0);
+            }
+            for (const attachment of content.attachments ?? []) {
+                // Weight the block the projection actually emits, not the display
+                // fields: name+mimeType is ~25 chars while the formatted attachment
+                // block with its Read guidance runs to hundreds (#4815 review).
+                total += formatAttachmentRefs([attachment]).length;
+            }
+            // Directory references project as one fixed envelope per message; count
+            // what it actually emits, or a directory-only message estimates to zero
+            // and the history-compact gate drops a model-visible event from the
+            // replay successors (#4815 review).
+            if (content.directoryReferences?.length) {
+                total += formatDirectoryReferences(content.directoryReferences).length;
+            }
+        }
+    }
     else if (content?.kind === 'function_call')
         total += content.name.length + stableJsonLength(content.args);
     else if (content?.kind === 'function_response')
@@ -724,7 +746,7 @@ function formatAttachmentRefs(attachments) {
         .map((attachment) => {
         const resourceRef = formatAttachmentResourceRef(attachment.ref);
         const readArgument = resourceRef
-            ? { ref: resourceRef }
+            ? { path: resourceRef }
             : attachment.ref.kind === 'workspace_file'
                 ? { path: attachment.ref.relativePath }
                 : attachment.ref.kind === 'external_file'
@@ -737,7 +759,7 @@ function formatAttachmentRefs(attachments) {
                     ...(attachment.kind === 'image'
                         ? [`Markdown image source: ${JSON.stringify(resourceRef)}`]
                         : []),
-                    'This is a Session resource, not a workspace file. Use the ref above; never use the display name as a path.',
+                    'This is a Session resource, not a workspace file. Use the path above; never use the display name as a path.',
                 ].join('\n')
                 : `Read argument: ${JSON.stringify(readArgument)}`
             : 'The attachment content is unavailable to Read.';

package/node_modules/@maka/runtime/dist/pipe-tail-collector.js

@@ -16,9 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { redactSecrets } from '@maka/core/redaction';
 import { BashTailBuffer } from './bash-tail-buffer.js';
-import { BASH_MAX_RETAINED_CHARS, shellTailValueWithUnsafeDropMarker } from './shell-exec.js';
+import { BASH_MAX_RETAINED_CHARS } from './shell-exec.js';
 export class PipeTailCollector {
     stdout;
     stderr;
@@ -47,18 +46,16 @@ export class PipeTailCollector {
         return this.generation;
     }
     snapshot() {
-        const stdoutRaw = shellTailValueWithUnsafeDropMarker(this.stdout);
-        const stderrRaw = shellTailValueWithUnsafeDropMarker(this.stderr);
-        const stdout = redactSecrets(stdoutRaw);
-        const stderr = redactSecrets(stderrRaw);
+        const stdout = this.stdout.value();
+        const stderr = this.stderr.value();
         return {
             mode: 'pipes',
             stdout,
             stderr,
             ...(this.latestStream ? { latestStream: this.latestStream } : {}),
-            stdoutTruncated: this.stdoutChars > stdoutRaw.length || this.stdout.hasDroppedUnsafe(),
-            stderrTruncated: this.stderrChars > stderrRaw.length || this.stderr.hasDroppedUnsafe(),
-            redacted: stdout !== stdoutRaw || stderr !== stderrRaw,
+            stdoutTruncated: this.stdoutChars > stdout.length,
+            stderrTruncated: this.stderrChars > stderr.length,
+            redacted: false,
         };
     }
     currentGeneration() {

package/node_modules/@maka/runtime/dist/read-page.js

@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+export const READ_PAGE_MAX_CHARS = 7_500;
+export const READ_DESCRIPTION = 'Read a file or a Maka resource. Only path is required. By default, read from the beginning and return one bounded page. offset and limit select a line range; offset is zero-based. A large limit cannot bypass the response-size cap. If next is non-null, pass its contents to Read to continue; otherwise the requested range is complete. Use a smaller limit for a short excerpt. A partialLine page continues automatically through next.';
+export const readParameters = z.object({
+    path: z
+        .string({
+        error: 'path is required. Provide a file path or the Maka address returned by a tool.',
+    })
+        .min(1, 'path cannot be empty. Provide the location to read.')
+        .describe('File path relative to the session cwd, an absolute path, or a Maka address returned by a tool.'),
+    offset: z
+        .number({ error: 'offset must be a non-negative integer. Omit it to start at the beginning.' })
+        .int('offset must be an integer. Omit it to start at the beginning.')
+        .nonnegative('offset must be non-negative. Omit it to start at the beginning.')
+        .optional()
+        .describe('Zero-based starting line; defaults to 0. offset 200 starts at line 201. Omit when using a continuation address.'),
+    limit: z
+        .number({ error: 'limit must be a positive integer. Omit it to read one bounded page.' })
+        .int('limit must be an integer. Omit it to read one bounded page.')
+        .positive('limit must be positive. Omit it to read one bounded page.')
+        .optional()
+        .describe('Maximum lines in the requested range. Omit to browse one bounded page at a time. Use next to obtain any remaining content.'),
+});
+export const readPageSchema = z.object({
+    content: z.string(),
+    offset: z.number().int().nonnegative(),
+    returnedLines: z.number().int().nonnegative(),
+    totalLines: z.number().int().nonnegative(),
+    partialLine: z.literal(true).optional(),
+    next: readParameters.nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const readContinuationSchema = z
+    .object({
+    position: z.number().int().nonnegative(),
+    digest: z.string().regex(/^[a-f0-9]{32}$/),
+})
+    .strict();
+const CONTINUATION_PREFIX = 'maka://read/';
+export function resolveReadInput(input) {
+    if (!input.path.startsWith(CONTINUATION_PREFIX))
+        return { path: input.path };
+    try {
+        const url = new URL(input.path);
+        const path = Buffer.from(url.pathname.slice(1), 'base64url').toString('utf8');
+        const at = url.searchParams.get('at') ?? '';
+        const position = Number(at);
+        const digest = url.searchParams.get('sha') ?? '';
+        if (!path ||
+            path.startsWith(CONTINUATION_PREFIX) ||
+            !/^\d+$/.test(at) ||
+            !Number.isSafeInteger(position) ||
+            !/^[a-f0-9]{32}$/.test(digest) ||
+            input.offset !== undefined)
+            throw new Error();
+        return { path, position, digest };
+    }
+    catch {
+        throw new Error('Invalid Read continuation. Copy the complete next object from the preceding result. To start again, use the original path and omit offset and limit.');
+    }
+}
+function digestText(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 32);
+}
+export function readPage(content, input, maxChars = READ_PAGE_MAX_CHARS, continuation) {
+    const resolved = continuation ? { path: input.path, ...continuation } : resolveReadInput(input);
+    if (resolved.digest && digestText(content) !== resolved.digest) {
+        throw new Error('The content changed since the previous page. This continuation cannot be used. Read the original path again to start from the current content.');
+    }
+    if (resolved.position !== undefined && resolved.position > content.length) {
+        throw new Error('Invalid Read continuation position. Copy the complete next object from the preceding result.');
+    }
+    const starts = [0];
+    for (let at = content.indexOf('\n'); at >= 0; at = content.indexOf('\n', at + 1))
+        starts.push(at + 1);
+    const totalLines = starts.length;
+    const lineAt = (position) => {
+        let low = 0;
+        let high = starts.length - 1;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            if (starts[middle] <= position)
+                low = middle;
+            else
+                high = middle - 1;
+        }
+        return low;
+    };
+    const offset = resolved.position === undefined ? (input.offset ?? 0) : lineAt(resolved.position);
+    const start = resolved.position ?? starts[Math.min(offset, totalLines)] ?? content.length;
+    const lastLine = Math.min(totalLines, offset + (input.limit ?? totalLines));
+    const end = lastLine < totalLines ? starts[lastLine] - 1 : content.length;
+    let digest = resolved.digest;
+    const makePage = (stop) => {
+        const complete = stop >= end;
+        const nextLine = Math.max(offset, lineAt(stop));
+        const boundary = stop === (starts[nextLine + 1] ?? content.length + 1) - 1;
+        const partialLine = !complete && !boundary;
+        const returnedLines = offset >= totalLines
+            ? 0
+            : complete
+                ? lastLine - offset
+                : nextLine - offset + (partialLine ? 0 : 1);
+        let next = null;
+        if (!complete) {
+            const remaining = input.limit === undefined ? undefined : input.limit - returnedLines;
+            const position = partialLine ? stop : stop + 1;
+            next = {
+                path: `${CONTINUATION_PREFIX}${Buffer.from(resolved.path).toString('base64url')}?at=${position}&sha=${(digest ??= digestText(content))}`,
+                ...(remaining === undefined ? {} : { limit: remaining }),
+            };
+        }
+        return {
+            content: content.slice(start, Math.max(start, stop)),
+            offset,
+            returnedLines,
+            totalLines,
+            ...(partialLine || (offset < totalLines && start > starts[offset])
+                ? { partialLine: true }
+                : {}),
+            next,
+        };
+    };
+    if (end - start <= maxChars) {
+        const page = makePage(end);
+        if (JSON.stringify(page).length <= maxChars)
+            return page;
+    }
+    let low = start;
+    let high = Math.min(end, start + maxChars);
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (JSON.stringify(makePage(middle)).length <= maxChars)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    // Never split a UTF-16 surrogate pair between responses.
+    if (low > start && /[\uD800-\uDBFF]/.test(content[low - 1]))
+        low--;
+    if (low <= start)
+        throw new Error('The Read address is too long to fit a bounded response. Use a shorter original path.');
+    const newline = content.lastIndexOf('\n', low);
+    if (newline > start)
+        low = newline;
+    return makePage(low);
+}
+export function readableToolResult(serialized) {
+    try {
+        const value = JSON.parse(serialized);
+        if (typeof value === 'string')
+            return value;
+        if (value &&
+            typeof value === 'object' &&
+            Object.keys(value).length === 2 &&
+            'kind' in value &&
+            value.kind === 'text' &&
+            'text' in value &&
+            typeof value.text === 'string')
+            return value.text;
+        if (value &&
+            typeof value === 'object' &&
+            Object.keys(value).length === 1 &&
+            'content' in value &&
+            typeof value.content === 'string')
+            return value.content;
+        if (value &&
+            typeof value === 'object' &&
+            'kind' in value &&
+            (value.kind === 'terminal' || value.kind === 'shell_run')) {
+            const shell = value;
+            let output;
+            if (typeof shell.output === 'string')
+                output = shell.output;
+            if (shell.output && typeof shell.output === 'object') {
+                const shellOutput = shell.output;
+                output = (shellOutput.mode === 'pty'
+                    ? [shellOutput.scrollback, shellOutput.screen, shellOutput.lastAlternateScreen]
+                    : [shellOutput.stdout, shellOutput.stderr])
+                    .filter((part) => typeof part === 'string' && part.length > 0)
+                    .join('\n');
+            }
+            if (typeof shell.failureMessage === 'string' && shell.failureMessage.length > 0)
+                return output ? `${output}\n${shell.failureMessage}` : shell.failureMessage;
+            if (output !== undefined)
+                return output;
+        }
+    }
+    catch {
+        /* Plain text projections are already readable. */
+    }
+    return serialized;
+}
+export function readToolResultPage(serialized, input, maxChars = READ_PAGE_MAX_CHARS) {
+    let metadata;
+    try {
+        const value = JSON.parse(serialized);
+        if (value?.kind === 'terminal' || value?.kind === 'shell_run') {
+            metadata = Object.fromEntries(Object.entries(value).filter(([key]) => ['kind', 'status', 'exitCode', 'signal', 'revision', 'mode'].includes(key)));
+            if (value.output && typeof value.output === 'object')
+                for (const key of ['stdoutTruncated', 'stderrTruncated', 'redacted']) {
+                    if (typeof value.output[key] === 'boolean')
+                        metadata[key] = value.output[key];
+                }
+        }
+    }
+    catch {
+        /* Text has no separate execution metadata. */
+    }
+    const page = readPage(readableToolResult(serialized), input, maxChars - (metadata ? JSON.stringify(metadata).length + 16 : 0));
+    return metadata ? { ...page, metadata } : page;
+}

package/node_modules/@maka/runtime/dist/request-projection.js

@@ -16,21 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-/**
- * Deterministic request-projection pipeline over ONE provider-visible request.
- * Order is a contract: mid-turn capacity compaction runs first among the
- * message-shaping hooks so every later mechanism operates on its projection —
- * active tool-result pruning re-archives large tool results in the rebuilt
- * tail.
- *
- * Every hook here only SHAPES the projection. The pass/terminate capacity
- * verdict is issued once, after the whole pipeline, by the final-request
- * estimate owner (buildMidTurnFinalRequestVerdict) over the actual outgoing
- * (messages, tools) payload — never by an individual hook over an intermediate
- * projection that a later hook could still rescue.
- */
-export function composeRequestProjection(toolAvailability, midTurnCapacityCompact, activeToolResultPrune) {
-    const hooks = [toolAvailability, midTurnCapacityCompact, activeToolResultPrune].filter(Boolean);
+export function composeRequestProjection(...stages) {
+    const hooks = stages.filter((stage) => stage !== undefined);
     if (hooks.length === 0)
         return undefined;
     return async (context) => {

package/node_modules/@maka/runtime/dist/ripgrep-executable.js

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { constants } from 'node:fs';
+import { access, realpath } from 'node:fs/promises';
+import { delimiter, isAbsolute, join } from 'node:path';
+export function defaultRipgrepCandidates(env, platform = process.platform) {
+    const executableName = platform === 'win32' ? 'rg.exe' : 'rg';
+    return [
+        ...(env.PATH ?? '')
+            .split(delimiter)
+            .filter(Boolean)
+            .map((directory) => join(directory, executableName)),
+        ...(platform === 'win32' ? [] : ['/opt/homebrew/bin/rg', '/usr/local/bin/rg', '/usr/bin/rg']),
+        // winget adds this directory to PATH only for processes started after the
+        // install. A running Host must probe it explicitly for install-and-retry.
+        ...(platform === 'win32' && env.LOCALAPPDATA
+            ? [join(env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links', executableName)]
+            : []),
+    ];
+}
+export async function* resolveRipgrepCandidates(candidates) {
+    const resolved = new Set();
+    for (const candidate of candidates) {
+        const executable = await resolveExecutable(candidate);
+        if (!executable || resolved.has(executable))
+            continue;
+        resolved.add(executable);
+        yield executable;
+    }
+}
+export async function resolveRipgrepExecutable(candidates) {
+    for await (const executable of resolveRipgrepCandidates(candidates))
+        return executable;
+    return undefined;
+}
+async function resolveExecutable(candidate) {
+    if (!candidate || !isAbsolute(candidate))
+        return undefined;
+    try {
+        await access(candidate, constants.X_OK);
+        return await realpath(candidate);
+    }
+    catch {
+        return undefined;
+    }
+}