minimal-agent 0.10.0 → 0.12.0

package/src/tools/memory/policy.ts

@@ -0,0 +1,72 @@
+import { hasAskHandler, requestUserChoice } from '../../askBridge.js';
+import type { ToolCallContext, ToolResult } from '../../types.js';
+
+export const EXPLICIT_MEMORY_INTENT =
+  /记住|记下来|保存.{0,8}(?:记忆|偏好|决定)|更新.{0,8}(?:记忆|偏好|决定)|确认.{0,8}(?:记忆|偏好|事实)|remember|save.{0,12}(?:memory|preference|decision)|update.{0,12}(?:memory|preference|decision)|confirm.{0,12}(?:memory|fact)/i;
+export const EXPLICIT_FORGET_INTENT =
+  /忘记|别再记|删除.{0,8}(?:记忆|偏好|决定)|清除.{0,8}(?:记忆|偏好|决定)|forget|delete.{0,12}(?:memory|preference|decision)/i;
+export const EXPLICIT_PERSONA_INTENT =
+  /人格|人设|角色设定|你的(?:语气|风格|性格)|你以后.{0,12}(?:说话|回答|表现)|扮演|persona|your (?:tone|style|personality)|act as/i;
+export const EXPLICIT_CROSS_WORKSPACE_INTENT =
+  /所有(?:项目|工作区)|跨(?:项目|工作区)|其他(?:项目|工作区)|all (?:projects|workspaces)|across (?:projects|workspaces)/i;
+
+export function denyUnlessLocalOwner(
+  ctx: ToolCallContext,
+  access: 'read' | 'write' = 'write',
+): ToolResult | null {
+  const allowed = access === 'read'
+    ? ctx.memoryAccess === 'read-only'
+      || ctx.memoryAccess === 'read-write'
+      || ctx.memoryAccess === 'local-owner'
+    : ctx.memoryAccess === 'read-write' || ctx.memoryAccess === 'local-owner';
+  if (allowed) return null;
+  return {
+    ok: false,
+    error: ctx.memoryAccess === 'read-only'
+      ? '当前本机会话对长期记忆只有读取权限；请交由主 Agent 完成写入'
+      : '当前宿主未获长期记忆访问权限',
+    recovery: 'user-action',
+    sensitivity: 'local',
+  };
+}
+
+export function requireCurrentEvidence(
+  ctx: ToolCallContext,
+  evidenceQuote: string,
+): ToolResult | null {
+  return (ctx.currentUserInput ?? '').includes(evidenceQuote)
+    ? null
+    : {
+        ok: false,
+        error: 'evidenceQuote 不是当前用户消息的逐字片段，拒绝写入推断性记忆',
+      };
+}
+
+export async function confirmSensitiveMemory(
+  statement: string,
+  sensitivity: 'normal' | 'sensitive',
+  signal?: AbortSignal,
+): Promise<'user_stated' | 'user_confirmed' | null> {
+  if (sensitivity === 'normal') return 'user_stated';
+  if (!hasAskHandler()) return null;
+  const [answer] = await requestUserChoice(
+    [
+      {
+        header: '保存记忆',
+        question: `是否把概括后的内容“${statement.slice(0, 120)}”保存为本机长期记忆？`,
+        options: [
+          {
+            label: '不保存（推荐）',
+            description: '继续当前任务，但不写入长期记忆。',
+          },
+          {
+            label: '确认保存',
+            description: '只保存概括；原始敏感证据不会写入 Markdown。',
+          },
+        ],
+      },
+    ],
+    signal,
+  );
+  return answer?.selected.includes('确认保存') ? 'user_confirmed' : null;
+}

package/src/tools/notebook/notebookEdit.js

@@ -0,0 +1,114 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { z } from 'zod';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { fileActivityMetadata } from '../shared/fileActivity.js';
+import { assertFresh, hashFileBytes, recordRead } from '../shared/fileState.js';
+import { emitFileMutation } from '../shared/fileMutationBus.js';
+import { applyLineEnding, atomicWriteFile, encodeTextFile, readTextFile, resolveToolPath } from '../shared/fileUtils.js';
+import { filePathField } from '../shared/schemas.js';
+import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+const inputSchema = z.object({
+    notebook_path: filePathField('编辑').refine((path) => path.toLowerCase().endsWith('.ipynb'), '必须是 .ipynb 文件'),
+    edit_mode: z.enum(['replace', 'insert', 'delete']),
+    cell_id: z.string().min(1).optional().describe('现有 cell.id，或 Read 输出中的 cell-N 标识。insert 时省略会追加到末尾'),
+    new_source: z.string().optional().describe('replace/insert 后的完整单元格源码'),
+    cell_type: z.enum(['code', 'markdown', 'raw']).optional().describe('insert 时必填；replace 时可用于改变类型'),
+}).superRefine((value, ctx) => {
+    if (value.edit_mode !== 'insert' && !value.cell_id)
+        ctx.addIssue({ code: 'custom', path: ['cell_id'], message: 'replace/delete 必须提供 cell_id' });
+    if (value.edit_mode !== 'delete' && value.new_source === undefined)
+        ctx.addIssue({ code: 'custom', path: ['new_source'], message: 'replace/insert 必须提供 new_source' });
+    if (value.edit_mode === 'insert' && !value.cell_type)
+        ctx.addIssue({ code: 'custom', path: ['cell_type'], message: 'insert 必须提供 cell_type' });
+});
+function sourceLines(source) {
+    const parts = source.match(/.*(?:\r\n|\n|\r)|.+$/g) ?? [];
+    return parts.length > 0 ? parts : [''];
+}
+function findCellIndex(cells, id) {
+    const exact = cells.findIndex((cell) => cell.id === id);
+    if (exact >= 0)
+        return exact;
+    const numbered = /^cell-(\d+)$/.exec(id);
+    return numbered ? Number(numbered[1]) - 1 : -1;
+}
+async function call(input, state, cwd) {
+    const resolved = resolveToolPath(input.notebook_path, cwd);
+    if (!resolved.ok)
+        return resolved;
+    const path = resolved.resolvedPath;
+    if (!existsSync(path))
+        return { ok: false, error: `Notebook 不存在：${path}` };
+    const freshness = assertFresh(path, {}, state);
+    if (!freshness.ok)
+        return { ok: false, error: freshness.error };
+    try {
+        const snapshot = await readTextFile(path);
+        const notebook = JSON.parse(snapshot.content);
+        if (!Array.isArray(notebook.cells))
+            return { ok: false, error: `${path} 不是有效的 Jupyter Notebook：缺少 cells 数组` };
+        let targetIndex = notebook.cells.length;
+        if (input.cell_id) {
+            targetIndex = findCellIndex(notebook.cells, input.cell_id);
+            if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+                return { ok: false, error: `找不到单元格 ${input.cell_id}。请重新 Read Notebook 获取最新 cell ID。` };
+            }
+        }
+        if (input.edit_mode === 'delete') {
+            notebook.cells.splice(targetIndex, 1);
+        }
+        else if (input.edit_mode === 'replace') {
+            const oldCell = notebook.cells[targetIndex];
+            const nextType = input.cell_type ?? oldCell.cell_type;
+            notebook.cells[targetIndex] = {
+                ...oldCell,
+                cell_type: nextType,
+                source: sourceLines(input.new_source),
+                ...(nextType === 'code' ? { outputs: [], execution_count: null } : {}),
+            };
+            if (nextType !== 'code') {
+                delete notebook.cells[targetIndex].outputs;
+                delete notebook.cells[targetIndex].execution_count;
+            }
+        }
+        else {
+            const cell = {
+                id: randomUUID().replaceAll('-', '').slice(0, 8),
+                cell_type: input.cell_type,
+                metadata: {},
+                source: sourceLines(input.new_source),
+                ...(input.cell_type === 'code' ? { outputs: [], execution_count: null } : {}),
+            };
+            const insertionIndex = input.cell_id ? targetIndex : notebook.cells.length;
+            notebook.cells.splice(insertionIndex, 0, cell);
+            targetIndex = insertionIndex;
+        }
+        const indent = /^(\s+)"/.exec(snapshot.content.split(/\r?\n/)[1] ?? '')?.[1]?.length ?? 2;
+        let output = JSON.stringify(notebook, null, Math.max(1, Math.min(indent, 4))) + '\n';
+        output = applyLineEnding(output, snapshot.lineEnding);
+        await atomicWriteFile(path, output, snapshot.encoding);
+        recordRead(path, { contentHash: hashFileBytes(encodeTextFile(output, snapshot.encoding)) }, state);
+        emitFileMutation(path);
+        return {
+            ok: true,
+            content: `${input.edit_mode === 'insert' ? '已插入' : input.edit_mode === 'delete' ? '已删除' : '已更新'} Notebook 单元格（位置 ${targetIndex + 1}）：${path}`,
+            metadata: await fileActivityMetadata(path, 'modified', 'not_run', 'support', cwd),
+        };
+    }
+    catch (error) {
+        return { ok: false, error: `Notebook 编辑失败：${error.message}` };
+    }
+}
+export const notebookEditTool = {
+    name: 'NotebookEdit',
+    description: 'Edits one Jupyter Notebook cell without rewriting cells manually. Use Read first to inspect cell IDs. Replace clears stale code outputs; insert creates a stable cell ID; delete removes only the selected cell.',
+    inputSchema,
+    parameters: toToolParameters(inputSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+    interruptBehavior: () => 'block',
+    call: (input) => call(input),
+    callWithContext: (input, _signal, context) => call(input, context.sessionState?.fileReads, context.cwd),
+};

package/src/tools/notebook/notebookEdit.ts

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { z } from 'zod';
+
+import type { Tool, ToolCallContext, ToolResult } from '../../types.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { fileActivityMetadata } from '../shared/fileActivity.js';
+import { assertFresh, hashFileBytes, recordRead, type FileReadState } from '../shared/fileState.js';
+import { emitFileMutation } from '../shared/fileMutationBus.js';
+import { applyLineEnding, atomicWriteFile, encodeTextFile, readTextFile, resolveToolPath } from '../shared/fileUtils.js';
+import { filePathField } from '../shared/schemas.js';
+import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+
+type NotebookCell = {
+  id?: string;
+  cell_type: 'code' | 'markdown' | 'raw';
+  source: string | string[];
+  metadata?: Record<string, unknown>;
+  outputs?: unknown[];
+  execution_count?: number | null;
+  [key: string]: unknown;
+};
+type Notebook = { cells: NotebookCell[]; [key: string]: unknown };
+
+const inputSchema = z.object({
+  notebook_path: filePathField('编辑').refine((path) => path.toLowerCase().endsWith('.ipynb'), '必须是 .ipynb 文件'),
+  edit_mode: z.enum(['replace', 'insert', 'delete']),
+  cell_id: z.string().min(1).optional().describe('现有 cell.id，或 Read 输出中的 cell-N 标识。insert 时省略会追加到末尾'),
+  new_source: z.string().optional().describe('replace/insert 后的完整单元格源码'),
+  cell_type: z.enum(['code', 'markdown', 'raw']).optional().describe('insert 时必填；replace 时可用于改变类型'),
+}).superRefine((value, ctx) => {
+  if (value.edit_mode !== 'insert' && !value.cell_id) ctx.addIssue({ code: 'custom', path: ['cell_id'], message: 'replace/delete 必须提供 cell_id' });
+  if (value.edit_mode !== 'delete' && value.new_source === undefined) ctx.addIssue({ code: 'custom', path: ['new_source'], message: 'replace/insert 必须提供 new_source' });
+  if (value.edit_mode === 'insert' && !value.cell_type) ctx.addIssue({ code: 'custom', path: ['cell_type'], message: 'insert 必须提供 cell_type' });
+});
+type NotebookEditInput = z.infer<typeof inputSchema>;
+
+function sourceLines(source: string): string[] {
+  const parts = source.match(/.*(?:\r\n|\n|\r)|.+$/g) ?? [];
+  return parts.length > 0 ? parts : [''];
+}
+
+function findCellIndex(cells: NotebookCell[], id: string): number {
+  const exact = cells.findIndex((cell) => cell.id === id);
+  if (exact >= 0) return exact;
+  const numbered = /^cell-(\d+)$/.exec(id);
+  return numbered ? Number(numbered[1]) - 1 : -1;
+}
+
+async function call(input: NotebookEditInput, state?: FileReadState, cwd?: string): Promise<ToolResult> {
+  const resolved = resolveToolPath(input.notebook_path, cwd);
+  if (!resolved.ok) return resolved;
+  const path = resolved.resolvedPath;
+  if (!existsSync(path)) return { ok: false, error: `Notebook 不存在：${path}` };
+  const freshness = assertFresh(path, {}, state);
+  if (!freshness.ok) return { ok: false, error: freshness.error };
+
+  try {
+    const snapshot = await readTextFile(path);
+    const notebook = JSON.parse(snapshot.content) as Notebook;
+    if (!Array.isArray(notebook.cells)) return { ok: false, error: `${path} 不是有效的 Jupyter Notebook：缺少 cells 数组` };
+
+    let targetIndex = notebook.cells.length;
+    if (input.cell_id) {
+      targetIndex = findCellIndex(notebook.cells, input.cell_id);
+      if (targetIndex < 0 || targetIndex >= notebook.cells.length) {
+        return { ok: false, error: `找不到单元格 ${input.cell_id}。请重新 Read Notebook 获取最新 cell ID。` };
+      }
+    }
+
+    if (input.edit_mode === 'delete') {
+      notebook.cells.splice(targetIndex, 1);
+    } else if (input.edit_mode === 'replace') {
+      const oldCell = notebook.cells[targetIndex]!;
+      const nextType = input.cell_type ?? oldCell.cell_type;
+      notebook.cells[targetIndex] = {
+        ...oldCell,
+        cell_type: nextType,
+        source: sourceLines(input.new_source!),
+        ...(nextType === 'code' ? { outputs: [], execution_count: null } : {}),
+      };
+      if (nextType !== 'code') {
+        delete notebook.cells[targetIndex]!.outputs;
+        delete notebook.cells[targetIndex]!.execution_count;
+      }
+    } else {
+      const cell: NotebookCell = {
+        id: randomUUID().replaceAll('-', '').slice(0, 8),
+        cell_type: input.cell_type!,
+        metadata: {},
+        source: sourceLines(input.new_source!),
+        ...(input.cell_type === 'code' ? { outputs: [], execution_count: null } : {}),
+      };
+      const insertionIndex = input.cell_id ? targetIndex : notebook.cells.length;
+      notebook.cells.splice(insertionIndex, 0, cell);
+      targetIndex = insertionIndex;
+    }
+
+    const indent = /^(\s+)"/.exec(snapshot.content.split(/\r?\n/)[1] ?? '')?.[1]?.length ?? 2;
+    let output = JSON.stringify(notebook, null, Math.max(1, Math.min(indent, 4))) + '\n';
+    output = applyLineEnding(output, snapshot.lineEnding);
+    await atomicWriteFile(path, output, snapshot.encoding);
+    recordRead(path, { contentHash: hashFileBytes(encodeTextFile(output, snapshot.encoding)) }, state);
+    emitFileMutation(path);
+    return {
+      ok: true,
+      content: `${input.edit_mode === 'insert' ? '已插入' : input.edit_mode === 'delete' ? '已删除' : '已更新'} Notebook 单元格（位置 ${targetIndex + 1}）：${path}`,
+      metadata: await fileActivityMetadata(path, 'modified', 'not_run', 'support', cwd),
+    };
+  } catch (error) {
+    return { ok: false, error: `Notebook 编辑失败：${(error as Error).message}` };
+  }
+}
+
+export const notebookEditTool: Tool<NotebookEditInput> = {
+  name: 'NotebookEdit',
+  description: 'Edits one Jupyter Notebook cell without rewriting cells manually. Use Read first to inspect cell IDs. Replace clears stale code outputs; insert creates a stable cell ID; delete removes only the selected cell.',
+  inputSchema,
+  parameters: toToolParameters(inputSchema),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+  interruptBehavior: () => 'block',
+  call: (input) => call(input),
+  callWithContext: (input, _signal, context: ToolCallContext) => call(input, context.sessionState?.fileReads, context.cwd),
+};

package/src/tools/powershell/powershell.js

@@ -0,0 +1,210 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { z } from 'zod';
+import { requestUserChoice } from '../../askBridge.js';
+import { getWorkingDir } from '../../bootstrap/workingDir.js';
+import { classifyCommand } from '../../irreversible/rules.js';
+import { toToolParameters } from '../../utils/zodToJson.js';
+import { checkForbidden, sanitizedChildEnv } from '../bash/bash.js';
+import { killTree } from '../shared/killTree.js';
+import { startBackgroundTask } from '../tasks/backgroundTaskService.js';
+import { processExecutionMetadata } from '../tasks/processEvidence.js';
+import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
+import { ToolOutputStore } from '../shared/toolOutputStore.js';
+const MAX_TIMEOUT_MS = 600_000;
+function findPowerShell() {
+    if (process.platform !== 'win32')
+        return undefined;
+    const explicit = process.env.MINIMAL_AGENT_POWERSHELL_PATH;
+    if (explicit && existsSync(explicit))
+        return explicit;
+    for (const name of ['pwsh.exe', 'powershell.exe']) {
+        for (const dir of (process.env.PATH ?? '').split(delimiter)) {
+            const path = join(dir, name);
+            if (existsSync(path))
+                return path;
+        }
+    }
+    const system = join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+    return existsSync(system) ? system : undefined;
+}
+const inputSchema = z.object({
+    command: z.string().min(1),
+    timeout: z.number().int().positive().max(MAX_TIMEOUT_MS).optional(),
+    description: z.string().optional(),
+    run_in_background: z.boolean().optional(),
+});
+function invocation(command) {
+    return [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`,
+    ];
+}
+async function approved(command, signal) {
+    const permanentDelete = permanentDeleteReason(command, 'powershell');
+    if (permanentDelete)
+        return {
+            ok: false,
+            error: `永久删除检查拒绝执行：${permanentDelete}\n命令：${command}`,
+        };
+    const forbidden = checkForbidden(command);
+    if (forbidden)
+        return {
+            ok: false,
+            error: `安全检查拒绝执行：${forbidden}\n命令：${command}`,
+        };
+    const irreversible = classifyCommand(command);
+    if (!irreversible)
+        return undefined;
+    const [answer] = await requestUserChoice([
+        {
+            question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`,
+            header: '不可逆操作',
+            options: [
+                { label: '取消，不执行 (推荐)', description: '放弃并改用可回滚做法' },
+                { label: '我已确认后果，执行', description: '继续执行不可逆操作' },
+            ],
+        },
+    ], signal);
+    return answer?.selected?.[0]?.includes('执行') &&
+        !answer.selected[0]?.includes('取消')
+        ? undefined
+        : { ok: false, error: `已拒绝执行不可逆 PowerShell 命令：${command}` };
+}
+async function call(input, signal, context) {
+    const executable = findPowerShell();
+    if (!executable)
+        return { ok: false, error: '当前宿主没有可用的 PowerShell' };
+    const refusal = await approved(input.command, signal);
+    if (refusal)
+        return refusal;
+    const args = invocation(input.command);
+    const cwd = context?.cwd ?? getWorkingDir();
+    if (input.run_in_background) {
+        try {
+            const task = await startBackgroundTask({
+                command: input.command,
+                executable,
+                args,
+                cwd,
+                env: sanitizedChildEnv(),
+                sessionId: context?.sessionId,
+                workspaceId: context?.workspaceId,
+                shellKind: 'powershell',
+            }, context?.sessionState?.backgroundTasks);
+            return {
+                ok: true,
+                content: `PowerShell 后台任务已启动。task_id=${task.id.replace(/^proc_/, '')}\nprocess_id=${task.id}\nlog=${task.logPath}`,
+                metadata: processExecutionMetadata({
+                    shell: 'powershell',
+                    mode: 'background',
+                    command: input.command,
+                    status: 'started',
+                    taskId: task.id,
+                }),
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: `PowerShell 后台任务启动失败：${error.message}`,
+            };
+        }
+    }
+    return await new Promise((resolvePromise) => {
+        const child = spawn(executable, args, {
+            cwd,
+            env: sanitizedChildEnv(),
+            windowsHide: true,
+            detached: false,
+        });
+        let finished = false;
+        const store = new ToolOutputStore({
+            workspaceId: context?.workspaceId,
+            sessionId: context?.sessionId,
+        });
+        const finish = async (status, code, prefix = '') => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            const output = await store.finish();
+            const reference = output.path
+                ? `\n[完整输出: ${output.path}; bytes=${output.bytes}; sha256=${output.sha256}; complete=${output.complete}]`
+                : '';
+            let text = `${prefix}${output.stdout ? `<stdout>\n${output.stdout.trimEnd()}\n</stdout>\n` : ''}${output.stderr ? `<stderr>\n${output.stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code ?? 'killed'}]`;
+            if (text.length + reference.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+                const suffix = `\n... (输出预览已截断)${reference}`;
+                text =
+                    text.slice(0, Math.max(0, DEFAULT_MAX_RESULT_SIZE_CHARS - suffix.length)) + suffix;
+            }
+            else
+                text += reference;
+            const metadata = processExecutionMetadata({
+                shell: 'powershell',
+                mode: 'foreground',
+                command: input.command,
+                status,
+                exitCode: code,
+            });
+            resolvePromise(status === 'completed'
+                ? { ok: true, content: text, metadata }
+                : { ok: false, error: text, metadata });
+        };
+        const abort = () => {
+            killTree(child);
+            void finish('stopped', null, 'PowerShell 命令被中断\n');
+        };
+        const timeout = input.timeout ?? 120_000;
+        const timer = setTimeout(() => {
+            killTree(child);
+            void finish('failed', null, `PowerShell 命令超时（${timeout}ms）\n`);
+        }, timeout);
+        signal?.addEventListener('abort', abort, { once: true });
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            if (!store.append('stdout', chunk)) {
+                child.stdout?.pause();
+                store.onDrain(() => child.stdout?.resume());
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            if (!store.append('stderr', chunk)) {
+                child.stderr?.pause();
+                store.onDrain(() => child.stderr?.resume());
+            }
+        });
+        child.once('error', (error) => {
+            void finish('failed', null, `PowerShell 启动失败：${error.message}\n`);
+        });
+        child.once('close', (code) => {
+            void finish(code === 0 ? 'completed' : 'failed', code);
+        });
+    });
+}
+export const powerShellTool = {
+    name: 'PowerShell',
+    description: 'Executes native PowerShell on Windows. Use for Windows-specific administration and scripts; use run_in_background for long builds, tests, or servers, then TaskOutput/TaskStop.',
+    inputSchema,
+    parameters: toToolParameters(inputSchema),
+    isReadOnly: false,
+    isConcurrencySafe: false,
+    maxResultSizeChars: DEFAULT_MAX_RESULT_SIZE_CHARS,
+    interruptBehavior: () => 'block',
+    resolveAvailability: () => {
+        const executable = findPowerShell();
+        return {
+            available: Boolean(executable),
+            signature: executable ?? 'unavailable',
+        };
+    },
+    call: (input, signal) => call(input, signal),
+    callWithContext: (input, signal, context) => call(input, signal, context),
+};