march-cli 0.1.12 → 0.1.14

package/src/agent/runtime/runner-process-client.mjs

@@ -0,0 +1,47 @@
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createProcessRuntimeIpcPeer } from "./ipc/process-ipc-transport.mjs";
+import { createRemoteRunnerClient } from "./remote-runner-client.mjs";
+import { createRuntimeUiEventTarget } from "./ui-event-bridge.mjs";
+
+const DEFAULT_ENTRY = new URL("./runner-process-entry.mjs", import.meta.url);
+
+export async function createRunnerProcessClient({
+  runnerOptions,
+  ui,
+  onModelPayload = null,
+  entry = fileURLToPath(DEFAULT_ENTRY),
+  forkImpl = fork,
+  timeoutMs = 0,
+} = {}) {
+  const child = forkImpl(entry, [], {
+    stdio: ["ignore", "inherit", "inherit", "ipc"],
+  });
+  const peer = createProcessRuntimeIpcPeer({
+    processLike: child,
+    target: {
+      ...createRuntimeUiEventTarget(ui),
+      modelPayload: (event) => onModelPayload?.(event),
+    },
+    timeoutMs,
+  });
+  const runner = createRemoteRunnerClient(peer);
+  try {
+    await runner.init(runnerOptions);
+  } catch (error) {
+    peer.dispose();
+    child.kill?.();
+    throw error;
+  }
+
+  const remoteDispose = runner.dispose;
+  const dispose = async () => {
+    try {
+      await remoteDispose.call(runner);
+    } finally {
+      child.kill?.();
+    }
+  };
+  runner.dispose = dispose;
+  return { runner, child, dispose };
+}

package/src/agent/runtime/runner-process-entry.mjs

@@ -0,0 +1,93 @@
+import { join } from "node:path";
+import { createRunner } from "../runner.mjs";
+import { createProcessRuntimeIpcPeer } from "./ipc/process-ipc-transport.mjs";
+import { createRemoteRuntimeUiClient } from "./remote-ui-client.mjs";
+import { createRunnerIpcTarget } from "./runner-ipc-target.mjs";
+import { createMarchAuthStorage } from "../../auth/storage.mjs";
+import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
+import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
+import { createMarkdownMemoryTools } from "../../memory/markdown-tools.mjs";
+import { initializeMcp } from "../../mcp/index.mjs";
+import { createWebToolsFromConfig } from "../../web/tools.mjs";
+import { createPermissionController } from "../../cli/permissions.mjs";
+import { resolvePiSessionManager } from "../../session/pi-manager.mjs";
+import { createModelContextDumper } from "../../debug/model-context-dumper.mjs";
+import { createLogger, installProcessLogHandlers } from "../../debug/logger.mjs";
+import { createDesktopTurnNotifier } from "../../notification/desktop-notifier.mjs";
+
+const peer = createProcessRuntimeIpcPeer({
+  target: createRunnerIpcTarget({ createRunnerImpl: createIsolatedRunner }),
+});
+
+process.once("disconnect", () => peer.dispose());
+
+async function createIsolatedRunner(options = {}) {
+  const ui = createRemoteRuntimeUiClient(peer);
+  const memoryStore = new MarkdownMemoryStore({ root: options.memoryRoot });
+  const memoryTools = createMarkdownMemoryTools(memoryStore);
+  const shellRuntime = options.shellRuntime ? createCliShellRuntime({ cwd: options.cwd }) : null;
+  const mcpInit = await initializeMcp({ projectDir: options.cwd });
+  const logger = createLogger({ logDir: options.logDir ?? (options.stateRoot ? join(options.stateRoot, "logs") : undefined) });
+  installProcessLogHandlers(logger);
+
+  const runner = await createRunner({
+    cwd: options.cwd,
+    modelId: options.modelId,
+    provider: options.provider,
+    serviceTier: options.serviceTier,
+    providers: options.providers,
+    stateRoot: options.stateRoot,
+    ui,
+    memoryRoot: options.memoryRoot,
+    profilePaths: options.profilePaths,
+    memoryStore,
+    memoryTools,
+    shellRuntime,
+    mcpTools: mcpInit.mcpTools,
+    mcpInjections: mcpInit.mcpInjections,
+    mcpClientManager: mcpInit.clientManager,
+    webTools: createWebToolsFromConfig(options.config ?? {}),
+    namespace: options.namespace,
+    projectMarchDir: options.projectMarchDir,
+    extensionPaths: options.extensionPaths ?? [],
+    sessionManager: resolvePiSessionManager({
+      cwd: options.cwd,
+      projectMarchDir: options.projectMarchDir,
+      enabled: true,
+    }),
+    useRuntimeHost: true,
+    syncPiSidecar: true,
+    lifecycleHooks: options.lifecycleHooks ?? [],
+    lifecycleDiagnostics: options.lifecycleDiagnostics ?? [],
+    authStorage: createMarchAuthStorage({
+      provider: options.provider ?? "deepseek",
+      providers: options.providers,
+      cwd: options.cwd,
+    }).authStorage,
+    maxTurns: options.config?.maxTurns ?? undefined,
+    trimBatch: options.config?.trimBatch ?? undefined,
+    hostedTools: options.config?.hostedTools,
+    permissionController: createPermissionController({ mode: options.permissionMode }),
+    modelContextDumper: createModelContextDumper(options.modelContextDumper ?? { enabled: false }),
+    turnNotifier: createDesktopTurnNotifier({
+      enabled: Boolean(options.config?.notifications?.turnEnd),
+      config: options.config?.notifications,
+    }),
+    logger,
+    onModelPayload: (event) => peer.notify("modelPayload", pickModelPayloadEvent(event)),
+  });
+
+  const originalDispose = runner.dispose;
+  runner.dispose = async () => {
+    try {
+      await originalDispose.call(runner);
+    } finally {
+      memoryStore.close?.();
+    }
+  };
+  return runner;
+}
+
+function pickModelPayloadEvent({ estimatedTokens, provider, model, kind, turnId } = {}) {
+  return { estimatedTokens, provider, model, kind, turnId };
+}

package/src/agent/runtime/runner-runtime-host.mjs

@@ -62,6 +62,7 @@ export async function createRunnerRuntimeHost({
         authStorage,
         projectMarchDir,
         hostedTools,
+        getCurrentModel: () => sessionBinding.get()?.model ?? null,
       });
     },
   });

package/src/agent/runtime/ui-event-bridge.mjs

@@ -0,0 +1,85 @@
+export function createRuntimeUiEventTarget(ui) {
+  return {
+    uiEvent: (event) => dispatchRuntimeUiEvent(ui, event),
+    uiRequest: (event) => dispatchRuntimeUiEvent(ui, event),
+  };
+}
+
+export function createRuntimeUiEventBus() {
+  const listeners = new Set();
+  return {
+    on(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(event) {
+      for (const listener of [...listeners]) listener(event);
+    },
+    async request(event) {
+      let response;
+      for (const listener of [...listeners]) {
+        const result = await listener(event);
+        if (response === undefined && result !== undefined) response = result;
+      }
+      return response;
+    },
+  };
+}
+
+export function createRuntimeUiBridge(ui, { eventBus = createRuntimeUiEventBus() } = {}) {
+  const detach = eventBus.on((event) => dispatchRuntimeUiEvent(ui, event));
+  return {
+    ui: createRuntimeUiClient(eventBus),
+    eventBus,
+    detach,
+  };
+}
+
+export function createRuntimeUiClient(eventBus) {
+  return {
+    turnStart: () => eventBus.emit({ type: "turn_start" }),
+    turnEnd: () => eventBus.emit({ type: "turn_end" }),
+    assistantReplyEnd: () => eventBus.emit({ type: "assistant_reply_end" }),
+    textDelta: (delta) => eventBus.emit({ type: "text_delta", delta }),
+    thinkingStart: () => eventBus.emit({ type: "thinking_start" }),
+    thinkingDelta: (delta) => eventBus.emit({ type: "thinking_delta", delta }),
+    thinkingEnd: (tokens) => eventBus.emit({ type: "thinking_end", tokens }),
+    toolStart: (name, args) => eventBus.emit({ type: "tool_start", name, args }),
+    toolEnd: (name, isError, result) => eventBus.emit({ type: "tool_end", name, isError, result }),
+    retryStart: (event) => eventBus.emit({ type: "retry_start", ...event }),
+    retryEnd: (event) => eventBus.emit({ type: "retry_end", ...event }),
+    status: (text) => eventBus.emit({ type: "status", text }),
+    memoryHint: ({ source, hints }) => eventBus.emit({ type: "memory_hint", source, hints }),
+    editDiff: (path, diffLines) => eventBus.emit({ type: "edit_diff", path, diffLines }),
+    requestPermission: (request) => eventBus.request({ type: "permission_request", ...request }),
+  };
+}
+
+export function dispatchRuntimeUiEvent(ui, event) {
+  switch (event.type) {
+    case "turn_start": return ui.turnStart?.();
+    case "turn_end": return ui.turnEnd?.();
+    case "assistant_reply_end": return ui.assistantReplyEnd?.();
+    case "text_delta": return ui.textDelta?.(event.delta);
+    case "thinking_start": return ui.thinkingStart?.();
+    case "thinking_delta": return ui.thinkingDelta?.(event.delta);
+    case "thinking_end": return ui.thinkingEnd?.(event.tokens);
+    case "tool_start": return ui.toolStart?.(event.name, event.args);
+    case "tool_end": return ui.toolEnd?.(event.name, event.isError, event.result);
+    case "retry_start": return ui.retryStart?.(pickRetryStart(event));
+    case "retry_end": return ui.retryEnd?.(pickRetryEnd(event));
+    case "status": return ui.status?.(event.text);
+    case "memory_hint": return ui.memoryHint?.({ source: event.source, hints: event.hints });
+    case "edit_diff": return ui.editDiff?.(event.path, event.diffLines);
+    case "permission_request": return ui.requestPermission?.({ toolName: event.toolName, params: event.params, category: event.category });
+    default: return undefined;
+  }
+}
+
+function pickRetryStart({ attempt, maxAttempts, delayMs, errorMessage }) {
+  return { attempt, maxAttempts, delayMs, errorMessage };
+}
+
+function pickRetryEnd({ success, attempt, finalError }) {
+  return { success, attempt, finalError };
+}

package/src/agent/screen-tools/list-windows-tool.mjs

@@ -0,0 +1,39 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { listWindowsWindows } from "./windows-screen.mjs";
+
+export function createListWindowsTool({ listWindowsImpl = listWindowsWindows } = {}) {
+  return defineTool({
+    name: "list_windows",
+    label: "List Windows",
+    description: "List visible desktop windows so the model can choose a windowId for screen({ target: 'window', windowId }).",
+    parameters: Type.Object({
+      limit: Type.Optional(Type.Number({ description: "Maximum windows to return; default 30" })),
+    }),
+    execute: async (_toolCallId, params = {}) => listWindowsTool({ listWindowsImpl, ...params }),
+  });
+}
+
+export function listWindowsTool({ listWindowsImpl = listWindowsWindows, limit = 30 } = {}) {
+  const result = listWindowsImpl();
+  if (!result?.ok) return textResult(`Error listing windows: ${result?.message || "unknown error"}`, { error: true });
+  const windows = (result.windows ?? []).slice(0, normalizeLimit(limit));
+  if (windows.length === 0) return textResult("No visible windows found.", { windows: [] });
+  const lines = ["Visible windows:"];
+  for (const item of windows) {
+    const process = item.process ? ` (${item.process})` : "";
+    const bounds = item.bounds ? ` ${item.bounds.width}x${item.bounds.height}+${item.bounds.x},${item.bounds.y}` : "";
+    const minimized = item.minimized ? " minimized" : "";
+    lines.push(`- ${item.id}${process}${bounds}${minimized}: ${item.title}`);
+  }
+  lines.push("Use screen({ target: 'window', windowId }) to capture a listed window.");
+  return textResult(lines.join("\n"), { windows });
+}
+
+function normalizeLimit(limit) {
+  return Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), 100) : 30;
+}
+
+function textResult(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}

package/src/agent/screen-tools/screen-tool.mjs

@@ -0,0 +1,49 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { currentModelImageInputError } from "../vision-capability.mjs";
+import { captureScreenWindows } from "./windows-screen.mjs";
+
+export function createScreenTool({ getCurrentModel = null, captureScreenImpl = captureScreenWindows } = {}) {
+  return defineTool({
+    name: "screen",
+    label: "Screen Capture",
+    description: "Capture the current desktop or a visible window and send it to the model as an image attachment.",
+    parameters: Type.Object({
+      target: Type.Optional(Type.String({ description: "desktop (default) or window" })),
+      windowId: Type.Optional(Type.String({ description: "Window id from list_windows when target is window" })),
+    }),
+    execute: async (_toolCallId, params = {}) => captureScreenTool({ getCurrentModel, captureScreenImpl, ...params }),
+  });
+}
+
+export function captureScreenTool({ getCurrentModel = null, captureScreenImpl = captureScreenWindows, target = "desktop", windowId = null } = {}) {
+  const capabilityError = currentModelImageInputError(getCurrentModel);
+  if (capabilityError) return screenError(capabilityError, { unsupportedModel: true });
+  const normalizedTarget = target === "window" ? "window" : "desktop";
+  const result = captureScreenImpl({ target: normalizedTarget, windowId });
+  if (!result?.ok) return screenError(`Error capturing screen: ${result?.message || "unknown error"}`, { target: normalizedTarget, windowId });
+
+  const bounds = result.bounds ?? {};
+  const label = normalizedTarget === "window" ? `window ${result.windowId || windowId}` : "desktop";
+  return {
+    content: [
+      { type: "text", text: `Captured ${label} screenshot\nMIME: ${result.mimeType || "image/png"}\nBounds: ${formatBounds(bounds)}` },
+      { type: "image", data: result.data, mimeType: result.mimeType || "image/png" },
+    ],
+    details: {
+      target: normalizedTarget,
+      windowId: result.windowId ?? windowId ?? undefined,
+      bounds,
+      mimeType: result.mimeType || "image/png",
+    },
+  };
+}
+
+function screenError(text, details = {}) {
+  return { content: [{ type: "text", text }], details: { ...details, error: true } };
+}
+
+function formatBounds(bounds) {
+  const { x = 0, y = 0, width = 0, height = 0 } = bounds ?? {};
+  return `${width}x${height} at ${x},${y}`;
+}

package/src/agent/screen-tools/windows-screen.mjs

@@ -0,0 +1,133 @@
+import { execFileSync } from "node:child_process";
+
+const POWERSHELL = process.env.SystemRoot ? `${process.env.SystemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe` : "powershell.exe";
+const MAX_BUFFER = 80 * 1024 * 1024;
+
+export function listWindowsWindows() {
+  return runJson(LIST_WINDOWS_SCRIPT);
+}
+
+export function captureScreenWindows({ target = "desktop", windowId = null } = {}) {
+  if (target === "window") {
+    if (!windowId) return { ok: false, message: "windowId is required when target is window" };
+    return runJson(CAPTURE_WINDOW_SCRIPT.replace("__WINDOW_ID__", escapePowershellString(windowId)));
+  }
+  return runJson(CAPTURE_DESKTOP_SCRIPT);
+}
+
+function runJson(script) {
+  if (process.platform !== "win32") return { ok: false, message: `screen tools are not supported on ${process.platform}` };
+  try {
+    const output = execFileSync(POWERSHELL, ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+      encoding: "utf8",
+      maxBuffer: MAX_BUFFER,
+      windowsHide: true,
+    }).trim();
+    return JSON.parse(output);
+  } catch (err) {
+    return { ok: false, message: `failed to run Windows screen capture: ${err.stderr || err.message}` };
+  }
+}
+
+function escapePowershellString(value) {
+  return String(value).replaceAll("'", "''");
+}
+
+const WIN32_TYPE = String.raw`
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+public static class MarchWin32 {
+  public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+  [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+  [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr hWnd);
+}
+`;
+
+const LIST_WINDOWS_SCRIPT = String.raw`
+Add-Type -TypeDefinition @'
+${WIN32_TYPE}
+'@
+$items = New-Object System.Collections.Generic.List[object]
+[MarchWin32]::EnumWindows({ param($hwnd, $lparam)
+  if (-not [MarchWin32]::IsWindowVisible($hwnd)) { return $true }
+  $length = [MarchWin32]::GetWindowTextLength($hwnd)
+  if ($length -le 0) { return $true }
+  $builder = New-Object System.Text.StringBuilder ($length + 1)
+  [void][MarchWin32]::GetWindowText($hwnd, $builder, $builder.Capacity)
+  $rect = New-Object MarchWin32+RECT
+  if (-not [MarchWin32]::GetWindowRect($hwnd, [ref]$rect)) { return $true }
+  $width = $rect.Right - $rect.Left
+  $height = $rect.Bottom - $rect.Top
+  if ($width -le 0 -or $height -le 0) { return $true }
+  $pidValue = 0
+  [void][MarchWin32]::GetWindowThreadProcessId($hwnd, [ref]$pidValue)
+  $processName = $null
+  try { $processName = (Get-Process -Id $pidValue -ErrorAction Stop).ProcessName } catch {}
+  $items.Add([ordered]@{
+    id = ("0x{0:x}" -f $hwnd.ToInt64())
+    title = $builder.ToString()
+    process = $processName
+    pid = $pidValue
+    bounds = [ordered]@{ x = $rect.Left; y = $rect.Top; width = $width; height = $height }
+    minimized = [MarchWin32]::IsIconic($hwnd)
+  }) | Out-Null
+  return $true
+}, [IntPtr]::Zero) | Out-Null
+[ordered]@{ ok = $true; windows = $items } | ConvertTo-Json -Compress -Depth 5
+`;
+
+const CAPTURE_DESKTOP_SCRIPT = String.raw`
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$bounds = [System.Windows.Forms.SystemInformation]::VirtualScreen
+$bitmap = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+$graphics.CopyFromScreen($bounds.Left, $bounds.Top, 0, 0, $bounds.Size)
+$stream = New-Object System.IO.MemoryStream
+$bitmap.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+$graphics.Dispose(); $bitmap.Dispose()
+[ordered]@{
+  ok = $true; data = [Convert]::ToBase64String($stream.ToArray()); mimeType = "image/png";
+  target = "desktop"; bounds = [ordered]@{ x = $bounds.Left; y = $bounds.Top; width = $bounds.Width; height = $bounds.Height }
+} | ConvertTo-Json -Compress -Depth 5
+`;
+
+const CAPTURE_WINDOW_SCRIPT = String.raw`
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition @'
+${WIN32_TYPE}
+'@
+$rawId = '__WINDOW_ID__'
+$hex = $rawId -replace '^0x',''
+try { $hwnd = [IntPtr]::new([Convert]::ToInt64($hex, 16)) } catch {
+  [ordered]@{ ok = $false; message = "invalid windowId: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+if ([MarchWin32]::IsIconic($hwnd)) {
+  [ordered]@{ ok = $false; message = "window is minimized and cannot be captured" } | ConvertTo-Json -Compress; exit 0
+}
+$rect = New-Object MarchWin32+RECT
+if (-not [MarchWin32]::GetWindowRect($hwnd, [ref]$rect)) {
+  [ordered]@{ ok = $false; message = "window not found: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+$width = $rect.Right - $rect.Left; $height = $rect.Bottom - $rect.Top
+if ($width -le 0 -or $height -le 0) {
+  [ordered]@{ ok = $false; message = "window has empty bounds: $rawId" } | ConvertTo-Json -Compress; exit 0
+}
+$bitmap = New-Object System.Drawing.Bitmap $width, $height
+$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+$graphics.CopyFromScreen($rect.Left, $rect.Top, 0, 0, (New-Object System.Drawing.Size $width, $height))
+$stream = New-Object System.IO.MemoryStream
+$bitmap.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+$graphics.Dispose(); $bitmap.Dispose()
+[ordered]@{
+  ok = $true; data = [Convert]::ToBase64String($stream.ToArray()); mimeType = "image/png";
+  target = "window"; windowId = $rawId; bounds = [ordered]@{ x = $rect.Left; y = $rect.Top; width = $width; height = $height }
+} | ConvertTo-Json -Compress -Depth 5
+`;

package/src/agent/session/session-options.mjs

@@ -17,6 +17,7 @@ export function resolveRunnerSessionOptions({
   permissionController = null,
   authStorage = null,
   projectMarchDir = null,
+  getCurrentModel = null,
 }) {
   if (engine.cwd !== cwd) {
     throw new Error(`Runtime session cwd mismatch: engine=${engine.cwd}, session=${cwd}`);
@@ -28,7 +29,7 @@ export function resolveRunnerSessionOptions({
     ?? (provider && modelId ? getModel(provider, modelId) : null);
   if (!model) throw new Error(`Model not found: ${provider}/${modelId}`);
 
-  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir });
+  const customTools = createMarchCustomTools({ cwd, engine, ui, memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController, authStorage, projectMarchDir, getCurrentModel: () => getCurrentModel?.() ?? model });
   const customToolNames = customTools.map((tool) => tool.name);
   const tools = [
     ...customToolNames.filter((name) => name === "read"),

package/src/agent/tool-summary.mjs

@@ -0,0 +1,112 @@
+export function formatToolStartLine(name, args = {}) {
+  if (name === "edit_file") {
+    const path = compactPath(args?.path ?? "");
+    const editCount = Array.isArray(args?.edits) ? args.edits.length : 0;
+    const mode = args?.mode ?? "patch";
+    const summary = mode === "patch" ? `${editCount} edit${editCount === 1 ? "" : "s"}` : mode;
+    return joinToolParts("◆", name, [path, summary]);
+  }
+  if (name === "command_exec") return joinToolParts("◆", name, [compactText(args?.command ?? "")]);
+  if (name === "terminal_send") return joinToolParts("◆", name, [args?.shell_id, formatTerminalSendAction(args)]);
+  if (name?.startsWith?.("terminal_")) return joinToolParts("◆", name, [args?.shell_id, formatTerminalDetails(args)]);
+  if (name === "external_web_search") return joinToolParts("◆", name, [quoteCompact(args?.query ?? "")]);
+  if (name === "web_fetch") return joinToolParts("◆", name, [compactText(args?.url ?? "")]);
+  if (name === "context_stats") return joinToolParts("◆", name, []);
+  if (name === "read") {
+    const path = compactPath(args?.path ?? args?.filePath ?? "");
+    return joinToolParts("→", name, [path, formatReadRange(args)]);
+  }
+  if (name === "grep") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  if (name === "glob") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  if (name === "find") {
+    const path = compactPath(args?.path ?? "");
+    return joinToolParts("✱", name, [quoteCompact(args?.pattern ?? ""), path]);
+  }
+  return joinToolParts("◆", name, [formatSmallOptions(args)]);
+}
+
+export function formatToolSuccessSummary(name, result, out = "") {
+  if (name === "grep") {
+    const matches = result?.details?.results?.length ?? countMatchLines(out);
+    return `${matches} match${matches === 1 ? "" : "es"}`;
+  }
+  if (name === "glob") {
+    const matches = Array.isArray(result?.details?.matches) ? result.details.matches.length : countNonEmptyLines(out);
+    return `${matches} file${matches === 1 ? "" : "s"}`;
+  }
+  if (name === "find") {
+    const matches = result?.details?.count ?? countNonEmptyLines(out);
+    return `${matches} file${matches === 1 ? "" : "s"}`;
+  }
+  if (name === "memory_open") {
+    return compactText(result?.details?.entry?.name ?? compactPath(result?.details?.path ?? ""));
+  }
+  return "";
+}
+
+function joinToolParts(icon, name, parts) {
+  const clean = parts.map((part) => String(part ?? "").trim()).filter(Boolean);
+  return `${icon} ${name}${clean.length ? ` · ${clean.join(" · ")}` : ""}`;
+}
+
+function formatReadRange(args = {}) {
+  if (args.offset == null && args.limit == null) return "";
+  if (args.offset != null && args.limit != null) return `lines ${args.offset}-${Number(args.offset) + Number(args.limit) - 1}`;
+  if (args.offset != null) return `from line ${args.offset}`;
+  return `limit ${args.limit}`;
+}
+
+function formatTerminalSendAction(args = {}) {
+  const hasText = typeof args.text === "string" && args.text.length > 0;
+  const key = args.key ? String(args.key) : "";
+  if (hasText && key) return `text+${key}`;
+  if (hasText) return args.text.includes("\n") || args.text.includes("\r") ? "text+enter" : "text";
+  return key || "send";
+}
+
+function formatTerminalDetails(args = {}) {
+  const details = [];
+  if (args.pattern) details.push(quoteCompact(args.pattern));
+  if (args.cols && args.rows) details.push(`${args.cols}x${args.rows}`);
+  if (args.command) details.push(compactText(args.command));
+  return details.join(" · ");
+}
+
+function formatSmallOptions(args = {}) {
+  const parts = [];
+  for (const [key, value] of Object.entries(args ?? {})) {
+    if (value == null || typeof value === "object") continue;
+    parts.push(`${key}=${compactText(value)}`);
+    if (parts.length >= 2) break;
+  }
+  return parts.join(", ");
+}
+
+function compactPath(path) {
+  return String(path ?? "").split(/[/\\]/).filter(Boolean).slice(-4).join("\\");
+}
+
+function quoteCompact(value) {
+  return JSON.stringify(compactText(value));
+}
+
+function compactText(value, limit = 80) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+function countMatchLines(text) {
+  const match = String(text ?? "").match(/(\d+)\s+matches?\b/i);
+  if (match) return Number(match[1]);
+  return countNonEmptyLines(text);
+}
+
+function countNonEmptyLines(text) {
+  return String(text ?? "").split("\n").filter(Boolean).length;
+}

package/src/agent/tools.mjs

@@ -1,22 +1,29 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 import { createCommandExecTool } from "./command-exec-tool.mjs";
 import { createContextStatsTool } from "./context-stats-tool.mjs";
 import { createEditFileTool } from "./file-edit-tool.mjs";
-import { createReadFileTool } from "./read-file-tool.mjs";
+import { createReadFileTool } from "./file-tools/read-file-tool.mjs";
+import { createReadImageTool } from "./file-tools/read-image-tool.mjs";
+import { createScreenTool } from "./screen-tools/screen-tool.mjs";
+import { createListWindowsTool } from "./screen-tools/list-windows-tool.mjs";
 import { toolText } from "./tool-result.mjs";
 import { createShellTools } from "../shell/tools.mjs";
-import { createWebTools } from "../web/tools.mjs";
 import { initImageGen } from "../image-gen/index.mjs";
 import { createSuperGrokTool } from "../supergrok/tool.mjs";
-export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null }) {
+
+export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shellRuntime = null, lspService = null, mcpTools = [], webTools = [], permissionController = null, authStorage = null, projectMarchDir = null, getCurrentModel = null }) {
   const commandExecTool = createCommandExecTool({ cwd });
   const contextStatsTool = createContextStatsTool({ engine });
   const editFileTool = createEditFileTool({ engine, ui, lspService });
   const readFileTool = createReadFileTool({ engine });
+  const readImageTool = createReadImageTool({ engine, getCurrentModel });
+  const screenTool = createScreenTool({ getCurrentModel });
+  const listWindowsTool = createListWindowsTool();
 
   const tools = [
     readFileTool,
+    readImageTool,
+    screenTool,
+    listWindowsTool,
     contextStatsTool,
     commandExecTool,
     editFileTool,