pi-chrome 0.15.48 → 0.15.51

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable user-facing changes to `pi-chrome`.
 
+## 0.15.51 — 2026-09-10
+
+- **Fewer Chrome commands.** Removed `/chrome status`; use bare `/chrome` for the quick connection, authorization, and background dashboard plus controls. The dashboard remains lightweight and does not run page probes.
+- **Complete Doctor report.** `/chrome doctor` now includes authorization and background state alongside connection, version, page checks, and troubleshooting hints, even when Chrome is offline or outdated.
+- **Command regressions.** Added tests for command dispatch/completion, lightweight dashboard behavior, Doctor state reporting, and failure paths. `/chrome background status` remains available.
+
+## 0.15.50 — 2026-09-10
+
+- **README clarity.** Lead with workflow examples, correct setup ordering and platform-specific onboarding instructions, and clarify privacy guidance. Describe background behavior and the on/off/status controls directly.
+- **Documentation-only release.** Browser behavior and permissions are unchanged. The companion version matches the npm package version.
+
+## 0.15.49 — 2026-09-10
+
+- **Validation scope.** Node regression suites passed. Live browser validation remains incomplete: an input attempt encountered `Input.dispatchMouseEvent: Detached while handling command.`; a subsequent retest was blocked by a disconnected companion. No live-browser pass is claimed for these changes.
+
+- **Upload node fallback.** When Chrome cannot convert a file input's remote object to a DOM node ID, use that same `objectId` directly. Release the remote object after success or failure and reject stale snapshot UIDs. No native file picker or new permissions.
+- **Native rich-editor insertion.** `chrome_type` and `chrome_fill` use one CDP `Input.insertText` for focused contenteditables. Inputs/textareas keep individual key events; `perCharacter:true` preserves that path for rich editors needing `keydown` events. Results report `typing` as `insertText`, `keys`, or `none`. Existing DOM-fallback controls and background policy remain intact.
+- **Complete rich-editor fill and single Enter.** Select all requested contenteditable contents before deletion, not only one paragraph. `pressEnter` sends one Enter instead of two; Enter after type/fill stays pinned to the resolved tab.
+- **Shift-only typing.** Shift+a, Shift+1, and other US-layout printable chords now carry shifted text. Ctrl/Meta/Alt shortcuts still suppress literal insertion.
+- **Input regressions.** Added worker fault-injection tests and challenge 44. Challenge 16 explicitly tests per-character typing; challenge 21 waits for Shift release before grading.
+
 ## 0.15.48 — 2026-09-09
 
 - **Existing background mode is now hard background.** `/chrome background on` (still the default) overrides per-call foreground requests, keeps new tabs inactive, and blocks `chrome_tab activate`. Use the existing `/chrome background off` for foreground/watch mode; no new command or lock state.

package/README.md

@@ -1,151 +1,111 @@
 # pi-chrome
 
-> Let [Pi](https://pi.dev) use your existing signed-in Chrome profile after explicit authorization.
+**Give Pi the Chrome you're already signed into.**
 
-**MIT · 0 runtime deps · loopback-only bridge (`127.0.0.1:17318`) · inspectable unpacked Chrome extension.** Review [`extensions/chrome-profile-bridge/browser-extension/`](./extensions/chrome-profile-bridge/browser-extension) before loading. Verify setup with `/chrome doctor`.
+Debug your app, inspect signed-in dashboards, and capture screenshots using your existing Chrome profile—without setting up a separate automation browser.
 
-```text
-You:    "Find my open GitHub PR tab, summarize review state, and screenshot failing CI."
-Agent:  chrome_tab(list) → chrome_snapshot(uid:…) → chrome_screenshot(...)
-        ✓ 3 reviewers, 1 change requested, CI red on iOS. Saved → .pi/chrome-screenshots/ci.png
-You:    [keeps coding — agent never asked you to log in]
-```
+Built for the [Pi coding agent](https://pi.dev).
 
-`pi-chrome` runs through a small Chrome extension inside the Chrome profile **you already use** — including sites where you're already signed in. Agents can inspect or control Chrome only after you run `/chrome authorize` in current Pi session.
+## What you can do
 
----
+Try prompts like these after setup:
 
-## Install
+| Use case | Ask Pi |
+| --- | --- |
+| **Debug a signed-in app** | “Reproduce the filter bug in my staging app. Inspect captured console and network errors, then save a screenshot.” |
+| **Understand an existing page** | “Find my open dashboard tab and summarize what's on the page. Don't change anything.” |
+| **Create evidence for a PR** | “On my local app, capture the empty, loading, and populated states of this feature for my PR.” |
 
-```bash
-pi install npm:pi-chrome
-```
+Pi gets tools to inspect pages, click, type, fill forms, scroll, upload files, capture screenshots, and inspect captured console logs and `fetch`/`XMLHttpRequest` responses. You describe the task; Pi handles the agent loop.
 
-In Pi:
+**Best fit:** interactive workflows in the Chrome profile you already use. For deterministic CI tests, consider a test framework such as Playwright; for fleets of isolated browsers, consider a hosted browser service. See [more workflows](./docs/EXAMPLES.md) and [browser-tool comparisons](./docs/COMPARISON.md).
 
-```text
-/chrome onboard
-```
+## Quick start
 
-This opens `chrome://extensions` and copies bundled extension path. In Chrome Extensions:
-
-1. Turn on **Developer mode**.
-2. Click **Load unpacked**.
-3. Open path field with **Cmd+Shift+G** on macOS or **Ctrl+L** on Windows/Linux.
-4. Paste copied path.
-5. Press Enter.
+**Requirements:** [Pi](https://pi.dev) and Google Chrome. Setup includes a one-time manual installation of the bundled Chrome companion extension.
 
-Reload Pi so installed package loads:
+> **Trust and privacy:** The companion has broad browser permissions and runs in your real Chrome profile. Review [its source](./extensions/chrome-profile-bridge/browser-extension/) before loading it, and authorize only tasks you trust. The browser bridge is local, but page content returned to Pi may be sent to your configured model provider.
 
-```text
-/reload
-```
+### 1. Install and load the Pi package
 
-Check bridge:
+In your terminal:
 
-```text
-/chrome doctor
+```bash
+pi install npm:pi-chrome
 ```
 
-You should see:
+Start Pi with `pi`. If Pi is already running, run `/reload` in that session **before** using the `/chrome` commands.
 
-```text
-✓ Chrome is connected (...)
-```
+### 2. Connect Chrome
 
-Authorize current session:
+In Pi:
 
 ```text
-/chrome authorize
-/chrome doctor
+/chrome onboard
 ```
 
-Second doctor run should show all checks passing.
-
----
+The setup dialog shows the companion extension's folder path.
 
-## What it can do
+- **macOS:** after confirmation, Pi opens `chrome://extensions`, reveals the companion folder in Finder, and copies its path to your clipboard.
+- **Windows/Linux:** copy the folder path shown in the dialog and open `chrome://extensions` manually. Automatic desktop opening and clipboard setup are currently macOS-only.
 
-- Read and summarize pages you're already signed into.
-- Click, type, fill forms, scroll, drag, tap, and upload files.
-- Capture screenshots for bugs, PRs, and demos.
-- Inspect console logs and captured `fetch`/`XMLHttpRequest` responses.
-- Manage tabs without taking over your active window.
+In Chrome:
 
-Tool parameters and gotchas are documented inline in Pi.
-
----
+1. Turn on **Developer mode**.
+2. Click **Load unpacked**.
+3. Select the companion folder shown by `/chrome onboard`. On macOS, press **Cmd+Shift+G** in the folder picker and paste the copied path.
 
-## Safety model
+### 3. Authorize and verify
 
-Chrome control is locked by default. Authorize per Pi session:
+In Pi:
 
 ```text
-/chrome authorize          # 15 minutes
-/chrome authorize 30m      # custom duration
-/chrome authorize indefinite
-/chrome revoke             # lock again
-/chrome status
+/chrome authorize
+/chrome doctor
 ```
 
-Safety properties:
-
-- Extension runs in your real Chrome profile and has broad tab/scripting permissions. Install only from trusted package source.
-- Pi side binds to `127.0.0.1:17318` only; no default network exposure.
-- Bridge rejects browser-origin command requests, so ordinary web pages cannot drive it through CORS.
-- Each Pi session gets its own automation target; user tabs/windows are not closed by cleanup.
-- `/chrome revoke` closes only calling session's automation target.
-
-Security details: [`SECURITY.md`](./SECURITY.md). Architecture details: [`docs/ARCHITECTURE.md`](./docs/ARCHITECTURE.md).
+Approve the authorization prompt for a task you trust. The default authorization lasts **15 minutes**. Doctor should report `✓ Chrome is connected (...)`; follow its instructions if any checks fail.
 
----
-
-## Commands
+Then try a read-only first task:
 
 ```text
-/chrome onboard             # guided setup
-/chrome doctor              # connectivity + version + eval checks
-/chrome status              # connection + auth + background state
-/chrome authorize [duration]
-/chrome revoke
-/chrome background on       # default: hard background policy
-/chrome background off      # foreground/watch mode
-/chrome background status
+List my open Chrome tabs without navigating, clicking, or changing anything.
 ```
 
-If loaded extension is older than installed `pi-chrome`, `/chrome doctor` tells you to reload it from `chrome://extensions`.
-
-### Background policy
-
-`/chrome background on` is enforced, not an overridable default. Per-call `background:false` cannot bring Chrome forward, new tabs stay inactive, and `chrome_tab activate` is blocked. Use the existing `/chrome background off` for foreground/watch mode; per-call `background:true` still works when that mode is off.
-
-Screenshots use CDP without activating background tabs. Debugger/capture failures return errors, never an activation fallback. Reload both Pi and the Chrome companion after upgrading; old companions reject background tab creation/screenshots rather than silently switching tabs.
+Run `/chrome revoke` when finished. Use `/chrome authorize` again whenever you want to grant access for another task or session.
 
-This prevents explicit pi-chrome focus/activation, not every Chrome/OS side effect. Trusted input, page popups, native prompts, debugger banners, and macOS Spaces can still affect focus. Inactive pages may throttle rendering or reject focus-gated actions. See [scope and risks](./docs/ARCHITECTURE.md#scope-and-risks).
+## Safety
 
----
+- **Per-session approval.** Pi's Chrome tools require `/chrome authorize`. `/chrome revoke` locks them and requests cleanup of that session's owned automation tabs. Cleanup preserves existing user tabs.
+- **Separate targets by default.** Page actions without an explicit target use a session-owned automation window or tab. The agent can deliberately target an existing tab when your task calls for it.
+- **Local transport, not a sandbox.** The bridge binds to `127.0.0.1:17318` and rejects browser-origin command requests. It does not authenticate arbitrary non-browser local callers; it is not protection against hostile processes on your machine.
+- **Background mode:** `/chrome background on` (default) blocks pi-chrome tools from directly bringing Chrome to the front or switching your selected tab. Use `/chrome background off` to allow those actions, and `/chrome background status` to check the setting.
 
-## Limits
+### Limits
 
-`pi-chrome` works best on web-page workflows exposed through DOM, screenshots, tabs, network, console, and Chrome input. It is not full OS automation.
+This is browser automation, not full OS control. Native Chrome/OS dialogs, password-manager prompts, passkeys/security keys/biometrics, CAPTCHA challenges, cross-origin iframe DOM access, rich multitouch/stylus gestures, and arbitrary desktop apps are outside its reliable tool surface. Some workflows need human assistance.
 
-Current limits include native Chrome/OS surfaces, print/save dialogs, permission bubbles, password-manager prompts, cross-origin iframe DOM access, CAPTCHA/bot challenges, passkeys/security keys/biometrics, rich multitouch/pinch/stylus gestures, and arbitrary desktop apps.
+If page inspection or evaluation is blocked, use screenshots and coordinate input where possible. Background pages can throttle rendering or reject focus-gated actions. See the [FAQ](./docs/FAQ.md) for details.
 
-For strict-CSP pages, use screenshots + coordinate input when snapshot/evaluate paths are blocked.
-
----
+## Commands
 
-## Docs
+```text
+/chrome                      # quick connection/auth/background dashboard and controls
+/chrome onboard              # one-time companion setup
+/chrome authorize            # authorize this Pi session for 15 minutes
+/chrome authorize 30m        # choose a duration
+/chrome authorize indefinite # no time limit; revoke when finished
+/chrome revoke               # lock tools and request session cleanup
+/chrome doctor               # full diagnostics, including authorization/background state
+/chrome background on        # default: block explicit focus/tab activation
+/chrome background off       # allow foreground/watch mode
+/chrome background status
+```
 
-- Examples: [`docs/EXAMPLES.md`](./docs/EXAMPLES.md)
-- FAQ: [`docs/FAQ.md`](./docs/FAQ.md)
-- Comparison: [`docs/COMPARISON.md`](./docs/COMPARISON.md)
-- Security: [`SECURITY.md`](./SECURITY.md)
-- Benchmark suite: [`test-suite/README.md`](./test-suite/README.md)
-- Architecture: [`docs/ARCHITECTURE.md`](./docs/ARCHITECTURE.md)
+Bare `/chrome` checks the connection without running page probes. Use `/chrome doctor` for version and page checks, troubleshooting hints, and authorization/background state.
 
----
+Tool parameters are documented inline in Pi. See [architecture](./docs/ARCHITECTURE.md) for target ownership, screenshot behavior, and background-policy details.
 
-## License
+### Updating and troubleshooting
 
-MIT. See [LICENSE](./LICENSE).
+After `pi update npm:pi-chrome`, run `/reload` in Pi and reload **Pi Chrome Connector** in `chrome://extensions`. Run `/chrome doctor` to check the connection and companion version.

package/extensions/chrome-profile-bridge/browser-extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Pi Chrome Connector",
-  "version": "0.15.48",
+  "version": "0.15.51",
   "description": "Lets Pi control tabs in Chrome via a local connector at 127.0.0.1.",
   "permissions": [
     "tabs",

package/extensions/chrome-profile-bridge/browser-extension/service_worker.js

@@ -681,7 +681,13 @@ function cdpKeyInfo(key, shifted) {
   };
   if (SPECIAL[key]) return { key, ...SPECIAL[key] };
   if (key.length === 1) {
-    const ch = key;
+    // Explicit Shift chords need shifted text as well as a modifier bit. CDP does
+    // not derive printable text from code/windowsVirtualKeyCode for us.
+    const SHIFTED = {
+      "`": "~", "1": "!", "2": "@", "3": "#", "4": "$", "5": "%", "6": "^", "7": "&", "8": "*", "9": "(", "0": ")",
+      "-": "_", "=": "+", "[": "{", "]": "}", "\\": "|", ";": ":", "'": "\"", ",": "<", ".": ">", "/": "?",
+    };
+    const ch = shifted ? (/^[a-z]$/.test(key) ? key.toUpperCase() : SHIFTED[key] || key) : key;
     const layout = usKeyLayoutForChar(ch);
     return { key: ch, code: layout.code, windowsVirtualKeyCode: layout.keyCode, text: ch };
   }
@@ -809,13 +815,14 @@ async function chromeInputKey(params) {
     await cdp(tab.id, "Input.dispatchKeyEvent", { type: "keyDown", key: m.key, code: m.code, windowsVirtualKeyCode: m.vk, modifiers: modBits });
     await sleep(rng(6, 18));
   }
-  const info = cdpKeyInfo(key);
-  // When modifiers are active, browsers usually emit "rawKeyDown" (no text) so chords like Cmd+V don't insert the literal char.
-  const downType = modBits ? "rawKeyDown" : "keyDown";
+  const info = cdpKeyInfo(key, mods.shiftKey);
+  // Ctrl/Meta/Alt chords must not insert literal text (e.g. Cmd+V). Shift alone
+  // still types: Shift+a -> A, Shift+1 -> !, and Shift+Enter carries a newline.
+  const shortcut = !!(mods.ctrlKey || mods.metaKey || mods.altKey);
   await cdp(tab.id, "Input.dispatchKeyEvent", {
-    type: downType, key: info.key, code: info.code,
+    type: shortcut ? "rawKeyDown" : "keyDown", key: info.key, code: info.code,
     windowsVirtualKeyCode: info.windowsVirtualKeyCode, nativeVirtualKeyCode: info.windowsVirtualKeyCode,
-    text: modBits ? "" : info.text, unmodifiedText: modBits ? "" : info.text, modifiers: modBits,
+    text: shortcut ? "" : info.text, unmodifiedText: shortcut ? "" : info.text, modifiers: modBits,
   });
   await sleep(rng(25, 90));
   await cdp(tab.id, "Input.dispatchKeyEvent", {
@@ -829,6 +836,49 @@ async function chromeInputKey(params) {
   return { input: "chrome", key: info.key, modifiers: mods };
 }
 
+// Read the actual focused editor, not a role=textbox lookalike. For fill, select
+// the requested editor's entire contents: triple-click only selects a paragraph.
+// Selection uses the DOM; deletion and insertion still use Chrome's input layer.
+async function contentEditableInTab(tabId, selectAllParams = null) {
+  const results = await executeScriptTimed({
+    target: { tabId, frameIds: [0] },
+    world: "MAIN",
+    func: (selector, uid, selectAll) => {
+      const active = document.activeElement;
+      if (selectAll) {
+        const state = window.__PI_CHROME_STATE__;
+        const el = uid ? state?.elements?.[uid] : document.querySelector(selector);
+        if (uid && (!el || !el.isConnected)) throw new Error(`snapshot uid ${uid} is stale; refresh chrome_snapshot`);
+        if (!el?.isContentEditable) return false;
+        if (!active?.isContentEditable || !(el === active || el.contains(active) || active.contains(el))) {
+          throw new Error("chrome.fill: requested contenteditable is not focused");
+        }
+        const selection = window.getSelection();
+        if (!selection) throw new Error("Could not select contenteditable contents");
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        selection.removeAllRanges();
+        selection.addRange(range);
+      }
+      return active?.isContentEditable === true;
+    },
+    args: [selectAllParams?.selector ?? null, selectAllParams?.uid ?? null, selectAllParams !== null],
+  }, `inspect contenteditable in tab ${tabId}`);
+  return results?.[0]?.result === true;
+}
+
+async function typeTextInTab(tabId, text, perCharacter) {
+  if (!text) return "none";
+  if (!perCharacter && await contentEditableInTab(tabId)) {
+    // One native edit avoids per-character delays and rich-editor render races.
+    // Do not retry as keystrokes if insertion fails: it may already have applied.
+    await cdp(tabId, "Input.insertText", { text });
+    return "insertText";
+  }
+  for (const ch of Array.from(text)) await cdpTypeChar(tabId, ch);
+  return "keys";
+}
+
 async function chromeInputType(params) {
   const tab = await getTabByParams(params);
   await bringToFront(tab, params);
@@ -844,12 +894,9 @@ async function chromeInputType(params) {
     await sleep(rng(50, 120));
   }
   const text = String(params.text || "");
-  for (const ch of Array.from(text)) await cdpTypeChar(tab.id, ch);
-  if (params.pressEnter) {
-    await cdpTypeChar(tab.id, "\r").catch(() => undefined);
-    await chromeInputKey({ ...params, key: "Enter" });
-  }
-  return { input: "chrome", length: text.length };
+  const typing = await typeTextInTab(tab.id, text, params.perCharacter);
+  if (params.pressEnter) await chromeInputKey({ ...params, targetId: tab.id, key: "Enter" });
+  return { input: "chrome", length: text.length, typing };
 }
 
 async function domFillFallback(tabId, params, cause) {
@@ -908,14 +955,15 @@ async function chromeInputFill(params) {
       await cdp(tab.id, "Input.dispatchMouseEvent", { type: "mouseReleased", x: point.x, y: point.y, button: "left", buttons: 0, clickCount: i, pointerType: "mouse" });
       await sleep(rng(20, 60));
     }
+    await contentEditableInTab(tab.id, params);
     // Delete selection.
     await cdp(tab.id, "Input.dispatchKeyEvent", { type: "keyDown", key: "Delete", code: "Delete", windowsVirtualKeyCode: 46 });
     await cdp(tab.id, "Input.dispatchKeyEvent", { type: "keyUp", key: "Delete", code: "Delete", windowsVirtualKeyCode: 46 });
     await sleep(rng(20, 60));
     const text = String(params.text || "");
-    for (const ch of Array.from(text)) await cdpTypeChar(tab.id, ch);
-    if (params.submit) await chromeInputKey({ ...params, key: "Enter" });
-    return { input: "chrome", length: text.length };
+    const typing = await typeTextInTab(tab.id, text, params.perCharacter);
+    if (params.submit) await chromeInputKey({ ...params, targetId: tab.id, key: "Enter" });
+    return { input: "chrome", length: text.length, typing };
   } catch (error) {
     if (params.domFallback === false) throw error;
     return domFillFallback(tab.id, params, error);
@@ -1024,25 +1072,31 @@ async function chromeInputUpload(params) {
     const selector = ${JSON.stringify(params.selector ?? null)};
     const uid = ${JSON.stringify(params.uid ?? null)};
     const state = window.__PI_CHROME_STATE__;
-    const el = uid && state && state.elements ? state.elements[uid] : (selector ? document.querySelector(selector) : null);
+    const el = uid ? state?.elements?.[uid] : (selector ? document.querySelector(selector) : null);
+    if (uid && (!el || !el.isConnected)) throw new Error("snapshot uid " + uid + " is stale; refresh chrome_snapshot");
     if (!el || el.tagName !== "INPUT" || el.type !== "file") throw new Error("Target must be <input type=file>");
     el.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
     return el;
   })()`;
   const evaluated = await cdp(tab.id, "Runtime.evaluate", { expression, objectGroup: "pi-chrome-upload", includeCommandLineAPI: false, returnByValue: false });
-  if (evaluated.exceptionDetails) throw new Error(evaluated.exceptionDetails.text || "Could not resolve file input");
+  if (evaluated.exceptionDetails) throw new Error(cdpExceptionText(evaluated.exceptionDetails) || "Could not resolve file input");
   const objectId = evaluated.result?.objectId;
   if (!objectId) throw new Error("Could not resolve file input object");
-  await cdp(tab.id, "DOM.enable", {}).catch(() => undefined);
-  const requested = await cdp(tab.id, "DOM.requestNode", { objectId });
-  if (!requested.nodeId) throw new Error("Could not resolve file input node");
-  await cdp(tab.id, "DOM.setFileInputFiles", { nodeId: requested.nodeId, files: paths });
-  await cdp(tab.id, "Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: `function() { this.dispatchEvent(new Event("input", { bubbles: true })); this.dispatchEvent(new Event("change", { bubbles: true })); return this.files ? this.files.length : 0; }`,
-    returnByValue: true,
-  }).catch(() => undefined);
-  await cdp(tab.id, "Runtime.releaseObject", { objectId }).catch(() => undefined);
+  try {
+    await cdp(tab.id, "DOM.enable", {}).catch(() => undefined);
+    // Some DOM agents return nodeId:0 (or reject conversion) for a valid remote
+    // element. CDP accepts that same objectId directly, before any file mutation.
+    const requested = await cdp(tab.id, "DOM.requestNode", { objectId }).catch(() => null);
+    const target = requested?.nodeId ? { nodeId: requested.nodeId } : { objectId };
+    await cdp(tab.id, "DOM.setFileInputFiles", { ...target, files: paths });
+    await cdp(tab.id, "Runtime.callFunctionOn", {
+      objectId,
+      functionDeclaration: `function() { this.dispatchEvent(new Event("input", { bubbles: true })); this.dispatchEvent(new Event("change", { bubbles: true })); return this.files ? this.files.length : 0; }`,
+      returnByValue: true,
+    }).catch(() => undefined);
+  } finally {
+    await cdp(tab.id, "Runtime.releaseObject", { objectId }).catch(() => undefined);
+  }
   return { input: "chrome", uploaded: paths.map((path) => ({ path })) };
 }
 // ===============================================================

package/extensions/chrome-profile-bridge/index.ts

@@ -992,7 +992,11 @@ Usage rules:
 	// Shared handlers, dispatched by the unified /chrome command below.
 	const doctorHandler = async (ctx: ExtensionContext) => {
 			ctx.ui.notify("Checking pi-chrome…", "info");
-			const lines: string[] = [`pi-chrome v${PI_CHROME_VERSION}`];
+			const lines: string[] = [
+				`pi-chrome v${PI_CHROME_VERSION}`,
+				`• Authorization: ${authSummary()}.`,
+				`• Background: ${backgroundEnabled ? "on (hard)" : "off (foreground/watch mode)"}.`,
+			];
 			const status = bridge.status();
 			const roleLabel = status.mode === "client" ? "sharing another pi session's connection" : "running the Chrome connection for this machine";
 			lines.push(`• This pi session is ${roleLabel}.`);
@@ -1144,8 +1148,7 @@ Usage rules:
 		);
 	};
 
-	// One-line snapshot of pi-chrome's current state. Used as a header in the bare-/chrome
-	// picker and as the body of /chrome status.
+	// Lightweight connection/auth/background header for the bare-/chrome picker. No page probes.
 	const statusSummary = async (): Promise<string> => {
 		const parts: string[] = [];
 		try {
@@ -1163,11 +1166,6 @@ Usage rules:
 		return parts.join(" · ");
 	};
 
-	const statusHandler = async (ctx: ExtensionContext) => {
-		ctx.ui.notify("Checking Chrome connection…", "info");
-		ctx.ui.notify(await statusSummary(), "info");
-	};
-
 	const openAuthorizeMenu = async (ctx: ExtensionContext): Promise<void> => {
 		while (true) {
 			const choice = await ctx.ui.select("Authorize Chrome control", [
@@ -1225,7 +1223,7 @@ Usage rules:
 
 	pi.registerCommand("chrome", {
 		description:
-			"All pi-chrome controls in one place.\n  /chrome authorize [15m|30m|<minutes>|indefinite] — allow this Pi session to use chrome_* tools.\n  /chrome revoke   — lock Chrome control.\n  /chrome status   — one-line snapshot of connection, auth, and background setting.\n  /chrome doctor   — full health check.\n  /chrome onboard  — install the Chrome companion extension.\n  /chrome background [on|off|status|toggle] — enforce no explicit focus/tab activation, or allow foreground/watch mode.\nRun with no arguments for an interactive picker that shows current state.",
+			"All pi-chrome controls in one place.\n  /chrome authorize [15m|30m|<minutes>|indefinite] — allow this Pi session to use chrome_* tools.\n  /chrome revoke   — lock Chrome control.\n  /chrome doctor   — full health check plus authorization and background state.\n  /chrome onboard  — install the Chrome companion extension.\n  /chrome background [on|off|status|toggle] — enforce no explicit focus/tab activation, or allow foreground/watch mode.\nRun with no arguments for an interactive picker that shows current state.",
 		getArgumentCompletions: (prefix) => {
 			const raw = prefix;
 			const trimmedRight = raw.replace(/\s+$/, "");
@@ -1244,8 +1242,7 @@ Usage rules:
 				candidates = [
 					{ fullValue: "authorize", label: "authorize", description: "Allow this Pi session to use chrome_* tools." },
 					{ fullValue: "revoke", label: "revoke", description: "Lock Chrome control for this Pi session." },
-					{ fullValue: "status", label: "status", description: "One-line summary: connection, auth, and background setting." },
-					{ fullValue: "doctor", label: "doctor", description: "Full health check. Tells you if Chrome is connected and what's wrong if it isn't." },
+					{ fullValue: "doctor", label: "doctor", description: "Full diagnostics: connection, version, page checks, authorization, and background state." },
 					{ fullValue: "onboard", label: "onboard", description: "Install the Chrome companion extension (first-time setup)." },
 					{ fullValue: "background", label: "background", description: "Enforce hard background or allow foreground/watch mode." },
 				];
@@ -1279,7 +1276,6 @@ Usage rules:
 			switch (head) {
 				case "authorize": return authorizeHandler(ctx, subArgs);
 				case "revoke": return revokeHandler(ctx);
-				case "status": return statusHandler(ctx);
 				case "doctor": return doctorHandler(ctx);
 				case "onboard": return onboardHandler(ctx);
 				case "background":
@@ -1292,7 +1288,7 @@ Usage rules:
 					return;
 				}
 				default:
-					ctx.ui.notify(`Unknown subcommand '${head}'. Try: /chrome authorize | revoke | status | doctor | onboard | background.`, "warning");
+					ctx.ui.notify(`Unknown subcommand '${head}'. Run /chrome for current state and controls, or try: /chrome authorize | revoke | doctor | onboard | background.`, "warning");
 			}
 		},
 	});
@@ -1564,12 +1560,13 @@ Usage rules:
 		name: "chrome_type",
 		label: "Chrome Type",
 		description:
-			"Focus an optional snapshot uid or CSS selector, then type text using Chrome's real keyboard input. Pass includeSnapshot=true to return a fresh snapshot after typing.",
+			"Focus an optional snapshot uid or CSS selector, then type using Chrome's real input. Contenteditables use one native text insertion; other fields use key events. Set perCharacter=true for editors needing individual keydown events. Pass includeSnapshot=true to verify after typing.",
 		promptSnippet: "Type text into Chrome, optionally focusing a snapshot uid or selector first.",
 		parameters: Type.Object({
 			text: Type.String(),
 			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot." })),
 			selector: Type.Optional(Type.String({ description: "CSS selector to focus before typing." })),
+			perCharacter: Type.Optional(Type.Boolean({ default: false, description: "Send individual key events even in contenteditables. Default: one native text insertion for contenteditables; key events for other fields." })),
 			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after typing." })),
 			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			pressEnter: Type.Optional(Type.Boolean()),
@@ -1595,12 +1592,13 @@ Usage rules:
 		name: "chrome_fill",
 		label: "Chrome Fill",
 		description:
-			"Set the full value of a text input, textarea, or contenteditable element using Chrome click/select/delete/type input. Accepts a snapshot uid or CSS selector. Pass includeSnapshot=true to verify after filling.",
+			"Set the full value of a text input, textarea, or contenteditable using Chrome click/select/delete/type input. Contenteditables use one native text insertion; perCharacter=true retains individual keydown events. Accepts a snapshot uid or CSS selector. Pass includeSnapshot=true to verify after filling.",
 		promptSnippet: "Fill a Chrome form field by snapshot uid or selector, optionally returning a fresh snapshot.",
 		parameters: Type.Object({
 			text: Type.String(),
 			uid: Type.Optional(Type.String({ description: "Stable element uid from chrome_snapshot." })),
 			selector: Type.Optional(Type.String({ description: "CSS selector to fill if uid is omitted." })),
+			perCharacter: Type.Optional(Type.Boolean({ default: false, description: "Send individual key events even in contenteditables. Default: one native text insertion for contenteditables; key events for other fields." })),
 			submit: Type.Optional(Type.Boolean({ description: "If true, press Enter after filling." })),
 			domFallback: Type.Optional(Type.Boolean({ description: "If true (default), fall back to DOM value-setting if Chrome's CDP input path is blocked by another extension overlay or debugger failure." })),
 			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after filling." })),
@@ -1636,7 +1634,7 @@ Usage rules:
 				ctrlKey: Type.Optional(Type.Boolean()),
 				altKey: Type.Optional(Type.Boolean()),
 				metaKey: Type.Optional(Type.Boolean()),
-			}, { description: "Modifier keys to hold while pressing the key (chord)." })),
+			}, { description: "Modifier keys to hold while pressing the key. Shift alone types the shifted US-layout character (a → A, 1 → !); Ctrl/Meta/Alt chords do not insert literal text." })),
 			includeSnapshot: Type.Optional(Type.Boolean({ description: "If true, include a fresh chrome_snapshot result after the keypress." })),
 			maxElements: Type.Optional(Type.Number({ default: MAX_ELEMENTS, description: "Max elements in the included snapshot." })),
 			targetId: Type.Optional(Type.String()),

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "pi-chrome",
-	"version": "0.15.48",
+	"version": "0.15.51",
 	"scripts": {
-		"test": "node test-suite/unit/csp-eval.test.mjs && node test-suite/unit/automation-target.test.mjs && node test-suite/unit/session-cleanup.test.mjs && node test-suite/unit/background-policy.test.mjs",
+		"test": "node test-suite/unit/csp-eval.test.mjs && node test-suite/unit/automation-target.test.mjs && node test-suite/unit/session-cleanup.test.mjs && node test-suite/unit/background-policy.test.mjs && node test-suite/unit/input-reliability.test.mjs && node test-suite/unit/chrome-command.test.mjs",
 		"version": "node scripts/sync-manifest-version.js",
 		"prepublishOnly": "node scripts/sync-manifest-version.js"
 	},

package/test-suite/README.md

@@ -177,6 +177,15 @@ The dashboard renders this from `manifest.json`. In brief:
 41. explicit tab lifecycle
 42. strict CSP eval/snapshot via CDP (regression guard for the CSP bypass)
 43. hard background: inactive-tab visibility and trusted input
+44. input reliability: native rich-editor insertion, full replacement, per-character override, Shift chords, single Enter, and file upload
+
+### Input regressions (16, 21, 31, 44)
+
+Challenge 44 exercises `chrome_type`/`chrome_fill` bulk insertion into contenteditables, including long Unicode text and multiple paragraphs. It also checks `perCharacter:true`, Shift-only printable keys, one Enter per `pressEnter`, and real file contents. Read `window.__inputFixture.caption` and follow its manifest recipe. Use `domFallback:false` to ensure failures are not hidden by synthetic events.
+
+Challenge 16 intentionally requests `perCharacter:true`: its grader requires a caret update for each keystroke. Challenge 21 focuses its field before sending Shift+a and grades after Shift release, not during the earlier input event. Challenge 31 retains standalone upload coverage.
+
+`npm test` also fault-injects zero/missing/rejected upload node IDs, attachment/cleanup failures, stale UIDs, insertion failures, shortcut suppression, and authorization/option forwarding. These mocked tests cannot prove `isTrusted` or real browser selection behavior; run the browser challenges too.
 
 ### Hard-background regression (43)
 

package/test-suite/challenges/21-keyboard-modifiers.html

@@ -30,9 +30,12 @@ for (const name of ["keydown","keypress","keyup","input"]) {
   });
 }
 
-t.addEventListener("input", () => {
-  if (t.value !== "A") return;
+// input fires before keyup. Grade only when Shift is released so a valid chord
+// cannot fail merely because its release events have not happened yet.
+t.addEventListener("keyup", (event) => {
+  if (event.key !== "Shift") return;
   const bad = [];
+  if (t.value !== "A") bad.push(`value=${JSON.stringify(t.value)} (need 'A')`);
   const downShift = log.find(e => e.name === "keydown" && e.key === "Shift");
   const downA     = log.find(e => e.name === "keydown" && e.code === "KeyA");
   const upShift   = log.find(e => e.name === "keyup"   && e.key === "Shift");