@reclaimprotocol/agent 0.1.24 → 0.1.25

package/lib/mcp/tools/agent/live-view.js

@@ -16,12 +16,9 @@
 import { badRequest, conflict } from '@hapi/boom';
 import assert from 'node:assert';
 import { startTunnel } from "../../../live/tunnel.js";
-import { startLiveView } from "../../../live/viewer.js";
 import { LOGGER } from "../../../logger.js";
 import { defineTool } from "../../server.js";
-/** Modes whose browser we reach over our own CDP connection, and which
- *  therefore have no hosted live view of their own. */
-const SHAREABLE_MODES = new Set(['dedicated', 'attach', 'custom']);
+import { SHAREABLE_MODES } from "./attach.js";
 /** Tear down whatever share is running. Safe when none is. Exported so the
  *  session tools can call it from `dispose_browser` / `reset_session`. */
 export async function stopLiveShare(ref) {
@@ -30,98 +27,87 @@ export async function stopLiveShare(ref) {
         return false;
     }
     ref.current = undefined;
-    await share.view.stop().catch((err) => {
-        LOGGER.warn({ err }, 'live view: server stop failed');
-    });
+    // Only the tunnel is ours to close. The browser and its viewer belong to the
+    // container, which keeps running until the browser is disposed.
     await share.tunnel.stop().catch((err) => {
         LOGGER.warn({ err }, 'live view: tunnel stop failed');
     });
     return true;
 }
-export function liveViewTools(attachRef, captures, shareRef) {
+export function liveViewTools(attachRef, shareRef) {
     return [
         defineTool({
             name: 'share_browser_view',
-            description: 'Put the attached tab behind a PUBLIC HTTPS URL (a cloudflared '
-                + 'quick tunnel) so someone elsewhere can watch it live, and by '
-                + 'default click and type in it. Use it to hand a login or a 2FA '
-                + 'step to the person who holds the credentials, or to let a '
-                + 'colleague watch a capture. Returns the URL — relay it to the '
-                + 'developer VERBATIM, on its own line. '
-                + 'ONLY for a locally attached browser (attach_browser mode '
-                + '`dedicated`, `attach`, or `custom`). In `builder` mode the '
-                + 'Popcorn browser already has a hosted live view: use the '
-                + '`liveViewUrl` that attach_browser returned instead. '
-                + 'THE URL IS A CREDENTIAL: anyone holding it can see this tab, '
-                + 'and with the default `interactive: true` can act in it as the '
-                + 'signed-in user. Share it only with the person who needs it, and '
-                + 'call stop_browser_view the moment they are done. Pass '
-                + '`interactive: false` for a watch-only link. '
+            description: 'Put the attached browser\'s live view behind a PUBLIC HTTPS URL (a '
+                + 'cloudflared quick tunnel) so someone elsewhere can watch it and '
+                + 'act in it. Use it to hand a login or a 2FA step to the person '
+                + 'who holds the credentials, or to let a colleague watch a '
+                + 'capture. Returns the URL — relay it to the developer VERBATIM, '
+                + 'on its own line. '
+                + 'ONLY for `container` mode, whose browser runs its own viewer. '
+                + 'A `builder` browser already has a hosted live view: use the '
+                + '`liveViewUrl` attach_browser returned. A local browser '
+                + '(`dedicated`, `attach`, `custom`) cannot be shared at all — no '
+                + 'tunnel can fix that, because there is no viewer behind it. Tell '
+                + 'them so, and offer to re-attach: `container` is free and needs '
+                + 'Docker, `builder` needs no install but is chargeable. '
+                + 'THE URL IS THE ONLY CREDENTIAL: the random hostname is the whole '
+                + 'secret, with no token or login behind it, so anyone who learns '
+                + 'it can see and drive this browser as the signed-in user. Share '
+                + 'it only with the person who needs it, and call stop_browser_view '
+                + 'the moment they are done. '
                 + 'Needs cloudflared: an existing install on PATH is used as-is, '
                 + 'otherwise it is downloaded once to ~/.reclaim/bin on first '
                 + 'share (never at install time). Set RECLAIM_CLOUDFLARED_PATH to '
                 + 'point at your own copy instead.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    tabId: {
-                        type: 'string',
-                        description: 'Tab to stream, from list_tabs. Defaults to the tab the '
-                            + 'active capture is on, else the first tab.',
-                    },
-                    interactive: {
-                        type: 'boolean',
-                        description: 'Let the viewer click and type in the page. Default true. '
-                            + 'Set false to stream a read-only view.',
-                    },
-                },
-            },
-        }, async ({ tabId, interactive }) => {
+            inputSchema: { type: 'object', properties: {} },
+        }, async () => {
             const attached = attachRef.current;
             assert(attached, badRequest('No browser attached. Call attach_browser first.'));
             assert(SHAREABLE_MODES.has(attached.mode), badRequest(`share_browser_view does not apply to \`${attached.mode}\` mode. `
-                + 'That browser already has a hosted live view — use the '
-                + '`liveViewUrl` from attach_browser'
-                + (attached.liveViewUrl ? `: ${attached.liveViewUrl}` : '')
+                + (attached.liveViewUrl
+                    ? 'That browser already has a hosted live view — use the '
+                        + `\`liveViewUrl\` from attach_browser: ${attached.liveViewUrl}`
+                    : 'That browser has no live view to put behind a URL. To let '
+                        + 'someone else in, re-attach with mode "container" (the '
+                        + 'Reclaim runtime in Docker — free, needs Docker) or '
+                        + '"builder" (hosted, no install, chargeable)')
                 + '.'));
             assert(!shareRef.current, conflict('A live view is already running at '
                 + `${shareRef.current?.url}. Call stop_browser_view first, or `
                 + 'reuse that URL.'));
-            const tabs = tabId || captures.activeTab
-                ? []
-                : await attached.handles.listTabs();
-            const target = tabId ?? captures.activeTab ?? tabs[0]?.tabId;
-            assert(target, badRequest('No tab to stream. Open a tab, or call list_tabs to pick one.'));
-            const tab = await attached.handles.attachToTab(target);
-            const wantsInput = interactive !== false;
-            const view = await startLiveView({
-                tab,
-                interactive: wantsInput,
-                title: `Reclaim — ${attached.mode} browser`,
-            });
-            let tunnel;
-            try {
-                tunnel = await startTunnel(view.port);
-            }
-            catch (err) {
-                // Don't leave the loopback server behind if the tunnel failed.
-                await view.stop().catch(() => { });
-                throw err;
-            }
-            const url = `${tunnel.url}${view.path}`;
+            // The container publishes its viewer on loopback and its full CDP
+            // port beside it. Only the VIEWER is ever tunnelled: the CDP port is
+            // unauthenticated, total control of the browser, and putting it on a
+            // public URL would hand that to anyone with the link.
+            const viewerPort = attached.viewerPort;
+            assert(viewerPort, badRequest('This browser reports no live-view port. Re-attach with mode '
+                + '"container".'));
+            const tunnel = await startTunnel(viewerPort);
+            // The path is the runtime's own viewer page; `magnify=1` is what makes
+            // it lay out for the device that opens it.
+            const url = `${tunnel.url}/liveview.html?magnify=1`;
             const share = {
-                view, tunnel, url, interactive: wantsInput, startedAt: Date.now(),
+                tunnel, url,
             };
             shareRef.current = share;
-            LOGGER.info({ mode: attached.mode, interactive: wantsInput }, 'live view shared');
+            LOGGER.info({ mode: attached.mode }, 'live view shared');
             return {
                 url,
-                interactive: wantsInput,
-                tabId: target,
                 ...(share.tunnel.binary.source === 'downloaded'
                     ? { cloudflaredInstalled: true }
                     : {}),
-                ...(share.tunnel.ready ? {} : { propagating: true }),
+                ...(share.tunnel.ready
+                    ? {}
+                    : {
+                        propagating: true,
+                        // cloudflared's own last words. Without them, "the URL does
+                        // not connect" is unactionable: the tunnel, the local server
+                        // and this machine's egress all look identical from outside.
+                        ...(share.tunnel.diagnostics
+                            ? { cloudflaredLog: share.tunnel.diagnostics }
+                            : {}),
+                    }),
                 _notes: [
                     ...(share.tunnel.binary.source === 'downloaded'
                         ? ['cloudflared was not installed, so it was downloaded once '
@@ -129,24 +115,31 @@ export function liveViewTools(attachRef, captures, shareRef) {
                         : []),
                     ...(share.tunnel.ready
                         ? []
-                        : ['The tunnel had not started routing yet — if the URL '
-                                + 'errors, wait a few seconds and reload.']),
+                        : ['The tunnel never confirmed a connection to Cloudflare, so '
+                                + 'the URL may not resolve yet. Give it ~10s and reload '
+                                + 'first. If it still fails, say so and offer to retry '
+                                + '(stop_browser_view then share_browser_view) — a quick '
+                                + 'tunnel does sometimes fail to register. '
+                                + '`cloudflaredLog` has its output if it keeps happening.']),
                     'Relay `url` to the developer verbatim, on its own line.',
-                    'The URL is a credential: it needs no login, and anyone with '
-                        + 'it can see this tab'
-                        + (wantsInput ? ' and act in it as the signed-in user.' : '.'),
-                    'Call stop_browser_view when they are done — the tunnel stays '
-                        + 'open until you do.',
+                    'The URL is a credential: it needs no login, and anyone with it '
+                        + 'can see this browser and act in it as the signed-in user.',
+                    'It shows the whole browser, so a sign-in that opens a separate '
+                        + 'window is visible too — unlike a single-tab stream.',
+                    'Opening it on a phone lays the page out for that phone, with '
+                        + 'touch, pinch-zoom and the soft keyboard.',
+                    'Call stop_browser_view when they are done. That closes the '
+                        + 'tunnel only — the browser keeps running.',
                 ],
             };
         }),
         defineTool({
             name: 'stop_browser_view',
-            description: 'Close the public live view opened by share_browser_view: stops '
-                + 'the screen stream and shuts the tunnel down, so the URL stops '
-                + 'resolving. Call it as soon as the person you shared with is '
-                + 'finished. The browser itself stays attached and the capture '
-                + 'keeps running.',
+            description: 'Close the public URL opened by share_browser_view: shuts the '
+                + 'tunnel down, so the URL stops resolving for whoever still has '
+                + 'it. Call it as soon as the person you shared with is finished. '
+                + 'Nothing else changes — the browser stays attached, its own live '
+                + 'view keeps serving locally, and any capture keeps running.',
             inputSchema: { type: 'object', properties: {} },
         }, async () => ({ stopped: await stopLiveShare(shareRef) })),
     ];

package/lib/mcp/tools/agent/session.d.ts

@@ -7,3 +7,17 @@ export declare function sessionTools(attachRef: {
     current?: AttachState;
     config: ConfigStore;
 }, captures: CaptureStore, liveShare: LiveShareRef): RegisteredTool[];
+/**
+ * Release everything a session holds: the public tunnel, the captures, and the
+ * browser itself.
+ *
+ * Exported because a session can end WITHOUT anyone calling `dispose_browser` —
+ * the developer closes their agent, the client kills the server, the transport
+ * drops. Nothing runs on its own then, so `start.ts` runs this. Without it a
+ * container keeps running and, worse, a public URL to a live browser outlives
+ * the session that created it.
+ */
+export declare function resetAll(attachRef: {
+    current?: AttachState;
+    config: ConfigStore;
+}, captures: CaptureStore, liveShare: LiveShareRef): Promise<void>;

package/lib/mcp/tools/agent/session.js

@@ -24,11 +24,7 @@ export function sessionTools(attachRef, captures, liveShare) {
             // URL can recover it instead of opening a second tunnel.
             ...(liveShare.current
                 ? {
-                    sharedView: {
-                        url: liveShare.current.url,
-                        interactive: liveShare.current.interactive,
-                        viewers: liveShare.current.view.viewers(),
-                    },
+                    sharedView: { url: liveShare.current.url },
                 }
                 : {}),
         })),
@@ -55,9 +51,19 @@ export function sessionTools(attachRef, captures, liveShare) {
         }),
     ];
 }
-async function resetAll(attachRef, captures, liveShare) {
-    // Before the captures: the live view holds a tab session of its own, and a
-    // public URL must never outlive the browser it points at.
+/**
+ * Release everything a session holds: the public tunnel, the captures, and the
+ * browser itself.
+ *
+ * Exported because a session can end WITHOUT anyone calling `dispose_browser` —
+ * the developer closes their agent, the client kills the server, the transport
+ * drops. Nothing runs on its own then, so `start.ts` runs this. Without it a
+ * container keeps running and, worse, a public URL to a live browser outlives
+ * the session that created it.
+ */
+export async function resetAll(attachRef, captures, liveShare) {
+    // Before the captures: a public URL must never outlive the browser it points
+    // at.
     await stopLiveShare(liveShare);
     await resetCaptures(captures);
     await disposeAttached(attachRef);

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@reclaimprotocol/agent",
 	"title": "Reclaim Agent",
-	"version": "0.1.24",
+	"version": "0.1.25",
 	"description": "Reclaim Protocol tools for AI coding agents. Reclaim lets your app verify data points about its users, such as a follower count, an account balance, or an order history. This package is the Reclaim MCP server: it gives your agent the tools to find, build, test, and fix data verification providers by capturing and replaying browser requests, drafting provider recipes, running zkTLS proofs, and publishing provider versions.",
 	"type": "module",
 	"main": "./lib/index.js",
@@ -83,7 +83,7 @@
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@noble/hashes": "^2.2.0",
 		"@reclaimprotocol/attestor-core": "^5.0.8",
-		"@reclaimprotocol/client": "0.1.24",
+		"@reclaimprotocol/client": "0.1.25",
 		"@reclaimprotocol/tls": "^0.1.3",
 		"chrome-remote-interface": "^0.33.0",
 		"domhandler": "^6.0.0",

package/skill/SKILL.common.md

@@ -22,24 +22,45 @@ already names it.
 <!-- section: browser -->
 ## Choosing a browser
 
-**Ask the developer which browser they want, then call `attach_browser` ONCE
-with their chosen `mode`.** Never pick for them, and never assume last session's
-choice still applies. You don't need a discovery call — the four options are
-spelled out in the tool's own description (and summarized below). Calling with
-no `mode` returns the same list as `needsChoice: true` + `options`, if you'd
-rather relay it verbatim.
-
-| mode | what it is | needs | live view |
+- Choosing one — ask who signs in, then offer the matching pair
+- Sharing the container's live view with someone remote
+- What happens when the session ends
+- When the container will not start
+
+**Ask one question first, before you list anything:**
+
+> Will you be doing this yourself, or does someone else need to sign in — the
+> person whose account it is, say?
+
+That answer decides half the list, and a developer can answer it without knowing
+what CDP is. Only then offer the matching pair, call `attach_browser` ONCE with
+the `mode` they pick, and never pick for them or assume last session's choice
+still applies.
+
+**They're doing it themselves** — no link, no Docker, nothing to install:
+
+| mode | what it is | needs |
+| --- | --- | --- |
+| `dedicated` | Chrome the agent launches with its own profile (`~/.reclaim/chrome-profile`), which persists, so a site stays signed in. The default choice. | nothing |
+| `attach` | The Chrome they already have open, with its tabs, extensions and logins. | `port` (default 9222) |
+
+Neither can be shared, and neither needs to be: the browser is on their screen.
+
+**Someone else has to sign in, or the site only works on a phone** — these two
+are the only modes that produce a link another person can open:
+
+| mode | what it is | needs | costs |
 | --- | --- | --- | --- |
-| `dedicated` | Local Chrome the agent launches with its own profile (`~/.reclaim/chrome-profile`). Easiest local path. | nothing | `share_browser_view` on request |
-| `attach` | A Chrome the developer is already running. | `port` (default 9222) | `share_browser_view` on request |
-| `builder` | Quota-accounted remote Popcorn browser. Only way to browse from a **specific country**. | Builder auth, `orgId` | hosted `liveViewUrl`, returned by `attach_browser` |
-| `custom` | Any CDP websocket the developer supplies. | `cdpUrl` | `share_browser_view` on request |
+| `container` | The Reclaim runtime in Docker, on their machine. `share_browser_view` turns its viewer into a public link. | Docker running | free — their Docker, their bandwidth. 432 MB the first time, about 2 GB of RAM, 7 to 17 seconds to start |
+| `builder` | A browser in Reclaim's cloud. The link comes back immediately, with nothing to install. Also the only way to browse from a **specific country**. | Builder auth, `orgId` | **chargeable** — billed against the org's quota |
 
-**Say the live-view column out loud when you offer the choice.** How the
-developer watches the browser is part of picking one, and a local browser looks
-like it can't be shared at all unless you tell them `share_browser_view`
-exists.
+**Say which one costs money.** They are otherwise interchangeable from the
+developer's point of view, so price and "do you have Docker" are the whole
+decision. Do not quietly pick the billed one.
+
+`custom` (any `ws://`/`wss://` CDP endpoint they supply) exists for someone who
+was handed an endpoint and knows why. Don't offer it unprompted; it cannot be
+shared either.
 
 **`attach` gotcha (Chrome 136+, May 2025):** the developer's Chrome must be
 started with BOTH `--remote-debugging-port=9222` AND
@@ -72,31 +93,87 @@ default profile. If `attach` fails, say this verbatim and offer `dedicated`.
 **`custom` specifics:** the `cdpUrl` is a credential — never repeat, log, or
 persist it. If a `liveViewUrl` comes back, share it full and verbatim.
 
-### Sharing a local browser (`share_browser_view`)
-
-A `dedicated`, `attach`, or `custom` browser runs on the developer's machine,
-so only they can see it. `share_browser_view` puts the tab behind a public
-HTTPS URL through a cloudflared quick tunnel — use it when the person who has
-to act is not at that machine: a login or 2FA only they can complete, or a
-colleague watching a capture.
-
-- **`builder` mode already has one.** The Popcorn browser returns a hosted
-  `liveViewUrl` from `attach_browser`; share that instead. The tool refuses
-  here rather than opening a second tunnel.
-- **The URL is a credential.** It carries an unguessable token and needs no
-  login, so whoever holds it can see the tab — and, by default, click and type
-  in it as the signed-in user. Give it to one person, and say plainly what it
-  grants.
-- **Return it verbatim, on its own line**, exactly as with `liveViewUrl`.
-- `interactive: false` streams a watch-only view. Prefer it when the developer
-  only needs to see progress.
-- **Call `stop_browser_view` as soon as they're done.** The tunnel stays open
-  until you do. `dispose_browser` and `reset_session` also close it.
+### Sharing the container's live view (`share_browser_view`)
+
+A `container` browser serves its own viewer on loopback, so the developer can
+open it the moment `attach_browser` returns. `share_browser_view` puts that same
+viewer behind a public HTTPS URL through a cloudflared quick tunnel — for when
+the person who has to act is not at that machine: a login or 2FA only they can
+complete, or a colleague watching a capture.
+
+**Offer it whenever a login is coming and the developer is not the one holding
+the credentials.** Nobody asks for a feature they have no way of knowing exists.
+Ask plainly:
+
+> Do you want a link to this browser? You can open it yourself, or send it to
+> whoever holds the login — they can watch and click in it, including from a
+> phone.
+
+If they say yes, call `share_browser_view` and **relay the full URL verbatim, on
+its own line.**
+
+- **`container` is the only mode this applies to.** `builder` returns a hosted
+  `liveViewUrl` from `attach_browser` — relay that instead, full and verbatim.
+  `dedicated`, `attach`, and `custom` have no view to share at all; if someone
+  else needs to see the browser, say so and offer `container`.
+- **The URL is the ONLY credential.** The hostname Cloudflare hands out is the
+  whole secret: there is no token and no login behind it, so whoever learns the
+  URL has the browser, as the signed-in user. Give it to one person, say plainly
+  what it grants, and stop the share when they are done rather than leaving it
+  open. Tell them the watcher sees everything typed into that browser, including
+  a password — so if the point is for the DEVELOPER to log in, they should do it
+  before you share, not after.
+- **It shows the whole browser, not one tab.** A sign-in that opens a separate
+  window is visible too.
+- **Opening it on a phone lays the page out for that phone**, with touch,
+  pinch-zoom and the soft keyboard. That is the reason to reach for `container`
+  when a site only works on mobile.
+- **Call `stop_browser_view` as soon as they're done.** That closes the tunnel
+  only — the browser keeps running. `dispose_browser` and `reset_session` stop
+  the container itself.
+- **If the URL will not load**, the tunnel may not have registered with
+  Cloudflare — the hostname exists before the route does. Have them reload after
+  10 seconds; if it still fails, `stop_browser_view` then `share_browser_view`
+  again, since a quick tunnel does occasionally fail to come up. A
+  `propagating: true` in the result is that case, and `cloudflaredLog` carries
+  the reason.
 - **cloudflared is handled for you.** An existing install on PATH wins;
-  otherwise it's fetched once into `~/.reclaim/bin` on the first share, never
-  at install time. Say so when it happens — it's a ~37 MB download onto their
+  otherwise it's fetched once into `~/.reclaim/bin` on the first share, never at
+  install time. Say so when it happens — it's a 37 MB download onto their
   machine. `RECLAIM_CLOUDFLARED_PATH` points at their own copy instead.
 
+### How containers are shared, and when they close
+
+- **Closing the agent releases the browser.** The server stops the container and
+  the tunnel when its connection drops, so a public URL never outlives the
+  session that made it. `dispose_browser` does the same on demand.
+- **Re-attaching in one session reuses the same browser** — under a second,
+  rather than the twenty a fresh one costs — so whatever it is signed into is
+  still there.
+- **A second session working at the same time gets its own container.** They
+  cannot share one: the live view streams the whole screen, so two sessions in
+  one container would see each other's browsing, and two browsers on one profile
+  corrupt the cookie jar they share. Each concurrent session therefore has its
+  own profile, and starts out signed in to nothing.
+- **Four at once is the ceiling**, because each is about 2 GB of RAM. Past that,
+  `attach_browser` says so and points at `dedicated`.
+- **A crash cannot strand one for long.** A killed session runs no cleanup, so
+  the next `container` attach removes any container whose owning process is gone.
+  One belonging to a session that is still alive is never touched.
+
+### When the container will not start
+
+- **Docker is not running.** The error says so and names the other browser
+  modes. Docker is not something you can install for them.
+- **Apple Silicon.** The image is amd64 and cannot be built for arm64, so it
+  runs translated. OrbStack does this itself; Docker Desktop needs "Use Rosetta
+  for x86/amd64 emulation" turned on. Under QEMU instead of Rosetta, Chromium
+  crashes on launch.
+- **First run looks stuck.** It is downloading 432 MB. Say that rather than
+  letting it look hung.
+- A container left over from a crashed run is **reused if it is still serving**,
+  and replaced if it is not — a second attach does not need a different port.
+
 **When a local attach errors or `waitForCdpReady` reports a dead port**, walk
 these before retrying:
 

package/skill/builder-mode.md

@@ -18,15 +18,17 @@ device-pairing `code` + `attachUrl` — give the user the URL, then poll
 `authenticate({ code })` until LINKED. Tokens cache ~2 days.
 (→ `how_it_works({ topic: "auth" })`)
 
-**Browser choice is the developer's, and so is watching it.** `attach_browser`
-advertises all four sources in its own description — relay them, including each
-one's live-view line. A `builder` browser returns a hosted `liveViewUrl`; a
-local or custom CDP browser is private until you call `share_browser_view`,
-which tunnels a public URL with cloudflared. Say that option exists: nobody
-guesses it.
+**Ask who is doing the signing in, then offer a browser.** "Yourself, or does
+someone else need to log in?" decides half of `attach_browser`'s list. Doing it
+themselves → `dedicated` or `attach`, both local, neither shareable. Someone
+else, or a phone-only site → `container` (the Reclaim runtime in Docker, free,
+shareable with `share_browser_view`) or `builder` (hosted, no install,
+**chargeable**). Say which costs money, and say `container` exists at all:
+nobody guesses it.
 
 **The flow:** `attach_browser` (ask the developer which browser source — local
-Chrome, a CDP URL they supply, or a remote Builder browser) → `start_capture`
+Chrome, the Reclaim runtime in Docker, a remote Builder browser, or a CDP URL
+they supply) → `start_capture`
 ⇒ **`captureId`** (the handle every browser/inspect tool takes first) → drive
 the page (`navigate`, `wait_for_page`, `eval_in_page`, `get_cookies`) → inspect
 (`list_requests`, `get_request`, `find_requests_containing`) →

package/skill/interception.md

@@ -96,7 +96,7 @@ to detect and nothing to disable — and `builder` never delivers intercepted
 traffic to the page at all (topic `user-script`). A verification on those that
 won't load or won't sign in is almost always a CAPTCHA or bot challenge
 instead: check `analyze_request_constraints` for a `botChallenge` concern, and
-treat it as a site that needs a human through the live view rather than a
+treat it as a site that needs a human through a live view rather than a
 provider to fix.
 
 ### Then bisect, cheapest change first
@@ -232,4 +232,5 @@ oversight.
   `window.Reclaim` is inert on Builder's own client.
 - `hash-validation` — declaring script-fired requests without breaking
   `verifyProof({ providerId })`.
-- `browser` — live view, for handing a stuck sign-in to a human.
+- `browser` — the modes with a live view (`container`, `builder`), for handing
+  a stuck sign-in to a human.

package/skill/old-mode.md

@@ -12,16 +12,18 @@ topic at a time — call `how_it_works({})` for the topic index. Topics:
 `user-script`, `interception`, `hash-validation`, `credentials`, `never-do`,
 `troubleshooting`.
 
-**Browser choice is the developer's, and so is watching it.** `attach_browser`
-advertises all four sources in its own description — relay them, including each
-one's live-view line. A `builder` browser returns a hosted `liveViewUrl`; a
-local or custom CDP browser is private until you call `share_browser_view`,
-which tunnels a public URL with cloudflared. Say that option exists: nobody
-guesses it.
+**Ask who is doing the signing in, then offer a browser.** "Yourself, or does
+someone else need to log in?" decides half of `attach_browser`'s list. Doing it
+themselves → `dedicated` or `attach`, both local, neither shareable. Someone
+else, or a phone-only site → `container` (the Reclaim runtime in Docker, free,
+shareable with `share_browser_view`) or `builder` (hosted, no install,
+**chargeable**). Say which costs money, and say `container` exists at all:
+nobody guesses it.
 
 **The flow:** `reclaim_authenticate` once → `attach_browser` (ask the developer
-which browser source — local Chrome, a CDP URL they supply, or a remote Builder
-browser) → `start_capture` ⇒ **`captureId`** → drive the page (`navigate`,
+which browser source — local Chrome, the Reclaim runtime in Docker, a remote
+Builder browser, or a CDP URL they supply) → `start_capture` ⇒ **`captureId`** →
+drive the page (`navigate`,
 `wait_for_page`, `eval_in_page`) → inspect (`list_requests`, `get_request`,
 `find_requests_containing`) → `propose_provider` ⇒ **`draftId`** →
 `replay_request(captureId, draftId)` → `run_proof(captureId, draftId,