@proagentstore/cli 0.4.96 → 0.4.98

package/dist/browser-runner/local-apply/contract.js

@@ -46,6 +46,18 @@ export const LOCAL_APPLY_HANDOFF_FRAME_PATH = "/local-apply/handoff/frame";
 export const LOCAL_APPLY_HANDOFF_INPUT_PATH = "/local-apply/handoff/input";
 export const LOCAL_APPLY_HANDOFF_RESUME_PATH = "/local-apply/handoff/resume";
 export const LOCAL_APPLY_HANDOFF_END_PATH = "/local-apply/handoff/end";
+/**
+ * A separate, browser-only receipt/history check for an already-ended uncertain attempt.  This is
+ * deliberately not an application run: it receives no engine, sources, artifacts or submit gate.
+ */
+export const LOCAL_APPLY_RECONCILIATION_RUN_PATH = "/local-apply/reconciliation/run";
+export const LOCAL_APPLY_RECONCILIATION_STATUS_PATH = "/local-apply/reconciliation/status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_PATH = "/local-apply/reconciliation/handoff";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_STATUS_PATH = "/local-apply/reconciliation/handoff-status";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_FRAME_PATH = "/local-apply/reconciliation/handoff/frame";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_INPUT_PATH = "/local-apply/reconciliation/handoff/input";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_RESUME_PATH = "/local-apply/reconciliation/handoff/resume";
+export const LOCAL_APPLY_RECONCILIATION_HANDOFF_END_PATH = "/local-apply/reconciliation/handoff/end";
 export const LOCAL_APPLY_ENGINES = ["claude", "codex"];
 export const LOCAL_APPLY_AUTH_MODES = ["machine", "subscription"];
 export const LOCAL_APPLY_MODES = ["fill_and_review", "auto_submit"];
@@ -95,12 +107,12 @@ export const LOCAL_APPLY_BLOCK_REASONS = [
  * dispatch, naming the update, rather than silently producing the older behaviour (`apply.ts`
  * `runnerContractProblem`).
  *
- * ── Why it moved to 0.4.96 (#1013)
+ * ── Why it moved to 0.4.97 (#1013)
  *
- * #953 adds the read-only `/local-apply/preflight` route used before an email lead can enter
- * tailoring. That route lives in `packages/browser-runner`, which ships INSIDE the published CLI.
- * A machine below this floor cannot make the live/expired/unverifiable observation, so it must
- * not silently look equivalent to a current runner.
+ * #1013 adds the exact isolated-run browser handoff used when a sign-in or CAPTCHA blocks an
+ * application. That route lives in `packages/browser-runner`, which ships INSIDE the published
+ * CLI. A machine below this floor cannot retain the actual isolated page and must not silently
+ * substitute the shared/default browser page.
  *
  * A behaviour change in the runner is a CONTRACT change, because the cloud's decisions assume it.
  * So this floor moves with it: #1013's exact-page login/CAPTCHA handoff and post-submit receipt
@@ -111,7 +123,7 @@ export const LOCAL_APPLY_BLOCK_REASONS = [
  * been published. `cliAtLeast` treats an unreported version as capable, which is the convention
  * every MIN_CLI gate here follows.
  */
-export const LOCAL_APPLY_CONTRACT_MIN_CLI = "0.4.96";
+export const LOCAL_APPLY_CONTRACT_MIN_CLI = "0.4.97";
 export const LOCAL_APPLY_DIAGNOSTIC_CAUSES = ["bridge_unused", "engine_exited_nonzero", "timed_out", "no_engine_output", "submit_unconfirmed"];
 export const LOCAL_APPLY_CONFIRMATION_MARKERS = ["page_text", "url_receipt", "already_applied_notice"];
 export const LOCAL_APPLY_SIGNALS = [

package/dist/browser-runner/local-apply/live-run-browser.js

@@ -0,0 +1,101 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { McpRuntime } from "../mcp-runtime.js";
+/** Bind application handoff to the run browser, not to the runner-wide active page. */
+export function createLocalApplyBrowserFactory(options) {
+    return async (profile, runDir) => {
+        if (profile === "isolated")
+            return createIsolatedApplyBrowser(runDir, options.headless);
+        const browser = await options.defaultBrowser(profile, runDir);
+        return { ...browser, handoffPage: options.sharedPage };
+    };
+}
+/**
+ * Keep local-apply's browser construction out of `runner.ts`: research uses the generic factory,
+ * while application runs get a page-owning isolated context for the scoped handoff.
+ */
+export function createRunnerBrowserFactories(options) {
+    const browserFor = async (profile, runDir) => {
+        if (profile === "default")
+            return { tools: await options.defaultTools(), stop: async () => undefined };
+        const mcp = new McpRuntime();
+        await mcp.start({ userDataDir: join(runDir, "profile"), headless: options.headless });
+        return { tools: mcp, stop: () => mcp.stop() };
+    };
+    return { browserFor, applyBrowserFor: createLocalApplyBrowserFactory({ headless: options.headless, defaultBrowser: browserFor, sharedPage: options.sharedPage }) };
+}
+/**
+ * Start the disposable browser context for one application run and retain only its current live
+ * page for the bounded takeover adapter.  This deliberately does not seed, copy, or persist an
+ * owner profile: the profile remains the run's existing throwaway `runDir/profile` directory.
+ */
+export async function createIsolatedApplyBrowser(runDir, headless) {
+    const playwright = await import("playwright");
+    const profileDir = join(runDir, "profile");
+    let context;
+    let mcp;
+    let activePage = null;
+    let stopped = false;
+    try {
+        context = await playwright.chromium.launchPersistentContext(profileDir, {
+            headless,
+            acceptDownloads: true,
+            viewport: null,
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--start-maximized",
+                "--window-size=1512,982",
+                "--remote-debugging-port=0",
+                "--use-fake-ui-for-media-stream",
+                "--use-fake-device-for-media-stream",
+            ],
+        });
+        await context.addInitScript(() => {
+            Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+        }).catch(() => undefined);
+        const track = (page) => {
+            activePage = page;
+            // Never fall back to another tab after the exact page closes: that would hand a
+            // person a different site/page. A lost page is terminal for this handoff.
+            page.once("close", () => {
+                if (activePage === page)
+                    activePage = null;
+            });
+        };
+        context.on("page", track);
+        const initial = context.pages().at(-1) ?? await context.newPage();
+        track(initial);
+        mcp = new McpRuntime();
+        await mcp.start({ cdpEndpoint: await cdpEndpoint(profileDir) });
+        return {
+            tools: mcp,
+            handoffPage: () => activePage && !activePage.isClosed() ? activePage : null,
+            stop: async () => {
+                if (stopped)
+                    return;
+                stopped = true;
+                activePage = null;
+                await mcp.stop().catch(() => undefined);
+                await context.close().catch(() => undefined);
+            },
+        };
+    }
+    catch (error) {
+        await mcp?.stop().catch(() => undefined);
+        await context?.close().catch(() => undefined);
+        throw error;
+    }
+}
+async function cdpEndpoint(profileDir) {
+    const portFile = join(profileDir, "DevToolsActivePort");
+    for (let i = 0; i < 50; i++) {
+        if (existsSync(portFile)) {
+            const text = await import("node:fs/promises").then(({ readFile }) => readFile(portFile, "utf8"));
+            const port = text.split("\n", 1)[0]?.trim();
+            if (port)
+                return `http://127.0.0.1:${port}`;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error("could not read the local application browser CDP port");
+}

package/dist/browser-runner/local-apply/reconciliation-routes.js

@@ -0,0 +1,24 @@
+/** Separate from apply and generic tasks: this surface has no bridge/fill/submit operation. */
+export async function routeLocalApplyReconciliation(runtime, method, path, read) {
+    if (method !== "POST")
+        return undefined;
+    if (path === "/local-apply/reconciliation/run")
+        return runtime.start(await read());
+    if (path === "/local-apply/reconciliation/status")
+        return runtime.status(await read());
+    if (path === "/local-apply/reconciliation/handoff")
+        return runtime.handoff(await read());
+    if (path === "/local-apply/reconciliation/handoff-status")
+        return runtime.status(await read());
+    if (path === "/local-apply/reconciliation/handoff/frame")
+        return runtime.handoffFrame(await read());
+    if (path === "/local-apply/reconciliation/handoff/input") {
+        await runtime.handoffInput(await read());
+        return { ok: true };
+    }
+    if (path === "/local-apply/reconciliation/handoff/resume")
+        return runtime.resume(await read());
+    if (path === "/local-apply/reconciliation/handoff/end")
+        return runtime.end(await read());
+    return undefined;
+}

package/dist/browser-runner/local-apply/reconciliation-runtime.js

@@ -0,0 +1,210 @@
+/**
+ * Read-only reconciliation for an ended `submit_unconfirmed` attempt.
+ *
+ * This is intentionally independent of ApplyBridge: it launches no CLI, receives no source or
+ * artifact paths and has no action surface capable of filling, uploading or submitting.  The only
+ * page inspection remains in this process and returns a closed evidence vocabulary to PAGS.
+ */
+import { join } from "node:path";
+import { RunnerInputError } from "../errors.js";
+import { domainWithin } from "../local-browser/bridge.js";
+const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
+const TTL_MS = 10 * 60_000;
+/** Dedicated runtime; there is deliberately no bridge, engine, or generic browser-task fallback. */
+export class LocalApplyReconciliationRuntime {
+    deps;
+    sessions = new Map();
+    now;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? (() => Date.now());
+    }
+    async start(raw) {
+        const envelope = parseEnvelope(raw);
+        const existing = this.sessions.get(envelope.reconciliationId);
+        if (existing) {
+            if (existing.envelope.runId !== envelope.runId || existing.envelope.applicationId !== envelope.applicationId || existing.envelope.instanceId !== envelope.instanceId || existing.envelope.browserProfile !== envelope.browserProfile)
+                throw new RunnerInputError("The reconciliation id is already bound to another attempt", 409);
+            return this.view(existing);
+        }
+        const browser = await this.deps.browserFor(envelope.browserProfile, join(this.deps.dataDir, "reconciliation", envelope.reconciliationId));
+        const session = { envelope, browser, state: "running", expiresAt: this.now() + TTL_MS };
+        this.sessions.set(envelope.reconciliationId, session);
+        try {
+            const page = this.page(session);
+            if (!page)
+                return await this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+            await page.goto(envelope.applicationUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
+            return await this.inspect(session);
+        }
+        catch {
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        }
+    }
+    async status(raw) {
+        const session = this.require(raw);
+        if (session.state === "ended")
+            return this.view(session);
+        if (session.expiresAt <= this.now())
+            return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+        if (!this.page(session))
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        if (session.handoff?.state === "ready" && (session.handoff.expiresAt <= this.now() || !this.deps.takeover || await this.deps.takeover.state(session.handoff.id) !== "ready"))
+            await this.closeHandoff(session, session.handoff.expiresAt <= this.now() ? "expired" : "page_lost");
+        return this.view(session);
+    }
+    async handoff(raw) {
+        const request = this.handoffRequest(raw);
+        const session = this.require(request);
+        this.assertHandoffBinding(session, request);
+        if (session.state !== "paused" || !session.pauseReason)
+            throw new RunnerInputError("Reconciliation handoff is available only for a live login or CAPTCHA pause", 409);
+        if (session.handoff)
+            throw new RunnerInputError("A reconciliation handoff already exists", 409);
+        const page = this.page(session);
+        if (!page || !this.deps.takeover)
+            return this.closedHandoff(session, request.handoffId, "profile_unavailable");
+        try {
+            await this.deps.takeover.open(request, page);
+        }
+        catch {
+            return this.closedHandoff(session, request.handoffId, "page_lost");
+        }
+        session.handoff = { id: request.handoffId, expiresAt: this.now() + TTL_MS, state: "ready" };
+        return this.view(session);
+    }
+    async handoffFrame(raw) {
+        const session = await this.liveHandoff(raw);
+        try {
+            return await this.deps.takeover.frame(session.handoff.id);
+        }
+        catch {
+            await this.closeHandoff(session, "page_lost");
+            throw new RunnerInputError("The reconciliation page is no longer available", 409);
+        }
+    }
+    async handoffInput(raw) {
+        const request = raw && typeof raw === "object" ? raw : {};
+        const session = await this.liveHandoff(request);
+        if (!request.input || typeof request.input !== "object")
+            throw new RunnerInputError("handoff input is required");
+        // A person may authenticate/solve a CAPTCHA, but once that wall is gone this session accepts
+        // no further controls. It can never become an application fill/submit surface.
+        const blocker = await this.blocker(this.page(session));
+        if (!blocker)
+            throw new RunnerInputError("The read-only reconciliation handoff no longer accepts browser input", 409);
+        try {
+            await this.deps.takeover.input(session.handoff.id, request.input);
+        }
+        catch {
+            await this.closeHandoff(session, "page_lost");
+            throw new RunnerInputError("The reconciliation page is no longer available", 409);
+        }
+    }
+    async resume(raw) {
+        const session = await this.liveHandoff(raw);
+        return this.inspect(session);
+    }
+    async end(raw) {
+        const session = this.require(raw);
+        if (session.handoff?.state === "ready")
+            await this.closeHandoff(session, "unavailable");
+        session.state = "running";
+        session.pauseReason = undefined;
+        return this.view(session);
+    }
+    liveWork() { return [...this.sessions.values()].filter((s) => s.state !== "ended").map((s) => `reconciliation:${s.envelope.reconciliationId}`); }
+    closeAll() { for (const session of this.sessions.values())
+        void this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" }); }
+    async inspect(session) {
+        const page = this.page(session);
+        if (!page)
+            return this.finish(session, { state: "unavailable", proofKind: "authorized_profile_unavailable" });
+        const state = await this.pageState(page).catch(() => null);
+        if (!state || !this.permitted(session, state.url))
+            return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+        if (state.login || state.captcha) {
+            session.state = "paused";
+            session.pauseReason = state.captcha ? "captcha" : "login_required";
+            return this.view(session);
+        }
+        // A handoff which has just cleared authentication is the one case where we retain the
+        // bounded browser.  It lets the owner inspect their authenticated account/job view without
+        // turning generic page prose into an outcome.  Explicit end or the ten-minute deadline
+        // resolves it as ambiguous unless a future provider-specific verifier supplies exact proof.
+        if (session.handoff?.state === "ready") {
+            session.state = "running";
+            session.pauseReason = undefined;
+            return this.view(session);
+        }
+        // SEEK has no validated account/job receipt or history contract in this runtime. Generic
+        // prose, receipt-like URLs, unauthenticated pages and absent receipts prove nothing.
+        return this.finish(session, { state: "ambiguous", proofKind: "ambiguous_site_history" });
+    }
+    async finish(session, result) {
+        if (session.state === "ended")
+            return this.view(session);
+        if (session.handoff?.state === "ready")
+            await this.closeHandoff(session, "unavailable");
+        session.state = "ended";
+        session.pauseReason = undefined;
+        session.result = result;
+        await session.browser.stop().catch(() => undefined);
+        return this.view(session);
+    }
+    async closeHandoff(session, reason) {
+        if (!session.handoff || session.handoff.state === "closed")
+            return;
+        session.handoff.state = "closed";
+        session.handoff.reason = reason;
+        await this.deps.takeover?.end(session.handoff.id).catch(() => undefined);
+    }
+    closedHandoff(session, id, reason) { session.handoff = { id, expiresAt: this.now(), state: "closed", reason }; return this.view(session); }
+    page(session) { const page = session.browser.handoffPage?.(); return page && !page.isClosed() ? page : null; }
+    permitted(session, raw) { try {
+        const host = new URL(raw).hostname.toLowerCase();
+        return session.envelope.allowDomains.some((d) => domainWithin(host, d));
+    }
+    catch {
+        return false;
+    } }
+    async blocker(page) { const state = page ? await this.pageState(page).catch(() => null) : null; return !!state && (state.login || state.captcha); }
+    async pageState(page) {
+        return page.evaluate(() => {
+            const text = (document.body?.innerText ?? "").toLowerCase();
+            const captcha = !!document.querySelector('iframe[src*="hcaptcha.com"], .h-captcha, iframe[src*="challenges.cloudflare.com"], .cf-turnstile, iframe[src*="arkoselabs"], .geetest_holder') || /confirm (that )?you('?re| are) not a robot|i'?m not a robot|verify (that )?you('?re| are) (a )?human|checking (if the site connection is secure|your browser)/.test(text);
+            // Kept in the page: site prose never crosses the runner boundary.  This is deliberately
+            // narrower than a guess; anything unrecognised becomes `ambiguous`.
+            const password = !!document.querySelector("input[type=password]");
+            const otp = !!document.querySelector("input[autocomplete='one-time-code'], input[name*='otp' i], input[name*='verification' i], input[id*='otp' i], input[id*='verification' i]");
+            const emailSignIn = !!document.querySelector("form[action*='login' i] input[type=email], form[action*='sign-in' i] input[type=email], [data-auth-screen] input[type=email]");
+            return { url: location.href, login: password || otp || emailSignIn, captcha };
+        });
+    }
+    require(raw) { const id = typeof raw?.reconciliationId === "string" ? raw.reconciliationId : ""; if (!SAFE_ID.test(id))
+        throw new RunnerInputError("reconciliationId is required"); const session = this.sessions.get(id); if (!session)
+        throw new RunnerInputError("Reconciliation session not found", 404); return session; }
+    handoffRequest(raw) { const o = raw && typeof raw === "object" ? raw : {}; const handoffId = typeof o.handoffId === "string" ? o.handoffId : ""; const runId = typeof o.runId === "string" ? o.runId : ""; const applicationId = typeof o.applicationId === "string" ? o.applicationId : ""; const reconciliationId = typeof o.reconciliationId === "string" ? o.reconciliationId : ""; const browserProfile = o.browserProfile === "isolated" || o.browserProfile === "default" ? o.browserProfile : null; if (![handoffId, runId, applicationId, reconciliationId].every((v) => SAFE_ID.test(v)) || !browserProfile)
+        throw new RunnerInputError("reconciliation handoff needs opaque ids and browserProfile"); return { handoffId, runId, applicationId, reconciliationId, browserProfile }; }
+    assertHandoffBinding(session, request) { const e = session.envelope; if (e.reconciliationId !== request.reconciliationId || e.runId !== request.runId || e.applicationId !== request.applicationId || e.browserProfile !== request.browserProfile)
+        throw new RunnerInputError("The reconciliation handoff does not match this exact attempt", 403); }
+    async liveHandoff(raw) { const request = this.handoffRequest(raw); const session = this.require(request); this.assertHandoffBinding(session, request); if ((session.state !== "paused" && session.state !== "running") || session.handoff?.id !== request.handoffId || session.handoff.state !== "ready")
+        throw new RunnerInputError("The reconciliation handoff is closed", 409); if (session.handoff.expiresAt <= this.now()) {
+        await this.closeHandoff(session, "expired");
+        throw new RunnerInputError("The reconciliation handoff is closed", 409);
+    } return session; }
+    view(session) { const e = session.envelope; return { reconciliationId: e.reconciliationId, runId: e.runId, applicationId: e.applicationId, browserProfile: e.browserProfile, context: "separate_read_only_context", state: session.state, ...(session.pauseReason ? { pauseReason: session.pauseReason } : {}), ...(session.result ? { result: session.result } : {}) }; }
+}
+function parseEnvelope(raw) {
+    const o = raw && typeof raw === "object" ? raw : {};
+    const ids = ["reconciliationId", "runId", "instanceId", "applicationId"];
+    for (const key of ids)
+        if (typeof o[key] !== "string" || !SAFE_ID.test(o[key]))
+            throw new RunnerInputError(`Invalid reconciliation: ${key} is required`);
+    if (o.type !== "local_browser.apply.reconciliation" || (o.browserProfile !== "isolated" && o.browserProfile !== "default") || typeof o.applicationUrl !== "string" || !/^https?:\/\/[^\s/]+/i.test(o.applicationUrl))
+        throw new RunnerInputError("Invalid read-only reconciliation envelope");
+    const allowDomains = Array.isArray(o.allowDomains) ? o.allowDomains.filter((d) => typeof d === "string" && /^[a-z0-9.-]+$/i.test(d)).map((d) => d.toLowerCase()) : [];
+    if (!allowDomains.length || typeof o.jobIdentity !== "string" || !o.materialFingerprint || typeof o.materialFingerprint !== "object")
+        throw new RunnerInputError("Invalid reconciliation binding");
+    return { type: o.type, reconciliationId: o.reconciliationId, runId: o.runId, instanceId: o.instanceId, applicationId: o.applicationId, browserProfile: o.browserProfile, applicationUrl: o.applicationUrl, allowDomains, jobIdentity: o.jobIdentity, materialFingerprint: o.materialFingerprint };
+}

package/dist/browser-runner/local-apply/runtime-handoff.js

@@ -17,8 +17,11 @@ export class LocalApplyHandoffRuntime {
             throw new RunnerInputError("A handoff already exists for this application run", 409);
         if (!this.host.takeover)
             return this.closed(run, request.handoffId, "unavailable");
+        const page = run.browser?.handoffPage?.();
+        if (!page || page.isClosed())
+            return this.closed(run, request.handoffId, "page_lost");
         try {
-            await this.host.takeover.open(request);
+            await this.host.takeover.open(request, page);
         }
         catch {
             return this.closed(run, request.handoffId, "profile_unavailable");

package/dist/browser-runner/local-apply/takeover-adapter.js

@@ -5,14 +5,12 @@ export function isLocalApplyTakeover(id) { return id.startsWith(prefix); }
 export function createLocalApplyTakeoverAdapter(deps) {
     const key = (handoffId) => `${prefix}${handoffId}`;
     return {
-        async open(request) {
-            if (request.browserProfile !== "default")
-                throw new RunnerInputError("This browser profile has no live handoff page", 409);
+        async open(request, page) {
             const id = key(request.handoffId);
             if (deps.get(id))
                 throw new RunnerInputError("A local application handoff already exists", 409);
-            // Do not create a page here: a destroyed page must remain a lost handoff, never look ready.
-            const page = deps.activePage();
+            // Do not create or substitute a page here. The runtime supplied the page retained by
+            // this exact run/profile; a destroyed page must remain a lost handoff, never look ready.
             if (!page || page.isClosed())
                 throw new RunnerInputError("The local application page is no longer available", 409);
             deps.set(id, page);

package/dist/browser-runner/runner.js

@@ -17,7 +17,9 @@ import { LOCAL_BROWSER_TASK_TYPE } from "./local-browser/contract.js";
 import { LocalArtifactRuntime } from "./local-artifact/runtime.js";
 import { LOCAL_ARTIFACT_TASK_TYPE } from "./local-artifact/contract.js";
 import { LocalApplyRuntime } from "./local-apply/runtime.js";
+import { LocalApplyReconciliationRuntime } from "./local-apply/reconciliation-runtime.js";
 import { LOCAL_APPLY_TASK_TYPE } from "./local-apply/contract.js";
+import { createRunnerBrowserFactories } from "./local-apply/live-run-browser.js";
 import { createLocalApplyTakeoverAdapter, isLocalApplyTakeover } from "./local-apply/takeover-adapter.js";
 import { WORKFLOW_DRIVEN_TASKS } from "./task-types.js";
 /** True for a plain object. */
@@ -86,6 +88,8 @@ export class LocalRunner {
     localArtifact;
     /** Local application execution (#957): a signed-in CLI filling one application through the apply bridge. */
     localApply;
+    /** Browser-only, no-bridge reconciliation for an ended uncertain apply attempt. */
+    localApplyReconciliation;
     /** This runner's own local URL, once the server listens — the bridge forwarder calls back to it. */
     selfUrl = null;
     /** Live human-takeover sessions, keyed by task id (the page is kept alive). */
@@ -95,23 +99,17 @@ export class LocalRunner {
         mkdirSync(config.dataDir, { recursive: true });
         this.store = new RunnerStore(config.dataDir);
         this.coding = new CodingRuntime(join(config.dataDir, "repos"));
-        // `default` is the runner's own signed-in browser, shared and never closed by a run;
-        // `isolated` is a fresh profile inside the run's folder, removed with it.
-        const browserFor = async (profile, runDir) => {
-            if (profile === "default")
-                return { tools: await this.getMcp(), stop: async () => undefined };
-            const mcp = new McpRuntime();
-            await mcp.start({ userDataDir: join(runDir, "profile"), headless: config.headless });
-            return { tools: mcp, stop: () => mcp.stop() };
-        };
+        const { browserFor, applyBrowserFor } = createRunnerBrowserFactories({ headless: config.headless, defaultTools: () => this.getMcp(), sharedPage: () => this.activePage });
         this.localBrowser = new LocalBrowserRuntime({ dataDir: config.dataDir, selfUrl: () => this.selfUrl, browserFor });
         this.localArtifact = new LocalArtifactRuntime({ dataDir: config.dataDir });
+        const localApplyTakeover = createLocalApplyTakeoverAdapter({ get: (id) => this.takeovers.get(id), set: (id, page) => this.takeovers.set(id, { page, reason: "local_apply", humanDone: false }), frame: (id) => this.takeoverFrame(id), input: (id, input) => this.takeoverInput(id, input), end: (id) => this.endTakeover(id) });
         this.localApply = new LocalApplyRuntime({
             dataDir: config.dataDir,
             selfUrl: () => this.selfUrl,
-            browserFor,
-            takeover: createLocalApplyTakeoverAdapter({ activePage: () => this.activePage, get: (id) => this.takeovers.get(id), set: (id, page) => this.takeovers.set(id, { page, reason: "local_apply", humanDone: false }), frame: (id) => this.takeoverFrame(id), input: (id, input) => this.takeoverInput(id, input), end: (id) => this.endTakeover(id) }),
+            browserFor: applyBrowserFor,
+            takeover: localApplyTakeover,
         });
+        this.localApplyReconciliation = new LocalApplyReconciliationRuntime({ dataDir: config.dataDir, browserFor: applyBrowserFor, takeover: localApplyTakeover });
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
         const expired = this.store.expireInFlightTasks();
@@ -129,7 +127,7 @@ export class LocalRunner {
      */
     liveWork() {
         const coding = this.coding.liveWork();
-        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork()];
+        const local = [...this.localBrowser.liveWork(), ...this.localArtifact.liveWork(), ...this.localApply.liveWork(), ...this.localApplyReconciliation.liveWork()];
         return { codingTurns: coding.length, localRuns: local.length, detail: [...coding, ...local].slice(0, 10) };
     }
     capabilities() {
@@ -290,6 +288,7 @@ export class LocalRunner {
         this.localBrowser.closeAll();
         this.localArtifact.closeAll();
         this.localApply.closeAll();
+        this.localApplyReconciliation.closeAll();
         try {
             this.coding.closeAll();
         }

package/dist/browser-runner/server.js

@@ -5,6 +5,7 @@ import { probeGitSshIdentity } from "./coding/repo.js";
 import { checkEngine } from "./coding/engine-check.js";
 import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
 import { routeLocalApplyHandoff } from "./local-apply/handoff-routes.js";
+import { routeLocalApplyReconciliation } from "./local-apply/reconciliation-routes.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
         try {
@@ -239,6 +240,9 @@ async function route(runner, req, res) {
     const handoff = await routeLocalApplyHandoff(runner.localApply, req.method, path, () => readJson(req));
     if (handoff)
         return json(res, 200, handoff);
+    const reconciliation = await routeLocalApplyReconciliation(runner.localApplyReconciliation, req.method, path, () => readJson(req));
+    if (reconciliation !== undefined)
+        return json(res, 200, reconciliation);
     if (req.method === "POST" && path === "/local-apply/resume") {
         return json(res, 200, runner.localApply.resume(await readJson(req)));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-	"version": "0.4.96",
+  "version": "0.4.98",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",