@modelprofile.com/flexharness 10.17.1 → 10.19.0

package/dist_ts_tools/tool.filesystem.js

@@ -75,6 +75,47 @@ export function createFilesystemTools(context, options = {}) {
             },
         }),
     };
+    if (options.includeEdit === true) {
+        tools.edit_file = plugins.tool({
+            description: 'Replace an exact snippet of a UTF-8 file in the active workspace. `find` must occur exactly once unless `replaceAll` is set; include enough surrounding text to make it unique. Requires host permission when configured.',
+            inputSchema: plugins.z.object({
+                path: plugins.z.string().describe('File path'),
+                find: plugins.z.string().min(1).describe('Exact text to replace, copied from the current file'),
+                replace: plugins.z.string().describe('The text to put in its place'),
+                replaceAll: plugins.z
+                    .boolean()
+                    .optional()
+                    .describe('Replace every occurrence instead of exactly one. Default: false'),
+            }),
+            execute: async ({ path: filePath, find, replace, replaceAll, }, invocationOptions) => {
+                if (!context.fs) {
+                    throw new Error('Filesystem tools are not available in this execution context.');
+                }
+                const abortSignal = invocationOptions?.abortSignal ?? context.abortSignal;
+                const invocation = { toolCallId: invocationOptions?.toolCallId, abortSignal };
+                // asked before the file is read: an edit made while the request waits is kept, not overwritten
+                await context.requestPermission?.({
+                    type: 'write',
+                    title: 'Edit file',
+                    metadata: { path: filePath },
+                    toolCallId: invocationOptions?.toolCallId,
+                    abortSignal,
+                });
+                const content = await context.fs.readFile(filePath, undefined, invocation);
+                const occurrences = content.split(find).length - 1;
+                if (occurrences === 0) {
+                    throw new Error(`The text to replace does not occur in ${filePath}.`);
+                }
+                if (occurrences > 1 && replaceAll !== true) {
+                    throw new Error(`The text to replace occurs ${occurrences} times in ${filePath}; include more surrounding text or set replaceAll.`);
+                }
+                const updated = replaceAll === true ? content.split(find).join(replace) : content.replace(find, () => replace);
+                await context.fs.writeFile(filePath, updated, invocation);
+                const replaced = replaceAll === true ? occurrences : 1;
+                return truncate(`Replaced ${replaced} occurrence${replaced === 1 ? '' : 's'} in ${filePath}`);
+            },
+        });
+    }
     if (options.includeDelete !== false) {
         tools.delete_file = plugins.tool({
             description: 'Delete a file or empty directory in the active workspace. Requires host permission when configured.',
@@ -103,4 +144,4 @@ export function createFilesystemTools(context, options = {}) {
     }
     return tools;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools_node/classes.workspacereversion.d.ts

@@ -0,0 +1,48 @@
+import * as plugins from './plugins.js';
+import type { IToolFileChangeObserver } from './tool.context.js';
+export interface IInMemoryWorkspaceReversionOptions {
+    /** The workspace a revertible turn names in the session's reversion info. */
+    workspace: plugins.IFlexAffectedWorkspace;
+    /**
+     * The bytes of file images one turn may hold. A turn that changes more is recorded as
+     * nonrevertible (`capture-too-large`) and its images are dropped. Default: 64 MiB.
+     */
+    maxCaptureBytes?: number;
+}
+/**
+ * Turn reversion for the local filesystem tools, held in memory: FlexHarness `/undo` and `/redo`
+ * move a turn's file changes together with its transcript.
+ *
+ * Give each run's `createLocalToolExecutionContext` the observer `observerFor(context.runId)`. The
+ * first change of a file in a turn records what the file held before; `finalize` records what it
+ * holds after. Undo puts the before images back and redo the after images, each only while every
+ * file still holds what the other direction left, so a later edit of the user is never overwritten.
+ * A turn that ran a shell command is nonrevertible, since the command may have changed files no
+ * observer saw.
+ *
+ * Captures live as long as the process. A capture FlexHarness asks about after a restart is
+ * `missing`, and undoing past it fails without changing anything. Only root-session runs are
+ * captured; a change of a run without a prepared capture is refused.
+ */
+export declare class InMemoryWorkspaceReversion<TScope = unknown> implements plugins.IFlexTurnReversionProviderV2<TScope> {
+    readonly protocolVersion = 2;
+    private readonly workspace;
+    private readonly maxCaptureBytes;
+    private readonly captures;
+    private readonly captureIdsByRun;
+    constructor(optionsArg: IInMemoryWorkspaceReversionOptions);
+    /** The observer of one run's file changes and shell commands. */
+    observerFor(runIdArg: string): IToolFileChangeObserver;
+    prepare(contextArg: plugins.IFlexTurnReversionBaseContext<TScope>): void;
+    inspectCapture(contextArg: plugins.IFlexTurnReversionBaseContext<TScope>): plugins.TFlexTurnReversionCaptureInspectionV2;
+    finalize(contextArg: plugins.IFlexTurnReversionBaseContext<TScope>): Promise<plugins.TFlexTurnReversionFinalizedOutcome>;
+    apply(contextArg: plugins.IFlexTurnReversionApplyContext<TScope>): Promise<void>;
+    inspectApply(contextArg: plugins.IFlexTurnReversionApplyContext<TScope>): plugins.IFlexTurnReversionApplyInspection;
+    release(contextArg: plugins.IFlexTurnReversionReleaseContext<TScope>): void;
+    private recordChange;
+    private markNonrevertible;
+    private rollBack;
+    private requirePreparedCapture;
+    private requireCapture;
+    private captureOf;
+}

package/dist_ts_tools_node/classes.workspacereversion.js

@@ -0,0 +1,202 @@
+import * as plugins from './plugins.js';
+import { fileImageBytes, fileImagesEqual, missingAncestors, readFileImage, removeEmptyDirectories, writeFileImage, } from './functions.fileimages.js';
+const DEFAULT_MAX_CAPTURE_BYTES = 64 * 1024 * 1024;
+const isCaptureReference = (valueArg) => !!valueArg
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && typeof valueArg.captureId === 'string';
+/**
+ * Turn reversion for the local filesystem tools, held in memory: FlexHarness `/undo` and `/redo`
+ * move a turn's file changes together with its transcript.
+ *
+ * Give each run's `createLocalToolExecutionContext` the observer `observerFor(context.runId)`. The
+ * first change of a file in a turn records what the file held before; `finalize` records what it
+ * holds after. Undo puts the before images back and redo the after images, each only while every
+ * file still holds what the other direction left, so a later edit of the user is never overwritten.
+ * A turn that ran a shell command is nonrevertible, since the command may have changed files no
+ * observer saw.
+ *
+ * Captures live as long as the process. A capture FlexHarness asks about after a restart is
+ * `missing`, and undoing past it fails without changing anything. Only root-session runs are
+ * captured; a change of a run without a prepared capture is refused.
+ */
+export class InMemoryWorkspaceReversion {
+    protocolVersion = 2;
+    workspace;
+    maxCaptureBytes;
+    captures = new Map();
+    captureIdsByRun = new Map();
+    constructor(optionsArg) {
+        this.workspace = { id: optionsArg.workspace.id, label: optionsArg.workspace.label };
+        this.maxCaptureBytes = optionsArg.maxCaptureBytes ?? DEFAULT_MAX_CAPTURE_BYTES;
+        if (!Number.isSafeInteger(this.maxCaptureBytes) || this.maxCaptureBytes <= 0) {
+            throw new Error('maxCaptureBytes must be a positive integer.');
+        }
+    }
+    /** The observer of one run's file changes and shell commands. */
+    observerFor(runIdArg) {
+        return {
+            beforeFileChange: (changeArg) => this.recordChange(runIdArg, changeArg),
+            beforeShellCommand: () => {
+                this.markNonrevertible(this.requirePreparedCapture(runIdArg), 'shell-command');
+            },
+        };
+    }
+    prepare(contextArg) {
+        contextArg.signal.throwIfAborted();
+        if (this.captures.has(contextArg.captureId))
+            return;
+        this.captures.set(contextArg.captureId, {
+            captureId: contextArg.captureId,
+            runId: contextArg.runId,
+            state: 'prepared',
+            files: new Map(),
+            bytes: 0,
+            appliedOperations: new Set(),
+            uncertainOperations: new Set(),
+        });
+        this.captureIdsByRun.set(contextArg.runId, contextArg.captureId);
+    }
+    inspectCapture(contextArg) {
+        const capture = this.captures.get(contextArg.captureId);
+        if (!capture)
+            return { status: 'missing' };
+        return capture.outcome ? { status: 'finalized', outcome: capture.outcome } : { status: 'prepared' };
+    }
+    async finalize(contextArg) {
+        contextArg.signal.throwIfAborted();
+        const capture = this.requireCapture(contextArg.captureId);
+        if (capture.outcome)
+            return capture.outcome;
+        const reference = { captureId: capture.captureId };
+        if (!capture.nonrevertibleReason) {
+            for (const [filePath, record] of capture.files) {
+                record.after = await readFileImage(filePath);
+                if (fileImagesEqual(record.before, record.after))
+                    capture.files.delete(filePath);
+            }
+        }
+        capture.state = 'finalized';
+        if (capture.nonrevertibleReason) {
+            capture.outcome = {
+                disposition: 'nonrevertible',
+                reference: { ...reference },
+                reasonCode: capture.nonrevertibleReason,
+                affectedWorkspaces: [this.workspace],
+            };
+        }
+        else if (capture.files.size === 0) {
+            capture.outcome = { disposition: 'no-change', reference: { ...reference } };
+        }
+        else {
+            capture.outcome = { disposition: 'revertible', reference: { ...reference }, affectedWorkspaces: [this.workspace] };
+        }
+        this.captureIdsByRun.delete(capture.runId);
+        return capture.outcome;
+    }
+    async apply(contextArg) {
+        contextArg.signal.throwIfAborted();
+        const capture = this.captureOf(contextArg.reference);
+        if (capture.outcome?.disposition !== 'revertible') {
+            throw new Error('This turn has no revertible workspace changes.');
+        }
+        const records = [...capture.files.entries()];
+        const expected = (recordArg) => (contextArg.direction === 'undo' ? recordArg.after : recordArg.before);
+        const target = (recordArg) => (contextArg.direction === 'undo' ? recordArg.before : recordArg.after);
+        for (const [filePath, record] of records) {
+            if (!fileImagesEqual(await readFileImage(filePath), expected(record))) {
+                throw new Error(`"${filePath}" changed after the turn; its changes were not ${contextArg.direction === 'undo' ? 'undone' : 'redone'}.`);
+            }
+        }
+        const written = [];
+        try {
+            for (const entry of records) {
+                await writeFileImage(entry[0], target(entry[1]));
+                written.push(entry);
+            }
+        }
+        catch (error) {
+            await this.rollBack(written, expected, contextArg.operationId, capture);
+            throw error;
+        }
+        if (contextArg.direction === 'undo') {
+            for (const [, record] of records)
+                await removeEmptyDirectories(record.createdDirectories);
+        }
+        capture.appliedOperations.add(contextArg.operationId);
+    }
+    inspectApply(contextArg) {
+        const capture = this.captures.get(isCaptureReference(contextArg.reference) ? contextArg.reference.captureId : '');
+        if (!capture)
+            return { status: 'not-applied' };
+        if (capture.appliedOperations.has(contextArg.operationId))
+            return { status: 'applied' };
+        if (capture.uncertainOperations.has(contextArg.operationId))
+            return { status: 'unknown' };
+        return { status: 'not-applied' };
+    }
+    release(contextArg) {
+        const captureId = isCaptureReference(contextArg.reference) ? contextArg.reference.captureId : contextArg.captureId;
+        const capture = this.captures.get(captureId);
+        if (!capture)
+            return;
+        this.captures.delete(captureId);
+        if (this.captureIdsByRun.get(capture.runId) === captureId)
+            this.captureIdsByRun.delete(capture.runId);
+    }
+    async recordChange(runIdArg, changeArg) {
+        const capture = this.requirePreparedCapture(runIdArg);
+        if (capture.nonrevertibleReason || capture.files.has(changeArg.path))
+            return;
+        const before = await readFileImage(changeArg.path);
+        const createdDirectories = before.kind === 'absent' && changeArg.kind === 'write'
+            ? await missingAncestors(changeArg.path)
+            : [];
+        if (capture.files.has(changeArg.path))
+            return;
+        capture.bytes += fileImageBytes(before);
+        if (capture.bytes > this.maxCaptureBytes) {
+            this.markNonrevertible(capture, 'capture-too-large');
+            return;
+        }
+        capture.files.set(changeArg.path, { before, createdDirectories });
+    }
+    markNonrevertible(captureArg, reasonArg) {
+        captureArg.nonrevertibleReason ??= reasonArg;
+        captureArg.files.clear();
+        captureArg.bytes = 0;
+    }
+    async rollBack(writtenArg, expectedArg, operationIdArg, captureArg) {
+        try {
+            for (const [filePath, record] of writtenArg.reverse())
+                await writeFileImage(filePath, expectedArg(record));
+        }
+        catch {
+            // the workspace holds part of the change; FlexHarness learns that the outcome is unknown
+            captureArg.uncertainOperations.add(operationIdArg);
+        }
+    }
+    requirePreparedCapture(runIdArg) {
+        const captureId = this.captureIdsByRun.get(runIdArg);
+        const capture = captureId ? this.captures.get(captureId) : undefined;
+        if (!capture || capture.state !== 'prepared') {
+            throw new Error(`No workspace capture is open for run "${runIdArg}"; the change was refused.`);
+        }
+        return capture;
+    }
+    requireCapture(captureIdArg) {
+        const capture = this.captures.get(captureIdArg);
+        if (!capture)
+            throw new Error(`The workspace capture "${captureIdArg}" is not held.`);
+        return capture;
+    }
+    captureOf(referenceArg) {
+        if (!isCaptureReference(referenceArg))
+            throw new Error('The workspace capture reference is malformed.');
+        const capture = this.captures.get(referenceArg.captureId);
+        if (!capture)
+            throw new Error('The workspace changes of this turn are no longer held in memory.');
+        return capture;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.workspacereversion.js","sourceRoot":"","sources":["../ts_tools_node/classes.workspacereversion.ts"],"names":[],"mappings":"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"}

package/dist_ts_tools_node/functions.fileimages.d.ts

@@ -0,0 +1,22 @@
+/** What one path holds at a moment: nothing, a regular file, or a symbolic link. */
+export type TFileImage = {
+    kind: 'absent';
+} | {
+    kind: 'file';
+    bytes: Buffer;
+    mode: number;
+} | {
+    kind: 'symlink';
+    target: string;
+};
+/** Reads what the path holds, without following a final symbolic link. */
+export declare const readFileImage: (pathArg: string) => Promise<TFileImage>;
+/** The bytes an image keeps in memory. */
+export declare const fileImageBytes: (imageArg: TFileImage) => number;
+export declare const fileImagesEqual: (leftArg: TFileImage, rightArg: TFileImage) => boolean;
+/** Puts the image at the path, creating parent directories as needed. */
+export declare const writeFileImage: (pathArg: string, imageArg: TFileImage) => Promise<void>;
+/** The ancestors of the path that do not exist yet, deepest first: a write would create them. */
+export declare const missingAncestors: (pathArg: string) => Promise<string[]>;
+/** Removes the directories, deepest first, as far as they are empty. */
+export declare const removeEmptyDirectories: (directoriesArg: readonly string[]) => Promise<void>;

package/dist_ts_tools_node/functions.fileimages.js

@@ -0,0 +1,87 @@
+import * as plugins from './plugins.js';
+const isMissing = (error) => {
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+/** Reads what the path holds, without following a final symbolic link. */
+export const readFileImage = async (pathArg) => {
+    let stats;
+    try {
+        stats = await plugins.fs.promises.lstat(pathArg);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return { kind: 'absent' };
+        throw error;
+    }
+    if (stats.isSymbolicLink())
+        return { kind: 'symlink', target: await plugins.fs.promises.readlink(pathArg) };
+    if (stats.isFile())
+        return { kind: 'file', bytes: await plugins.fs.promises.readFile(pathArg), mode: stats.mode & 0o7777 };
+    throw new Error(`"${pathArg}" is neither a file nor a symbolic link.`);
+};
+/** The bytes an image keeps in memory. */
+export const fileImageBytes = (imageArg) => imageArg.kind === 'file'
+    ? imageArg.bytes.byteLength
+    : imageArg.kind === 'symlink'
+        ? Buffer.byteLength(imageArg.target)
+        : 0;
+export const fileImagesEqual = (leftArg, rightArg) => {
+    if (leftArg.kind === 'absent' || rightArg.kind === 'absent')
+        return leftArg.kind === rightArg.kind;
+    if (leftArg.kind === 'symlink' || rightArg.kind === 'symlink') {
+        return leftArg.kind === 'symlink' && rightArg.kind === 'symlink' && leftArg.target === rightArg.target;
+    }
+    return leftArg.bytes.equals(rightArg.bytes);
+};
+/** Puts the image at the path, creating parent directories as needed. */
+export const writeFileImage = async (pathArg, imageArg) => {
+    if (imageArg.kind === 'absent') {
+        await plugins.fs.promises.rm(pathArg, { force: true });
+        return;
+    }
+    await plugins.fs.promises.mkdir(plugins.path.dirname(pathArg), { recursive: true });
+    if (imageArg.kind === 'symlink') {
+        await plugins.fs.promises.rm(pathArg, { force: true });
+        await plugins.fs.promises.symlink(imageArg.target, pathArg);
+        return;
+    }
+    if ((await readFileImage(pathArg)).kind === 'symlink')
+        await plugins.fs.promises.rm(pathArg);
+    await plugins.fs.promises.writeFile(pathArg, imageArg.bytes);
+    await plugins.fs.promises.chmod(pathArg, imageArg.mode);
+};
+/** The ancestors of the path that do not exist yet, deepest first: a write would create them. */
+export const missingAncestors = async (pathArg) => {
+    const missing = [];
+    let current = plugins.path.dirname(pathArg);
+    while (current !== plugins.path.dirname(current)) {
+        try {
+            await plugins.fs.promises.lstat(current);
+            break;
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+            missing.push(current);
+            current = plugins.path.dirname(current);
+        }
+    }
+    return missing;
+};
+/** Removes the directories, deepest first, as far as they are empty. */
+export const removeEmptyDirectories = async (directoriesArg) => {
+    for (const directory of directoriesArg) {
+        try {
+            await plugins.fs.promises.rmdir(directory);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTEMPTY' || code === 'EEXIST')
+                return;
+            if (!isMissing(error))
+                throw error;
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools_node/index.d.ts

@@ -1,5 +1,7 @@
 export { createLocalToolExecutionContext } from './tool.context.js';
-export type { ILocalToolExecutionContextOptions } from './tool.context.js';
+export type { ILocalToolExecutionContextOptions, IToolFileChange, IToolFileChangeObserver, } from './tool.context.js';
+export { InMemoryWorkspaceReversion } from './classes.workspacereversion.js';
+export type { IInMemoryWorkspaceReversionOptions } from './classes.workspacereversion.js';
 export { FileToolJobStore } from './tool.persistence.js';
 export type { IFileToolJobStoreOptions } from './tool.persistence.js';
 export * from './tools.local.js';

package/dist_ts_tools_node/index.js

@@ -1,4 +1,5 @@
 export { createLocalToolExecutionContext } from './tool.context.js';
+export { InMemoryWorkspaceReversion } from './classes.workspacereversion.js';
 export { FileToolJobStore } from './tool.persistence.js';
 export * from './tools.local.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29sc19ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXBFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELGNBQWMsa0JBQWtCLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190b29sc19ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBTXBFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTdFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRXpELGNBQWMsa0JBQWtCLENBQUMifQ==

package/dist_ts_tools_node/plugins.d.ts

@@ -11,3 +11,4 @@ import { createFilesystemTools, createShellTools } from '@modelprofile.com/flexh
 export { createFilesystemTools, createShellTools };
 export type { ICreateFilesystemToolsOptions, ICreateShellToolsOptions, ToolSet } from '@modelprofile.com/flexharness/tools';
 export type { IBrowserToolInput, IShellCommand, IShellFinishedResult, IShellStartedResult, IToolBrowserContext, IToolBrowserRunOptions, IToolExecutionContext, IToolFilesystemContext, IToolFilesystemListOptions, IToolFilesystemReadOptions, IToolInvocationOptions, IToolJobContext, IToolJobEvent, IToolJobHandle, IToolJobOutputEvent, IToolJobRequest, IToolJobSnapshot, IToolJobState, IToolJobStore, IToolPermissionRequest, IToolRunOptions, IToolShellContext, IToolShellResult, TBrowserToolAction, TToolJobEvent, TToolJobEventListener, } from '@modelprofile.com/flexharness-agent';
+export type { IFlexAffectedWorkspace, IFlexTurnReversionApplyContext, IFlexTurnReversionApplyInspection, IFlexTurnReversionBaseContext, IFlexTurnReversionProviderV2, IFlexTurnReversionReleaseContext, TFlexTurnReversionCaptureInspectionV2, TFlexTurnReversionFinalizedOutcome, TJsonValue, } from '@modelprofile.com/flexharness';

package/dist_ts_tools_node/tool.context.d.ts

@@ -1,4 +1,22 @@
 import type { IToolJobStore, IToolPermissionRequest, IToolJobState, IToolExecutionContext } from './plugins.js';
+/** A file a tool is about to change, named by its canonical path. */
+export interface IToolFileChange {
+    kind: 'write' | 'delete';
+    /**
+     * The canonical absolute path the operation changes. A write follows a symlink to its target; a
+     * delete removes the link itself, so its path is the link's.
+     */
+    path: string;
+}
+/**
+ * Sees every change the local filesystem tools make, after the path checks and before the change,
+ * and every shell command before it starts. A rejection refuses the operation.
+ */
+export interface IToolFileChangeObserver {
+    beforeFileChange(change: IToolFileChange): Promise<void> | void;
+    /** A shell command or background job may change files the observer does not see. */
+    beforeShellCommand(): Promise<void> | void;
+}
 export interface ILocalToolExecutionContextOptions {
     cwd?: string;
     rootDir?: string;
@@ -7,6 +25,8 @@ export interface ILocalToolExecutionContextOptions {
     abortSignal?: AbortSignal;
     /** Guards each local filesystem operation or shell side effect. */
     beforeOperation?: () => Promise<void> | void;
+    /** Observes every file change and shell command, for example to capture a turn for undo. */
+    fileChangeObserver?: IToolFileChangeObserver;
     /** Hard combined stdout/stderr capture limit for each local shell command. Default: 1 MiB. */
     maxShellOutputBytes?: number;
     /** Number of terminal background job snapshots retained for get/list. Default: 100. */