@oh-my-pi/pi-coding-agent 16.1.9 → 16.1.10

package/dist/types/config/settings-schema.d.ts

@@ -912,6 +912,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Surface the active model identifier in the system prompt so the agent knows which model it is";
         };
     };
+    readonly includeWorkspaceTree: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Prompt";
+            readonly label: "Include Workspace Tree";
+            readonly description: "Render the workspace directory tree in the system prompt. WARNING: This can bust prompt caching across sessions when files are modified.";
+        };
+    };
     readonly personality: {
         readonly type: "enum";
         readonly values: readonly ["default", "friendly", "pragmatic", "none"];

package/dist/types/edit/streaming.d.ts

@@ -63,12 +63,12 @@ export interface EditStreamingStrategy<Args = unknown> {
 }
 /**
  * Given an edits array parsed from partial JSON, drop the last entry when the
- * corresponding object in `partialJson` does not yet end with a closed `}`.
+ * corresponding object in `partialJson` has not yet closed with `}`.
  *
- * This guards against `partial-json` silently coercing truncated tails like
- * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
- * last entry render a spurious null-write error until the value finishes
- * streaming.
+ * The streaming parser materializes a trailing edit object from the fields seen
+ * so far before its closing `}` arrives, so an unfinished last entry can render
+ * as a (partial) edit mid-stream. Dropping it until the object closes keeps the
+ * preview from showing an incomplete edit.
  */
 export declare function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[];
 export declare const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>>;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -1,7 +1,6 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { SessionObserverRegistry } from "../session-observer-registry";
-export declare function formatTemporaryModelStatus(modelLabel: string, roleSelectorHint?: string): string;
 export declare class SelectorController {
     #private;
     private ctx;

package/dist/types/sdk.d.ts

@@ -318,6 +318,7 @@ export interface BuildSystemPromptOptions {
     customPrompt?: string;
     appendPrompt?: string;
     inlineToolDescriptors?: boolean;
+    includeWorkspaceTree?: boolean;
 }
 /**
  * Build the default provider-facing system prompt blocks.

package/dist/types/system-prompt.d.ts

@@ -110,6 +110,8 @@ export interface BuildSystemPromptOptions {
     model?: string;
     /** Personality preset rendered into the default system prompt. "none" omits the block. Default: "default" */
     personality?: Personality;
+    /** Whether to include the workspace directory tree in the system prompt. Default: false */
+    includeWorkspaceTree?: boolean;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

package/dist/types/tools/browser/aria/aria-snapshot.d.ts

@@ -0,0 +1,39 @@
+import type { ElementHandle, Page } from "puppeteer-core";
+export interface AriaSnapshotOptions {
+    /** Maximum tree depth to render. */
+    depth?: number;
+    /** Append `[box=x,y,w,h]` bounding boxes to each node. */
+    boxes?: boolean;
+}
+/**
+ * Capture a Playwright-format ARIA snapshot of `root` (or the whole document when
+ * null). Always runs in `ai` mode so every node carries a `[ref=eN]` id; resolve
+ * those to elements with {@link resolveAriaRefHandle}. Ids are renumbered from e1
+ * on each call and remain valid until the next snapshot.
+ */
+export declare function captureAriaSnapshot(page: Page, root: ElementHandle | null, options?: AriaSnapshotOptions): Promise<string>;
+/**
+ * Resolve a `[ref=eN]` id from the latest snapshot to a live `ElementHandle`, or
+ * null when the ref no longer matches any element. Runs in the main world so it
+ * sees the `_ariaRef` expandos the snapshot wrote.
+ */
+export declare function resolveAriaRefHandle(page: Page, ref: string): Promise<ElementHandle | null>;
+/**
+ * Recognize the explicit `[ref=eN]` selector forms and return the bare ref id,
+ * else null. Accepts `aria-ref=e5` (Playwright-MCP style), `aria-ref/e5`, and
+ * `ariaref/e5` — lets `tab.click("aria-ref=e5")` etc. act on snapshot refs. A
+ * bare `e5` is intentionally NOT a ref selector: the cmux backend already uses
+ * bare `eN`/`@eN` for its own observe ids, so requiring the prefix keeps action
+ * selectors meaning the same thing on both backends. (`tab.ref("e5")` still
+ * accepts a bare id directly.)
+ */
+export declare function parseAriaRefSelector(selector: string): string | null;
+/**
+ * Build a self-contained expression script that runs the vendored bundle in the
+ * page and returns the ARIA snapshot YAML. Used by the cmux backend, whose
+ * `browser.eval` RPC takes a script string and returns the completion value (it
+ * has no ElementHandle to pass in). The script resolves `selector` via
+ * `document.querySelector` in-page (CSS selectors only) or falls back to the
+ * whole document. Like the puppeteer path it installs nothing on `window`.
+ */
+export declare function buildAriaSnapshotScript(selector: string | undefined, options?: AriaSnapshotOptions): string;

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -1,5 +1,6 @@
 import { JsRuntime } from "../../../eval/js/shared/runtime";
 import type { ToolSession } from "../../../sdk";
+import { type AriaSnapshotOptions } from "../aria/aria-snapshot";
 import { type ReadableFormat } from "../readable";
 import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
 import type { CmuxSocketClient } from "./socket-client";
@@ -75,6 +76,8 @@ export declare class CmuxTab {
         timeoutMs?: number;
     }): Promise<void>;
     observe(opts?: ObserveOptions): Promise<Observation>;
+    ariaSnapshot(selector?: string, opts?: AriaSnapshotOptions): Promise<string>;
+    ref(id: string): Promise<CmuxElementHandle>;
     click(selector: string): Promise<void>;
     dblclick(selector: string): Promise<void>;
     hover(selector: string): Promise<void>;

package/dist/types/tools/browser.d.ts

@@ -4,6 +4,7 @@ import type { ToolSession } from "../sdk";
 import { type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import type { OutputMeta } from "./output-meta";
+export { type AriaSnapshotOptions, buildAriaSnapshotScript, parseAriaRefSelector, } from "./browser/aria/aria-snapshot";
 export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval } from "./browser/cmux/rpc";
 export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";

package/dist/types/tools/find.d.ts

@@ -60,8 +60,7 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
     private readonly session;
     readonly name = "find";
     readonly approval: "read";
-    readonly summary = "Find files and directories matching a glob pattern";
-    readonly loadMode = "discoverable";
+    readonly loadMode = "essential";
     readonly label = "Find";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{

package/dist/types/tools/write.d.ts

@@ -40,8 +40,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     }, {}>;
     readonly strict = true;
     readonly concurrency = "exclusive";
-    readonly loadMode = "discoverable";
-    readonly summary = "Write content to a file (creates or overwrites)";
+    readonly loadMode = "essential";
     /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
     matcherDigest(args: unknown): string | undefined;
     constructor(session: ToolSession);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.9",
+	"version": "16.1.10",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.9",
-		"@oh-my-pi/omp-stats": "16.1.9",
-		"@oh-my-pi/pi-agent-core": "16.1.9",
-		"@oh-my-pi/pi-ai": "16.1.9",
-		"@oh-my-pi/pi-catalog": "16.1.9",
-		"@oh-my-pi/pi-mnemopi": "16.1.9",
-		"@oh-my-pi/pi-natives": "16.1.9",
-		"@oh-my-pi/pi-tui": "16.1.9",
-		"@oh-my-pi/pi-utils": "16.1.9",
-		"@oh-my-pi/pi-wire": "16.1.9",
-		"@oh-my-pi/snapcompact": "16.1.9",
+		"@oh-my-pi/hashline": "16.1.10",
+		"@oh-my-pi/omp-stats": "16.1.10",
+		"@oh-my-pi/pi-agent-core": "16.1.10",
+		"@oh-my-pi/pi-ai": "16.1.10",
+		"@oh-my-pi/pi-catalog": "16.1.10",
+		"@oh-my-pi/pi-mnemopi": "16.1.10",
+		"@oh-my-pi/pi-natives": "16.1.10",
+		"@oh-my-pi/pi-tui": "16.1.10",
+		"@oh-my-pi/pi-utils": "16.1.10",
+		"@oh-my-pi/pi-wire": "16.1.10",
+		"@oh-my-pi/snapcompact": "16.1.10",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/generate-aria-snapshot.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+/**
+ * Regenerates the committed browser asset
+ *
+ *   src/tools/browser/aria/aria-snapshot.bundle.txt   ← bundled CJS module
+ *
+ * by fetching Playwright's injected ARIA-snapshot sources (pinned to
+ * PLAYWRIGHT_TAG), wrapping them with a small entry, and bundling — all in a
+ * throwaway temp dir. Only the bundle is committed; the upstream sources are NOT
+ * vendored into the repo (no shipping both source + generated copies). This is a
+ * dev-time, network-bound step, exactly like `generate-models`.
+ *
+ * The tab worker imports the `.txt` with `{ type: "text" }`, wraps it in a
+ * `new Function` worker-side, and runs it via puppeteer's CDP evaluate (it
+ * installs nothing on `window`). The committed output means binary and source
+ * installs need no network or build step at runtime.
+ *
+ * Usage: bun scripts/generate-aria-snapshot.ts
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const PLAYWRIGHT_TAG = "v1.61.0";
+const RAW_BASE = `https://raw.githubusercontent.com/microsoft/playwright/${PLAYWRIGHT_TAG}/packages`;
+
+const OUTPUT = path.join(import.meta.dir, "..", "src", "tools", "browser", "aria", "aria-snapshot.bundle.txt");
+
+// Upstream source path -> temp path (relative to the temp root).
+const VENDOR_FILES: Array<[string, string]> = [
+	["injected/src/ariaSnapshot.ts", "injected/ariaSnapshot.ts"],
+	["injected/src/roleUtils.ts", "injected/roleUtils.ts"],
+	["injected/src/domUtils.ts", "injected/domUtils.ts"],
+	["isomorphic/ariaSnapshot.ts", "isomorphic/ariaSnapshot.ts"],
+	["isomorphic/stringUtils.ts", "isomorphic/stringUtils.ts"],
+	["isomorphic/cssTokenizer.ts", "isomorphic/cssTokenizer.ts"],
+	["isomorphic/yaml.ts", "isomorphic/yaml.ts"],
+];
+
+// Entry wrapping the upstream modules. Always runs Playwright's `ai` mode so every
+// node carries a `[ref=eN]` id; matched nodes get an `_ariaRef` expando. Existing
+// expandos are cleared first so the fresh module's counter renumbers from e1
+// deterministically (refs are valid until the next snapshot). Installs nothing on
+// `window`.
+const ENTRY_SOURCE = `
+import { generateAriaTree, renderAriaTree } from "./injected/ariaSnapshot";
+
+export interface AriaSnapshotRequest {
+	depth?: number;
+	boxes?: boolean;
+}
+
+function walkElements(fn: (el: Element) => void): void {
+	const walk = (root: { querySelectorAll(s: string): ArrayLike<Element> }): void => {
+		for (const el of Array.from(root.querySelectorAll("*"))) {
+			fn(el);
+			const shadow = (el as Element & { shadowRoot?: { querySelectorAll(s: string): ArrayLike<Element> } | null }).shadowRoot;
+			if (shadow) walk(shadow);
+		}
+	};
+	walk(document as unknown as { querySelectorAll(s: string): ArrayLike<Element> });
+}
+type RefElement = Element & { _ariaRef?: { role: string; name: string; ref: string } };
+
+export function ariaSnapshot(root: Element | null, request: AriaSnapshotRequest = {}): string {
+	walkElements(el => {
+		if ((el as RefElement)._ariaRef) delete (el as RefElement)._ariaRef;
+	});
+	const target = root ?? document.body ?? document.documentElement;
+	const options = { mode: "ai", depth: request.depth, boxes: request.boxes } as const;
+	const tree = generateAriaTree(target, options);
+	return renderAriaTree(tree, options).text;
+}
+
+export function resolveAriaRef(ref: string): Element | null {
+	let found: Element | null = null;
+	walkElements(el => {
+		if (!found && (el as RefElement)._ariaRef?.ref === ref) found = el;
+	});
+	return found;
+}
+`;
+
+async function main(): Promise<void> {
+	const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "omp-aria-"));
+	try {
+		// Fetch pinned upstream sources into the temp dir.
+		for (const [src, dst] of VENDOR_FILES) {
+			const url = `${RAW_BASE}/${src}`;
+			const res = await fetch(url);
+			if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`);
+			await Bun.write(path.join(tmp, dst), await res.text());
+		}
+		const entry = path.join(tmp, "entry.ts");
+		await Bun.write(entry, ENTRY_SOURCE);
+
+		// The injected sources import isomorphic modules via the `@isomorphic/*`
+		// alias and the `yaml` package (type-only). Resolve the alias to the fetched
+		// copies and stub `yaml` (only referenced from erased `import type`).
+		const aliasPlugin: Bun.BunPlugin = {
+			name: "aria-vendor-alias",
+			setup(build) {
+				build.onResolve({ filter: /^@isomorphic\// }, args => ({
+					path: path.join(tmp, "isomorphic", `${args.path.slice("@isomorphic/".length)}.ts`),
+				}));
+				build.onResolve({ filter: /^yaml$/ }, () => ({ path: "yaml", namespace: "aria-yaml-stub" }));
+				build.onLoad({ filter: /.*/, namespace: "aria-yaml-stub" }, () => ({
+					contents: "export {};",
+					loader: "ts",
+				}));
+			},
+		};
+
+		const result = await Bun.build({
+			entrypoints: [entry],
+			target: "browser",
+			format: "cjs",
+			minify: true,
+			plugins: [aliasPlugin],
+		});
+		if (!result.success) {
+			for (const log of result.logs) console.error(log);
+			throw new Error("aria snapshot bundle failed");
+		}
+		const code = await result.outputs[0].text();
+		const header = `// @generated by scripts/generate-aria-snapshot.ts from Playwright ${PLAYWRIGHT_TAG}\n// Bundled from Playwright's injected ARIA-snapshot sources (Apache-2.0, (c) Microsoft).\n// Do not edit by hand. Regenerate with: bun scripts/generate-aria-snapshot.ts\n`;
+		await Bun.write(OUTPUT, header + code);
+		console.log(`bundled ${path.relative(process.cwd(), OUTPUT)} (${code.length}b)`);
+	} finally {
+		await fs.rm(tmp, { recursive: true, force: true });
+	}
+}
+
+await main();

package/src/config/settings-schema.ts

@@ -967,6 +967,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	includeWorkspaceTree: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Prompt",
+			label: "Include Workspace Tree",
+			description:
+				"Render the workspace directory tree in the system prompt. WARNING: This can bust prompt caching across sessions when files are modified.",
+		},
+	},
+
 	personality: {
 		type: "enum",
 		values: ["default", "friendly", "pragmatic", "none"] as const,

package/src/edit/streaming.ts

@@ -85,12 +85,12 @@ export interface EditStreamingStrategy<Args = unknown> {
 
 /**
  * Given an edits array parsed from partial JSON, drop the last entry when the
- * corresponding object in `partialJson` does not yet end with a closed `}`.
+ * corresponding object in `partialJson` has not yet closed with `}`.
  *
- * This guards against `partial-json` silently coercing truncated tails like
- * `"write":nu` / `"write":nul` into `{ write: null }`, which would make the
- * last entry render a spurious null-write error until the value finishes
- * streaming.
+ * The streaming parser materializes a trailing edit object from the fields seen
+ * so far before its closing `}` arrives, so an unfinished last entry can render
+ * as a (partial) edit mid-stream. Dropping it until the object closes keeps the
+ * preview from showing an incomplete edit.
  */
 export function dropIncompleteLastEdit<T>(edits: readonly T[], partialJson: string | undefined, listKey: string): T[] {
 	if (!Array.isArray(edits) || edits.length === 0) return [...(edits ?? [])];