march-cli 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",
@@ -14,6 +14,7 @@
   "scripts": {
     "dev": "cd .. && node march-cli/bin/march.mjs",
     "test": "node test/smoke.test.mjs",
+    "test:fast": "node test/fast.test.mjs",
     "test:real": "npm run test:shell-runtime-real && npm run test:shell-tui-real && npm run test:tui-key-real",
     "test:shell-runtime-real": "node test/shell-real-runtime.acceptance.mjs",
     "test:shell-tui-real": "node test/shell-tui-real.acceptance.mjs",

package/src/agent/{read-file-tool.mjs → file-tools/read-file-tool.mjs}

@@ -2,7 +2,7 @@ import { readFileSync, readdirSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { toolText } from "./tool-result.mjs";
+import { toolText } from "../tool-result.mjs";
 
 const DEFAULT_LIMIT = 30;
 const DEFAULT_DIRECTORY_LIMIT = 200;
@@ -47,7 +47,7 @@ export function readFileSlice({ engine, path, offset = 1, limit = DEFAULT_LIMIT
   const count = clampLimit(limit);
   const selected = lines.slice(start - 1, start - 1 + count);
   const end = start + selected.length - 1;
-  const body = selected.map((line, index) => `${start + index} | ${line}`).join("\n");
+  const body = selected.map((line, index) => `${start + index}| ${line}`).join("\n");
   const header = `--- ${absPath} (lines ${start}-${end} of ${lines.length}) ---`;
   const remaining = lines.length - end;
   const footer = remaining > 0 ? `\n\n[${remaining} more lines in file. Use offset=${end + 1} to continue.]` : "";

package/src/agent/file-tools/read-image-tool.mjs

@@ -0,0 +1,76 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { currentModelImageInputError } from "../vision-capability.mjs";
+const IMAGE_MIME_BY_EXT = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".webp", "image/webp"],
+  [".gif", "image/gif"],
+]);
+
+export function createReadImageTool({ engine, getCurrentModel = null }) {
+  return defineTool({
+    name: "read_image",
+    label: "Read Image",
+    description: "Read a local image file and send it to the model as an image attachment. Supports png, jpg/jpeg, webp, and gif.",
+    parameters: Type.Object({
+      path: Type.String({ description: "Absolute or relative path to the image file" }),
+    }),
+    execute: async (_toolCallId, params) => {
+      const capabilityError = currentModelImageInputError(getCurrentModel);
+      if (capabilityError) return imageError(capabilityError, { unsupportedModel: true });
+      return readImageFile({ engine, ...params });
+    },
+  });
+}
+
+export function readImageFile({ engine, path }) {
+  const absPath = engine.resolvePath(path);
+  let stat;
+  try {
+    stat = statSync(absPath);
+  } catch (err) {
+    return imageError(`Error reading image ${absPath}: ${err.message}`, { path: absPath });
+  }
+  if (stat.isDirectory()) {
+    return imageError(`Error reading image ${absPath}: this is a directory. Use ls(path) or find(pattern, path) to inspect it.`, { path: absPath, isDirectory: true });
+  }
+
+  const mimeType = IMAGE_MIME_BY_EXT.get(extname(absPath).toLowerCase());
+  if (!mimeType) {
+    return imageError(`Error reading image ${absPath}: unsupported image type. Supported types: png, jpg, jpeg, webp, gif.`, { path: absPath });
+  }
+
+  let data;
+  try {
+    data = readFileSync(absPath).toString("base64");
+  } catch (err) {
+    return imageError(`Error reading image ${absPath}: ${err.message}`, { path: absPath });
+  }
+
+  const size = formatSize(stat.size);
+  return {
+    content: [
+      { type: "text", text: `Read image file: ${absPath}\nMIME: ${mimeType}\nSize: ${size}` },
+      { type: "image", data, mimeType },
+    ],
+    details: {
+      path: absPath,
+      mimeType,
+      sizeBytes: stat.size,
+    },
+  };
+}
+
+function imageError(text, details = {}) {
+  return { content: [{ type: "text", text }], details: { ...details, error: true } };
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/agent/runner.mjs

@@ -83,6 +83,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       cwd, provider, modelId, modelRegistry, engine, ui: runtimeUi,
       memoryTools, shellRuntime, lspService, mcpTools, webTools, permissionController,
       authStorage: resolvedAuth, projectMarchDir,
+      getCurrentModel: () => sessionBinding.get()?.model ?? selectedModel,
     });
     const { session } = await createAgentSessionImpl({
       cwd, agentDir: stateRoot, ...sessionOptions,

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/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/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,

package/src/agent/vision-capability.mjs

@@ -0,0 +1,14 @@
+export function modelSupportsImageInput(model) {
+  if (!model || typeof model !== "object") return false;
+  if (Array.isArray(model.input) && model.input.includes("image")) return true;
+  if (model.capabilities?.images === true || model.capabilities?.vision === true) return true;
+  return false;
+}
+
+export function currentModelImageInputError(getCurrentModel) {
+  if (typeof getCurrentModel !== "function") return null;
+  const model = getCurrentModel();
+  if (modelSupportsImageInput(model)) return null;
+  const label = model ? `${model.name || model.id || "unknown"} (${model.provider || "unknown provider"})` : "unknown";
+  return `Current model does not support image input: ${label}. Switch to a vision-capable model before using read_image or screen.`;
+}

package/src/cli/args.mjs

@@ -11,6 +11,8 @@ export function parseCliArgs(argv) {
       extension: { type: "string", short: "e", multiple: true },
       extension: { type: "string", short: "e", multiple: true },
       config: { type: "boolean" },
+      "include-key": { type: "boolean" },
+      "profile-only": { type: "boolean" },
       "dump-context": { type: "boolean" },
       "pi-sessions": { type: "boolean" },
       "pi-runtime-host": { type: "boolean" },
@@ -33,6 +35,8 @@ export function parseCliArgs(argv) {
     extensions: values.extension ?? [],
     dumpContext: values["dump-context"] ?? false,
     providerConfig: values.config ?? false,
+    includeKey: values["include-key"] ?? false,
+    profileOnly: values["profile-only"] ?? false,
     piSessions: values["pi-sessions"] ?? false,
     piRuntimeHost: values["pi-runtime-host"] ?? false,
     shellRuntime: values["no-shell-runtime"] ? false : true,
@@ -50,6 +54,8 @@ Usage:
   march [options]            (starts REPL)
   march login [provider]     Login to an OAuth provider
   march provider --config    Configure provider credentials
+  march provider share [id]  Share a provider profile
+  march provider accept <token>
   march websearch --config  Configure web search credentials
 
 Options:
@@ -58,6 +64,8 @@ Options:
   --resume <id>        Resume a pi session by default
   --json               JSON output mode (no TUI)
   --config             With provider/websearch command, open configuration
+  --include-key        With provider share, include API key
+  --profile-only       With provider share, omit API key
   --dump-context       Write every prompt sent to the model under .march/context-dumps/
   --pi-sessions        Force pi JSONL SessionManager persistence
   --pi-runtime-host    Force pi AgentSessionRuntime host path

package/src/cli/tui/status/status-bar.mjs

@@ -75,7 +75,8 @@ export class StatusBar {
     const mode = formatModeLabel(parts.mode || DEFAULT_STATUS_TEXT);
     const activity = parts.activity ? statusBar.muted(`${parts.activity} · `) : "";
     const right = [parts.model, parts.thinking].filter(Boolean).join(" • ");
-    const line = composeMetaLine({ left: `${activity}${mode}`, right, width: innerWidth, muteLeft: false });
+    const paintWidth = inputPaintWidth(innerWidth);
+    const line = composeMetaLine({ left: `${activity}${mode}`, right, width: paintWidth, muteLeft: false });
     return ["", `${insetLeft}${line}${insetRight}`];
   }
 }

package/src/config/config-json.mjs

@@ -38,6 +38,17 @@ export function upsertProviderProfile({ path = globalConfigJsonPath(), id, type,
   return config;
 }
 
+export function upsertSharedProviderProfile({ path = globalConfigJsonPath(), id, provider }) {
+  const config = readConfigJson(path);
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers)
+    ? config.providers
+    : {};
+  providers[id] = provider;
+  config.providers = providers;
+  writeConfigJson(path, config);
+  return config;
+}
+
 export function upsertModelSelection({ path = globalConfigJsonPath(), provider, model, serviceTier }) {
   const config = readConfigJson(path);
   config.provider = provider;

package/src/context/system-core/base.md

@@ -53,7 +53,8 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 </git_contract>
 
 <memory_system>
-- [memory_hint source="..."] blocks in recent_chat show memory hints matched from your thinking output. Use memory_open(id) to read the full content.
+- [memory_hint source="..."] blocks in recent_chat are lightweight recall hints matched from prior thinking output. Treat them as possibly relevant pointers, not as complete facts.
+- If a memory hint may help the current task, use memory_open(id) to read the full memory before relying on it. Ignore hints that are clearly unrelated or too low-value for the task.
 - Use memory_search(query) for full-text search across all memories.
 - To edit an existing memory, use memory_open(id) to get its path, then edit_file with mode="patch" for targeted edits.
 - Use memory_save() to create memories or update whole fields. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase kebab-case tags like 'march-cli', 'tooling', 'permissions'.

package/src/main.mjs

@@ -30,7 +30,7 @@ import { createWebToolsFromConfig } from "./web/tools.mjs";
 import { createModelContextDumper } from "./debug/model-context-dumper.mjs";
 import { createLogger, installProcessLogHandlers } from "./debug/logger.mjs";
 import { defaultProfilePaths, ensureProfileFiles } from "./context/profiles.mjs";
-import { runProviderConfigCommand } from "./provider/config-command.mjs";
+import { runProviderCommand } from "./provider/command.mjs";
 import { runWebSearchConfigCommand } from "./web/config-command.mjs";
 import { createDesktopTurnNotifier } from "./notification/desktop-notifier.mjs";
 import { registerSuperGrokOAuthProvider } from "./supergrok/oauth-provider.mjs";
@@ -60,11 +60,12 @@ export async function run(argv) {
       return 1;
     }
   }
-
-  if (args.command?.name === "provider" || args.command?.name === "websearch") {
-    const command = args.command.name === "provider" ? runProviderConfigCommand : runWebSearchConfigCommand;
-    if (args.providerConfig) return await command({ homeDir: homedir() });
-    process.stderr.write(`Usage: march ${args.command.name} --config\n`);
+  if (args.command?.name === "provider") {
+    return await runProviderCommand(args);
+  }
+  if (args.command?.name === "websearch") {
+    if (args.providerConfig) return await runWebSearchConfigCommand({ homeDir: homedir() });
+    process.stderr.write("Usage: march websearch --config\n");
     return 1;
   }
 

package/src/provider/accept-command.mjs

@@ -0,0 +1,89 @@
+import { globalConfigJsonPath, readConfigJson, upsertSharedProviderProfile } from "../config/config-json.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { hasApiKey, parseProviderShareToken } from "./share-payload.mjs";
+
+export async function runProviderAcceptCommand({
+  homeDir,
+  token,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+} = {}) {
+  if (!token) {
+    output.write("Usage: march provider accept <march-provider-v1-token>\n");
+    return 1;
+  }
+
+  let payload;
+  try {
+    payload = parseProviderShareToken(token);
+  } catch (error) {
+    output.write(`Invalid provider share token: ${error.message}\n`);
+    return 1;
+  }
+
+  output.write(formatImportPreview(payload));
+  const path = globalConfigJsonPath(homeDir);
+  const config = readConfigJson(path);
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers) ? config.providers : {};
+  if (providers[payload.providerId]) {
+    const action = await select({
+      input,
+      output,
+      message: `Provider "${payload.providerId}" already exists`,
+      items: [
+        { label: "Overwrite existing provider", value: "overwrite" },
+        { label: "Cancel", value: "cancel" },
+      ],
+    });
+    if (action !== "overwrite") {
+      output.write("Provider import cancelled.\n");
+      return 1;
+    }
+  } else {
+    const action = await select({
+      input,
+      output,
+      message: "Import provider?",
+      items: [
+        { label: "Import", value: "import" },
+        { label: "Cancel", value: "cancel" },
+      ],
+    });
+    if (action !== "import") {
+      output.write("Provider import cancelled.\n");
+      return 1;
+    }
+  }
+
+  upsertSharedProviderProfile({ path, id: payload.providerId, provider: payload.provider });
+  output.write(`Imported provider: ${payload.providerId}\n`);
+  output.write(`Config: ${path}\n`);
+  return 0;
+}
+
+export function formatImportPreview(payload) {
+  const provider = payload.provider;
+  const models = Array.isArray(provider.models) ? provider.models : [];
+  const lines = [
+    "Provider to import:",
+    `  Id: ${payload.providerId}`,
+    `  Name: ${typeof provider.name === "string" && provider.name ? provider.name : "-"}`,
+    `  Type: ${provider.type}`,
+  ];
+  if (typeof provider.baseUrl === "string" && provider.baseUrl) lines.push(`  Base URL: ${provider.baseUrl}`);
+  if (typeof provider.api === "string" && provider.api) lines.push(`  API: ${provider.api}`);
+  if (models.length) {
+    lines.push(`  Models: ${models.length}`);
+    for (const model of models.slice(0, 5)) lines.push(`    - ${formatModel(model)}`);
+    if (models.length > 5) lines.push(`    ... ${models.length - 5} more`);
+  }
+  lines.push(`  API key: ${hasApiKey(provider) ? "included" : "not included"}`);
+  lines.push("");
+  return `${lines.join("\n")}\n`;
+}
+
+function formatModel(model) {
+  if (model && typeof model === "object" && !Array.isArray(model)) return model.name || model.id || "<unnamed>";
+  return String(model);
+}

package/src/provider/command.mjs

@@ -0,0 +1,21 @@
+import { homedir } from "node:os";
+import { runProviderConfigCommand } from "./config-command.mjs";
+import { runProviderShareCommand } from "./share-command.mjs";
+import { runProviderAcceptCommand } from "./accept-command.mjs";
+
+export async function runProviderCommand(args, { homeDir = homedir(), stderr = process.stderr } = {}) {
+  if (args.providerConfig) return await runProviderConfigCommand({ homeDir });
+  if (args.command.args[0] === "share") {
+    return await runProviderShareCommand({
+      homeDir,
+      providerId: args.command.args[1],
+      includeKey: args.includeKey,
+      profileOnly: args.profileOnly,
+    });
+  }
+  if (args.command.args[0] === "accept") {
+    return await runProviderAcceptCommand({ homeDir, token: args.command.args[1] });
+  }
+  stderr.write("Usage: march provider --config | march provider share [id] | march provider accept <token>\n");
+  return 1;
+}

package/src/provider/custom-provider.mjs

@@ -52,7 +52,7 @@ function normalizeModels(providerId, models, { api, baseUrl }) {
       api: normalizeApi(providerId, model.api ?? api),
       baseUrl: typeof model.baseUrl === "string" && model.baseUrl.trim() ? model.baseUrl : baseUrl,
       reasoning: typeof model.reasoning === "boolean" ? model.reasoning : false,
-      input: normalizeInput(model.input),
+      input: normalizeInput(model.input, model.capabilities),
       cost: normalizeCost(model.cost),
       contextWindow: normalizePositiveNumber(model.contextWindow, 128000),
       maxTokens: normalizePositiveNumber(model.maxTokens, 4096),
@@ -75,9 +75,10 @@ function requireString(providerId, field, value) {
   return value;
 }
 
-function normalizeInput(input) {
-  if (!Array.isArray(input) || input.length === 0) return ["text"];
-  const normalized = input.filter((item) => item === "text" || item === "image");
+function normalizeInput(input, capabilities = null) {
+  const normalized = Array.isArray(input) ? input.filter((item) => item === "text" || item === "image") : [];
+  if ((capabilities?.images === true || capabilities?.vision === true) && !normalized.includes("image")) normalized.push("image");
+  if (!normalized.includes("text")) normalized.unshift("text");
   return normalized.length > 0 ? normalized : ["text"];
 }
 

package/src/provider/share-command.mjs

@@ -0,0 +1,79 @@
+import { globalConfigJsonPath, readConfigJson } from "../config/config-json.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { cloneProviderForShare, createProviderShareToken, hasApiKey } from "./share-payload.mjs";
+
+export async function runProviderShareCommand({
+  homeDir,
+  providerId,
+  includeKey = false,
+  profileOnly = false,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+} = {}) {
+  if (includeKey && profileOnly) {
+    output.write("Choose either --include-key or --profile-only, not both.\n");
+    return 1;
+  }
+
+  const config = readConfigJson(globalConfigJsonPath(homeDir));
+  const providers = normalizeProviders(config.providers);
+  const selectedProviderId = providerId ?? await selectProvider({ providers, input, output, select });
+  if (!selectedProviderId) {
+    output.write(Object.keys(providers).length ? "Provider share cancelled.\n" : "No providers configured. Run: march provider --config\n");
+    return 1;
+  }
+
+  const provider = providers[selectedProviderId];
+  if (!provider) {
+    output.write(`Provider not found: ${selectedProviderId}\n`);
+    return 1;
+  }
+
+  const includeApiKey = includeKey || (!profileOnly && await selectShareMode({ input, output, select }));
+  const sharedProvider = cloneProviderForShare(provider, { includeApiKey });
+  const token = createProviderShareToken({
+    providerId: selectedProviderId,
+    provider: sharedProvider,
+    mode: includeApiKey ? "full" : "profile-only",
+  });
+
+  output.write(`Provider: ${selectedProviderId}\n`);
+  output.write(`Mode: ${includeApiKey ? "Full config, including API key" : "Profile only, without API key"}\n`);
+  output.write(`API key: ${hasApiKey(sharedProvider) ? "included" : "not included"}\n\n`);
+  output.write(`march provider accept ${token}\n`);
+  return 0;
+}
+
+function normalizeProviders(providers) {
+  return providers && typeof providers === "object" && !Array.isArray(providers) ? providers : {};
+}
+
+async function selectProvider({ providers, input, output, select }) {
+  const items = Object.entries(providers).map(([id, provider]) => ({
+    value: id,
+    label: formatProviderLabel(id, provider),
+  }));
+  return await select({ input, output, message: "Choose provider to share", items });
+}
+
+async function selectShareMode({ input, output, select }) {
+  const mode = await select({
+    input,
+    output,
+    message: "Choose share mode",
+    items: [
+      { label: "Full config, including API key", value: "full" },
+      { label: "Profile only, without API key", value: "profile-only" },
+    ],
+  });
+  return mode === "full";
+}
+
+function formatProviderLabel(id, provider) {
+  const name = typeof provider?.name === "string" && provider.name ? provider.name : "-";
+  const type = typeof provider?.type === "string" && provider.type ? provider.type : "unknown";
+  const modelCount = Array.isArray(provider?.models) ? `${provider.models.length} model${provider.models.length === 1 ? "" : "s"}` : "built-in";
+  const key = hasApiKey(provider) ? "API key configured" : "no API key";
+  return `${id}  ${name}  ${type}  ${modelCount}  ${key}`;
+}

package/src/provider/share-payload.mjs

@@ -0,0 +1,52 @@
+const KIND = "march.provider.share";
+const VERSION = 1;
+const PREFIX = "march-provider-v1.";
+
+export function createProviderShareToken({ providerId, provider, mode }) {
+  const payload = {
+    kind: KIND,
+    version: VERSION,
+    mode,
+    containsApiKey: hasApiKey(provider),
+    providerId,
+    provider,
+  };
+  return `${PREFIX}${Buffer.from(JSON.stringify(payload), "utf8").toString("base64url")}`;
+}
+
+export function parseProviderShareToken(token) {
+  const text = String(token ?? "").trim();
+  if (!text.startsWith(PREFIX)) throw new Error(`Provider share token must start with ${PREFIX}`);
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(text.slice(PREFIX.length), "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Invalid provider share token");
+  }
+  validateProviderSharePayload(payload);
+  return payload;
+}
+
+export function cloneProviderForShare(provider, { includeApiKey }) {
+  const clone = structuredClone(provider);
+  if (!includeApiKey && clone.auth && typeof clone.auth === "object" && !Array.isArray(clone.auth)) {
+    delete clone.auth.apiKey;
+  }
+  return clone;
+}
+
+export function hasApiKey(provider) {
+  return typeof provider?.auth?.apiKey === "string" && provider.auth.apiKey.length > 0;
+}
+
+export function validateProviderSharePayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("Invalid provider share payload");
+  if (payload.kind !== KIND || payload.version !== VERSION) throw new Error("Unsupported provider share token");
+  if (typeof payload.providerId !== "string" || !payload.providerId.trim()) throw new Error("Provider share token is missing providerId");
+  validateProviderProfile(payload.provider);
+}
+
+function validateProviderProfile(provider) {
+  if (!provider || typeof provider !== "object" || Array.isArray(provider)) throw new Error("Provider share token is missing provider config");
+  if (typeof provider.type !== "string" || !provider.type.trim()) throw new Error("Provider config is missing type");
+}

package/src/supergrok/tool.mjs

@@ -13,14 +13,14 @@ export function createSuperGrokTool({ authStorage, projectMarchDir, resolveCrede
     name: "supergrok",
     label: "SuperGrok",
     description:
-      "Use SuperGrok capabilities through xAI: realtime web search, X/Twitter search, and Grok image generation. " +
-      "Default search behavior is broad and enables image/video understanding where supported. Requires SuperGrok OAuth or XAI_API_KEY.",
-    promptSnippet: "supergrok(action, query, options?) - Use SuperGrok web_search, x_search, or image_generate",
+      "Use SuperGrok for complex research tasks that would otherwise require multiple searches or source comparison. " +
+      "It is backed by an agent team that can search repeatedly, verify across sources, and synthesize an answer.",
+    promptSnippet: "supergrok(action, query, options?) - Prefer SuperGrok for complex web/X research or Grok image generation",
     promptGuidelines: [
-      "Use action=web_search for current web/news/documentation facts.",
-      "Use action=x_search for current X/Twitter posts, reactions, profiles, and threads.",
+      "Prefer action=web_search for broad, ambiguous, current, or multi-step research.",
+      "Use action=x_search for targeted X/Twitter posts, reactions, profiles, and threads.",
       "Use action=image_generate when the user asks Grok/SuperGrok to create an image.",
-      "Do not add domain, handle, or date filters unless the user asks for that narrower scope.",
+      "Use narrower tools instead for simple lookups, exact URL fetching, targeted X search, or non-Grok image generation.",
     ],
     parameters: Type.Object({
       action: Type.String({ enum: ACTIONS, description: "SuperGrok capability to invoke" }),