@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/tools/bash.js

@@ -1,147 +1,41 @@
-// allow: SIZE_OK - pre-existing cohesive shell integration; this patch only hardens its output-finalization seam.
 import { constants } from "node:fs";
 import { access as fsAccess } from "node:fs/promises";
 import { constants as osConstants } from "node:os";
-import { Type } from "typebox";
 import { annotateShellTrust } from "../../engine-trust/shell-trust.js";
 import { getShellConfig, getShellEnv, noteDetachedChildExited, pruneTrackedDetachedChildren, trackDetachedChildPid, } from "../../utils/shell.js";
+import { createShellToolCore } from "./bash-core.js";
+import { bashToolConfig, } from "./bash-schema.js";
 import { defaultToolMachine } from "./machine.js";
-import { modelOnlyText } from "./model-only-text.js";
-import { OutputAccumulator } from "./output-accumulator.js";
-import { SecretOutputRedactor } from "./secret-output-redactor.js";
-import { BASH_UPDATE_THROTTLE_MS, createShellRenderers } from "./renderers/bash.js";
+import { createTempFileSpill } from "./output-accumulator.js";
+import { createShellRenderers } from "./renderers/bash.js";
+import { createShellOperations } from "./shell-operations.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
-const MAX_TIMEOUT_MS = 2_147_483_647;
-/** Output limit of `structuredContent.output`, which programmatic callers such as codemode scripts receive. */
-const STRUCTURED_OUTPUT_MAX_BYTES = 1024 * 1024;
-const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
-function resolveTimeoutMs(timeout) {
-    if (timeout === undefined)
-        return undefined;
-    if (!Number.isFinite(timeout) || timeout <= 0) {
-        throw new Error("Invalid timeout: must be a finite number of seconds");
-    }
-    const timeoutMs = timeout * 1000;
-    if (timeoutMs > MAX_TIMEOUT_MS) {
-        throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
-    }
-    return timeoutMs;
-}
-const bashSchema = Type.Object({
-    command: Type.String({ description: "Shell command to execute" }),
-    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
-});
-export const bashToolSystemPromptContribution = {
-    snippet: "Execute bash commands (ls, rg, find, etc.)",
-    guidelines: ["PI_* env vars = current model + session details."],
-    fullGuidelines: ["You can inspect PI_* environment variables for current model and session details."],
-};
-/**
- * Result for programmatic callers such as codemode scripts. A non-zero exit code is an error result for the model, but scripts still resolve to this value.
- * `output` is not limited like the model-facing output: callers decide how much of it reaches the model.
- */
-const bashOutputSchema = Type.Object({
-    output: Type.String({
-        description: "Combined stdout and stderr, up to 1 MiB. Longer output keeps its first and last 512 KiB around an omission marker.",
-    }),
-    truncated: Type.Boolean({ description: "Whether `output` omits part of the command output" }),
-    full_output_path: Type.Optional(Type.String({ description: "Temp file with the full output, when truncated" })),
-    exit_code: Type.Number(),
-    wall_time_seconds: Type.Number(),
-});
+export { bashToolSystemPromptContribution, } from "./bash-schema.js";
 /**
  * Shared process execution used by the built-in shell tools: one `process.exec` of the operation layer (own
  * process group, scope token, abort/timeout kill the group). The tool keeps its own output handling.
  */
 export function createLocalShellOperations(shellName, resolveShellConfig, machine = defaultToolMachine()) {
-    return {
-        exec: async (command, cwd, { onData, signal, timeout, env }) => {
-            const timeoutMs = resolveTimeoutMs(timeout);
-            if (signal?.aborted) {
-                throw new Error("aborted");
-            }
+    return createShellOperations(shellName, machine, {
+        resolveShell: () => {
             const shellConfig = resolveShellConfig();
-            try {
-                await fsAccess(cwd, constants.F_OK);
-            }
-            catch {
-                throw new Error(`Working directory does not exist: ${cwd}\nCannot execute ${shellName} commands.`);
-            }
-            let streamCallbackError;
-            let hasStreamCallbackError = false;
-            // A failing output callback stops the command the same way an abort does.
-            const callbackAbort = new AbortController();
-            const failStream = (error) => {
-                if (hasStreamCallbackError)
-                    return;
-                streamCallbackError = error;
-                hasStreamCallbackError = true;
-                callbackAbort.abort();
-            };
-            const handleData = (data, stream) => {
-                if (hasStreamCallbackError)
-                    return;
-                try {
-                    const callbackResult = onData(data, stream);
-                    if (callbackResult && typeof callbackResult.then === "function") {
-                        void Promise.resolve(callbackResult).catch(failStream);
-                    }
-                }
-                catch (error) {
-                    failStream(error);
-                }
-            };
-            const shell = {
+            return {
                 path: shellConfig.shell,
                 args: shellConfig.args,
                 commandTransport: shellConfig.commandTransport === "stdin" ? "stdin" : "argv",
             };
-            const execSignal = signal ? AbortSignal.any([signal, callbackAbort.signal]) : callbackAbort.signal;
-            let result;
-            try {
-                result = await machine.ops.process.exec({
-                    command,
-                    cwd,
-                    env: env ?? getShellEnv(),
-                    envMode: "exact",
-                    shell,
-                    timeoutMs: timeoutMs ?? Number.POSITIVE_INFINITY,
-                    onOutput: handleData,
-                    // Tracked as a process group: whatever the shell backgrounds keeps running in it, and ownership
-                    // is released only once that group is empty (senpi#1697).
-                    onSpawn: trackDetachedChildPid,
-                    onExit: noteDetachedChildExited,
-                }, machine.context(execSignal));
-            }
-            catch (error) {
-                if (hasStreamCallbackError)
-                    throw streamCallbackError;
-                if (signal?.aborted)
-                    throw new Error("aborted");
-                throw error;
-            }
-            finally {
-                // Groups kept past their shell's exit must not accumulate across a session.
-                pruneTrackedDetachedChildren();
-            }
-            if (hasStreamCallbackError) {
-                throw streamCallbackError;
-            }
-            if (signal?.aborted) {
-                throw new Error("aborted");
-            }
-            if (result.timedOut) {
-                throw new Error(`timeout:${timeout}`);
-            }
-            // A signal-killed shell has no exit code. Use the standard shell convention so
-            // callers do not mistake the termination for a successful command.
-            return {
-                exitCode: result.exitCode ??
-                    (result.signal ? 128 + (osConstants.signals[result.signal] ?? 0) : 1),
-            };
         },
-    };
+        checkCwd: (cwd) => fsAccess(cwd, constants.F_OK),
+        envMode: "exact",
+        defaultEnv: getShellEnv,
+        signalNumber: (signal) => osConstants.signals[signal],
+        // Tracked as a process group: whatever the shell backgrounds keeps running in it, and ownership
+        // is released only once that group is empty (senpi#1697).
+        onSpawn: trackDetachedChildPid,
+        onExit: noteDetachedChildExited,
+        // Groups kept past their shell's exit must not accumulate across a session.
+        afterExec: pruneTrackedDetachedChildren,
+    });
 }
 /**
  * Create bash operations using pi's built-in local shell execution backend.
@@ -165,38 +59,6 @@ const toolsViaDaemon = (tool, env = process.env) => (env.OMO_TOOLS_VIA_DAEMON ??
     .split(",")
     .map((name) => name.trim())
     .includes(tool);
-function resolveSpawnContext(command, cwd, spawnHook, exposeSessionEnvironment, ctx) {
-    const env = { ...getShellEnv() };
-    delete env.PI_SESSION_ID;
-    delete env.PI_SESSION_FILE;
-    delete env.PI_SESSION_CWD;
-    delete env.PI_GOAL_STORE_FILE;
-    delete env.PI_PROVIDER;
-    delete env.PI_MODEL;
-    delete env.PI_REASONING_LEVEL;
-    delete env.OMO_BROWSER_ENGINE;
-    if (exposeSessionEnvironment && ctx) {
-        const model = ctx.model;
-        env.PI_SESSION_ID = ctx.sessionManager.getSessionId();
-        env.PI_SESSION_CWD = ctx.cwd;
-        if (ctx.goalStoreFile)
-            env.PI_GOAL_STORE_FILE = ctx.goalStoreFile;
-        const sessionFile = ctx.sessionManager.getSessionFile();
-        if (sessionFile)
-            env.PI_SESSION_FILE = sessionFile;
-        if (model) {
-            env.PI_PROVIDER = model.provider;
-            env.PI_MODEL = model.id;
-        }
-        if (ctx.thinkingLevel)
-            env.PI_REASONING_LEVEL = ctx.thinkingLevel;
-        if (ctx.browserEngine)
-            env.OMO_BROWSER_ENGINE = ctx.browserEngine;
-        Object.assign(env, ctx.sessionEnv);
-    }
-    const baseContext = { command, cwd, env };
-    return spawnHook ? spawnHook(baseContext) : baseContext;
-}
 export function createShellToolDefinition(cwd, config, options) {
     const machine = options?.machine ?? defaultToolMachine();
     // OMO_TOOLS_VIA_DAEMON=bash (default off): run on the session's device, never on this machine. The flag decides even
@@ -216,261 +78,22 @@ export function createShellToolDefinition(cwd, config, options) {
             },
         }
         : (options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath, machine }));
-    const commandPrefix = options?.commandPrefix;
-    const exposeSessionEnvironment = options?.exposeSessionEnvironment ?? true;
-    const spawnHook = options?.spawnHook;
     return {
-        ...(options?.operations !== undefined || spawnHook !== undefined ? { serverPinned: true } : {}),
-        name: config.name,
-        label: config.label,
-        description: `Execute a ${config.shellName} command in the current working directory. Returns stdout and stderr. Output is truncated to last ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
-        promptSnippet: config.promptSnippet,
-        promptGuidelines: exposeSessionEnvironment && config.promptGuidelines ? [...config.promptGuidelines] : undefined,
-        fullPromptGuidelines: exposeSessionEnvironment && config.fullPromptGuidelines ? [...config.fullPromptGuidelines] : undefined,
-        parameters: bashSchema,
-        outputSchema: bashOutputSchema,
-        constrainedSampling: { type: "json_schema", strict: "prefer" },
-        async execute(_toolCallId, { command, timeout }, signal, onUpdate, ctx) {
-            const admitted = machine.begin("process.exec", { command, timeout }, signal);
-            if (admitted !== undefined)
-                await admitted;
-            const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
-            const spawnContext = resolveSpawnContext(resolvedCommand, ctx?.cwd || cwd, spawnHook, exposeSessionEnvironment, ctx);
-            const output = new OutputAccumulator({ tempFilePrefix: config.tempFilePrefix });
-            const streams = options?.redactSecretsInOutput === true
-                ? new Map()
-                : undefined;
-            let acceptingOutput = true;
-            let updateTimer;
-            let updateDirty = false;
-            let lastUpdateAt = 0;
-            let outputUpdateError;
-            let hasOutputUpdateError = false;
-            const emitOutputUpdate = () => {
-                if (!onUpdate || !updateDirty || hasOutputUpdateError)
-                    return;
-                updateDirty = false;
-                lastUpdateAt = Date.now();
-                const snapshot = output.snapshot({ persistIfTruncated: true });
-                try {
-                    onUpdate({
-                        content: [{ type: "text", text: snapshot.content || "" }],
-                        details: {
-                            truncation: snapshot.truncation.truncated ? snapshot.truncation : undefined,
-                            fullOutputPath: snapshot.fullOutputPath,
-                        },
-                    });
-                }
-                catch (error) {
-                    outputUpdateError = error;
-                    hasOutputUpdateError = true;
-                }
-            };
-            const clearUpdateTimer = () => {
-                if (updateTimer) {
-                    clearTimeout(updateTimer);
-                    updateTimer = undefined;
-                }
-            };
-            const scheduleOutputUpdate = () => {
-                if (!onUpdate)
-                    return;
-                updateDirty = true;
-                const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
-                if (delay <= 0) {
-                    clearUpdateTimer();
-                    emitOutputUpdate();
-                    return;
-                }
-                updateTimer ??= setTimeout(() => {
-                    updateTimer = undefined;
-                    emitOutputUpdate();
-                }, delay);
-            };
-            if (onUpdate) {
-                onUpdate({ content: [], details: undefined });
-            }
-            const handleData = (data, stream = "stdout") => {
-                if (!acceptingOutput)
-                    return;
-                if (streams) {
-                    let state = streams.get(stream);
-                    if (!state) {
-                        state = { redactor: new SecretOutputRedactor(), decoder: new TextDecoder() };
-                        streams.set(stream, state);
-                    }
-                    output.appendText(state.redactor.push(state.decoder.decode(data, { stream: true })));
-                }
-                else
-                    output.append(data);
-                scheduleOutputUpdate();
-            };
-            const finishOutput = async () => {
-                acceptingOutput = false;
-                clearUpdateTimer();
-                let primaryError;
-                let hasPrimaryError = false;
-                let snapshot;
-                try {
-                    if (streams) {
-                        for (const { redactor, decoder } of streams.values()) {
-                            output.appendText(redactor.push(decoder.decode()) + redactor.finish());
-                        }
-                        updateDirty = true;
-                    }
-                    output.finish();
-                    emitOutputUpdate();
-                    snapshot = output.snapshot({ persistIfTruncated: true });
-                    if (hasOutputUpdateError) {
-                        primaryError = outputUpdateError;
-                        hasPrimaryError = true;
-                    }
-                }
-                catch (error) {
-                    primaryError = error;
-                    hasPrimaryError = true;
-                }
-                try {
-                    await output.closeTempFile();
-                }
-                catch (closeError) {
-                    if (hasPrimaryError) {
-                        throw new AggregateError([primaryError, closeError], "Bash output finalization and spill cleanup failed");
-                    }
-                    throw closeError;
-                }
-                if (hasPrimaryError) {
-                    try {
-                        await output.removeTempFile();
-                    }
-                    catch (unlinkError) {
-                        if (!(unlinkError instanceof Error))
-                            throw unlinkError;
-                        throw new AggregateError([primaryError, unlinkError], "Bash output finalization and spill cleanup failed");
-                    }
-                    throw primaryError;
-                }
-                if (snapshot === undefined) {
-                    throw new Error("Bash output finalization produced no snapshot");
-                }
-                return snapshot;
-            };
-            const formatOutput = (snapshot, emptyText = "(no output)") => {
-                const truncation = snapshot.truncation;
-                const text = snapshot.content || emptyText;
-                let notice;
-                let details;
-                if (truncation.truncated) {
-                    details = { truncation, fullOutputPath: snapshot.fullOutputPath };
-                    const startLine = truncation.totalLines - truncation.outputLines + 1;
-                    const endLine = truncation.totalLines;
-                    if (truncation.lastLinePartial) {
-                        const lastLineSize = formatSize(output.getLastLineBytes());
-                        notice = `[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
-                    }
-                    else if (truncation.truncatedBy === "lines") {
-                        notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]`;
-                    }
-                    else {
-                        notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${snapshot.fullOutputPath}]`;
-                    }
-                }
-                const content = [{ type: "text", text: notice === undefined ? text : `${text}\n` }];
-                if (notice !== undefined)
-                    content.push(modelOnlyText(notice));
-                return { text: notice === undefined ? text : `${text}\n\n${notice}`, content, details };
-            };
-            const appendStatus = (text, status) => `${text ? `${text}\n\n` : ""}${status}`;
-            const startedAt = performance.now();
-            try {
-                let exitCode;
-                try {
-                    const result = await ops.exec(spawnContext.command, spawnContext.cwd, {
-                        onData: handleData,
-                        redactSecretsInOutput: options?.redactSecretsInOutput === true,
-                        signal,
-                        timeout,
-                        env: spawnContext.env,
-                    });
-                    exitCode = result.exitCode;
-                }
-                catch (err) {
-                    let snapshot;
-                    try {
-                        snapshot = await finishOutput();
-                    }
-                    catch (cleanupError) {
-                        throw new AggregateError([err, cleanupError], "Bash command and output cleanup failed");
-                    }
-                    const { text } = formatOutput(snapshot, "");
-                    if (err instanceof Error && err.message === "aborted") {
-                        throw new Error(appendStatus(text, "Command aborted"));
-                    }
-                    if (err instanceof Error && err.message.startsWith("timeout:")) {
-                        const timeoutSecs = err.message.split(":")[1];
-                        throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
-                    }
-                    try {
-                        await output.removeTempFile();
-                    }
-                    catch (unlinkError) {
-                        throw new AggregateError([err, unlinkError], "Bash command and output cleanup failed");
-                    }
-                    throw err;
-                }
-                const snapshot = await finishOutput();
-                const { text: outputText, content, details } = formatOutput(snapshot);
-                if (exitCode === null) {
-                    throw new Error(appendStatus(outputText, "Command terminated without an exit code"));
-                }
-                const wallTimeSeconds = Math.round((performance.now() - startedAt) / 100) / 10;
-                const fullOutput = await output.readFullOutput(STRUCTURED_OUTPUT_MAX_BYTES);
-                const structuredContent = {
-                    output: fullOutput.content,
-                    truncated: fullOutput.truncated,
-                    ...(fullOutput.truncated && snapshot.fullOutputPath
-                        ? { full_output_path: snapshot.fullOutputPath }
-                        : {}),
-                    exit_code: exitCode,
-                    wall_time_seconds: wallTimeSeconds,
-                };
-                if (exitCode !== 0) {
-                    const text = appendStatus(outputText, `Command exited with code ${exitCode}`);
-                    // The engine trust annotation (omo#10762) rides only on error results, so the success
-                    // `outputSchema` (and the prompt bytes it costs) stays unchanged.
-                    const annotation = annotateShellTrust({ exitCode, output: fullOutput.content });
-                    if (annotation === undefined) {
-                        return { content: [{ type: "text", text }], details, structuredContent, isError: true };
-                    }
-                    return {
-                        content: [
-                            { type: "text", text: annotation.text === undefined ? text : `${text}\n\n${annotation.text}` },
-                        ],
-                        details: { ...details, trust: annotation.trust },
-                        structuredContent: { ...structuredContent, trust: annotation.trust },
-                        isError: true,
-                    };
-                }
-                // Success keeps the fork's model-only truncation notice; the error text above carries it inline.
-                return { content, details, structuredContent };
-            }
-            finally {
-                clearUpdateTimer();
-            }
-        },
+        ...(options?.operations !== undefined || options?.spawnHook !== undefined ? { serverPinned: true } : {}),
+        ...createShellToolCore(cwd, config, {
+            machine,
+            operations: ops,
+            outputSpill: createTempFileSpill,
+            shellEnv: getShellEnv,
+            annotateTrust: annotateShellTrust,
+            redactSecretsInOutput: options?.redactSecretsInOutput,
+            commandPrefix: options?.commandPrefix,
+            exposeSessionEnvironment: options?.exposeSessionEnvironment,
+            spawnHook: options?.spawnHook,
+        }),
         ...createShellRenderers(config.prompt),
     };
 }
-const bashToolConfig = {
-    name: "bash",
-    label: "bash",
-    shellName: "bash",
-    prompt: "$",
-    promptSnippet: bashToolSystemPromptContribution.snippet,
-    promptGuidelines: bashToolSystemPromptContribution.guidelines,
-    fullPromptGuidelines: bashToolSystemPromptContribution.fullGuidelines,
-    tempFilePrefix: "pi-bash",
-};
 export function createBashToolDefinition(cwd, options) {
     return {
         ...createShellToolDefinition(cwd, bashToolConfig, options),

package/dist/core/tools/coding-tools-core.d.ts

@@ -0,0 +1,24 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type CoreBashToolOptions } from "./bash-core.ts";
+import type { bashSchema } from "./bash-schema.ts";
+import { type CoreEditToolOptions, type editSchema } from "./edit-core.ts";
+import { type CoreReadToolOptions, type readSchema } from "./read-core.ts";
+import type { ToolMachine } from "./tool-machine.ts";
+import { type CoreWriteToolOptions, type writeSchema } from "./write-core.ts";
+export interface CoreCodingToolsOptions {
+    /** The one effect channel of all four tools. */
+    machine: ToolMachine;
+    read?: Omit<CoreReadToolOptions, "machine">;
+    bash?: Omit<CoreBashToolOptions, "machine">;
+    edit?: Omit<CoreEditToolOptions, "machine">;
+    write?: Omit<CoreWriteToolOptions, "machine">;
+}
+/** read, bash, edit and write, in `createCodingTools` order, for a host whose only effect channel is `machine`. */
+export type CoreCodingTools = [
+    AgentTool<typeof readSchema>,
+    AgentTool<typeof bashSchema>,
+    AgentTool<typeof editSchema>,
+    AgentTool<typeof writeSchema>
+];
+export declare function createCoreCodingTools(cwd: string, options: CoreCodingToolsOptions): CoreCodingTools;
+//# sourceMappingURL=coding-tools-core.d.ts.map

package/dist/core/tools/coding-tools-core.js

@@ -0,0 +1,14 @@
+import { createCoreBashTool } from "./bash-core.js";
+import { createCoreEditTool } from "./edit-core.js";
+import { createCoreReadTool } from "./read-core.js";
+import { createCoreWriteTool } from "./write-core.js";
+export function createCoreCodingTools(cwd, options) {
+    const { machine } = options;
+    return [
+        createCoreReadTool(cwd, { ...options.read, machine }),
+        createCoreBashTool(cwd, { ...options.bash, machine }),
+        createCoreEditTool(cwd, { ...options.edit, machine }),
+        createCoreWriteTool(cwd, { ...options.write, machine }),
+    ];
+}
+//# sourceMappingURL=coding-tools-core.js.map

package/dist/core/tools/edit-core.d.ts

@@ -0,0 +1,56 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { type Static, Type } from "typebox";
+import type { FilesystemPolicyChecker, ToolDefinition } from "../extensions/types.ts";
+import { type FileMutationQueue, type ToolPathCanonicalizer, type ToolPathResolver } from "./file-tool-host.ts";
+import type { ToolMachine } from "./tool-machine.ts";
+declare const editSchema: Type.TObject<{
+    path: Type.TString;
+    edits: Type.TArray<Type.TObject<{
+        oldText: Type.TString;
+        newText: Type.TString;
+    }>>;
+}>;
+export declare const editToolSystemPromptContribution: {
+    readonly snippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call";
+    readonly guidelines: readonly ["All changes to one file -> one edit call."];
+    readonly fullGuidelines: readonly ["Use edit for precise changes (edits[].oldText must match exactly)", "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls", "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.", "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."];
+};
+export type EditToolInput = Static<typeof editSchema>;
+export interface EditToolDetails {
+    /** Display-oriented diff of the changes made */
+    diff: string;
+    /** Standard unified patch of the changes made */
+    patch: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+}
+/**
+ * Pluggable operations for the edit tool.
+ * Override these to delegate file editing to remote systems (for example SSH).
+ */
+export interface EditOperations {
+    /** Read file contents */
+    readFile: (absolutePath: string) => Promise<Uint8Array>;
+    /** Write content to a file */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Check if file is readable and writable (throw if not) */
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface CoreEditToolOptions {
+    /** Operation layer and policy gate. */
+    machine: ToolMachine;
+    /** Custom operations for file editing. Default: edits through `machine` */
+    operations?: EditOperations;
+    /** Extension-registered filesystem policy checker. */
+    filesystemPolicy?: FilesystemPolicyChecker;
+    /** Default: POSIX resolution against the cwd. */
+    resolvePath?: ToolPathResolver;
+    /** Default: one queue per path string in this isolate, shared with the core write tool. */
+    withMutationQueue?: FileMutationQueue;
+    /** The path `filesystemPolicy` judges. Default: the resolved path as is. */
+    canonicalizePath?: ToolPathCanonicalizer;
+}
+export declare function createCoreEditToolDefinition(cwd: string, options: CoreEditToolOptions): ToolDefinition<typeof editSchema, EditToolDetails | undefined>;
+export declare function createCoreEditTool(cwd: string, options: CoreEditToolOptions): AgentTool<typeof editSchema>;
+export { editSchema };
+//# sourceMappingURL=edit-core.d.ts.map