@evandu/super-pi 0.1.104 → 0.1.106

package/dist/server/application/provider-service.js

@@ -0,0 +1,165 @@
+import { KNOWN_APIS, publicProviders, validateProvider } from "../providers.js";
+/**
+ * THE PROVIDERS A PERSON ADDED, as a service.
+ *
+ * The service owns the sequence, and the sequence is the whole point: a provider is not "saved"
+ * when it is in Super Pi's registry, it is saved when Pi can use it. So every change goes through
+ * the same four steps, in this order:
+ *
+ *   1. WRITE PI'S FILES. The definitions go into Pi's `models.json` and the key into Pi's
+ *      `auth.json`, merged into whatever is already there.
+ *   2. WRITE SUPER PI'S REGISTRY. It is the truth source, and it is written AFTER Pi's files so
+ *      that a failure to write them leaves Super Pi claiming nothing it has not done.
+ *   3. INVALIDATE THE CATALOG. Pi's model list is cached - the SDK's is remembered for the life of
+ *      the process and the runtime's has a ten-minute TTL - so a provider added now would not
+ *      appear in the picker until the cache expired. Ten minutes of a picker that cannot see the
+ *      model the person just added is exactly the "decorative control" this project refuses to ship.
+ *   4. INVALIDATE THE LIVE SESSIONS. A session holds its own `ModelRuntime`, created when the
+ *      session was built, and that runtime does not know a provider added a minute ago. Pi's
+ *      refusal to switch to an unknown model is swallowed by the session pool into a warning - the
+ *      turn then runs on the OLD model while the picker says the new one. So the sessions are made
+ *      stale instead, and each one is rebuilt at its next turn, which is a moment when throwing the
+ *      session away costs nothing.
+ */
+export class ProviderService {
+    registry;
+    runtime;
+    broadcaster;
+    catalogService;
+    store;
+    constructor(registry, runtime, broadcaster, catalogService, store) {
+        this.registry = registry;
+        this.runtime = runtime;
+        this.broadcaster = broadcaster;
+        this.catalogService = catalogService;
+        this.store = store;
+    }
+    /** The providers Super Pi manages, as the browser may see them: no keys, only the fact of one. */
+    async list() {
+        return publicProviders(await this.registry.load());
+    }
+    /**
+     * Adds a provider, or adds a model to one, or updates one.
+     *
+     * ONE CALL, THREE THINGS, because the form collects a provider and a model together and a person
+     * saving a second model under the same provider should not have to retype the API address. The
+     * merge is by id: the provider's fields are replaced by what the form said, and the model with
+     * the same id is replaced while the provider's other models stay.
+     *
+     * THE KEY IS LEFT ALONE UNLESS THE FORM SAYS OTHERWISE. An empty key field means "I did not type
+     * one", not "remove the key": the key is never shown again once it is stored, so an empty field
+     * is the normal state of a form for a provider that already has one. `clearKey` is how a person
+     * asks for it to go.
+     */
+    async set(input) {
+        const requested = validateProvider(input);
+        const raw = (input ?? {});
+        const previous = await this.registry.load();
+        const existing = previous.find((provider) => provider.id === requested.id);
+        const apiKey = requested.apiKey
+            ? requested.apiKey
+            : (raw.clearKey === true ? undefined : existing?.apiKey);
+        // A MODEL WITH THE SAME ID IS REPLACED WHERE IT STANDS, not moved to the end: the list a person
+        // sees in the panel is the list they added, and re-ordering it because they edited its first
+        // entry would be a change nobody asked for. A model with a NEW id is appended.
+        const incoming = requested.models[0];
+        const models = !existing
+            ? requested.models
+            : (existing.models.some((model) => model.id === incoming.id)
+                ? existing.models.map((model) => (model.id === incoming.id ? incoming : model))
+                : [...existing.models, incoming]);
+        const merged = {
+            id: requested.id,
+            ...(requested.name ? { name: requested.name } : {}),
+            baseUrl: requested.baseUrl,
+            api: requested.api,
+            ...(apiKey ? { apiKey } : {}),
+            models,
+        };
+        const next = existing
+            ? [...previous.filter((provider) => provider.id !== requested.id), merged]
+            : [...previous, merged];
+        await this.registry.applyToPi(previous, next);
+        try {
+            await this.registry.save(next);
+        }
+        catch (error) {
+            // The registry is the truth source, so a failure to write it means Super Pi no longer knows
+            // what it put into Pi's files. Pi's files are put back the way they were, and the failure is
+            // reported rather than swallowed: a registry that disagrees with Pi's files is a state the
+            // next write would trip over.
+            await this.registry.applyToPi(next, previous).catch(() => undefined);
+            throw error;
+        }
+        await this.afterChange();
+        return publicProviders(next);
+    }
+    /** Removes a provider Super Pi manages, and only one it manages. */
+    async remove(providerId) {
+        const previous = await this.registry.load();
+        const existing = previous.find((provider) => provider.id === providerId);
+        if (!existing)
+            throw new Error(`Super Pi 没有管理供应商「${providerId}」`);
+        const next = previous.filter((provider) => provider.id !== providerId);
+        await this.registry.applyToPi(previous, next);
+        await this.registry.save(next);
+        await this.afterChange();
+        return publicProviders(next);
+    }
+    /**
+     * Removes ONE model from a provider, leaving the provider and its other models alone.
+     *
+     * WHY THIS IS NOT JUST A DELETE-AND-RE-ADD. A provider is a group of models sharing one address,
+     * one API type and one key, so removing a model must not touch any of those - and the key in
+     * particular is not something to re-type. The provider's entry in Pi's file is rewritten with the
+     * remaining models, and its credential stays exactly where it was.
+     *
+     * THE LAST MODEL GOES WITH THE PROVIDER. A provider with no models offers nothing, and Pi's file
+     * would keep an entry that can never be selected - so the provider is removed, and with it the
+     * credential, because a credential for a provider that no longer exists is a secret left lying in
+     * a file for nothing.
+     */
+    async removeModel(providerId, modelId) {
+        const previous = await this.registry.load();
+        const existing = previous.find((provider) => provider.id === providerId);
+        if (!existing)
+            throw new Error(`Super Pi 没有管理供应商「${providerId}」`);
+        const remaining = existing.models.filter((model) => model.id !== modelId);
+        if (remaining.length === existing.models.length)
+            throw new Error(`供应商「${providerId}」里没有模型「${modelId}」`);
+        if (!remaining.length)
+            return this.remove(providerId);
+        const next = previous.map((provider) => (provider.id === providerId ? { ...provider, models: remaining } : provider));
+        await this.registry.applyToPi(previous, next);
+        await this.registry.save(next);
+        await this.afterChange();
+        return publicProviders(next);
+    }
+    /**
+     * What has to happen after the files are written, for the change to be REAL rather than pending.
+     *
+     * The catalog is re-read for every live conversation - the same loop the model rules use - rather
+     * than broadcast once without a conversation, because a catalog without a conversation is the
+     * UNFILTERED one, and handing that to a conversation that has model rules would offer it models
+     * those rules forbid.
+     */
+    async afterChange() {
+        this.runtime.invalidateCatalog?.();
+        this.runtime.bumpModelEpoch?.();
+        for (const conversation of this.store.snapshot().conversations) {
+            if (conversation.archivedAt)
+                continue;
+            try {
+                await this.catalogService.broadcastCatalog(conversation.model, conversation.id);
+            }
+            catch (error) {
+                console.warn(`供应商已保存，刷新会话 ${conversation.id} 的模型目录失败：${String(error)}`);
+            }
+        }
+        // The settings panel's OWN list, which is unfiltered and therefore has to be asked for
+        // separately. Without this the person who just added a provider would not see their own model
+        // in the default-model dropdown until they closed the window and opened it again.
+        await this.catalogService.broadcastAllCatalog?.();
+        this.broadcaster.broadcast({ type: "providers.list", providers: await this.list(), apis: [...KNOWN_APIS] });
+    }
+}

package/dist/server/application/run-service.d.ts

@@ -5,6 +5,7 @@ import type { Conversation, Message, MessageImage, PiQueueSnapshot, QuestionAnsw
 import type { EventBroadcaster } from "../server-context.js";
 import type { ExtensionUiService } from "./extension-ui-service.js";
 import type { WorkflowEngine } from "../workflow-engine.js";
+import { FileChangeTracker } from "../file-changes.js";
 export interface SubagentDispatchRequestBody {
     conversationId?: string;
     subagent_type?: string;
@@ -62,6 +63,16 @@ export declare class RunService {
     private readonly workflows;
     private memory?;
     setMemory(memory: import("../active-memory.js").ActiveMemory): void;
+    /**
+     * WHAT THE AGENT CHANGED, and what each file looked like before.
+     *
+     * The tracker is a SETTER rather than a constructor argument, for the same reason `memory` is: it is
+     * optional, and a service that must be handed one cannot be built before the thing that builds it.
+     */
+    private fileChanges?;
+    private fileIndexes?;
+    setFileChanges(tracker: FileChangeTracker): void;
+    setFileIndexes(indexes: Map<string, import("../file-index.js").FileIndex>): void;
     reviewMemoryBoundary(conversationId: string): void;
     private readonly activeRuns;
     /**
@@ -129,6 +140,14 @@ export declare class RunService {
     private readonly detached;
     constructor(store: Store, runtime: AgentRuntime, subagents: SubagentRunRecorder, broadcaster: EventBroadcaster, extensionUiService: ExtensionUiService, agentsDir: string | string[], workflows: WorkflowEngine);
     setAgentsDir(dir: string | string[]): void;
+    /**
+     * TELLS THE BROWSER WHICH FILES THE AGENT CHANGED.
+     *
+     * The whole list goes every time rather than just the newest file, because the event is a SNAPSHOT
+     * (like `state` and `subagent.event`): a browser that missed one rebuilds the list from the next
+     * one, instead of holding a list assembled from a partial sequence of deltas.
+     */
+    broadcastFileChanges(workspaceId: string): void;
     /**
      * RECORDS WHAT THE PERSON CHOSE, ON THE `question` CALL THAT ASKED.
      *

package/dist/server/application/run-service.js

@@ -137,6 +137,16 @@ export class RunService {
     workflows;
     memory;
     setMemory(memory) { this.memory = memory; }
+    /**
+     * WHAT THE AGENT CHANGED, and what each file looked like before.
+     *
+     * The tracker is a SETTER rather than a constructor argument, for the same reason `memory` is: it is
+     * optional, and a service that must be handed one cannot be built before the thing that builds it.
+     */
+    fileChanges;
+    fileIndexes;
+    setFileChanges(tracker) { this.fileChanges = tracker; }
+    setFileIndexes(indexes) { this.fileIndexes = indexes; }
     reviewMemoryBoundary(conversationId) {
         const conversation = this.store.snapshot().conversations.find(c => c.id === conversationId);
         if (conversation)
@@ -317,6 +327,31 @@ export class RunService {
     setAgentsDir(dir) {
         this.agentsDir = dir;
     }
+    /**
+     * TELLS THE BROWSER WHICH FILES THE AGENT CHANGED.
+     *
+     * The whole list goes every time rather than just the newest file, because the event is a SNAPSHOT
+     * (like `state` and `subagent.event`): a browser that missed one rebuilds the list from the next
+     * one, instead of holding a list assembled from a partial sequence of deltas.
+     */
+    broadcastFileChanges(workspaceId) {
+        const tracker = this.fileChanges;
+        if (!tracker)
+            return;
+        const { changes, dropped } = tracker.list(workspaceId);
+        this.broadcaster.broadcast({
+            type: "files.changed",
+            workspaceId,
+            dropped,
+            changes: changes.map((change) => ({
+                path: change.path,
+                baseline: change.before,
+                ...(change.beforeUnknown ? { baselineUnknown: true } : {}),
+                ...(change.conversationId ? { conversationId: change.conversationId } : {}),
+                at: change.at,
+            })),
+        });
+    }
     /**
      * RECORDS WHAT THE PERSON CHOSE, ON THE `question` CALL THAT ASKED.
      *
@@ -867,6 +902,36 @@ export class RunService {
             }));
             preparingRows.set(call.contentIndex, { row, name: call.name });
         };
+        /**
+         * THE AGENT IS ABOUT TO WRITE A FILE.
+         *
+         * The baseline is captured HERE, at the announcement, because this is the last moment the old content
+         * is still on the disk. By the time the tool has finished, the file holds the new content and the
+         * "before" is gone - which is why a diff cannot be reconstructed afterwards from the file itself.
+         *
+         * The read inside `record` is SYNCHRONOUS on purpose (see `file-changes.ts` for the race it
+         * closes), and it is bounded by a size cap, so it costs a fraction of a millisecond for an
+         * ordinary source file.
+         */
+        /**
+         * THE PATHS THE AGENT IS WRITING, keyed by tool call id.
+         *
+         * The key is what lets the tool's END confirm the baseline of the right file. The alternative - the
+         * tool card's one-line summary - is a DISPLAY string: whitespace-collapsed and length-capped, so
+         * it is not a path the server can read a file by, and a path with a run of spaces in it would come
+         * back as a path with one space.
+         */
+        const fileWritePaths = new Map();
+        const onFileWrite = (path, _toolName, toolCallId) => {
+            const tracker = this.fileChanges;
+            if (!tracker)
+                return;
+            tracker.record(workspace.id, path, { root: workspace.path, conversationId: conversation.id });
+            void this.fileIndexes?.get(workspace.id)?.refresh(path);
+            if (toolCallId)
+                fileWritePaths.set(toolCallId, path);
+            this.broadcastFileChanges(workspace.id);
+        };
         const onToolCall = (call) => {
             const at = spoken;
             // THE PLACEHOLDER THAT BELONGS TO THIS CALL, IF ONE IS ON SCREEN.
@@ -920,6 +985,18 @@ export class RunService {
             enqueueTools("a tool call update", () => this.store.updateToolCall(conversation.id, assistant.id, index, { ...(call.args ? { args: call.args } : {}), ...(call.live !== undefined ? { live: call.live } : {}) }));
         };
         const onToolEnd = (call) => {
+            // THE WRITE IS FINISHED, so the baseline can be CHECKED. The tracker recorded the file's etag when
+            // the write was announced; if the file's etag now differs, the baseline really is the content
+            // from before the write. If it does not, the baseline was taken too late to be shown, and the
+            // tracker says so rather than letting the diff view claim two identical versions are the same.
+            const writtenPath = call.id ? fileWritePaths.get(call.id) : undefined;
+            if (writtenPath) {
+                this.fileChanges?.confirm(workspace.id, writtenPath, workspace.path);
+                void this.fileIndexes?.get(workspace.id)?.refresh(writtenPath);
+                if (call.id)
+                    fileWritePaths.delete(call.id);
+                this.broadcastFileChanges(workspace.id);
+            }
             const index = call.id ? rowByToolCallId.get(call.id) : undefined;
             if (index === undefined)
                 return;
@@ -992,6 +1069,7 @@ export class RunService {
                 onUserEntry: (entryId) => this.store.setMessagePiEntryId(conversation.id, userMessageId, entryId),
                 onSessionFile: (path) => this.store.setConversationPiSessionFile(conversation.id, path),
                 onToolCall,
+                onFileWrite,
                 onToolPreparing,
                 onToolUpdate,
                 onToolEnd,

package/dist/server/command-handler.d.ts

@@ -4,6 +4,7 @@ import type { ConversationService } from "./application/conversation-service.js"
 import type { RunService } from "./application/run-service.js";
 import type { ExtensionUiService } from "./application/extension-ui-service.js";
 import type { CatalogService } from "./application/catalog-service.js";
+import type { ProviderService } from "./application/provider-service.js";
 import type { TerminalService } from "./terminal.js";
 export type SocketSender = (event: ServerEvent) => void;
 /**
@@ -17,6 +18,13 @@ export declare class CommandHandler {
     private readonly catalogService;
     /** Path to the Super Pi repository root, used to spawn the restart script. */
     private readonly rootDir?;
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    private readonly providerService?;
     /**
      * The built-in terminal service.
      *
@@ -25,7 +33,14 @@ export declare class CommandHandler {
     private readonly terminalService?;
     constructor(workspaceService: WorkspaceService, conversationService: ConversationService, runService: RunService, extensionUiService: ExtensionUiService, catalogService: CatalogService, terminalService?: TerminalService, 
     /** Path to the Super Pi repository root, used to spawn the restart script. */
-    rootDir?: string | undefined);
+    rootDir?: string | undefined, 
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    providerService?: ProviderService | undefined);
     /**
      * Processes a client command.
      *

package/dist/server/command-handler.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { join } from "node:path";
+import { KNOWN_APIS } from "./providers.js";
 import { packageUpdateArgs } from "./update.js";
 /**
  * Routes client commands to appropriate application services and converts results or errors.
@@ -11,6 +12,7 @@ export class CommandHandler {
     extensionUiService;
     catalogService;
     rootDir;
+    providerService;
     /**
      * The built-in terminal service.
      *
@@ -19,13 +21,21 @@ export class CommandHandler {
     terminalService;
     constructor(workspaceService, conversationService, runService, extensionUiService, catalogService, terminalService, 
     /** Path to the Super Pi repository root, used to spawn the restart script. */
-    rootDir) {
+    rootDir, 
+    /**
+     * The providers a person added through the settings window.
+     *
+     * Optional because the command handler is constructed by tests that do not care about providers,
+     * and a missing service has to say so rather than take the whole handler down.
+     */
+    providerService) {
         this.workspaceService = workspaceService;
         this.conversationService = conversationService;
         this.runService = runService;
         this.extensionUiService = extensionUiService;
         this.catalogService = catalogService;
         this.rootDir = rootDir;
+        this.providerService = providerService;
         this.terminalService = terminalService;
     }
     /**
@@ -69,6 +79,35 @@ export class CommandHandler {
             await this.catalogService.setDefaultModel(command.model);
             return;
         }
+        // THE PROVIDERS A PERSON ADDED. The list is answered to the ASKING socket only - it is a panel's
+        // private list, and broadcasting it would put a provider's API address in every other tab's state
+        // for no gain. The set and the remove broadcast the new list themselves, because everybody who
+        // has the settings window open has to see the change.
+        if (command.type === "providers.set") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            await this.providerService.set(command.provider);
+            return;
+        }
+        if (command.type === "providers.remove") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            await this.providerService.remove(command.providerId);
+            return;
+        }
+        if (command.type === "providers.removeModel") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            await this.providerService.removeModel(command.providerId, command.modelId);
+            return;
+        }
+        if (command.type === "providers.fetch") {
+            if (!this.providerService)
+                throw new Error("供应商功能不可用");
+            if (sendToSocket)
+                sendToSocket({ type: "providers.list", providers: await this.providerService.list(), apis: [...KNOWN_APIS] });
+            return;
+        }
         if (command.type === "workspace.create") {
             return await this.workspaceService.createWorkspace(command.name, command.path);
         }

package/dist/server/content-search.d.ts

@@ -0,0 +1,32 @@
+import type { FileIndexSnapshot } from "./file-index.js";
+export declare const MAX_CONTENT_RESULTS = 500;
+export declare const MAX_CONTENT_FILE_BYTES: number;
+export declare const MAX_CONTENT_DEPTH = 12;
+export declare const MAX_CONTENT_MS = 10000;
+export type ContentSearchCandidate = {
+    path: string;
+    kind: "file" | "directory";
+    text: boolean | null;
+    size: number | null;
+};
+export type ContentSearchHit = {
+    path: string;
+    name: string;
+    line: number;
+    text: string;
+};
+export type ContentSearchResult = {
+    hits: ContentSearchHit[];
+    truncated: boolean;
+    skipped: string[];
+    complete: boolean;
+    reasons: string[];
+};
+/**
+ * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
+ * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
+ * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
+ * Instead give it one verified indexed file at a time; validate again before publishing any hit.
+ * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
+ */
+export declare function searchByContent(root: string, candidates: readonly ContentSearchCandidate[], query: string, indexStatus?: Pick<FileIndexSnapshot, "complete" | "skipped">): Promise<ContentSearchResult>;

package/dist/server/content-search.js

@@ -0,0 +1,155 @@
+import { open } from "node:fs/promises";
+import { basename } from "node:path";
+import { createGrepTool } from "@earendil-works/pi-coding-agent";
+import { isTextName, looksBinary, resolveInsideRoot } from "./files.js";
+export const MAX_CONTENT_RESULTS = 500;
+export const MAX_CONTENT_FILE_BYTES = 512 * 1024;
+export const MAX_CONTENT_DEPTH = 12;
+export const MAX_CONTENT_MS = 10000;
+/**
+ * SDK probe: createGrepTool(root).execute(id, { pattern, path, literal: true }) works without a
+ * session or running turn (Pi 0.86). Use it for matching. Directory-wide SDK grep would walk a second
+ * tree and cannot accept FileIndex candidates or our per-file containment/size/depth policy.
+ * Instead give it one verified indexed file at a time; validate again before publishing any hit.
+ * The SDK owns ripgrep and its match/byte/line truncation; we expose those limits, never hide them.
+ */
+export async function searchByContent(root, candidates, query, indexStatus = { complete: true, skipped: [] }) {
+    await resolveInsideRoot(root, "");
+    const hits = [];
+    const skipped = new Set(indexStatus.skipped);
+    const reasons = new Set(indexStatus.complete ? [] : ["index"]);
+    const needle = query.trim();
+    if (!needle)
+        return { hits, truncated: false, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
+    const tool = createGrepTool(root);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), MAX_CONTENT_MS);
+    try {
+        for (const candidate of candidates) {
+            if (candidate.kind !== "file")
+                continue;
+            if (controller.signal.aborted) {
+                reasons.add("time");
+                break;
+            }
+            // Validate even an excluded candidate: metadata and cached paths are not a security boundary.
+            let absolute;
+            try {
+                absolute = await resolveInsideRoot(root, candidate.path);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === "outside_workspace" || code === "bad_path" || code === "workspace_missing")
+                    throw error;
+                skipped.add(candidate.path);
+                reasons.add("unreadable");
+                continue;
+            }
+            if (candidate.path.replace(/\\/g, "/").split("/").length - 1 > MAX_CONTENT_DEPTH) {
+                skipped.add(candidate.path);
+                reasons.add("depth");
+                continue;
+            }
+            if (candidate.text === false || !isTextName(candidate.path)) {
+                skipped.add(candidate.path);
+                continue;
+            }
+            let bytes;
+            try {
+                // Read at most cap+1 bytes even if a file grows after stat; never allocate its untrusted size.
+                const handle = await open(absolute, "r");
+                try {
+                    const info = await handle.stat();
+                    if (!info.isFile()) {
+                        skipped.add(candidate.path);
+                        reasons.add("unreadable");
+                        continue;
+                    }
+                    if (info.size > MAX_CONTENT_FILE_BYTES) {
+                        skipped.add(candidate.path);
+                        reasons.add("size");
+                        continue;
+                    }
+                    const buffer = Buffer.alloc(MAX_CONTENT_FILE_BYTES + 1);
+                    let length = 0;
+                    while (length < buffer.length) {
+                        const read = await handle.read(buffer, length, buffer.length - length, null);
+                        if (!read.bytesRead)
+                            break;
+                        length += read.bytesRead;
+                    }
+                    if (length > MAX_CONTENT_FILE_BYTES) {
+                        skipped.add(candidate.path);
+                        reasons.add("size");
+                        continue;
+                    }
+                    bytes = buffer.subarray(0, length);
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            catch {
+                skipped.add(candidate.path);
+                reasons.add("unreadable");
+                continue;
+            }
+            if (looksBinary(bytes) || bytes.includes(0)) {
+                skipped.add(candidate.path);
+                continue;
+            }
+            try {
+                new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+            }
+            catch {
+                skipped.add(candidate.path);
+                continue;
+            }
+            let result;
+            try {
+                result = await tool.execute("content-search", {
+                    pattern: needle, path: absolute, literal: true, limit: MAX_CONTENT_RESULTS - hits.length,
+                }, controller.signal);
+            }
+            catch (error) {
+                if (controller.signal.aborted) {
+                    reasons.add("time");
+                    break;
+                }
+                // SDK/ripgrep failures are request failures, never a successful empty search.
+                throw error;
+            }
+            const prefix = basename(absolute) + ":";
+            const rows = [];
+            for (const block of result.content) {
+                if (block.type !== "text")
+                    continue;
+                for (const row of block.text.split("\n")) {
+                    if (!row.startsWith(prefix))
+                        continue;
+                    const match = /^(\d+): (.*)$/.exec(row.slice(prefix.length));
+                    if (!match)
+                        continue;
+                    rows.push({ path: candidate.path, name: basename(absolute), line: Number(match[1]), text: match[2] });
+                }
+            }
+            if (rows.length) {
+                await resolveInsideRoot(root, candidate.path);
+                hits.push(...rows.slice(0, MAX_CONTENT_RESULTS - hits.length));
+            }
+            const details = result.details;
+            if (details?.truncation?.truncated)
+                reasons.add("output");
+            if (details?.linesTruncated)
+                reasons.add("line");
+            if (details?.matchLimitReached || hits.length >= MAX_CONTENT_RESULTS) {
+                reasons.add("results");
+                break;
+            }
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return { hits, truncated: reasons.size > 0, skipped: [...skipped], complete: indexStatus.complete, reasons: [...reasons] };
+}