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

package/node_modules/@maka/runtime/dist/filesystem-worker/operations.js

@@ -16,16 +16,17 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { spawn } from 'node:child_process';
+import { searchFiles, GrepSearchError } from '../grep-search.js';
 import { promises as fs } from 'node:fs';
-import { glob as nodeGlob } from 'node:fs/promises';
+import { globFiles } from '../glob-search.js';
 import { dirname, isAbsolute, parse, resolve } from 'node:path';
 import { isPathInside } from '../path-containment.js';
+import { ripgrepMissingMessage, ripgrepVanishedMessage, } from '../ripgrep-guidance.js';
 import { sandboxPathApi } from './sandbox-paths.js';
 import { sandboxBoundaryExpansionAllowsPath } from '@maka/core/sandbox-boundary';
 import { ApplyPatchRejectedError, applyUpdateToContent, createPatchedFile, } from '../apply-patch-file.js';
 import { computeEditedSource } from '../edit-replace.js';
-import { readTextLineWindow } from '../text-line-window.js';
+import { readPage } from '../read-page.js';
 import { createEditUnifiedDiff, createUnifiedDiff } from '../unified-diff.js';
 import { compareAndDeleteEntry, hostVisibilityAfterWrite, openStableTarget, readModifyWriteThroughHandle, StableWriteFailure, writeThroughHandle, } from '../file-stable-write.js';
 import { isSupportedImagePath, readWorkspaceImage } from '../image-file.js';
@@ -35,9 +36,6 @@ import { isLikelySandboxDenial } from '../sandbox/detect.js';
 // on POSIX, lexical + reparse-rejecting inside the Windows AppContainer where
 // realpath is denied. See sandbox-paths.ts.
 const { realpath, realpathAllowMissing, resolveCanonicalDirectoryEntryTarget } = sandboxPathApi();
-const DEFAULT_GLOB_LIMIT = 200;
-const MAX_GREP_OUTPUT_BYTES = 8 * 1024 * 1024;
-const MAX_GREP_STDERR_BYTES = 16 * 1024;
 export async function executeFilesystemWorkerRequest(request, dependencies = {}) {
     try {
         await assertTargetUnchanged(request.operation.cwd, request.operation.path, request.expectedTarget, operationUsesDirectoryEntry(request.operation), operationAccess(request.operation.kind));
@@ -76,10 +74,14 @@ export async function executeFilesystemOperation(operation, operationBoundary, d
                 }
             }
             const content = await fs.readFile(path, 'utf8');
-            return {
-                kind: 'read',
-                content: readTextLineWindow(content, operation.offset, operation.limit),
-            };
+            try {
+                return { kind: 'read', ...readPage(content, operation, undefined, operation.continuation) };
+            }
+            catch (error) {
+                throw operationError('invalid_request', error instanceof Error
+                    ? error.message
+                    : 'Read pagination failed. Use the original path again.');
+            }
         }
         case 'write': {
             const path = await resolveWritableAllowed(operation.cwd, operation.path, 'Write', operationBoundary);
@@ -258,14 +260,7 @@ export async function executeFilesystemOperation(operation, operationBoundary, d
         case 'glob': {
             assertContainedGlobPattern(operation.pattern);
             const path = await resolveExistingAllowed(operation.cwd, operation.path, 'Glob cwd', 'read', operationBoundary);
-            const files = [];
-            const limit = operation.limit ?? DEFAULT_GLOB_LIMIT;
-            for await (const file of nodeGlob(operation.pattern, { cwd: path })) {
-                files.push(typeof file === 'string' ? file : file.name);
-                if (files.length >= limit)
-                    break;
-            }
-            return { kind: 'glob', files };
+            return { kind: 'glob', ...(await globFiles({ ...operation, cwd: path })) };
         }
         case 'grep': {
             const path = await resolveExistingAllowed(operation.cwd, operation.path, 'Grep', 'read', operationBoundary);
@@ -281,34 +276,32 @@ export async function executeFilesystemOperation(operation, operationBoundary, d
             if (dependencies.windowsSandboxed) {
                 throw operationError('grep_unavailable', 'Grep is not available inside the Windows sandbox preview; use Glob and Read instead.');
             }
-            if (!dependencies.grepExecutable)
-                throw operationError('grep_unavailable', 'Grep is unavailable in this runtime.');
-            const args = ['-n', '--no-heading', `--max-count=${operation.maxCountPerFile}`];
-            if (operation.glob)
-                args.push('--glob', operation.glob);
-            args.push('--', operation.pattern, path);
-            const result = await (dependencies.runGrep ?? runRipgrep)({
-                executable: dependencies.grepExecutable,
-                args,
+            const grepExecutable = dependencies.grepExecutable;
+            if (!grepExecutable)
+                throw operationError('grep_unavailable', ripgrepMissingMessage(dependencies.ripgrepEnvironment));
+            const result = await searchFiles({
+                ...operation,
+                path,
+                executable: grepExecutable,
                 // The target is canonical and absolute. Running from its filesystem root avoids
                 // requiring operation-scoped workers to read the broader session workspace.
                 cwd: parse(path).root,
                 timeoutMs: operation.timeoutMs,
+            }, dependencies.runGrep).catch((error) => {
+                // The cwd is a filesystem root, which always exists, so a spawn ENOENT
+                // means the executable this worker was launched with is gone — removed
+                // after the launch configuration checked it. Left alone it would be
+                // normalized to `not_found` and read as a missing search path.
+                if (nodeErrorCode(error) === 'ENOENT')
+                    throw operationError('grep_unavailable', ripgrepVanishedMessage(grepExecutable, dependencies.ripgrepEnvironment));
+                if (error instanceof GrepSearchError) {
+                    throw operationError(isLikelySandboxDenial({ stdout: '', stderr: error.message, sandboxed: true })
+                        ? 'sandbox_denied'
+                        : 'filesystem_error', error.message);
+                }
+                throw error;
             });
-            if (result.exitCode === 1)
-                return { kind: 'grep', matches: [] };
-            if (result.exitCode !== 0) {
-                const detail = result.stderrTail.trim();
-                throw operationError(isLikelySandboxDenial({ stdout: result.stdout, stderr: detail, sandboxed: true })
-                    ? 'sandbox_denied'
-                    : 'filesystem_error', detail
-                    ? `Grep failed while searching files.\n${detail}`
-                    : 'Grep failed while searching files.');
-            }
-            return {
-                kind: 'grep',
-                matches: result.stdout.split('\n').filter(Boolean).slice(0, operation.limit),
-            };
+            return { kind: 'grep', ...result };
         }
     }
 }
@@ -483,59 +476,3 @@ function nodeErrorCode(error) {
         return undefined;
     return typeof error.code === 'string' ? error.code : undefined;
 }
-async function runRipgrep(input) {
-    return await new Promise((resolvePromise, reject) => {
-        const child = spawn(input.executable, [...input.args], {
-            cwd: input.cwd,
-            shell: false,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        const chunks = [];
-        let bytes = 0;
-        let stderrTail = Buffer.alloc(0);
-        let settled = false;
-        const timer = setTimeout(() => {
-            child.kill('SIGKILL');
-            rejectOnce(operationError('filesystem_error', 'Grep timed out.'));
-        }, input.timeoutMs);
-        child.stdout.on('data', (chunk) => {
-            bytes += chunk.length;
-            if (bytes > MAX_GREP_OUTPUT_BYTES) {
-                child.kill('SIGKILL');
-                rejectOnce(operationError('filesystem_error', 'Grep output exceeded the worker limit.'));
-            }
-            else {
-                chunks.push(chunk);
-            }
-        });
-        child.stderr.on('data', (chunk) => {
-            stderrTail = appendBoundedTail(stderrTail, chunk, MAX_GREP_STDERR_BYTES);
-        });
-        child.once('error', (error) => rejectOnce(error));
-        child.once('close', (exitCode) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolvePromise({
-                exitCode: exitCode ?? 2,
-                stdout: Buffer.concat(chunks).toString('utf8'),
-                stderrTail: stderrTail.toString('utf8'),
-            });
-        });
-        function rejectOnce(error) {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject(error);
-        }
-    });
-}
-function appendBoundedTail(current, chunk, limit) {
-    if (chunk.length >= limit)
-        return chunk.subarray(chunk.length - limit);
-    if (current.length + chunk.length <= limit)
-        return Buffer.concat([current, chunk]);
-    return Buffer.concat([current.subarray(current.length - (limit - chunk.length)), chunk]);
-}

package/node_modules/@maka/runtime/dist/filesystem-worker/protocol.js

@@ -17,13 +17,12 @@
  * under the License.
  */
 import { z } from 'zod';
+import { readContinuationSchema, readPageSchema } from '../read-page.js';
 import { validateSandboxBoundaryExpansion } from '@maka/core/sandbox-boundary';
-// v6 adds the captured target identity (opaque decimal-string dev/ino) to
-// FilesystemWorkerTarget, so the worker can compare-and-swap against the
-// inode that was authorised at lock acquisition instead of only the path
-// string. The identity is carried as strings because bigint cannot cross the
-// JSON protocol boundary.
-export const FILESYSTEM_WORKER_PROTOCOL_VERSION = 7;
+import { GREP_MAX_LINES, GREP_MAX_LINES_PER_FILE, GREP_MAX_MATCH_BYTES } from '../grep-search.js';
+// v10 adds bounded Read pages to v9's exact Grep counts. Older workers cannot
+// satisfy the combined result contract and must be rejected at the handshake.
+export const FILESYSTEM_WORKER_PROTOCOL_VERSION = 10;
 /** The single authority on which operation kinds are writes. Shared by the
  * client (permission/identity decisions) and the worker (operation guards) so
  * the set cannot drift. */
@@ -100,6 +99,7 @@ export const FilesystemWorkerOperationSchema = z.union([
         path,
         offset: z.number().int().nonnegative().optional(),
         limit: z.number().int().positive().optional(),
+        continuation: readContinuationSchema.optional(),
     })
         .strict(),
     z.object({ kind: z.literal('write'), cwd, path, content: z.string() }).strict(),
@@ -146,8 +146,8 @@ export const FilesystemWorkerOperationSchema = z.union([
         path,
         pattern: z.string(),
         glob: z.string().min(1).optional(),
-        maxCountPerFile: z.number().int().positive(),
-        limit: z.number().int().positive(),
+        maxCountPerFile: z.number().int().positive().max(GREP_MAX_LINES_PER_FILE),
+        limit: z.number().int().positive().max(GREP_MAX_LINES),
         timeoutMs: z.number().int().positive(),
     })
         .strict(),
@@ -162,7 +162,7 @@ export const FilesystemWorkerRequestSchema = z
 })
     .strict();
 export const FilesystemWorkerResultSchema = z.discriminatedUnion('kind', [
-    z.object({ kind: z.literal('read'), content: z.string() }).strict(),
+    readPageSchema.extend({ kind: z.literal('read') }).strict(),
     z
         .object({
         kind: z.literal('read_image'),
@@ -207,7 +207,22 @@ export const FilesystemWorkerResultSchema = z.discriminatedUnion('kind', [
     })
         .strict(),
     z.object({ kind: z.literal('glob'), files: z.array(z.string()) }).strict(),
-    z.object({ kind: z.literal('grep'), matches: z.array(z.string()) }).strict(),
+    z
+        .object({
+        kind: z.literal('grep'),
+        matchedLines: z.number().int().nonnegative(),
+        returnedLines: z.number().int().nonnegative(),
+        omittedLines: z.number().int().nonnegative(),
+        truncated: z.boolean(),
+        matches: z
+            .array(z.string())
+            .max(GREP_MAX_LINES)
+            .refine((matches) => Buffer.byteLength(JSON.stringify(matches)) <= GREP_MAX_MATCH_BYTES),
+    })
+        .strict()
+        .refine((result) => result.returnedLines === result.matches.length &&
+        result.matchedLines === result.returnedLines + result.omittedLines &&
+        result.truncated === result.omittedLines > 0),
 ]);
 export const FilesystemWorkerErrorCodeSchema = z.enum([
     'invalid_request',

package/node_modules/@maka/runtime/dist/filesystem-worker/worker-entry.js

@@ -18,6 +18,7 @@
  */
 import { stdin, stdout } from 'node:process';
 import { executeFilesystemWorkerRequest } from './operations.js';
+import { parseRipgrepEnvironmentArg } from '../ripgrep-guidance.js';
 import { FILESYSTEM_WORKER_PROTOCOL_VERSION, FilesystemWorkerRequestSchema, FilesystemWorkerResponseSchema, } from './protocol.js';
 const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 async function main() {
@@ -47,6 +48,7 @@ async function main() {
     }
     writeResponse(await executeFilesystemWorkerRequest(parsed.data, {
         grepExecutable: readOption('--grep-executable'),
+        ripgrepEnvironment: parseRipgrepEnvironmentArg(readOption('--ripgrep-environment')),
         windowsSandboxed: process.env.MAKA_WINDOWS_SANDBOX === '1',
     }));
 }

package/node_modules/@maka/runtime/dist/glob-search.js

@@ -0,0 +1,74 @@
+/*
+ * 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 { promises as fs, readdir } from 'node:fs';
+import { resolve } from 'node:path';
+import { globIterate } from 'glob';
+export async function globFiles(input) {
+    let failure;
+    const directories = new Set([resolve(input.cwd)]);
+    function record(error, path) {
+        // Speculative literal components may miss. A directory already admitted by
+        // cwd, stat, or enumeration disappearing instead makes this walk incomplete.
+        if (directories.has(resolve(path)) || (error.code !== 'ENOENT' && error.code !== 'ENOTDIR')) {
+            failure ??= error;
+        }
+    }
+    const files = [];
+    for await (const file of globIterate(input.pattern, {
+        cwd: input.cwd,
+        ignore: { childrenIgnored: (entry) => entry.isSymbolicLink() },
+        fs: {
+            readdir(path, options, callback) {
+                readdir(path, options, (error, entries) => {
+                    if (error)
+                        record(error, path);
+                    else
+                        for (const entry of entries) {
+                            if (entry.isDirectory())
+                                directories.add(resolve(path, entry.name));
+                        }
+                    callback(error, entries);
+                });
+            },
+            promises: {
+                async lstat(path) {
+                    try {
+                        const stat = await fs.lstat(path);
+                        if (stat.isDirectory())
+                            directories.add(resolve(path));
+                        return stat;
+                    }
+                    catch (error) {
+                        record(error, path);
+                        throw error;
+                    }
+                },
+            },
+        },
+    })) {
+        if (failure)
+            throw failure;
+        files.push(file);
+        if (files.length >= (input.limit ?? 200))
+            break;
+    }
+    if (failure)
+        throw failure;
+    return { files };
+}

package/node_modules/@maka/runtime/dist/goal-continuation.js

@@ -24,12 +24,14 @@
  * an in-memory backoff instead of immediately spending another turn.
  */
 import { evaluateGoal, } from './goal-evaluator.js';
-import { goalCheckpoint, } from './goal-state.js';
+import { goalCheckpoint, truncateGoalText, } from './goal-state.js';
 import { GoalSessionCloseFence, } from './goal-session-close-fence.js';
 import { GoalTaskGatePolicy } from './goal-task-gate-policy.js';
-import { isDrivingGoal, sameGoalControlLease, } from '@maka/core/goal';
+import { GOAL_PENDING_PROMPT_TEXT_LIMIT, isDrivingGoal, sameGoalControlLease, } from '@maka/core/goal';
 export const volatileGoalDurability = Object.freeze({
     flush: async () => { },
+    recordPendingContinuation: async () => { },
+    clearPendingContinuation: async () => { },
     recordCurrentExecution: async () => { },
     settleCurrentExecution: async () => { },
 });
@@ -287,6 +289,39 @@ export class GoalContinuationCoordinator {
             reason: goal.lastReason ?? 'Goal continuation recovered after Host restart.',
         });
     }
+    /** Restore the durable outbox entry before synthesizing generic recovery. */
+    recoverPendingContinuation(pending) {
+        if (this.disposed)
+            return;
+        const sessionId = this.deps.goalManager.getSessionIdByGoalId(pending.checkpoint.goalId);
+        if (!sessionId || this.sessionCloseFence.isClosed(sessionId))
+            return;
+        const goal = this.deps.goalManager.get(sessionId);
+        if (!goal ||
+            (goal.status !== 'active' && goal.status !== 'waiting') ||
+            !this.deps.goalManager.matches(sessionId, pending.checkpoint) ||
+            !this.deps.goalManager.matchesControlLease(sessionId, pending.controlLease)) {
+            return;
+        }
+        const lane = this.laneFor(sessionId);
+        if (lane.intent || lane.turns.size > 0)
+            return;
+        lane.intent = {
+            checkpoint: pending.checkpoint,
+            controlLease: pending.controlLease,
+            ...(pending.triggeringTurnId ? { triggeringTurnId: pending.triggeringTurnId } : {}),
+            recoveredPrompt: pending.prompt,
+            evaluation: {
+                met: false,
+                impossible: false,
+                progress: false,
+                waiting: goal.status === 'waiting',
+                evaluatorFailed: true,
+                reason: 'Durable Goal continuation recovered after Host restart.',
+            },
+        };
+        this.scheduleDrain(lane);
+    }
     /** Resume an exact paused Goal generation from Host control without a model-owned Turn. */
     resumeFromControl(sessionId, checkpoint) {
         if (this.disposed || this.sessionCloseFence.isClosed(sessionId))
@@ -353,9 +388,6 @@ export class GoalContinuationCoordinator {
     }
     enqueueTurn(outcome, controlLease, registration) {
         const lane = registration.lane;
-        // New evidence always outranks an older, not-yet-admitted continuation.
-        lane.intent = undefined;
-        this.clearWaitingTimer(lane);
         return new Promise((resolve) => {
             lane.queue.push({
                 turnId: registration.turnId,
@@ -484,10 +516,21 @@ export class GoalContinuationCoordinator {
         if (!this.deps.goalManager.matchesControlLease(lane.sessionId, item.controlLease)) {
             return;
         }
-        const goal = this.deps.goalManager.get(lane.sessionId);
         if (item.checkpoint && !this.deps.goalManager.matchesActive(lane.sessionId, item.checkpoint)) {
             return;
         }
+        if (sameGoalControlLease(lane.intent?.controlLease, item.controlLease)) {
+            // New evidence always outranks an older, not-yet-admitted continuation.
+            lane.intent = undefined;
+            this.clearWaitingTimer(lane);
+            await this.deps.durability.clearPendingContinuation(lane.sessionId, item.controlLease);
+            if (!this.isCurrent(lane) ||
+                !this.deps.goalManager.matchesControlLease(lane.sessionId, item.controlLease) ||
+                (item.checkpoint && !this.deps.goalManager.matchesActive(lane.sessionId, item.checkpoint))) {
+                return;
+            }
+        }
+        const goal = this.deps.goalManager.get(lane.sessionId);
         if (item.outcome.kind !== 'completed') {
             if (goal.status !== 'active' && goal.status !== 'waiting')
                 return;
@@ -592,6 +635,13 @@ export class GoalContinuationCoordinator {
             triggeringTurnId: turnId,
             evaluation,
         };
+        const pendingPrompt = truncateGoalText(buildContinuationPrompt(settled, evaluation, undefined), GOAL_PENDING_PROMPT_TEXT_LIMIT);
+        await this.deps.durability.recordPendingContinuation({
+            checkpoint: lane.intent.checkpoint,
+            controlLease,
+            prompt: pendingPrompt,
+            triggeringTurnId: turnId,
+        });
         if (settled.status === 'waiting') {
             lane.consecutiveWaits++;
             return;
@@ -621,7 +671,9 @@ export class GoalContinuationCoordinator {
             lane.intent = undefined;
             return;
         }
-        const prompt = buildContinuationPrompt(goal, intent.evaluation, taskPlan.reminder);
+        const prompt = intent.recoveredPrompt
+            ? attachTaskReminder(intent.recoveredPrompt, taskPlan.reminder)
+            : buildContinuationPrompt(goal, intent.evaluation, taskPlan.reminder);
         const admission = this.deps.admitTurn(lane.sessionId, prompt, intent.checkpoint, intent.controlLease);
         if (admission.kind === 'busy') {
             this.watchBusyLane(lane, admission.whenIdle);
@@ -720,7 +772,16 @@ export class GoalContinuationCoordinator {
                 return;
             lane.intent = { ...lane.intent, checkpoint: goalCheckpoint(woken) };
             void this.deps.durability
-                .flush(lane.sessionId)
+                .recordPendingContinuation({
+                checkpoint: lane.intent.checkpoint,
+                controlLease: lane.intent.controlLease,
+                prompt: lane.intent.recoveredPrompt ??
+                    buildContinuationPrompt(woken, lane.intent.evaluation, undefined),
+                ...(lane.intent.triggeringTurnId
+                    ? { triggeringTurnId: lane.intent.triggeringTurnId }
+                    : {}),
+            })
+                .then(() => this.deps.durability.flush(lane.sessionId))
                 .then(() => this.scheduleDrain(lane))
                 .catch(() => undefined);
         }, delayMs);
@@ -778,6 +839,15 @@ function buildContinuationPrompt(goal, evaluation, taskReminder) {
         `\n\nEvaluation: ${evaluation.reason}${evaluation.waiting ? ' (scheduled external-event re-check)' : ''}\n` +
         `Goal: "${goal.condition}" (turn ${goal.iterations}/${goal.maxIterations}${noProgress})`);
 }
+function attachTaskReminder(prompt, taskReminder) {
+    if (!taskReminder)
+        return prompt;
+    const evaluationMarker = '\n\nEvaluation:';
+    const evaluationAt = prompt.indexOf(evaluationMarker);
+    if (evaluationAt === -1)
+        return `${prompt}\n\n${taskReminder}`;
+    return `${prompt.slice(0, evaluationAt)}\n\n${taskReminder}${prompt.slice(evaluationAt)}`;
+}
 function waitBackoffMs(consecutiveWaits) {
     return Math.min(GOAL_WAIT_BACKOFF_MAX_MS, GOAL_WAIT_BACKOFF_BASE_MS * 2 ** Math.max(0, consecutiveWaits - 1));
 }

package/node_modules/@maka/runtime/dist/goal-state.js

@@ -158,6 +158,13 @@ export class GoalManager {
     get(sessionId) {
         return this.goals.get(sessionId)?.state;
     }
+    getSessionIdByGoalId(goalId) {
+        for (const [sessionId, record] of this.goals) {
+            if (record.state.id === goalId)
+                return sessionId;
+        }
+        return undefined;
+    }
     getActive(sessionId) {
         const goal = this.goals.get(sessionId)?.state;
         return goal?.status === 'active' ? goal : undefined;

package/node_modules/@maka/runtime/dist/grep-search.js

@@ -0,0 +1,155 @@
+/*
+ * 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 { spawn } from 'node:child_process';
+export const GREP_MAX_LINES_PER_FILE = 50;
+export const GREP_MAX_LINES = 200;
+export const GREP_MAX_MATCH_BYTES = 24 * 1024;
+const MAX_RECORD_BYTES = 256 * 1024;
+const MAX_STDERR_BYTES = 16 * 1024;
+export class GrepSearchError extends Error {
+}
+export async function searchFiles(input, run = runRipgrep) {
+    const matches = [];
+    let matchBytes = 2;
+    let returnedInFile = 0;
+    let matchedLines;
+    let pending = Buffer.alloc(0);
+    let oversized = false;
+    const perFile = Math.min(input.maxCountPerFile, GREP_MAX_LINES_PER_FILE);
+    const limit = Math.min(input.limit, GREP_MAX_LINES);
+    // Text mode prevents binary detection from stopping a file early. Single-threaded
+    // output keeps each file's begin/match/end records together without a growing map.
+    const args = ['--no-config', '--json', '--text', '--threads=1', '--line-buffered'];
+    if (input.glob)
+        args.push('--glob', input.glob);
+    args.push('--', input.pattern, input.path);
+    const result = await run({ ...input, args, onStdout });
+    if (result.exitCode !== 0 && result.exitCode !== 1) {
+        throw new GrepSearchError(`Grep failed; search totals are unknown. Check the regex and search path, then retry.\n${result.stderrTail.trim()}`);
+    }
+    if (pending.length || oversized || matchedLines === undefined || matchedLines < matches.length) {
+        throw new GrepSearchError('Grep did not produce a complete search summary; search totals are unknown. Retry with a narrower path or glob.');
+    }
+    return {
+        matchedLines,
+        returnedLines: matches.length,
+        omittedLines: matchedLines - matches.length,
+        truncated: matchedLines > matches.length,
+        matches,
+    };
+    function onStdout(chunk) {
+        let start = 0;
+        while (start < chunk.length) {
+            const newline = chunk.indexOf(10, start);
+            const end = newline === -1 ? chunk.length : newline;
+            if (!oversized) {
+                const part = chunk.subarray(start, end);
+                if (pending.length + part.length > MAX_RECORD_BYTES) {
+                    oversized = true;
+                    pending = Buffer.alloc(0);
+                }
+                else {
+                    pending = Buffer.concat([pending, part]);
+                }
+            }
+            if (newline === -1)
+                break;
+            // Oversized match records are omitted, not shortened. The final engine
+            // summary still counts their lines without retaining their content.
+            if (!oversized)
+                consumeRecord(pending.toString('utf8'));
+            pending = Buffer.alloc(0);
+            oversized = false;
+            start = newline + 1;
+        }
+    }
+    function consumeRecord(line) {
+        const event = JSON.parse(line);
+        if (matchedLines !== undefined)
+            throw new GrepSearchError('Grep emitted data after its summary; search totals are unknown.');
+        if (event.type === 'begin')
+            returnedInFile = 0;
+        if (event.type === 'summary') {
+            const count = event.data.stats.matched_lines;
+            if (!Number.isSafeInteger(count) || count < 0)
+                throw new GrepSearchError('Grep returned an invalid line count; search totals are unknown.');
+            matchedLines = count;
+        }
+        if (event.type !== 'match' || matches.length >= limit || returnedInFile >= perFile)
+            return;
+        const { path, lines, line_number: lineNumber } = event.data;
+        // ripgrep uses base64 for non-UTF8 paths/content; do not pass a lossy decoded
+        // filename or pretend that a replacement-character preview is the original.
+        if (typeof path.text !== 'string' || typeof lines.text !== 'string')
+            return;
+        const match = `${path.text}:${lineNumber}:${lines.text.replace(/\r?\n$/, '')}`;
+        const bytes = Buffer.byteLength(JSON.stringify(match)) + (matches.length ? 1 : 0);
+        if (matchBytes + bytes > GREP_MAX_MATCH_BYTES)
+            return;
+        matchBytes += bytes;
+        matches.push(match);
+        returnedInFile++;
+    }
+}
+async function runRipgrep(input) {
+    if (input.abortSignal?.aborted)
+        throw new GrepSearchError('Grep was cancelled; search totals are unknown.');
+    return await new Promise((resolve, reject) => {
+        const child = spawn(input.executable, [...input.args], {
+            cwd: input.cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderrTail = Buffer.alloc(0);
+        let failure;
+        const timer = setTimeout(() => fail(new GrepSearchError('Grep timed out; search totals are unknown. Retry with a narrower path or glob.')), input.timeoutMs);
+        const abort = () => fail(new GrepSearchError('Grep was cancelled; search totals are unknown.'));
+        input.abortSignal?.addEventListener('abort', abort, { once: true });
+        if (input.abortSignal?.aborted)
+            abort();
+        child.stdout.on('data', (chunk) => {
+            if (failure)
+                return;
+            try {
+                input.onStdout(chunk);
+            }
+            catch {
+                fail(new GrepSearchError('Grep returned invalid search output; search totals are unknown.'));
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrTail = Buffer.concat([stderrTail, chunk]).subarray(-MAX_STDERR_BYTES);
+        });
+        child.once('error', (error) => {
+            failure ??= error;
+        });
+        child.once('close', (exitCode) => {
+            clearTimeout(timer);
+            input.abortSignal?.removeEventListener('abort', abort);
+            if (failure)
+                reject(failure);
+            else
+                resolve({ exitCode: exitCode ?? 2, stderrTail: stderrTail.toString('utf8') });
+        });
+        function fail(error) {
+            failure ??= error;
+            child.kill('SIGKILL');
+        }
+    });
+}