@ai-matrx/desktop-protocol 0.21.2 → 0.21.4

package/dist/index.cjs

@@ -237,6 +237,25 @@ __export(src_exports, {
   FsWatchStopResult: () => FsWatchStopResult,
   FsWriteParams: () => FsWriteParams,
   FsWriteResult: () => FsWriteResult,
+  GIT_MAX_OUTPUT_CHARS: () => GIT_MAX_OUTPUT_CHARS,
+  GitAddParams: () => GitAddParams,
+  GitBranchParams: () => GitBranchParams,
+  GitBranchResult: () => GitBranchResult,
+  GitCloneParams: () => GitCloneParams,
+  GitCommitParams: () => GitCommitParams,
+  GitCommitResult: () => GitCommitResult,
+  GitDiffParams: () => GitDiffParams,
+  GitDiffResult: () => GitDiffResult,
+  GitLogCommit: () => GitLogCommit,
+  GitLogParams: () => GitLogParams,
+  GitLogResult: () => GitLogResult,
+  GitOutputResult: () => GitOutputResult,
+  GitPullParams: () => GitPullParams,
+  GitPushParams: () => GitPushParams,
+  GitStashParams: () => GitStashParams,
+  GitStatusFile: () => GitStatusFile,
+  GitStatusParams: () => GitStatusParams,
+  GitStatusResult: () => GitStatusResult,
   HelloMsg: () => HelloMsg,
   InputHotkeyParams: () => InputHotkeyParams,
   InputHotkeyResult: () => InputHotkeyResult,
@@ -409,10 +428,25 @@ __export(src_exports, {
   ToolPlatform: () => ToolPlatform,
   ToolResultsFile: () => ToolResultsFile,
   ToolTransport: () => ToolTransport,
+  ToolsServiceProgress: () => ToolsServiceProgress,
+  ToolsWebSearchParams: () => ToolsWebSearchParams,
   TranscriptSegment: () => TranscriptSegment,
   TranscriptionModelId: () => TranscriptionModelId,
   TranscriptionModelInfo: () => TranscriptionModelInfo,
   VERSIONED_RESULT_OPS: () => VERSIONED_RESULT_OPS,
+  WEB_MAX_TEXT_CHARS: () => WEB_MAX_TEXT_CHARS,
+  WebBrowserFetchParams: () => WebBrowserFetchParams,
+  WebBrowserFetchResult: () => WebBrowserFetchResult,
+  WebFetchParams: () => WebFetchParams,
+  WebFetchResult: () => WebFetchResult,
+  WebHeader: () => WebHeader,
+  WebScrapePage: () => WebScrapePage,
+  WebScrapeParams: () => WebScrapeParams,
+  WebScrapeResult: () => WebScrapeResult,
+  WebSearchHit: () => WebSearchHit,
+  WebSearchParams: () => WebSearchParams,
+  WebSearchQueryResult: () => WebSearchQueryResult,
+  WebSearchResult: () => WebSearchResult,
   Welcome: () => Welcome,
   WindowFocusParams: () => WindowFocusParams,
   WindowFocusResult: () => WindowFocusResult,
@@ -454,7 +488,7 @@ module.exports = __toCommonJS(src_exports);
 var import_zod = require("zod");
 var import_uuid = require("@ai-matrx/kit/uuid");
 var PROTOCOL_MAJOR = 1;
-var PROTOCOL_MINOR = 21;
+var PROTOCOL_MINOR = 22;
 var PROTOCOL_VERSION = `${PROTOCOL_MAJOR}.${PROTOCOL_MINOR}`;
 var ProtocolVersion = import_zod.z.string().regex(/^[1-9][0-9]{0,2}\.[0-9]{1,3}$/);
 var RequestId = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
@@ -1763,7 +1797,7 @@ var AppsWindowsSaveNamesParams = import_zod13.z.strictObject({ app_key: AppKey }
 // src/schema/service.ts
 var import_zod14 = require("zod");
 var SERVICE_MAX_FRAME_BYTES = 16777216;
-var ServiceName = import_zod14.z.enum(["ml", "coding"]);
+var ServiceName = import_zod14.z.enum(["ml", "coding", "tools"]);
 var ContractHash = import_zod14.z.string().regex(/^[0-9a-f]{64}$/);
 var ServiceToken = import_zod14.z.string().regex(/^[A-Za-z0-9_-]{43}$/);
 var ServiceRequestId = u32;
@@ -1898,112 +1932,251 @@ var ClipboardReadResult = import_zod17.z.strictObject({
 var ClipboardWriteParams = import_zod17.z.strictObject({ text: import_zod17.z.string().max(1048576) });
 var ClipboardWriteResult = import_zod17.z.strictObject({ bytes: nonNegInt });
 
-// src/schema/system.ts
+// src/schema/git.ts
 var import_zod18 = require("zod");
-var SystemOpenUrlParams = import_zod18.z.strictObject({
+var GIT_MAX_OUTPUT_CHARS = 262144;
+var GitText = import_zod18.z.string().max(GIT_MAX_OUTPUT_CHARS);
+var GitName = import_zod18.z.string().min(1).max(255).regex(/^[^-\s][^\s]*$/);
+var GitOutputResult = import_zod18.z.strictObject({ output: GitText, truncated: import_zod18.z.boolean() });
+var GitStatusParams = import_zod18.z.strictObject({ cwd: AbsPath });
+var GitStatusFile = import_zod18.z.strictObject({
+  path: import_zod18.z.string(),
+  /** Porcelain v1 status letters: index (staged) and worktree; "?" for untracked. */
+  index: import_zod18.z.string().length(1),
+  worktree: import_zod18.z.string().length(1)
+});
+var GitStatusResult = import_zod18.z.strictObject({
+  /** The checked-out branch; null when HEAD is detached. */
+  branch: import_zod18.z.string().nullable(),
+  upstream: import_zod18.z.string().nullable(),
+  ahead: nonNegInt,
+  behind: nonNegInt,
+  files: import_zod18.z.array(GitStatusFile).max(5e3),
+  clean: import_zod18.z.boolean(),
+  /** More than 5000 changed files: the list is cut. */
+  truncated: import_zod18.z.boolean()
+});
+var GitDiffParams = import_zod18.z.strictObject({ cwd: AbsPath, path: import_zod18.z.string().max(4096).optional(), staged: import_zod18.z.boolean().default(false) });
+var GitDiffResult = import_zod18.z.strictObject({ diff: GitText, truncated: import_zod18.z.boolean() });
+var GitLogParams = import_zod18.z.strictObject({ cwd: AbsPath, limit: import_zod18.z.int().min(1).max(500).default(50) });
+var GitLogCommit = import_zod18.z.strictObject({ sha: import_zod18.z.string(), short: import_zod18.z.string(), author: import_zod18.z.string(), date: import_zod18.z.string(), subject: import_zod18.z.string() });
+var GitLogResult = import_zod18.z.strictObject({ commits: import_zod18.z.array(GitLogCommit).max(500) });
+var GitAddParams = import_zod18.z.strictObject({ cwd: AbsPath, paths: import_zod18.z.array(import_zod18.z.string().min(1).max(4096)).min(1).max(1e3) });
+var GitCommitParams = import_zod18.z.strictObject({
+  cwd: AbsPath,
+  message: import_zod18.z.string().min(1).max(65536),
+  amend: import_zod18.z.boolean().default(false),
+  /** "Name <email>"; absent = the computer's own git identity. */
+  author: import_zod18.z.string().max(512).optional()
+});
+var GitCommitResult = import_zod18.z.strictObject({ sha: import_zod18.z.string(), output: GitText, truncated: import_zod18.z.boolean() });
+var GitPushParams = import_zod18.z.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), force_with_lease: import_zod18.z.boolean().default(false) });
+var GitPullParams = import_zod18.z.strictObject({ cwd: AbsPath, remote: GitName.default("origin"), branch: GitName.optional(), rebase: import_zod18.z.boolean().default(false) });
+var GitBranchParams = import_zod18.z.strictObject({ cwd: AbsPath, action: import_zod18.z.enum(["list", "create", "delete", "switch"]), name: GitName.optional() });
+var GitBranchResult = import_zod18.z.strictObject({
+  /** The branch checked out after the action; null when detached. */
+  current: import_zod18.z.string().nullable(),
+  /** Local branches (filled by `list`; empty otherwise). */
+  branches: import_zod18.z.array(import_zod18.z.string()).max(5e3),
+  output: GitText,
+  truncated: import_zod18.z.boolean()
+});
+var GitStashParams = import_zod18.z.strictObject({ cwd: AbsPath, action: import_zod18.z.enum(["push", "pop", "list", "drop"]), message: import_zod18.z.string().max(4096).optional() });
+var GitCloneParams = import_zod18.z.strictObject({
+  url: import_zod18.z.string().min(1).max(4096).regex(/^[^-]/),
+  /** The folder to create; must not exist yet (or be empty). */
+  dest: AbsPath,
+  branch: GitName.optional(),
+  depth: import_zod18.z.int().min(1).max(1e6).optional()
+});
+
+// src/schema/web.ts
+var import_zod19 = require("zod");
+var WEB_MAX_TEXT_CHARS = 524288;
+var WebUrl = import_zod19.z.string().min(1).max(8192).regex(/^https?:\/\//);
+var WebText = import_zod19.z.string().max(WEB_MAX_TEXT_CHARS);
+var WebHeader = import_zod19.z.strictObject({ name: import_zod19.z.string().min(1).max(256), value: import_zod19.z.string().max(8192) });
+var WebFetchParams = import_zod19.z.strictObject({
+  url: WebUrl,
+  method: import_zod19.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]).default("GET"),
+  headers: import_zod19.z.array(WebHeader).max(64).default([]),
+  body: import_zod19.z.string().max(1048576).optional(),
+  follow_redirects: import_zod19.z.boolean().default(true),
+  timeout_s: import_zod19.z.int().min(1).max(300).default(30)
+});
+var WebFetchResult = import_zod19.z.strictObject({
+  status: import_zod19.z.int().min(100).max(999),
+  reason: import_zod19.z.string(),
+  /** The final URL after redirects. */
+  url: import_zod19.z.string(),
+  content_type: import_zod19.z.string().nullable(),
+  headers: import_zod19.z.array(WebHeader),
+  body: WebText,
+  truncated: import_zod19.z.boolean(),
+  bytes: nonNegInt,
+  elapsed_ms: nonNegInt
+});
+var WebScrapeParams = import_zod19.z.strictObject({
+  urls: import_zod19.z.array(WebUrl).min(1).max(20),
+  use_cache: import_zod19.z.boolean().default(true),
+  get_links: import_zod19.z.boolean().default(false)
+});
+var WebScrapePage = import_zod19.z.strictObject({
+  url: import_zod19.z.string(),
+  ok: import_zod19.z.boolean(),
+  status: import_zod19.z.int().min(0).max(999).nullable(),
+  title: import_zod19.z.string().nullable(),
+  /** The page's readable content (markdown-like text from the scraper's parse). */
+  text: WebText,
+  truncated: import_zod19.z.boolean(),
+  /** Links found on the page (only with get_links). */
+  links: import_zod19.z.array(import_zod19.z.string()).max(2e3),
+  /** Why the page failed (blocked, timeout, not found…), in the scraper's words; null when ok. */
+  error: import_zod19.z.string().nullable(),
+  /** How the page was fetched (http, browser, cache). */
+  via: import_zod19.z.string().nullable()
+});
+var WebScrapeResult = import_zod19.z.strictObject({ pages: import_zod19.z.array(WebScrapePage), elapsed_ms: nonNegInt });
+var WebSearchParams = import_zod19.z.strictObject({
+  keywords: import_zod19.z.array(import_zod19.z.string().min(1).max(400)).min(1).max(5),
+  country: import_zod19.z.string().min(2).max(2).default("us"),
+  count: import_zod19.z.int().min(1).max(20).default(10),
+  freshness: import_zod19.z.enum(["pd", "pw", "pm", "py"]).optional()
+});
+var WebSearchHit = import_zod19.z.strictObject({ title: import_zod19.z.string(), url: import_zod19.z.string(), description: import_zod19.z.string() });
+var WebSearchQueryResult = import_zod19.z.strictObject({ keyword: import_zod19.z.string(), hits: import_zod19.z.array(WebSearchHit), error: import_zod19.z.string().nullable() });
+var WebSearchResult = import_zod19.z.strictObject({ queries: import_zod19.z.array(WebSearchQueryResult), elapsed_ms: nonNegInt });
+var ToolsWebSearchParams = import_zod19.z.strictObject({
+  keywords: import_zod19.z.array(import_zod19.z.string().min(1).max(400)).min(1).max(5),
+  country: import_zod19.z.string().min(2).max(2).default("us"),
+  count: import_zod19.z.int().min(1).max(20).default(10),
+  freshness: import_zod19.z.enum(["pd", "pw", "pm", "py"]).optional(),
+  brave_api_key: import_zod19.z.string().min(1).max(512).nullable()
+});
+var WebBrowserFetchParams = import_zod19.z.strictObject({
+  url: WebUrl,
+  /** A CSS selector to wait for before reading the page. */
+  wait_for: import_zod19.z.string().max(1024).optional(),
+  wait_timeout_ms: import_zod19.z.int().min(100).max(12e4).default(3e4),
+  /** true: readable text; false: the rendered HTML. */
+  extract_text: import_zod19.z.boolean().default(true)
+});
+var WebBrowserFetchResult = import_zod19.z.strictObject({
+  url: import_zod19.z.string(),
+  status: import_zod19.z.int().min(0).max(999).nullable(),
+  title: import_zod19.z.string().nullable(),
+  content: WebText,
+  truncated: import_zod19.z.boolean(),
+  elapsed_ms: nonNegInt
+});
+var ToolsServiceProgress = import_zod19.z.strictObject({ phase: import_zod19.z.enum(["fetching", "installing"]), done: nonNegInt, total: nonNegInt });
+
+// src/schema/system.ts
+var import_zod20 = require("zod");
+var SystemOpenUrlParams = import_zod20.z.strictObject({
   /** http, https or mailto; opened in the person's default app for it. */
-  url: import_zod18.z.string().min(1).max(4096)
+  url: import_zod20.z.string().min(1).max(4096)
 });
-var SystemOpenUrlResult = import_zod18.z.strictObject({ url: import_zod18.z.string().max(4096) });
-var SystemOpenPathParams = import_zod18.z.strictObject({
+var SystemOpenUrlResult = import_zod20.z.strictObject({ url: import_zod20.z.string().max(4096) });
+var SystemOpenPathParams = import_zod20.z.strictObject({
   path: AbsPath,
   /** Show it in the file manager (Finder, Explorer) instead of opening it. */
-  reveal: import_zod18.z.boolean().default(false)
+  reveal: import_zod20.z.boolean().default(false)
 });
-var SystemOpenPathResult = import_zod18.z.strictObject({ path: AbsPath, revealed: import_zod18.z.boolean() });
-var SystemNotifyParams = import_zod18.z.strictObject({
-  title: import_zod18.z.string().min(1).max(128),
-  body: import_zod18.z.string().max(1024).default("")
+var SystemOpenPathResult = import_zod20.z.strictObject({ path: AbsPath, revealed: import_zod20.z.boolean() });
+var SystemNotifyParams = import_zod20.z.strictObject({
+  title: import_zod20.z.string().min(1).max(128),
+  body: import_zod20.z.string().max(1024).default("")
 });
-var SystemNotifyResult = import_zod18.z.strictObject({
+var SystemNotifyResult = import_zod20.z.strictObject({
   /** False when this computer has no notification service to show it (a bare Linux box). */
-  shown: import_zod18.z.boolean()
+  shown: import_zod20.z.boolean()
 });
 
 // src/schema/screen.ts
-var import_zod19 = require("zod");
-var ScreenDisplay = import_zod19.z.strictObject({
+var import_zod21 = require("zod");
+var ScreenDisplay = import_zod21.z.strictObject({
   /** The OS's display id; pass it to screen.capture. */
   id: nonNegInt,
-  name: import_zod19.z.string().max(128),
+  name: import_zod21.z.string().max(128),
   /** Position and size in the OS's logical points (x and y may be negative left of or above the main display). */
-  x: import_zod19.z.int(),
-  y: import_zod19.z.int(),
-  width: import_zod19.z.int().min(1),
-  height: import_zod19.z.int().min(1),
+  x: import_zod21.z.int(),
+  y: import_zod21.z.int(),
+  width: import_zod21.z.int().min(1),
+  height: import_zod21.z.int().min(1),
   /** Pixels per point (2 on a Retina display). */
-  scale: import_zod19.z.number().min(0.1).max(8),
-  primary: import_zod19.z.boolean()
+  scale: import_zod21.z.number().min(0.1).max(8),
+  primary: import_zod21.z.boolean()
 });
-var ScreenListParams = import_zod19.z.strictObject({});
-var ScreenListResult = import_zod19.z.strictObject({ displays: import_zod19.z.array(ScreenDisplay).max(32) });
-var ScreenCaptureParams = import_zod19.z.strictObject({
+var ScreenListParams = import_zod21.z.strictObject({});
+var ScreenListResult = import_zod21.z.strictObject({ displays: import_zod21.z.array(ScreenDisplay).max(32) });
+var ScreenCaptureParams = import_zod21.z.strictObject({
   /** The display (from screen.list); the primary display when absent. */
   display_id: nonNegInt.optional(),
-  format: import_zod19.z.enum(["jpeg", "png"]).default("jpeg"),
+  format: import_zod21.z.enum(["jpeg", "png"]).default("jpeg"),
   /** Scale the picture down to at most this width in pixels (kept when already smaller). */
-  max_width: import_zod19.z.int().min(160).max(7680).default(1600)
+  max_width: import_zod21.z.int().min(160).max(7680).default(1600)
 });
-var ScreenCaptureResult = import_zod19.z.strictObject({
+var ScreenCaptureResult = import_zod21.z.strictObject({
   display_id: nonNegInt,
-  mime_type: import_zod19.z.enum(["image/jpeg", "image/png"]),
-  width: import_zod19.z.int().min(1),
-  height: import_zod19.z.int().min(1),
+  mime_type: import_zod21.z.enum(["image/jpeg", "image/png"]),
+  width: import_zod21.z.int().min(1),
+  height: import_zod21.z.int().min(1),
   /** The display's full resolution in pixels, before scaling. */
-  source_width: import_zod19.z.int().min(1),
-  source_height: import_zod19.z.int().min(1),
+  source_width: import_zod21.z.int().min(1),
+  source_height: import_zod21.z.int().min(1),
   /** The image, base64 (at most 6 MiB of text). */
-  data_base64: import_zod19.z.string().max(6291456)
+  data_base64: import_zod21.z.string().max(6291456)
 });
 
 // src/schema/window.ts
-var import_zod20 = require("zod");
-var WindowInfo = import_zod20.z.strictObject({
+var import_zod22 = require("zod");
+var WindowInfo = import_zod22.z.strictObject({
   /** The OS's window handle (macOS window number, Windows HWND, X11 window id). */
   id: nonNegInt,
-  title: import_zod20.z.string().max(512),
+  title: import_zod22.z.string().max(512),
   /** Position and size in logical points. */
-  x: import_zod20.z.int(),
-  y: import_zod20.z.int(),
-  width: import_zod20.z.int().min(0),
-  height: import_zod20.z.int().min(0),
+  x: import_zod22.z.int(),
+  y: import_zod22.z.int(),
+  width: import_zod22.z.int().min(0),
+  height: import_zod22.z.int().min(0),
   /**
    * The application that owns the window, by the name the OS shows people; absent when the OS does
    * not say. Optional (never null, the schema rule) because it was added in protocol 1.7: an older
    * app's answer has no such field (FIELDS_SINCE).
    */
-  app: import_zod20.z.string().max(256).optional(),
+  app: import_zod22.z.string().max(256).optional(),
   /** The owning process id; absent when the OS does not say. Added in protocol 1.7. */
-  pid: import_zod20.z.int().min(0).optional()
+  pid: import_zod22.z.int().min(0).optional()
 });
-var WindowListParams = import_zod20.z.strictObject({
+var WindowListParams = import_zod22.z.strictObject({
   /** Case-insensitive substring of the window title. */
-  title: import_zod20.z.string().min(1).max(256).optional(),
-  limit: import_zod20.z.int().min(1).max(500).default(100)
+  title: import_zod22.z.string().min(1).max(256).optional(),
+  limit: import_zod22.z.int().min(1).max(500).default(100)
 });
-var WindowListResult = import_zod20.z.strictObject({
-  windows: import_zod20.z.array(WindowInfo).max(500),
+var WindowListResult = import_zod22.z.strictObject({
+  windows: import_zod22.z.array(WindowInfo).max(500),
   total: nonNegInt,
-  truncated: import_zod20.z.boolean()
+  truncated: import_zod22.z.boolean()
 });
-var WindowFocusParams = import_zod20.z.strictObject({ id: nonNegInt });
-var WindowFocusResult = import_zod20.z.strictObject({ window: WindowInfo });
-var WindowMoveParams = import_zod20.z.strictObject({
+var WindowFocusParams = import_zod22.z.strictObject({ id: nonNegInt });
+var WindowFocusResult = import_zod22.z.strictObject({ window: WindowInfo });
+var WindowMoveParams = import_zod22.z.strictObject({
   id: nonNegInt,
   /** New top-left corner; unchanged when absent. */
-  x: import_zod20.z.int().optional(),
-  y: import_zod20.z.int().optional(),
+  x: import_zod22.z.int().optional(),
+  y: import_zod22.z.int().optional(),
   /** New size; unchanged when absent. */
-  width: import_zod20.z.int().min(50).max(16384).optional(),
-  height: import_zod20.z.int().min(50).max(16384).optional()
+  width: import_zod22.z.int().min(50).max(16384).optional(),
+  height: import_zod22.z.int().min(50).max(16384).optional()
 });
-var WindowMoveResult = import_zod20.z.strictObject({ window: WindowInfo });
-var WindowMinimizeParams = import_zod20.z.strictObject({ id: nonNegInt });
-var WindowMinimizeResult = import_zod20.z.strictObject({ id: nonNegInt });
+var WindowMoveResult = import_zod22.z.strictObject({ window: WindowInfo });
+var WindowMinimizeParams = import_zod22.z.strictObject({ id: nonNegInt });
+var WindowMinimizeResult = import_zod22.z.strictObject({ id: nonNegInt });
 
 // src/schema/input.ts
-var import_zod21 = require("zod");
-var InputKey = import_zod21.z.enum([
+var import_zod23 = require("zod");
+var InputKey = import_zod23.z.enum([
   "cmd",
   "ctrl",
   "alt",
@@ -2083,65 +2256,65 @@ var InputKey = import_zod21.z.enum([
   "backslash",
   "grave"
 ]);
-var InputTypeTextParams = import_zod21.z.strictObject({ text: import_zod21.z.string().min(1).max(1e4) });
-var InputTypeTextResult = import_zod21.z.strictObject({ characters: import_zod21.z.int().min(1) });
-var InputHotkeyParams = import_zod21.z.strictObject({
+var InputTypeTextParams = import_zod23.z.strictObject({ text: import_zod23.z.string().min(1).max(1e4) });
+var InputTypeTextResult = import_zod23.z.strictObject({ characters: import_zod23.z.int().min(1) });
+var InputHotkeyParams = import_zod23.z.strictObject({
   /** Pressed together in order and released in reverse: ["cmd", "shift", "t"]. */
-  keys: import_zod21.z.array(InputKey).min(1).max(6)
+  keys: import_zod23.z.array(InputKey).min(1).max(6)
 });
-var InputHotkeyResult = import_zod21.z.strictObject({ keys: import_zod21.z.array(InputKey) });
-var InputPoint = import_zod21.z.strictObject({ x: import_zod21.z.int(), y: import_zod21.z.int() });
-var InputMouseMoveParams = import_zod21.z.strictObject({
+var InputHotkeyResult = import_zod23.z.strictObject({ keys: import_zod23.z.array(InputKey) });
+var InputPoint = import_zod23.z.strictObject({ x: import_zod23.z.int(), y: import_zod23.z.int() });
+var InputMouseMoveParams = import_zod23.z.strictObject({
   /** Screen position in logical points (the coordinates screen.list and window.list report). */
-  x: import_zod21.z.int(),
-  y: import_zod21.z.int()
+  x: import_zod23.z.int(),
+  y: import_zod23.z.int()
 });
-var InputMouseMoveResult = import_zod21.z.strictObject({
+var InputMouseMoveResult = import_zod23.z.strictObject({
   /** Where the pointer is now, read back from the OS. */
   position: InputPoint
 });
-var InputMouseClickParams = import_zod21.z.strictObject({
+var InputMouseClickParams = import_zod23.z.strictObject({
   /** Move here first; clicks where the pointer is when absent. */
-  x: import_zod21.z.int().optional(),
-  y: import_zod21.z.int().optional(),
-  button: import_zod21.z.enum(["left", "right", "middle"]).default("left"),
-  double: import_zod21.z.boolean().default(false)
+  x: import_zod23.z.int().optional(),
+  y: import_zod23.z.int().optional(),
+  button: import_zod23.z.enum(["left", "right", "middle"]).default("left"),
+  double: import_zod23.z.boolean().default(false)
 });
-var InputMouseClickResult = import_zod21.z.strictObject({
+var InputMouseClickResult = import_zod23.z.strictObject({
   position: InputPoint,
-  button: import_zod21.z.enum(["left", "right", "middle"]),
-  double: import_zod21.z.boolean()
+  button: import_zod23.z.enum(["left", "right", "middle"]),
+  double: import_zod23.z.boolean()
 });
 
 // src/schema/power.ts
-var import_zod22 = require("zod");
-var PowerStatusParams = import_zod22.z.strictObject({});
-var PowerStatusResult = import_zod22.z.strictObject({
-  has_battery: import_zod22.z.boolean(),
+var import_zod24 = require("zod");
+var PowerStatusParams = import_zod24.z.strictObject({});
+var PowerStatusResult = import_zod24.z.strictObject({
+  has_battery: import_zod24.z.boolean(),
   /** 0–100; null without a battery. */
-  percent: import_zod22.z.number().min(0).max(100).nullable(),
-  charging: import_zod22.z.boolean().nullable(),
+  percent: import_zod24.z.number().min(0).max(100).nullable(),
+  charging: import_zod24.z.boolean().nullable(),
   /** On wall power; null where the OS does not say. */
-  plugged_in: import_zod22.z.boolean().nullable(),
+  plugged_in: import_zod24.z.boolean().nullable(),
   /** Minutes of battery left; null when charging, unknown or without a battery. */
   minutes_left: nonNegInt.nullable(),
   /** Matrx 2 is keeping the computer awake (power.prevent_sleep) until this time; null when it is not. */
   awake_until_ms: epochMs.nullable()
 });
-var PowerPreventSleepParams = import_zod22.z.strictObject({
+var PowerPreventSleepParams = import_zod24.z.strictObject({
   /** Keep the computer awake this long; 0 lets it sleep again now. */
-  seconds: import_zod22.z.int().min(0).max(86400),
+  seconds: import_zod24.z.int().min(0).max(86400),
   /** Shown where the OS lists what keeps it awake. */
-  reason: import_zod22.z.string().min(1).max(128).default("Matrx 2 is working")
+  reason: import_zod24.z.string().min(1).max(128).default("Matrx 2 is working")
 });
-var PowerPreventSleepResult = import_zod22.z.strictObject({
+var PowerPreventSleepResult = import_zod24.z.strictObject({
   /** When it may sleep again; null after seconds 0. */
   awake_until_ms: epochMs.nullable()
 });
 
 // src/schema/diag.ts
-var import_zod23 = require("zod");
-var DiagProcess = import_zod23.z.enum([
+var import_zod25 = require("zod");
+var DiagProcess = import_zod25.z.enum([
   "main",
   "renderer",
   "hosted_page",
@@ -2154,7 +2327,7 @@ var DiagProcess = import_zod23.z.enum([
   "coding_sessions",
   "claude_accounts"
 ]);
-var DiagErrorKind = import_zod23.z.enum([
+var DiagErrorKind = import_zod25.z.enum([
   "uncaught_exception",
   "unhandled_rejection",
   "renderer_crash",
@@ -2166,148 +2339,148 @@ var DiagErrorKind = import_zod23.z.enum([
   "banner",
   "logged_error"
 ]);
-var DiagErrorStatus = import_zod23.z.enum(["waiting", "sent", "resolved"]);
-var DiagErrorEntry = import_zod23.z.strictObject({
+var DiagErrorStatus = import_zod25.z.enum(["waiting", "sent", "resolved"]);
+var DiagErrorEntry = import_zod25.z.strictObject({
   /** sha256 prefix over process, kind, source, code and the normalized message. */
-  signature: import_zod23.z.string().regex(/^[0-9a-f]{32}$/),
+  signature: import_zod25.z.string().regex(/^[0-9a-f]{32}$/),
   process: DiagProcess,
   kind: DiagErrorKind,
   /** Where: a cap.op, a log event, a screen or page name. */
-  source: import_zod23.z.string().min(1).max(128),
+  source: import_zod25.z.string().min(1).max(128),
   /** An ErrorCode, an exit code or signal, an error class; null when there is none. */
-  code: import_zod23.z.string().max(64).nullable(),
+  code: import_zod25.z.string().max(64).nullable(),
   /** The first occurrence's message, personal data removed. */
-  message: import_zod23.z.string().max(500),
+  message: import_zod25.z.string().max(500),
   count: nonNegInt,
   first_seen_ms: epochMs,
   last_seen_ms: epochMs,
   status: DiagErrorStatus,
   /** What the agent who resolved it wrote; null until resolved. */
-  resolution_note: import_zod23.z.string().max(500).nullable(),
-  app_version: import_zod23.z.string().max(64)
+  resolution_note: import_zod25.z.string().max(500).nullable(),
+  app_version: import_zod25.z.string().max(64)
 });
-var DiagErrorsListParams = import_zod23.z.strictObject({
+var DiagErrorsListParams = import_zod25.z.strictObject({
   /** open = waiting or sent; all includes resolved. */
-  status: import_zod23.z.enum(["open", "all"]).default("open"),
-  limit: import_zod23.z.int().min(1).max(500).default(200)
+  status: import_zod25.z.enum(["open", "all"]).default("open"),
+  limit: import_zod25.z.int().min(1).max(500).default(200)
 });
-var DiagErrorsListResult = import_zod23.z.strictObject({
+var DiagErrorsListResult = import_zod25.z.strictObject({
   /** Newest last_seen first. */
-  entries: import_zod23.z.array(DiagErrorEntry).max(500),
+  entries: import_zod25.z.array(DiagErrorEntry).max(500),
   total_signatures: nonNegInt,
   total_occurrences: nonNegInt,
   /** Signatures with occurrences not yet delivered. */
   waiting: nonNegInt,
   /** signed_out = kept until sign-in; ok = the last delivery worked; failing = the last delivery failed (kept, retried). */
-  delivery: import_zod23.z.enum(["signed_out", "ok", "failing"]),
+  delivery: import_zod25.z.enum(["signed_out", "ok", "failing"]),
   last_delivery_ms: epochMs.nullable()
 });
-var DiagErrorsReportParams = import_zod23.z.strictObject({
-  process: import_zod23.z.enum(["renderer", "hosted_page"]),
-  kind: import_zod23.z.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
+var DiagErrorsReportParams = import_zod25.z.strictObject({
+  process: import_zod25.z.enum(["renderer", "hosted_page"]),
+  kind: import_zod25.z.enum(["uncaught_exception", "unhandled_rejection", "console_error", "banner"]),
   /** The screen or page, e.g. "code.chats". */
-  source: import_zod23.z.string().min(1).max(128),
-  message: import_zod23.z.string().min(1).max(2e3),
-  code: import_zod23.z.string().max(64).optional(),
-  stack: import_zod23.z.string().max(8e3).optional()
+  source: import_zod25.z.string().min(1).max(128),
+  message: import_zod25.z.string().min(1).max(2e3),
+  code: import_zod25.z.string().max(64).optional(),
+  stack: import_zod25.z.string().max(8e3).optional()
 });
-var DiagErrorsReportResult = import_zod23.z.strictObject({
-  signature: import_zod23.z.string().regex(/^[0-9a-f]{32}$/)
+var DiagErrorsReportResult = import_zod25.z.strictObject({
+  signature: import_zod25.z.string().regex(/^[0-9a-f]{32}$/)
 });
-var DiagErrorsChangedEvent = import_zod23.z.strictObject({
+var DiagErrorsChangedEvent = import_zod25.z.strictObject({
   total_signatures: nonNegInt,
   waiting: nonNegInt
 });
 
 // src/schema/resources.ts
-var import_zod24 = require("zod");
-var ResourcesDisk = import_zod24.z.strictObject({
+var import_zod26 = require("zod");
+var ResourcesDisk = import_zod26.z.strictObject({
   /** Where it is mounted ("/", "C:"). */
-  mount: import_zod24.z.string().max(512),
+  mount: import_zod26.z.string().max(512),
   /** The volume's name as the file manager shows it ("Macintosh HD", "Local Disk (C:)"). Since 1.17. */
-  name: import_zod24.z.string().max(256).optional(),
+  name: import_zod26.z.string().max(256).optional(),
   /** The file system ("apfs", "NTFS", "ext4"). */
-  fs: import_zod24.z.string().max(64),
+  fs: import_zod26.z.string().max(64),
   size_bytes: nonNegInt,
   used_bytes: nonNegInt,
   available_bytes: nonNegInt
 });
-var ResourcesSnapshotParams = import_zod24.z.strictObject({});
-var ResourcesSnapshotResult = import_zod24.z.strictObject({
-  cpu: import_zod24.z.strictObject({
+var ResourcesSnapshotParams = import_zod26.z.strictObject({});
+var ResourcesSnapshotResult = import_zod26.z.strictObject({
+  cpu: import_zod26.z.strictObject({
     /** Busy share of all cores, 0–100, measured now. */
-    percent: import_zod24.z.number().min(0).max(100),
-    cores: import_zod24.z.int().min(1),
+    percent: import_zod26.z.number().min(0).max(100),
+    cores: import_zod26.z.int().min(1),
     /** 1, 5 and 15 minute load averages; null on Windows. */
-    load: import_zod24.z.array(import_zod24.z.number().min(0)).length(3).nullable()
+    load: import_zod26.z.array(import_zod26.z.number().min(0)).length(3).nullable()
   }),
-  memory: import_zod24.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
-  swap: import_zod24.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
-  disks: import_zod24.z.array(ResourcesDisk).max(64),
+  memory: import_zod26.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt, available_bytes: nonNegInt }),
+  swap: import_zod26.z.strictObject({ total_bytes: nonNegInt, used_bytes: nonNegInt }),
+  disks: import_zod26.z.array(ResourcesDisk).max(64),
   uptime_seconds: nonNegInt
 });
-var ResourcesJobKind = import_zod24.z.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
-var ResourcesStrain = import_zod24.z.enum(["good", "strain", "overloaded"]);
-var ResourcesPressure = import_zod24.z.enum(["normal", "warning", "critical"]);
-var ResourcesJob = import_zod24.z.strictObject({
+var ResourcesJobKind = import_zod26.z.enum(["type-check", "tests", "build", "lint", "dev server", "language server", "search"]);
+var ResourcesStrain = import_zod26.z.enum(["good", "strain", "overloaded"]);
+var ResourcesPressure = import_zod26.z.enum(["normal", "warning", "critical"]);
+var ResourcesJob = import_zod26.z.strictObject({
   /** The job's root process (Stop takes its whole tree). */
-  pid: import_zod24.z.int().min(0),
+  pid: import_zod26.z.int().min(0),
   kind: ResourcesJobKind,
   /** Its heaviest process's command line, shortened ("…/lib/tsc --noEmit -p tsconfig.json"). */
-  command: import_zod24.z.string().max(256),
+  command: import_zod26.z.string().max(256),
   /** Who started it: "Claude Code", "Codex", "Cursor", "VS Code", "Terminal", "local stack", "detached"; null when unknown. */
-  started_by: import_zod24.z.string().max(64).nullable(),
+  started_by: import_zod26.z.string().max(64).nullable(),
   /** Whatever started it is gone and nothing waits for it. */
-  orphan: import_zod24.z.boolean(),
+  orphan: import_zod26.z.boolean(),
   /** A type-check queued for its turn (no compiler running yet). */
-  waiting: import_zod24.z.boolean(),
+  waiting: import_zod26.z.boolean(),
   /** The project folder it runs in ("matrx-frontend"); null when not in one. */
-  folder: import_zod24.z.string().max(256).nullable(),
+  folder: import_zod26.z.string().max(256).nullable(),
   /** The same command in the same folder, running this many times (1 = no duplicate). */
-  duplicates: import_zod24.z.int().min(1),
-  processes: import_zod24.z.int().min(1),
+  duplicates: import_zod26.z.int().min(1),
+  processes: import_zod26.z.int().min(1),
   /** Sum over the tree, as `ps` reports it: 100 = one full core. */
-  cpu_percent: import_zod24.z.number().min(0),
+  cpu_percent: import_zod26.z.number().min(0),
   /** Real memory (macOS: the physical footprint Activity Monitor shows, compressed included). */
   memory_bytes: nonNegInt,
   started_at_ms: epochMs.nullable(),
   /** False for an app, an agent session, a terminal, a system process, the local stack or Matrx 2 itself. */
-  stoppable: import_zod24.z.boolean()
+  stoppable: import_zod26.z.boolean()
 });
-var ResourcesProcess = import_zod24.z.strictObject({
-  pid: import_zod24.z.int().min(0),
+var ResourcesProcess = import_zod26.z.strictObject({
+  pid: import_zod26.z.int().min(0),
   /** The command line, shortened. */
-  name: import_zod24.z.string().max(256),
-  cpu_percent: import_zod24.z.number().min(0),
+  name: import_zod26.z.string().max(256),
+  cpu_percent: import_zod26.z.number().min(0),
   memory_bytes: nonNegInt,
-  started_by: import_zod24.z.string().max(64).nullable(),
+  started_by: import_zod26.z.string().max(64).nullable(),
   /** The job it belongs to ("type-check in aidream"); null when none. */
-  job: import_zod24.z.string().max(256).nullable(),
+  job: import_zod26.z.string().max(256).nullable(),
   started_at_ms: epochMs.nullable()
 });
-var ResourcesVerdict = import_zod24.z.strictObject({
+var ResourcesVerdict = import_zod26.z.strictObject({
   level: ResourcesStrain,
   /** One sentence ("Your Mac is under strain. 3 type-checks are running at once."). */
-  text: import_zod24.z.string().max(256),
+  text: import_zod26.z.string().max(256),
   /** The biggest jobs behind it; null when all is well. */
-  cause: import_zod24.z.string().max(1024).nullable()
+  cause: import_zod26.z.string().max(1024).nullable()
 });
-var ResourcesSample = import_zod24.z.strictObject({
+var ResourcesSample = import_zod26.z.strictObject({
   at_ms: epochMs,
   /** The 1-minute load average. */
-  load: import_zod24.z.number().min(0),
+  load: import_zod26.z.number().min(0),
   memory_used_bytes: nonNegInt,
   typechecks: nonNegInt
 });
-var ResourcesActivityParams = import_zod24.z.strictObject({});
-var ResourcesActivityResult = import_zod24.z.strictObject({
+var ResourcesActivityParams = import_zod26.z.strictObject({});
+var ResourcesActivityResult = import_zod26.z.strictObject({
   /** False until the first reading (a second or two after start). */
-  ready: import_zod24.z.boolean(),
+  ready: import_zod26.z.boolean(),
   sampled_at_ms: epochMs.nullable(),
-  cores: import_zod24.z.int().min(1),
+  cores: import_zod26.z.int().min(1),
   /** 1, 5 and 15 minute load averages. */
-  load: import_zod24.z.array(import_zod24.z.number().min(0)).length(3),
-  memory: import_zod24.z.strictObject({
+  load: import_zod26.z.array(import_zod26.z.number().min(0)).length(3),
+  memory: import_zod26.z.strictObject({
     total_bytes: nonNegInt,
     /** Activity Monitor's Memory Used: app memory + wired + compressed. */
     used_bytes: nonNegInt,
@@ -2318,252 +2491,252 @@ var ResourcesActivityResult = import_zod24.z.strictObject({
     pressure: ResourcesPressure.nullable()
   }),
   verdict: ResourcesVerdict,
-  typechecks: import_zod24.z.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
+  typechecks: import_zod26.z.strictObject({ running: nonNegInt, waiting: nonNegInt, comfort: nonNegInt }),
   /** Heaviest first (1 GB weighs as much as 16 % of a core). */
-  jobs: import_zod24.z.array(ResourcesJob).max(200),
+  jobs: import_zod26.z.array(ResourcesJob).max(200),
   /** The 15 heaviest by memory and the 15 busiest by CPU, together. */
-  top: import_zod24.z.array(ResourcesProcess).max(30),
+  top: import_zod26.z.array(ResourcesProcess).max(30),
   /** The last hour, oldest first. */
-  history: import_zod24.z.array(ResourcesSample).max(1200)
+  history: import_zod26.z.array(ResourcesSample).max(1200)
 });
-var ResourcesStopJobParams = import_zod24.z.strictObject({ pid: import_zod24.z.int().min(1) });
-var ResourcesStopJobResult = import_zod24.z.strictObject({
+var ResourcesStopJobParams = import_zod26.z.strictObject({ pid: import_zod26.z.int().min(1) });
+var ResourcesStopJobResult = import_zod26.z.strictObject({
   /** Processes signalled; whatever is still running 5 seconds later is force-stopped. */
   processes: nonNegInt,
   /** It had finished before the request arrived. */
-  already_finished: import_zod24.z.boolean()
+  already_finished: import_zod26.z.boolean()
 });
-var ResourcesIncident = import_zod24.z.strictObject({
+var ResourcesIncident = import_zod26.z.strictObject({
   at_ms: epochMs,
   verdict: ResourcesVerdict,
-  load: import_zod24.z.number().min(0),
+  load: import_zod26.z.number().min(0),
   memory_used_bytes: nonNegInt,
   compressed_bytes: nonNegInt,
   pressure: ResourcesPressure.nullable(),
-  jobs: import_zod24.z.array(
-    import_zod24.z.strictObject({
+  jobs: import_zod26.z.array(
+    import_zod26.z.strictObject({
       kind: ResourcesJobKind,
-      started_by: import_zod24.z.string().max(64).nullable(),
-      folder: import_zod24.z.string().max(256).nullable(),
-      command: import_zod24.z.string().max(256),
-      cpu_percent: import_zod24.z.number().min(0),
+      started_by: import_zod26.z.string().max(64).nullable(),
+      folder: import_zod26.z.string().max(256).nullable(),
+      command: import_zod26.z.string().max(256),
+      cpu_percent: import_zod26.z.number().min(0),
       memory_bytes: nonNegInt,
-      duplicates: import_zod24.z.int().min(1)
+      duplicates: import_zod26.z.int().min(1)
     })
   ).max(8)
 });
-var ResourcesIncidentsParams = import_zod24.z.strictObject({ limit: import_zod24.z.int().min(1).max(200).default(50) });
-var ResourcesIncidentsResult = import_zod24.z.strictObject({
+var ResourcesIncidentsParams = import_zod26.z.strictObject({ limit: import_zod26.z.int().min(1).max(200).default(50) });
+var ResourcesIncidentsResult = import_zod26.z.strictObject({
   /** Newest first; at most one a minute is written. */
-  incidents: import_zod24.z.array(ResourcesIncident).max(200)
+  incidents: import_zod26.z.array(ResourcesIncident).max(200)
 });
 
 // src/schema/stack.ts
-var import_zod25 = require("zod");
-var StackServerName = import_zod25.z.string().regex(/^[a-z0-9_-]{1,64}$/);
-var StackTone = import_zod25.z.enum(["good", "wait", "bad", "off"]);
-var StackServer = import_zod25.z.strictObject({
+var import_zod27 = require("zod");
+var StackServerName = import_zod27.z.string().regex(/^[a-z0-9_-]{1,64}$/);
+var StackTone = import_zod27.z.enum(["good", "wait", "bad", "off"]);
+var StackServer = import_zod27.z.strictObject({
   name: StackServerName,
   /** One word: Healthy, Starting, Unhealthy, Restarting, Stopping, Waiting, Stopped, Crashed, Off. */
-  label: import_zod25.z.string().max(32),
+  label: import_zod27.z.string().max(32),
   tone: StackTone,
   /** What is going on, in one or two plain sentences. */
-  sentence: import_zod25.z.string().max(2e3),
+  sentence: import_zod27.z.string().max(2e3),
   /** The config's own description of the server. */
-  description: import_zod25.z.string().max(512),
+  description: import_zod27.z.string().max(512),
   /** Where the server answers, when its description names an address. */
-  open_url: import_zod25.z.string().max(2048).nullable(),
-  log_file: import_zod25.z.string().max(4096),
+  open_url: import_zod27.z.string().max(2048).nullable(),
+  log_file: import_zod27.z.string().max(4096),
   /** When its log file was last written. */
   last_output_at_ms: epochMs.nullable(),
   started_at_ms: epochMs.nullable(),
   restarts: nonNegInt,
-  exit_code: import_zod25.z.int().nullable(),
-  pid: import_zod25.z.int().nullable(),
+  exit_code: import_zod27.z.int().nullable(),
+  pid: import_zod27.z.int().nullable(),
   /** (1.18) CPU of the server's process and everything under it, in percent of one core; absent when it is not running. */
-  cpu_percent: import_zod25.z.number().min(0).optional(),
+  cpu_percent: import_zod27.z.number().min(0).optional(),
   /** (1.18) Memory of the same processes: the physical footprint (Activity Monitor's Memory) summed; absent when it is not running. */
   memory_bytes: nonNegInt.optional()
 });
-var StackEvent = import_zod25.z.strictObject({
+var StackEvent = import_zod27.z.strictObject({
   at_ms: epochMs,
   /** A server name, or "stack" for the stack as a whole. */
-  server: import_zod25.z.string().max(64),
+  server: import_zod27.z.string().max(64),
   /** started · stopped · healthy · unhealthy · crashed · exited · restarting · stopping · action · action-done · action-failed · setup · error */
-  kind: import_zod25.z.string().max(32),
-  text: import_zod25.z.string().max(4e3)
+  kind: import_zod27.z.string().max(32),
+  text: import_zod27.z.string().max(4e3)
 });
-var StackStateParams = import_zod25.z.strictObject({});
-var StackStateResult = import_zod25.z.strictObject({
+var StackStateParams = import_zod27.z.strictObject({});
+var StackStateResult = import_zod27.z.strictObject({
   /** The stack's config file, when found. */
-  config_path: import_zod25.z.string().max(4096).nullable(),
+  config_path: import_zod27.z.string().max(4096).nullable(),
   /** Why the stack cannot be run from here (no config, no process-compose), else null. */
-  problem: import_zod25.z.string().max(1e3).nullable(),
-  stack_up: import_zod25.z.boolean(),
+  problem: import_zod27.z.string().max(1e3).nullable(),
+  stack_up: import_zod27.z.boolean(),
   stack_started_at_ms: epochMs.nullable(),
-  servers: import_zod25.z.array(StackServer).max(64),
+  servers: import_zod27.z.array(StackServer).max(64),
   /** One line about the one-shot setup steps ("Docker Desktop: running."), or null. */
-  setup_note: import_zod25.z.string().max(500).nullable(),
+  setup_note: import_zod27.z.string().max(500).nullable(),
   /** Start everything / Stop everything in flight. */
-  pending: import_zod25.z.strictObject({ verb: import_zod25.z.enum(["start", "stop"]), label: import_zod25.z.string().max(64), since_ms: epochMs }).nullable(),
+  pending: import_zod27.z.strictObject({ verb: import_zod27.z.enum(["start", "stop"]), label: import_zod27.z.string().max(64), since_ms: epochMs }).nullable(),
   /** The newest entries last. */
-  events: import_zod25.z.array(StackEvent).max(300)
+  events: import_zod27.z.array(StackEvent).max(300)
 });
-var StackStartParams = import_zod25.z.strictObject({});
-var StackStopParams = import_zod25.z.strictObject({});
-var StackRunResult = import_zod25.z.strictObject({ accepted: import_zod25.z.boolean() });
-var StackServerActionParams = import_zod25.z.strictObject({
+var StackStartParams = import_zod27.z.strictObject({});
+var StackStopParams = import_zod27.z.strictObject({});
+var StackRunResult = import_zod27.z.strictObject({ accepted: import_zod27.z.boolean() });
+var StackServerActionParams = import_zod27.z.strictObject({
   name: StackServerName,
-  verb: import_zod25.z.enum(["start", "stop", "restart"])
+  verb: import_zod27.z.enum(["start", "stop", "restart"])
 });
-var StackServerActionResult = import_zod25.z.strictObject({ message: import_zod25.z.string().max(1e3) });
-var StackLogsParams = import_zod25.z.strictObject({
+var StackServerActionResult = import_zod27.z.strictObject({ message: import_zod27.z.string().max(1e3) });
+var StackLogsParams = import_zod27.z.strictObject({
   name: StackServerName,
   /** Without `offset`: the last this-many complete lines. With it: new lines after it, at most this many. */
-  lines: import_zod25.z.int().min(1).max(2e5).default(2e3),
+  lines: import_zod27.z.int().min(1).max(2e5).default(2e3),
   /** Byte offset the last read ended at: answer only what was written after it (follow). */
   offset: nonNegInt.optional(),
   /** A "Clear" point: the lines written after this byte offset (no `offset`). */
   since: nonNegInt.optional(),
   /** With `offset`: wait up to this long for a new line when none is waiting (0 answers at once). */
-  wait_ms: import_zod25.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod27.z.int().min(0).max(25e3).default(0)
 });
-var StackLogsResult = import_zod25.z.strictObject({
+var StackLogsResult = import_zod27.z.strictObject({
   /** Complete lines, colour codes removed. */
-  lines: import_zod25.z.array(import_zod25.z.string().max(65536)).max(2e5),
+  lines: import_zod27.z.array(import_zod27.z.string().max(65536)).max(2e5),
   /** Where these lines end: pass it back as `offset` to follow. */
   offset: nonNegInt,
   /** False when `since` no longer exists (the log rotated): the lines are the plain tail instead. */
-  since_valid: import_zod25.z.boolean(),
+  since_valid: import_zod27.z.boolean(),
   /** The log was rotated or truncated since `offset`: these lines start the file again. */
-  reset: import_zod25.z.boolean(),
-  log_file: import_zod25.z.string().max(4096)
+  reset: import_zod27.z.boolean(),
+  log_file: import_zod27.z.string().max(4096)
 });
-var StackErrorsParams = import_zod25.z.strictObject({
-  window_minutes: import_zod25.z.int().min(1).max(1440).default(60)
+var StackErrorsParams = import_zod27.z.strictObject({
+  window_minutes: import_zod27.z.int().min(1).max(1440).default(60)
 });
-var StackErrorsResult = import_zod25.z.strictObject({
+var StackErrorsResult = import_zod27.z.strictObject({
   /** Per server: a heading line ("=== aidream — errors in the last 60 minutes (<file>) ===") and each error with the 10 lines after it. */
-  sections: import_zod25.z.array(import_zod25.z.strictObject({ name: StackServerName, heading: import_zod25.z.string().max(4096), lines: import_zod25.z.array(import_zod25.z.string().max(65536)).max(5e3) })).max(64),
-  window_minutes: import_zod25.z.int().min(1).max(1440)
+  sections: import_zod27.z.array(import_zod27.z.strictObject({ name: StackServerName, heading: import_zod27.z.string().max(4096), lines: import_zod27.z.array(import_zod27.z.string().max(65536)).max(5e3) })).max(64),
+  window_minutes: import_zod27.z.int().min(1).max(1440)
 });
 
 // src/schema/audio.ts
-var import_zod26 = require("zod");
-var AudioDevice = import_zod26.z.strictObject({
+var import_zod28 = require("zod");
+var AudioDevice = import_zod28.z.strictObject({
   /** The OS's name for it, as audio.record takes it. */
-  id: import_zod26.z.string().min(1).max(256),
-  name: import_zod26.z.string().max(256),
-  default: import_zod26.z.boolean()
+  id: import_zod28.z.string().min(1).max(256),
+  name: import_zod28.z.string().max(256),
+  default: import_zod28.z.boolean()
 });
-var AudioDevicesParams = import_zod26.z.strictObject({});
-var AudioDevicesResult = import_zod26.z.strictObject({
-  inputs: import_zod26.z.array(AudioDevice).max(64),
-  outputs: import_zod26.z.array(AudioDevice).max(64)
+var AudioDevicesParams = import_zod28.z.strictObject({});
+var AudioDevicesResult = import_zod28.z.strictObject({
+  inputs: import_zod28.z.array(AudioDevice).max(64),
+  outputs: import_zod28.z.array(AudioDevice).max(64)
 });
-var AudioRecordParams = import_zod26.z.strictObject({
-  seconds: import_zod26.z.number().min(0.5).max(600),
+var AudioRecordParams = import_zod28.z.strictObject({
+  seconds: import_zod28.z.number().min(0.5).max(600),
   /** The microphone (from audio.devices); the default input when absent. */
-  device_id: import_zod26.z.string().min(1).max(256).optional(),
+  device_id: import_zod28.z.string().min(1).max(256).optional(),
   /** Where the WAV file goes; a new file in the temp folder when absent. */
   path: AbsPath.optional()
 });
-var AudioRecordResult = import_zod26.z.strictObject({
+var AudioRecordResult = import_zod28.z.strictObject({
   path: AbsPath,
-  seconds: import_zod26.z.number().min(0),
+  seconds: import_zod28.z.number().min(0),
   bytes: nonNegInt,
   /** Loudest sample, 0–1: 0 means the device gave silence. */
-  peak: import_zod26.z.number().min(0).max(1)
+  peak: import_zod28.z.number().min(0).max(1)
 });
-var AudioPlayParams = import_zod26.z.strictObject({ path: AbsPath });
-var AudioPlayResult = import_zod26.z.strictObject({ path: AbsPath, seconds: import_zod26.z.number().min(0) });
+var AudioPlayParams = import_zod28.z.strictObject({ path: AbsPath });
+var AudioPlayResult = import_zod28.z.strictObject({ path: AbsPath, seconds: import_zod28.z.number().min(0) });
 
 // src/schema/fs-watch.ts
-var import_zod27 = require("zod");
-var FsWatchId = import_zod27.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
-var FsWatchStartParams = import_zod27.z.strictObject({
+var import_zod29 = require("zod");
+var FsWatchId = import_zod29.z.string().regex(/^fw_[A-Za-z0-9]{12,40}$/);
+var FsWatchStartParams = import_zod29.z.strictObject({
   path: AbsPath,
-  recursive: import_zod27.z.boolean().default(true),
+  recursive: import_zod29.z.boolean().default(true),
   /** Globs relative to `path` whose changes are not reported (".git/**", "node_modules/**"). */
-  ignore: import_zod27.z.array(import_zod27.z.string().max(256)).max(64).default([])
+  ignore: import_zod29.z.array(import_zod29.z.string().max(256)).max(64).default([])
 });
-var FsWatchStartResult = import_zod27.z.strictObject({
+var FsWatchStartResult = import_zod29.z.strictObject({
   watch_id: FsWatchId,
   path: AbsPath,
   /** The watch ends by itself if nobody reads it for 30 minutes. */
   expires_at_ms: epochMs
 });
-var FsWatchEventsParams = import_zod27.z.strictObject({
+var FsWatchEventsParams = import_zod29.z.strictObject({
   watch_id: FsWatchId,
   /** Wait up to this long for a first change when none is waiting (0 answers at once). */
-  wait_ms: import_zod27.z.int().min(0).max(25e3).default(0)
+  wait_ms: import_zod29.z.int().min(0).max(25e3).default(0)
 });
-var FsWatchEventsResult = import_zod27.z.strictObject({
+var FsWatchEventsResult = import_zod29.z.strictObject({
   /** What changed since the last read, oldest first; re-checked against the disk when read. */
-  changes: import_zod27.z.array(FsChange).max(1e3),
+  changes: import_zod29.z.array(FsChange).max(1e3),
   /** Changes were dropped (more than 1000 waited): list the folder again. */
-  overflow: import_zod27.z.boolean(),
+  overflow: import_zod29.z.boolean(),
   expires_at_ms: epochMs
 });
-var FsWatchStopParams = import_zod27.z.strictObject({ watch_id: FsWatchId });
-var FsWatchStopResult = import_zod27.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopParams = import_zod29.z.strictObject({ watch_id: FsWatchId });
+var FsWatchStopResult = import_zod29.z.strictObject({ watch_id: FsWatchId });
 
 // src/schema/exec-job.ts
-var import_zod28 = require("zod");
-var ExecJobId = import_zod28.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
-var ExecJobStartParams = import_zod28.z.strictObject({
-  command: import_zod28.z.string().min(1).max(131072),
+var import_zod30 = require("zod");
+var ExecJobId = import_zod30.z.string().regex(/^job_[A-Za-z0-9]{12,40}$/);
+var ExecJobStartParams = import_zod30.z.strictObject({
+  command: import_zod30.z.string().min(1).max(131072),
   /** The folder it runs in; the home folder when absent. */
   cwd: AbsPath.optional(),
-  env: import_zod28.z.record(import_zod28.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod28.z.string().max(32768)).optional()
+  env: import_zod30.z.record(import_zod30.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), import_zod30.z.string().max(32768)).optional()
 });
-var ExecJobStartResult = import_zod28.z.strictObject({ job_id: ExecJobId, pid: import_zod28.z.int().min(1), cwd: AbsPath });
-var ExecJobOutputParams = import_zod28.z.strictObject({
+var ExecJobStartResult = import_zod30.z.strictObject({ job_id: ExecJobId, pid: import_zod30.z.int().min(1), cwd: AbsPath });
+var ExecJobOutputParams = import_zod30.z.strictObject({
   job_id: ExecJobId,
   /** Byte offset into the job's output to read from (next_offset of the last read; 0 = the start). */
   offset: nonNegInt.default(0),
   /** Wait up to this long for new output or the exit when none is waiting (0 answers at once). */
-  wait_ms: import_zod28.z.int().min(0).max(25e3).default(0),
-  max_bytes: import_zod28.z.int().min(1024).max(1048576).default(65536)
+  wait_ms: import_zod30.z.int().min(0).max(25e3).default(0),
+  max_bytes: import_zod30.z.int().min(1024).max(1048576).default(65536)
 });
-var ExecJobOutputResult = import_zod28.z.strictObject({
+var ExecJobOutputResult = import_zod30.z.strictObject({
   /** stdout and stderr interleaved as they arrived (UTF-8). */
-  output: import_zod28.z.string(),
+  output: import_zod30.z.string(),
   next_offset: nonNegInt,
   /** Bytes before `offset` that are gone (the job keeps its last 4 MiB). */
   dropped_bytes: nonNegInt,
-  running: import_zod28.z.boolean(),
-  exit_code: import_zod28.z.int().nullable()
+  running: import_zod30.z.boolean(),
+  exit_code: import_zod30.z.int().nullable()
 });
-var ExecJobStopParams = import_zod28.z.strictObject({
+var ExecJobStopParams = import_zod30.z.strictObject({
   job_id: ExecJobId,
   /** End it at once (SIGKILL; on Windows the whole tree with /F) instead of asking it to quit. */
-  force: import_zod28.z.boolean().default(false)
+  force: import_zod30.z.boolean().default(false)
 });
-var ExecJobStopResult = import_zod28.z.strictObject({ job_id: ExecJobId, exited: import_zod28.z.boolean(), exit_code: import_zod28.z.int().nullable() });
-var ExecJobInfo = import_zod28.z.strictObject({
+var ExecJobStopResult = import_zod30.z.strictObject({ job_id: ExecJobId, exited: import_zod30.z.boolean(), exit_code: import_zod30.z.int().nullable() });
+var ExecJobInfo = import_zod30.z.strictObject({
   job_id: ExecJobId,
-  command: import_zod28.z.string().max(1024),
-  pid: import_zod28.z.int().min(1),
+  command: import_zod30.z.string().max(1024),
+  pid: import_zod30.z.int().min(1),
   cwd: AbsPath,
-  running: import_zod28.z.boolean(),
-  exit_code: import_zod28.z.int().nullable(),
+  running: import_zod30.z.boolean(),
+  exit_code: import_zod30.z.int().nullable(),
   started_at_ms: epochMs,
   output_bytes: nonNegInt
 });
-var ExecJobListParams = import_zod28.z.strictObject({});
-var ExecJobListResult = import_zod28.z.strictObject({ jobs: import_zod28.z.array(ExecJobInfo).max(64) });
+var ExecJobListParams = import_zod30.z.strictObject({});
+var ExecJobListResult = import_zod30.z.strictObject({ jobs: import_zod30.z.array(ExecJobInfo).max(64) });
 
 // src/schema/coding.ts
-var import_zod29 = require("zod");
+var import_zod31 = require("zod");
 var import_uuid3 = require("@ai-matrx/kit/uuid");
-var CodingServiceCredentials = import_zod29.z.strictObject({
-  access_token: import_zod29.z.string().min(16).max(16384),
-  user_id: import_zod29.z.string().regex(import_uuid3.UUID_SHAPE_PATTERN),
+var CodingServiceCredentials = import_zod31.z.strictObject({
+  access_token: import_zod31.z.string().min(16).max(16384),
+  user_id: import_zod31.z.string().regex(import_uuid3.UUID_SHAPE_PATTERN),
   /** The AI Matrx server this app talks to (production, or a local server on the nightly copy). */
-  server_url: import_zod29.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
+  server_url: import_zod31.z.string().min(1).max(2048).regex(/^https?:\/\/[^\s/?#]+(\/[^\s?#]*)?$/)
 });
-var CodingHistoryBlocked = import_zod29.z.enum([
+var CodingHistoryBlocked = import_zod31.z.enum([
   "signed_out",
   "offline",
   "organization_required",
@@ -2571,11 +2744,11 @@ var CodingHistoryBlocked = import_zod29.z.enum([
   "cloud_list_unavailable",
   "history_too_large"
 ]);
-var CodingHistoryFailure = import_zod29.z.strictObject({
-  session_id: import_zod29.z.string().max(64),
-  reason: import_zod29.z.string().max(300)
+var CodingHistoryFailure = import_zod31.z.strictObject({
+  session_id: import_zod31.z.string().max(64),
+  reason: import_zod31.z.string().max(300)
 });
-var CodingHistoryRun = import_zod29.z.strictObject({
+var CodingHistoryRun = import_zod31.z.strictObject({
   /** Claude Code sessions found on this computer. */
   local_sessions: nonNegInt,
   /** Of those, already complete in AI Matrx. */
@@ -2590,39 +2763,39 @@ var CodingHistoryRun = import_zod29.z.strictObject({
   /** Changed while being read; a later run takes them. */
   changed: nonNegInt,
   failed: nonNegInt,
-  failures: import_zod29.z.array(CodingHistoryFailure).max(20),
+  failures: import_zod31.z.array(CodingHistoryFailure).max(20),
   /** Candidates not reached yet. */
   remaining: nonNegInt,
   /** The one line a person reads, e.g. "Imported 12 of 14 sessions. 140 already in AI Matrx." */
-  summary: import_zod29.z.string().max(400)
+  summary: import_zod31.z.string().max(400)
 });
-var CodingHistoryStep = import_zod29.z.strictObject({
+var CodingHistoryStep = import_zod31.z.strictObject({
   /** Null when the run could not start (blocked before a plan existed). */
-  plan_id: import_zod29.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
-  finished: import_zod29.z.boolean(),
+  plan_id: import_zod31.z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+  finished: import_zod31.z.boolean(),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun
 });
-var CodingPlanMissingParams = import_zod29.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
-var CodingImportNextParams = import_zod29.z.strictObject({
-  plan_id: import_zod29.z.string().regex(/^[0-9a-f]{32}$/),
+var CodingPlanMissingParams = import_zod31.z.strictObject({ credentials: CodingServiceCredentials.nullable() });
+var CodingImportNextParams = import_zod31.z.strictObject({
+  plan_id: import_zod31.z.string().regex(/^[0-9a-f]{32}$/),
   credentials: CodingServiceCredentials.nullable()
 });
-var CodingServiceProgress = import_zod29.z.strictObject({
-  phase: import_zod29.z.enum(["checking", "importing"]),
+var CodingServiceProgress = import_zod31.z.strictObject({
+  phase: import_zod31.z.enum(["checking", "importing"]),
   done: nonNegInt,
   total: nonNegInt
 });
-var CodingHistoryImportMissingParams = import_zod29.z.strictObject({});
-var CodingHistoryImportMissingResult = import_zod29.z.strictObject({
-  state: import_zod29.z.enum(["done", "blocked", "cancelled"]),
+var CodingHistoryImportMissingParams = import_zod31.z.strictObject({});
+var CodingHistoryImportMissingResult = import_zod31.z.strictObject({
+  state: import_zod31.z.enum(["done", "blocked", "cancelled"]),
   blocked: CodingHistoryBlocked.nullable(),
   run: CodingHistoryRun,
   elapsed_ms: nonNegInt
 });
-var CodingHistoryProgressEvent = import_zod29.z.strictObject({
+var CodingHistoryProgressEvent = import_zod31.z.strictObject({
   request_id: RequestId,
-  phase: import_zod29.z.enum(["checking", "importing"]),
+  phase: import_zod31.z.enum(["checking", "importing"]),
   /** Sessions settled so far, of `total` candidates (0 of 0 while checking). */
   done: nonNegInt,
   total: nonNegInt,
@@ -2744,7 +2917,23 @@ var OPS = {
   // 1.21: what a window's sidebar draws (the Move-all grouping check).
   "apps.windows.shown": { params: AppsWindowsShownParams, result: AppsWindowsShownResult, kind: "unary", since: "1.21", errors: ["NOT_FOUND", "PERMISSION_DENIED_OS", "PLATFORM_UNSUPPORTED", "INTERNAL"] },
   // Claude Code history (SPEC §6 coding): served by the `coding` Python service through SERVICES below.
-  "coding.history.import_missing": { params: CodingHistoryImportMissingParams, result: CodingHistoryImportMissingResult, kind: "unary", since: "1.5", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "INTERNAL"] }
+  "coding.history.import_missing": { params: CodingHistoryImportMissingParams, result: CodingHistoryImportMissingResult, kind: "unary", since: "1.5", errors: ["RESOURCE_BUSY", "RESOURCE_GONE", "CANCELLED", "INTERNAL"] },
+  // 1.22: git for agents (core `git`, the system git; the cloud sandbox's /git/* set, SPEC 6.1).
+  "git.status": { params: GitStatusParams, result: GitStatusResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.diff": { params: GitDiffParams, result: GitDiffResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.log": { params: GitLogParams, result: GitLogResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.add": { params: GitAddParams, result: GitOutputResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.commit": { params: GitCommitParams, result: GitCommitResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.push": { params: GitPushParams, result: GitOutputResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.pull": { params: GitPullParams, result: GitOutputResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.branch": { params: GitBranchParams, result: GitBranchResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.stash": { params: GitStashParams, result: GitOutputResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  "git.clone": { params: GitCloneParams, result: GitOutputResult, kind: "unary", since: "1.22", errors: ["NOT_FOUND", "INVALID_PARAMS", "CONFLICT", "PLATFORM_UNSUPPORTED", "TIMEOUT", "INTERNAL"] },
+  // 1.22: the web from this computer (the `tools` Python service: matrx_scraper's local lane).
+  "web.fetch": { params: WebFetchParams, result: WebFetchResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
+  "web.scrape": { params: WebScrapeParams, result: WebScrapeResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
+  "web.search": { params: WebSearchParams, result: WebSearchResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] },
+  "web.fetch_with_browser": { params: WebBrowserFetchParams, result: WebBrowserFetchResult, kind: "unary", since: "1.22", errors: ["INVALID_PARAMS", "TIMEOUT", "RESOURCE_BUSY", "AUTH_REQUIRED", "INTERNAL"] }
 };
 var EVENTS = {
   "fs.changed": FsChangedEvent,
@@ -2775,6 +2964,15 @@ var SERVICES = {
       "coding.plan_missing": { params: CodingPlanMissingParams, result: CodingHistoryStep },
       "coding.import_next": { params: CodingImportNextParams, result: CodingHistoryStep }
     }
+  },
+  tools: {
+    progress: ToolsServiceProgress,
+    ops: {
+      "tools.web_fetch": { params: WebFetchParams, result: WebFetchResult },
+      "tools.web_scrape": { params: WebScrapeParams, result: WebScrapeResult },
+      "tools.web_search": { params: ToolsWebSearchParams, result: WebSearchResult },
+      "tools.web_browser_fetch": { params: WebBrowserFetchParams, result: WebBrowserFetchResult }
+    }
   }
 };
 var NAMED_SCHEMAS = {
@@ -3136,7 +3334,39 @@ var NAMED_SCHEMAS = {
   AppsWindowsProcessesParams,
   AppsWindowsProcessesResult,
   AppsWindowsAddParams,
-  AppsWindowsSaveNamesParams
+  AppsWindowsSaveNamesParams,
+  GitOutputResult,
+  GitStatusParams,
+  GitStatusFile,
+  GitStatusResult,
+  GitDiffParams,
+  GitDiffResult,
+  GitLogParams,
+  GitLogCommit,
+  GitLogResult,
+  GitAddParams,
+  GitCommitParams,
+  GitCommitResult,
+  GitPushParams,
+  GitPullParams,
+  GitBranchParams,
+  GitBranchResult,
+  GitStashParams,
+  GitCloneParams,
+  WebHeader,
+  WebFetchParams,
+  WebFetchResult,
+  WebScrapeParams,
+  WebScrapePage,
+  WebScrapeResult,
+  WebSearchParams,
+  WebSearchHit,
+  WebSearchQueryResult,
+  WebSearchResult,
+  ToolsWebSearchParams,
+  WebBrowserFetchParams,
+  WebBrowserFetchResult,
+  ToolsServiceProgress
 };
 
 // src/versioning.ts
@@ -3282,7 +3512,7 @@ function forPeer(op, part, value, version) {
 var VERSIONED_RESULT_OPS = [.../* @__PURE__ */ new Set([...RESULT_PATH.keys(), ...WINDOW_RESULTS.keys(), ...NESTED_RESULTS.keys()])];
 
 // src/contract.ts
-var CONTRACT_SHA256 = "5745ca5b70c283eadfce68d0c66c06207405b60c7e112cb75aca7ff29b15d12e";
+var CONTRACT_SHA256 = "ac2b599f9511abd871a7374e298fab94a25972512797689c8022da288a5f2e06";
 
 // src/close-policy.ts
 var CLOSE_RULES = {
@@ -3315,7 +3545,7 @@ var TOOL_GROUPS = [
   { id: "files_shell", order: 1, title: "Files and shell", owner: "core" },
   { id: "os_control", order: 2, title: "Computer control", owner: "core" },
   { id: "personal_automation", order: 3, title: "Personal apps and automation", owner: "core" },
-  { id: "tools_service", order: 4, title: "Documents, OCR and entities", owner: "python_tools" },
+  { id: "tools_service", order: 4, title: "Web, documents, OCR and entities", owner: "python_tools" },
   { id: "ml_service", order: 5, title: "Speech", owner: "python_ml" },
   { id: "windows_admin", order: 6, title: "Windows administration", owner: "core" }
 ];
@@ -3331,6 +3561,7 @@ var TOOL_CATALOG = [
   { name: "fs_search", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["fs.search_paths", "fs.search_content"], platforms: ALL, summary: "Find files by name or content" },
   { name: "shell_execute", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["exec.run"], platforms: ALL, summary: "Run a command; cd carries over" },
   { name: "shell_python", group: "files_shell", state: "built", path: "sandbox_proxy", ops: ["exec.run"], platforms: ALL, summary: "Run a Python script" },
+  { name: "desktop_git", group: "files_shell", state: "planned", path: "device_op", ops: ["git.status", "git.diff", "git.log", "git.add", "git.commit", "git.push", "git.pull", "git.branch", "git.stash", "git.clone"], platforms: ALL, summary: "Git: status, diff, log, commit, branches, push and pull" },
   { name: "shell_job", group: "files_shell", state: "built", path: "device_op", ops: ["exec.job.start", "exec.job.output", "exec.job.stop", "exec.job.list"], platforms: ALL, summary: "Background commands: start, read output, stop" },
   // ── 2. Computer control (TS owners) ──────────────────────────────────────────────────────────
   { name: "desktop_process", group: "os_control", state: "built", path: "device_op", ops: ["proc.list", "proc.ports", "proc.kill"], platforms: ALL, summary: "Running processes and ports; stop one" },
@@ -3355,6 +3586,7 @@ var TOOL_CATALOG = [
   { name: "desktop_net", group: "personal_automation", state: "planned", path: "device_op", ops: ["net.info", "net.wifi", "net.bluetooth", "net.devices", "net.mdns", "net.scan", "net.download"], platforms: ALL, summary: "Local network and downloads" },
   // ── 4. Python `tools` service ────────────────────────────────────────────────────────────────
   { name: "desktop_documents", group: "tools_service", state: "planned", path: "device_op", ops: ["tools.pdf_extract", "tools.office_generate", "tools.ocr", "tools.image_resize"], platforms: ALL, summary: "PDF text, Office files, OCR, images" },
+  { name: "desktop_web", group: "tools_service", state: "planned", path: "device_op", ops: ["web.fetch", "web.scrape", "web.search", "web.fetch_with_browser"], platforms: ALL, summary: "Fetch, scrape and search the web from this computer's own connection" },
   { name: "desktop_entities", group: "tools_service", state: "planned", path: "device_op", ops: ["tools.ner", "tools.pii"], platforms: ALL, summary: "Names and private data, found on the device" },
   // ── 5. Python `ml` service ───────────────────────────────────────────────────────────────────
   // Built: models.transcribe through local_proxy's POST /op/{cap.op} (matrx-ai implementations/desktop.py).
@@ -3427,10 +3659,10 @@ var LEGACY_ACTIONS = {
   "local_browser.eval": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
   "local_browser.tabs": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
   "local_browser.close": dropped("The browser agent is the extension (matrx-extend) and the cloud browser"),
-  "local_web.fetch": dropped(CLOUD_SCRAPER),
-  "local_web.fetch_with_browser": dropped(CLOUD_SCRAPER),
-  "local_web.scrape": dropped(CLOUD_SCRAPER),
-  "local_web.search": dropped(CLOUD_SCRAPER),
+  "local_web.fetch": tool("desktop_web"),
+  "local_web.fetch_with_browser": tool("desktop_web"),
+  "local_web.scrape": tool("desktop_web"),
+  "local_web.search": tool("desktop_web"),
   "local_web.research": dropped(CLOUD_SCRAPER),
   "local_web.download": tool("desktop_net"),
   "local_web.upload": dropped("Uploads are cloud files (matrx-files) and file sync, one upload path"),