@mlola/browser-core 0.1.0

package/dist/orchestrator.js

@@ -0,0 +1,1168 @@
+/**
+ * Task orchestrator (PRD §8.1).
+ *
+ * Owns the run lifecycle: observation → action space → decision → policy →
+ * execution → verification → recovery, plus planning, memory, budgets, human
+ * intervention, artifacts and the event log.
+ *
+ * The loop is deliberately boring: every step is observable, every effect is
+ * verified, and no model has direct browser authority.
+ */
+import { DEFAULT_BROWSER_CONFIG, DEFAULT_POLICY, RuntimeError, actionSignature, addFact, addFailedAttempt, asRuntimeError, createMemory, describeAction, failureRecord, looksSecretField, newRunId, newSessionId, newStepId, } from "@mlola/browser-protocol";
+import { ApprovalBroker, PolicyEngine, assessRisk, isSafeNavigationUrl, mergePolicy, quarantineCandidates, } from "@mlola/browser-policy";
+import { ArtifactRegistry } from "@mlola/browser-artifacts";
+import { HumanHelpBroker, UnavailableHumanHelpHost } from "@mlola/browser-takeover";
+import { EventLog, ensureRunDirs, resolveHome, writeRunMeta, writeRunSummary, } from "@mlola/browser-trace";
+import { LoopDetector, nextStrategy } from "@mlola/browser-recovery";
+import { buildActionSpace, spaceSummary } from "./action-space.js";
+import { validateDecision } from "./decision-validation.js";
+import { BudgetManager } from "./budget.js";
+import { Executor } from "./executor.js";
+import { TextUnavailableError, resolveText } from "./text.js";
+import { inferDocumentTypeHint, verifyCompletion } from "./verifier.js";
+import { looksComplex, summarizeSnapshot } from "./state.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class TaskOrchestrator {
+    #opts;
+    #backend;
+    #events;
+    #artifacts;
+    #policy;
+    #budget;
+    #human;
+    #humanAvailable;
+    #approvals;
+    #executor;
+    #session;
+    #paths;
+    #runId = "";
+    #sessionId = "";
+    #status = "created";
+    #memory = createMemory("");
+    #history = [];
+    #subgoals = [];
+    #activeSubgoal = -1;
+    #planDisabled = false;
+    #loopDetector = new LoopDetector();
+    #forceFallback = false;
+    #paused = false;
+    #cancelled;
+    #uploadedArtifacts = new Set();
+    #recoveryAttemptsByStep = 0;
+    #stepNumber = 0;
+    #screenshotPolicy;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#backend = opts.backend;
+        this.#screenshotPolicy = opts.screenshot ?? "off";
+        this.#policy = new PolicyEngine(mergePolicy(DEFAULT_POLICY, opts.policy));
+        this.#humanAvailable = opts.humanHelp !== undefined;
+        this.#approvals =
+            opts.approvals ??
+                new ApprovalBroker({
+                    onRequest: (request) => this.#events?.emit("APPROVAL_REQUESTED", {
+                        approvalId: request.id,
+                        summary: request.summary,
+                        risk: request.risk,
+                        url: request.url,
+                    }),
+                    onResolved: (request, resolution) => this.#events?.emit("APPROVAL_RESOLVED", { approvalId: request.id, resolution }),
+                });
+    }
+    get status() {
+        return this.#status;
+    }
+    get runId() {
+        return this.#runId;
+    }
+    get events() {
+        return this.#events?.events ?? [];
+    }
+    get artifacts() {
+        return this.#artifacts?.summaries() ?? [];
+    }
+    pause(reason) {
+        this.#paused = true;
+        this.#status = "paused";
+        this.#events?.emit("RUN_PAUSED", { ...(reason ? { reason } : {}) });
+    }
+    resume(reason) {
+        if (!this.#paused)
+            return;
+        this.#paused = false;
+        this.#status = "running";
+        this.#events?.emit("RUN_RESUMED", { ...(reason ? { reason } : {}) });
+    }
+    cancel(reason = "cancelled by user") {
+        this.#cancelled = reason;
+    }
+    /* ─────────────────────────────── main run ─────────────────────────────── */
+    async run(task) {
+        const startedAt = Date.now();
+        const runId = newRunId();
+        const sessionId = newSessionId();
+        this.#runId = runId;
+        this.#sessionId = sessionId;
+        this.#memory = createMemory(task.goal);
+        const home = this.#opts.home ?? resolveHome();
+        const paths = ensureRunDirs(runId, home);
+        this.#paths = paths;
+        const browser = { ...DEFAULT_BROWSER_CONFIG, ...(task.browser ?? {}) };
+        if (task.screenshot)
+            this.#screenshotPolicy = task.screenshot;
+        this.#events = new EventLog({
+            runId,
+            sessionId,
+            eventsPath: paths.eventsPath,
+            ...(this.#opts.onEvent ? { onEvent: this.#opts.onEvent } : {}),
+        });
+        this.#artifacts = new ArtifactRegistry({ dir: paths.artifactsDir });
+        this.#budget = new BudgetManager({
+            ...(task.budgets ? { budgets: task.budgets } : {}),
+            ...(this.#opts.costRates ? { costRates: this.#opts.costRates } : {}),
+            ...(this.#opts.now ? { now: this.#opts.now } : {}),
+        });
+        this.#human = new HumanHelpBroker({
+            host: this.#opts.humanHelp ?? new UnavailableHumanHelpHost(),
+            onRequest: (request) => this.#events?.emit("HUMAN_HELP_REQUESTED", {
+                helpId: request.id,
+                prompt: request.prompt,
+                kind: request.kind,
+                ...(request.timeoutMs !== undefined ? { timeoutMs: request.timeoutMs } : {}),
+            }),
+            onResolved: (request, resolution) => this.#events?.emit("HUMAN_HELP_COMPLETED", {
+                helpId: request.id,
+                criteriaMet: resolution === "completed",
+                detail: resolution,
+            }),
+        });
+        this.#human.setVerifier(async () => ({
+            snapshot: await this.#backend.observe(this.#sessionId),
+            artifacts: this.#artifacts?.summaries() ?? [],
+            events: this.#events?.events ?? [],
+        }));
+        writeRunMeta({
+            runId,
+            goal: task.goal,
+            ...(task.startUrl ? { startUrl: task.startUrl } : {}),
+            backend: browser.backend,
+            startedAt,
+            version: "0.1.0",
+        }, home);
+        this.#events.emit("RUN_CREATED", {
+            goal: task.goal,
+            ...(task.startUrl !== undefined ? { startUrl: task.startUrl } : {}),
+            backend: browser.backend,
+        });
+        let result;
+        try {
+            this.#session = await this.#backend.startSession({
+                runId,
+                sessionId,
+                browser,
+                artifactsDir: paths.artifactsDir,
+                screenshotsDir: paths.screenshotsDir,
+            });
+            this.#executor = new Executor({
+                backend: this.#backend,
+                events: this.#events,
+                artifacts: this.#artifacts,
+                sessionId,
+                runId,
+            });
+            this.#events.emit("SESSION_CREATED", { sessionId, backend: this.#session.backend });
+            this.#events.emit("SESSION_CONNECTED", {
+                sessionId,
+                ...(this.#session.agentWindowId !== undefined ? { agentWindowId: this.#session.agentWindowId } : {}),
+            });
+            this.#events.emit("RUN_STARTED", { runId });
+            this.#status = "running";
+            result = await this.#mainLoop(task, startedAt);
+        }
+        catch (err) {
+            const runtimeError = asRuntimeError(err);
+            this.#events.emit("RUN_FAILED", { failure: failureRecord(runtimeError), status: this.#status });
+            result = this.#buildResult("failed", runtimeError.message, startedAt);
+        }
+        finally {
+            result = await this.#cleanup(result);
+        }
+        writeRunSummary(runId, result, home);
+        return result;
+    }
+    /* ────────────────────────────── main loop ─────────────────────────────── */
+    async #mainLoop(task, startedAt) {
+        const events = this.#requireEvents();
+        const budget = this.#requireBudget();
+        let snapshot;
+        let failureNote;
+        // Initial navigation (runtime-owned, policy-checked).
+        if (task.startUrl) {
+            if (!isSafeNavigationUrl(task.startUrl)) {
+                throw new RuntimeError("POLICY_DENIED", `refusing to navigate to non-http(s) URL: ${task.startUrl}`);
+            }
+            const outcome = this.#policy.evaluate({
+                runId: this.#runId,
+                stepId: newStepId(),
+                operation: "OPEN_TAB",
+                risk: "navigate",
+                origin: originOf(task.startUrl),
+                url: task.startUrl,
+            });
+            if (outcome.mode === "deny") {
+                throw new RuntimeError("POLICY_DENIED", `navigation to ${task.startUrl} denied (${outcome.reason})`);
+            }
+            const nav = await this.#backend.navigate(this.#sessionId, task.startUrl);
+            events.emit("ACTION_EXECUTED", {
+                stepId: newStepId(),
+                action: `NAVIGATE ${task.startUrl}`,
+                latencyMs: nav.latencyMs,
+            });
+        }
+        snapshot = await this.#observe();
+        if ((task.forcePlanner || looksComplex(task.goal)) && this.#opts.providers.planner) {
+            await this.#plan(task, "initial", snapshot);
+        }
+        while (true) {
+            if (this.#cancelled) {
+                events.emit("RUN_CANCELLED", { reason: this.#cancelled });
+                return this.#buildResult("cancelled", this.#cancelled, startedAt);
+            }
+            await this.#waitIfPaused();
+            if (this.#cancelled) {
+                events.emit("RUN_CANCELLED", { reason: this.#cancelled });
+                return this.#buildResult("cancelled", this.#cancelled, startedAt);
+            }
+            for (const warning of budget.warnings()) {
+                events.emit("BUDGET_WARNING", { reason: warning.reason, snapshot: numericSnapshot(budget) });
+            }
+            const verdict = budget.check();
+            if (verdict.kind === "fail") {
+                events.emit("BUDGET_EXHAUSTED", { reason: verdict.reason });
+                return this.#buildResult("failed", verdict.reason, startedAt);
+            }
+            if (verdict.kind === "degrade") {
+                this.#planDisabled = true;
+                events.emit("NOTE", { text: `degraded mode: ${verdict.reason}`, level: "warn" });
+            }
+            const outcome = await this.#runStep(task, snapshot, failureNote);
+            snapshot = outcome.pendingSnapshot ?? (await this.#observe());
+            if (outcome.kind === "complete") {
+                return this.#buildResult("completed", outcome.detail ?? "completed", startedAt, outcome.verification);
+            }
+            if (outcome.kind === "success" || outcome.kind === "no_effect") {
+                failureNote = undefined;
+                if (outcome.kind === "success")
+                    this.#recoveryAttemptsByStep = 0;
+                continue;
+            }
+            // fatal
+            const failure = outcome.failure ?? new RuntimeError("INTERNAL", outcome.detail ?? "fatal");
+            events.emit("RUN_FAILED", { failure: failureRecord(failure), status: "failed" });
+            return this.#buildResult("failed", failure.message, startedAt);
+        }
+    }
+    /* ─────────────────────────────── one step ─────────────────────────────── */
+    async #runStep(task, snapshotIn, failureNote) {
+        const events = this.#requireEvents();
+        const budget = this.#requireBudget();
+        const executor = this.#requireExecutor();
+        this.#stepNumber += 1;
+        const stepId = newStepId();
+        events.setStepId(stepId);
+        const snapshot = snapshotIn ?? (await this.#observe());
+        // 1. Action space (PRD §14) + injection quarantine (PRD §22).
+        const baseSpace = buildActionSpace({
+            snapshot,
+            uploadAllowed: this.#policy.modeForRisk("upload") !== "deny",
+            goal: task.goal,
+        });
+        const { space } = quarantineCandidates(baseSpace);
+        events.emit("ACTION_SPACE_BUILT", spaceSummary(space));
+        // 2. Decision (fast path with fallback).
+        let decision;
+        try {
+            decision = await this.#decide(task, snapshot, space, failureNote);
+        }
+        catch (err) {
+            const runtimeError = asRuntimeError(err);
+            return this.#recover(task, runtimeError, snapshot, stepId);
+        }
+        // 3. Terminal claims.
+        if (decision.operation === "DONE") {
+            return this.#handleDone(task, snapshot);
+        }
+        if (decision.operation === "BLOCKED" || decision.operation === "ASK_USER") {
+            return this.#handleHumanEscalation(task, snapshot, decision);
+        }
+        // 4. Resolve the target into a typed action.
+        let action;
+        try {
+            action = await this.#resolveAction(task, decision, space, snapshot);
+        }
+        catch (err) {
+            const runtimeError = asRuntimeError(err);
+            if (runtimeError.code === "SECRET_TARGET" || runtimeError instanceof TextUnavailableError) {
+                return this.#handleHumanEscalation(task, snapshot, decision, runtimeError);
+            }
+            return this.#recover(task, runtimeError, snapshot, stepId);
+        }
+        // 5. Policy (PRD §20, §61).
+        const policyResult = await this.#applyPolicy(task, snapshot, action, decision, stepId);
+        if (policyResult.kind === "stop")
+            return policyResult.outcome;
+        // 6. Stop-before boundary (PRD §64.20).
+        const boundary = stopBeforeMatch(task.stopBefore, action, snapshot);
+        if (boundary) {
+            events.emit("NOTE", { text: `stop boundary reached: ${boundary}`, level: "info" });
+            return {
+                kind: "complete",
+                detail: `stopped at the requested boundary (${boundary})`,
+                pendingSnapshot: snapshot,
+            };
+        }
+        // 7. Execute + verify.
+        const decided = { action, decision, snapshotId: snapshot.snapshotId, stepId };
+        const result = await executor.execute(decided, snapshot);
+        const signature = actionSignature(action);
+        const progressed = result.ok && result.verification.status === "verified" && !result.verification.noEffect;
+        const summary = {
+            step: this.#stepNumber,
+            action: describeAction(action),
+            outcome: result.ok ? (result.verification.noEffect ? "no_effect" : "ok") : "failed",
+            ...(result.verification.evidence[0] ? { detail: result.verification.evidence[0].detail } : {}),
+            url: result.after.url,
+        };
+        this.#history.push(summary);
+        if (this.#history.length > 24)
+            this.#history.shift();
+        events.emit("STEP_COMPLETED", { step: this.#stepNumber, summary });
+        budget.stepCompleted();
+        this.#recordMemory(action, result, snapshot);
+        const loop = this.#loopDetector.record({
+            step: this.#stepNumber,
+            signature,
+            fingerprint: result.after.fingerprint,
+            progressed,
+        });
+        if (loop) {
+            events.emit("LOOP_DETECTED", {
+                kind: loop,
+                detail: `${signature} repeated without progress`,
+                step: this.#stepNumber,
+            });
+            return this.#recover(task, new RuntimeError("LOOP_DETECTED", `loop detected (${loop})`, { evidence: { signature } }), result.after, stepId);
+        }
+        if (!result.ok) {
+            return this.#recover(task, result.failure ?? new RuntimeError("EXECUTION_FAILED", "action failed"), result.after, stepId);
+        }
+        if (result.verification.noEffect) {
+            return { kind: "no_effect", pendingSnapshot: result.after, detail: summary.detail };
+        }
+        return { kind: "success", pendingSnapshot: result.after };
+    }
+    /* ────────────────────────────── decisions ─────────────────────────────── */
+    async #decide(task, snapshot, space, failureNote) {
+        const events = this.#requireEvents();
+        const budget = this.#requireBudget();
+        const providers = this.#opts.providers;
+        const subgoal = this.#currentSubgoal();
+        const input = {
+            runId: this.#runId,
+            step: this.#stepNumber,
+            goal: task.goal,
+            ...(subgoal ? { subgoal: subgoal.description } : {}),
+            snapshot,
+            actionSpace: space,
+            memory: this.#memory,
+            artifacts: this.#artifacts?.summaries() ?? [],
+            history: this.#history,
+            ...(failureNote !== undefined ? { failure: failureNote } : {}),
+            budget: budget.snapshot,
+        };
+        events.emit("DECISION_REQUESTED", {
+            step: this.#stepNumber,
+            provider: providers.decision.name,
+            operations: space.operations.length,
+            targets: Object.values(space.heads).reduce((sum, list) => sum + (list?.length ?? 0), 0),
+        });
+        const tryProvider = async (provider, isFallback) => {
+            try {
+                const output = await provider.decide(input);
+                const validation = validateDecision(output, space, this.#opts.validation);
+                for (const warning of validation.warnings) {
+                    events.emit("NOTE", { text: `decision warning (${warning.code}): ${warning.detail}`, level: "warn" });
+                }
+                if (!validation.ok) {
+                    events.emit("DECISION_INVALID", {
+                        reason: validation.issues.map((i) => `${i.code}: ${i.detail}`).join("; "),
+                        ...(output.raw !== undefined ? { raw: output.raw } : {}),
+                    });
+                    return undefined;
+                }
+                budget.charge("decision", output.usage);
+                events.emit("DECISION_RECEIVED", {
+                    decision: { ...output, raw: undefined },
+                    ...(output.usage !== undefined ? { usage: output.usage } : {}),
+                });
+                if (isFallback)
+                    this.#forceFallback = false;
+                return output;
+            }
+            catch (err) {
+                const runtimeError = asRuntimeError(err);
+                if (runtimeError.code === "SECRET_TARGET")
+                    throw runtimeError;
+                events.emit("NOTE", {
+                    text: `decision provider ${provider.name} failed: ${runtimeError.message}`,
+                    level: "warn",
+                });
+                return undefined;
+            }
+        };
+        if (!this.#forceFallback) {
+            const fast = await tryProvider(providers.decision, false);
+            if (fast)
+                return fast;
+        }
+        const fallbackProvider = providers.fallbackDecision;
+        if (fallbackProvider && budget.fallbackAllowed() && !this.#planDisabled) {
+            events.emit("FALLBACK_STARTED", {
+                reason: this.#forceFallback ? "recovery escalated to fallback" : "fast path unavailable",
+                from: providers.decision.name,
+                to: fallbackProvider.name,
+                step: this.#stepNumber,
+            });
+            const escalated = await tryProvider(fallbackProvider, true);
+            events.emit("FALLBACK_COMPLETED", { provider: fallbackProvider.name, ok: escalated !== undefined });
+            if (escalated)
+                return escalated;
+        }
+        throw new RuntimeError("PROVIDER_FAILURE", `no valid decision from ${providers.decision.name}`);
+    }
+    /* ───────────────────────── target → typed action ──────────────────────── */
+    async #resolveAction(task, decision, space, snapshot) {
+        const head = space.headForOperation[decision.operation];
+        const refFor = (nodeIndex, nodeId) => {
+            const node = snapshot.nodes.find((n) => n.nodeId === nodeId);
+            return {
+                index: nodeIndex,
+                nodeId,
+                pageToken: snapshot.pageToken,
+                generation: snapshot.generation,
+                labelHash: node?.labelHash ?? "",
+            };
+        };
+        if (head !== undefined) {
+            const candidates = space.heads[head] ?? [];
+            const candidate = candidates.find((c) => c.key === decision.target);
+            if (!candidate) {
+                throw new RuntimeError("STALE_DECISION", `target ${decision.target} is no longer offered`);
+            }
+            switch (decision.operation) {
+                case "CLICK":
+                    return { op: "CLICK", ref: refFor(candidate.nodeIndex, candidate.nodeId) };
+                case "TYPE_TEXT": {
+                    const node = snapshot.nodes.find((n) => n.nodeId === candidate.nodeId);
+                    const subgoal = this.#currentSubgoal();
+                    const resolved = await resolveText({
+                        goal: task.goal,
+                        ...(subgoal ? { subgoal: subgoal.description } : {}),
+                        targetLabel: node?.label ?? candidate.label,
+                        targetRole: node?.role ?? "textbox",
+                        literals: [],
+                    }, {
+                        ...(this.#opts.providers.text ? { provider: this.#opts.providers.text } : {}),
+                        maxLength: this.#policy.config.maxTypedLength,
+                    });
+                    if (resolved.source === "model") {
+                        this.#requireBudget().charge("text", { provider: resolved.provider, calls: 1 });
+                        this.#events?.emit("PROVIDER_USAGE", {
+                            role: "text",
+                            usage: { provider: resolved.provider, calls: 1 },
+                        });
+                    }
+                    const keyboardMode = node?.role === "combobox" || node?.role === "contenteditable";
+                    return {
+                        op: "TYPE_TEXT",
+                        ref: refFor(candidate.nodeIndex, candidate.nodeId),
+                        text: resolved.text,
+                        mode: keyboardMode ? "keyboard" : "fill",
+                        ...(node?.role === "searchbox" ? { submitAfter: true } : {}),
+                    };
+                }
+                case "SELECT":
+                    return {
+                        op: "SELECT",
+                        ref: refFor(candidate.nodeIndex, candidate.nodeId),
+                        option: {
+                            index: candidate.optionIndex,
+                            label: optionLabelFromCandidate(candidate.label),
+                            value: candidate.optionValue ?? "",
+                        },
+                    };
+                case "DOWNLOAD":
+                    return { op: "DOWNLOAD", ref: refFor(candidate.nodeIndex, candidate.nodeId) };
+                case "UPLOAD": {
+                    const record = this.#selectArtifact(task);
+                    if (!record)
+                        throw new RuntimeError("UPLOAD_FAILED", "no verified artifact is available to upload");
+                    this.#uploadedArtifacts.add(record.id);
+                    return {
+                        op: "UPLOAD",
+                        ref: refFor(candidate.nodeIndex, candidate.nodeId),
+                        artifactId: record.id,
+                        mechanism: "file_input",
+                    };
+                }
+                case "OPEN_TAB": {
+                    const url = candidate.url;
+                    if (!url || !isSafeNavigationUrl(url)) {
+                        throw new RuntimeError("POLICY_DENIED", "refusing to open a non-http(s) URL");
+                    }
+                    return { op: "OPEN_TAB", url, sourceRef: refFor(candidate.nodeIndex, candidate.nodeId) };
+                }
+                case "SWITCH_TAB": {
+                    if (!candidate.tabId)
+                        throw new RuntimeError("STALE_DECISION", "tab no longer exists");
+                    return { op: "SWITCH_TAB", tabId: candidate.tabId };
+                }
+                default:
+                    break;
+            }
+        }
+        switch (decision.operation) {
+            case "SCROLL_UP":
+                return { op: "SCROLL_UP", amount: "half" };
+            case "SCROLL_DOWN":
+                return { op: "SCROLL_DOWN", amount: "half" };
+            case "WAIT":
+                return { op: "WAIT", ms: 600 };
+            case "BACK":
+                return { op: "BACK" };
+            case "FORWARD":
+                return { op: "FORWARD" };
+            case "ACCEPT_DIALOG":
+                return { op: "ACCEPT_DIALOG" };
+            case "DISMISS_DIALOG":
+                return { op: "DISMISS_DIALOG" };
+            default:
+                throw new RuntimeError("DECISION_INVALID", `cannot resolve operation ${decision.operation}`);
+        }
+    }
+    #selectArtifact(task) {
+        const records = this.#artifacts?.records.filter((r) => r.verified && r.source !== "upload") ?? [];
+        if (records.length === 0)
+            return undefined;
+        const hint = inferDocumentTypeHint(task.goal);
+        const fresh = records.filter((r) => !this.#uploadedArtifacts.has(r.id));
+        const pool = fresh.length > 0 ? fresh : records;
+        const preferred = pool.filter((r) => hint === undefined || r.documentType === hint);
+        const finalPool = preferred.length > 0 ? preferred : pool;
+        return [...finalPool].sort((a, b) => b.createdAt - a.createdAt)[0];
+    }
+    /* ─────────────────────────────── policy ───────────────────────────────── */
+    async #applyPolicy(task, snapshot, action, decision, stepId) {
+        const events = this.#requireEvents();
+        const origin = originOf(snapshot.url);
+        const targetLabel = targetLabelOf(action, snapshot);
+        const ref = "ref" in action ? action.ref : undefined;
+        const node = ref ? snapshot.nodes.find((n) => n.nodeId === ref.nodeId) : undefined;
+        const secretsTouched = action.op === "TYPE_TEXT" && looksSecretField(`${targetLabel ?? ""} ${node?.kind ?? ""} ${node?.label ?? ""}`);
+        const assessment = assessRisk({
+            operation: action.op,
+            ...(targetLabel !== undefined ? { targetLabel } : {}),
+            ...(secretsTouched ? { secretsTouched } : {}),
+        });
+        const outcome = this.#policy.evaluate({
+            runId: this.#runId,
+            stepId,
+            operation: action.op,
+            risk: assessment.refined,
+            origin,
+            url: snapshot.url,
+            ...(targetLabel !== undefined ? { targetLabel } : {}),
+            ...(secretsTouched ? { secretsTouched } : {}),
+        });
+        const summary = `${describeAction(action)} (risk: ${outcome.risk})`;
+        if (outcome.mode === "deny") {
+            events.emit("POLICY_DENIED", { outcome, summary });
+            if (this.#humanAvailable) {
+                return {
+                    kind: "stop",
+                    outcome: await this.#handleHumanEscalation(task, snapshot, decision, new RuntimeError("POLICY_DENIED", `policy denied: ${outcome.reason}`)),
+                };
+            }
+            return {
+                kind: "stop",
+                outcome: { kind: "fatal", failure: new RuntimeError("POLICY_DENIED", `policy denied: ${outcome.reason}`) },
+            };
+        }
+        if (outcome.mode === "allow") {
+            events.emit("POLICY_ALLOWED", { outcome, summary });
+            return { kind: "continue" };
+        }
+        if (outcome.mode === "ask") {
+            const resolution = await this.#approvals.request({
+                runId: this.#runId,
+                stepId,
+                summary,
+                risk: outcome.risk,
+                origin,
+                url: snapshot.url,
+                ...(targetLabel !== undefined ? { targetLabel } : {}),
+            });
+            if (resolution === "approved") {
+                events.emit("POLICY_ALLOWED", { outcome: { ...outcome, mode: "allow", reason: "approved by user" }, summary });
+                return { kind: "continue" };
+            }
+            if (resolution === "takeover") {
+                return { kind: "stop", outcome: await this.#handleHumanEscalation(task, snapshot, decision) };
+            }
+            events.emit("POLICY_DENIED", { outcome: { ...outcome, mode: "deny", reason: "approval denied" }, summary });
+            return {
+                kind: "stop",
+                outcome: {
+                    kind: this.#humanAvailable ? "no_effect" : "fatal",
+                    ...(this.#humanAvailable
+                        ? {}
+                        : { failure: new RuntimeError("APPROVAL_DENIED", "the user denied this action") }),
+                    detail: "approval denied",
+                },
+            };
+        }
+        // takeover mode (PRD §19, §20.2)
+        events.emit("TAKEOVER_STARTED", { reason: outcome.reason, prompt: summary });
+        const help = await this.#humanHelp(task, snapshot, {
+            kind: secretsTouched ? "credential" : "confirmation",
+            prompt: `${summary}\nReason: ${outcome.reason}\n` +
+                `Take over the browser to perform this step yourself, then hand control back.`,
+            completion: { criteria: { kind: "manual", description: "the human completed the step" } },
+        });
+        events.emit("TAKEOVER_ENDED", { resumedBy: help.resolution });
+        if (help.resolution === "cancelled") {
+            return {
+                kind: "stop",
+                outcome: { kind: "fatal", failure: new RuntimeError("HUMAN_HELP_TIMEOUT", "takeover was not completed") },
+            };
+        }
+        return { kind: "stop", outcome: { kind: "no_effect", detail: "human takeover" } };
+    }
+    /* ─────────────────────────── human intervention ───────────────────────── */
+    async #handleHumanEscalation(task, snapshot, decision, error) {
+        const budget = this.#requireBudget();
+        if (!this.#humanAvailable || budget.snapshot.humanHelpRequests >= budget.budgets.maxHumanHelpRequests) {
+            return {
+                kind: "fatal",
+                failure: error ?? new RuntimeError("BUDGET_EXHAUSTED", "human help is unavailable and no automatic path remains"),
+            };
+        }
+        const kind = error?.code === "SECRET_TARGET"
+            ? "credential"
+            : decision.operation === "ASK_USER"
+                ? "interaction"
+                : "recovery";
+        const prompt = error?.code === "SECRET_TARGET"
+            ? `This step needs a secret. Please enter it yourself, then hand control back.\n\nPage: ${snapshot.title} (${snapshot.url})`
+            : decision.operation === "ASK_USER"
+                ? `The agent asked for help.\nGoal: ${task.goal}\nPage: ${snapshot.title} (${snapshot.url})`
+                : `The agent reported it is blocked.\nGoal: ${task.goal}\nPage: ${snapshot.title} (${snapshot.url})`;
+        const help = await this.#humanHelp(task, snapshot, {
+            kind,
+            prompt,
+            completion: { criteria: { kind: "manual", description: "the human resolved the blocker" } },
+        });
+        if (help.resolution === "cancelled") {
+            return {
+                kind: "fatal",
+                failure: error ?? new RuntimeError("HUMAN_HELP_TIMEOUT", "human help was not completed"),
+            };
+        }
+        return { kind: "no_effect", detail: `human help: ${help.resolution}` };
+    }
+    #humanHelp(task, snapshot, input) {
+        const budget = this.#requireBudget();
+        budget.humanHelp();
+        this.#status = "human_control";
+        void task;
+        return this.#requireHuman()
+            .request({
+            runId: this.#runId,
+            sessionId: this.#sessionId,
+            kind: input.kind,
+            prompt: input.prompt,
+            ...(input.completion !== undefined ? { completion: input.completion } : {}),
+            url: snapshot.url,
+            tabId: snapshot.activeTabId,
+            targets: snapshot.nodes
+                .filter((n) => n.flags.visible && n.operations.includes("TYPE_TEXT"))
+                .slice(0, 5)
+                .map((n) => ({
+                ref: {
+                    index: n.index,
+                    nodeId: n.nodeId,
+                    pageToken: snapshot.pageToken,
+                    generation: snapshot.generation,
+                    labelHash: n.labelHash,
+                },
+                label: n.label,
+                role: n.role,
+            })),
+        })
+            .finally(() => {
+            this.#status = "running";
+        });
+    }
+    /* ───────────────────────────── completion ─────────────────────────────── */
+    async #handleDone(task, snapshot) {
+        const events = this.#requireEvents();
+        // With a plan, DONE means "current subgoal complete".
+        if (this.#subgoals.length > 0 && this.#activeSubgoal >= 0 && this.#activeSubgoal < this.#subgoals.length - 1) {
+            const current = this.#subgoals[this.#activeSubgoal];
+            current.status = "done";
+            events.emit("SUBGOAL_COMPLETED", { subgoal: current.description, index: this.#activeSubgoal });
+            this.#activeSubgoal += 1;
+            const next = this.#subgoals[this.#activeSubgoal];
+            next.status = "active";
+            events.emit("SUBGOAL_STARTED", { subgoal: next.description, index: this.#activeSubgoal });
+            addFact(this.#memory, `Subgoal completed: ${current.description}`, "system_runtime");
+            return { kind: "success", pendingSnapshot: snapshot, detail: "subgoal advanced", progressed: true };
+        }
+        const verification = verifyCompletion(task, {
+            snapshot,
+            artifacts: this.#artifacts?.summaries() ?? [],
+            events: events.events,
+        });
+        events.emit("VERIFICATION_RESULT", { verification });
+        if (verification.status === "verified") {
+            events.emit("RUN_COMPLETED", { result: { reason: "completion verified" }, status: "completed" });
+            this.#status = "completed";
+            return { kind: "complete", detail: "completion verified", verification, pendingSnapshot: snapshot };
+        }
+        if (verification.status === "unverified") {
+            // Unattended runs complete with an explicit "unverified" status rather
+            // than inventing confidence (PRD §51: never treat missing evidence as success).
+            if (!this.#humanAvailable) {
+                events.emit("RUN_COMPLETED", {
+                    result: { reason: "completion accepted without verification (no oracle, no human)" },
+                    status: "completed",
+                });
+                this.#status = "completed";
+                return {
+                    kind: "complete",
+                    detail: "completed without independent verification (no oracle available)",
+                    verification,
+                    pendingSnapshot: snapshot,
+                };
+            }
+            const help = await this.#humanHelp(task, snapshot, {
+                kind: "verification",
+                prompt: `The agent believes the task is complete, but the runtime cannot verify it.\n` +
+                    `Goal: ${task.goal}\nPage: ${snapshot.title} (${snapshot.url})\n` +
+                    `Confirm whether the task is complete, then hand control back.`,
+                completion: { criteria: { kind: "manual", description: "human confirmed completion" } },
+            });
+            if (help.resolution === "completed" && help.criteriaMet) {
+                const humanVerification = {
+                    status: "verified",
+                    evidence: [{ kind: "human", ok: true, detail: "human confirmed completion", at: Date.now() }],
+                };
+                events.emit("VERIFICATION_RESULT", { verification: humanVerification });
+                events.emit("RUN_COMPLETED", { result: { reason: "human-confirmed completion" }, status: "completed" });
+                this.#status = "completed";
+                return {
+                    kind: "complete",
+                    detail: "human-confirmed completion",
+                    verification: humanVerification,
+                    pendingSnapshot: snapshot,
+                };
+            }
+            addFact(this.#memory, "Unverified completion claim was not confirmed", "system_runtime");
+            return { kind: "no_effect", pendingSnapshot: snapshot, detail: "completion claim unverified" };
+        }
+        // Refuted: the model says done, the evidence says no.
+        addFact(this.#memory, "DONE claim refuted by runtime evidence", "system_runtime");
+        addFailedAttempt(this.#memory, "DONE claim refuted", this.#stepNumber);
+        events.emit("NOTE", { text: "completion claim refuted by the runtime oracle", level: "warn" });
+        return { kind: "no_effect", pendingSnapshot: snapshot, detail: "completion claim refuted" };
+    }
+    /* ───────────────────────────── recovery ───────────────────────────────── */
+    async #recover(task, failure, snapshot, stepId) {
+        const events = this.#requireEvents();
+        const budget = this.#requireBudget();
+        budget.recoveryAttempt();
+        this.#recoveryAttemptsByStep += 1;
+        this.#status = "recovering";
+        const decision = nextStrategy({
+            failure,
+            attempt: this.#recoveryAttemptsByStep,
+            maxAttemptsPerStep: budget.budgets.maxRecoveryAttemptsPerStep,
+            totalAttempts: budget.snapshot.recoveryAttempts,
+            maxAttemptsTotal: budget.budgets.maxRecoveryAttemptsTotal,
+            consecutiveNoProgress: this.#loopDetector.consecutiveNoProgress,
+            fallbackAvailable: budget.fallbackAllowed() && this.#opts.providers.fallbackDecision !== undefined,
+            humanAvailable: this.#humanAvailable && budget.snapshot.humanHelpRequests < budget.budgets.maxHumanHelpRequests,
+            actionRetrySafe: failure.code === "FILL_MISMATCH" || failure.code === "SELECT_MISMATCH" || failure.code === "DOWNLOAD_FAILED",
+        });
+        events.emit("RECOVERY_STARTED", {
+            failure: failureRecord(failure),
+            attempt: this.#recoveryAttemptsByStep,
+            strategy: decision.strategy.kind,
+        });
+        if (decision.escalate) {
+            events.emit("RECOVERY_ESCALATED", {
+                to: decision.strategy.kind,
+                reason: decision.strategy.kind === "fail" ? decision.strategy.reason : failure.message,
+            });
+        }
+        const result = await this.#applyRecoveryStrategy(task, decision.strategy, snapshot, stepId);
+        events.emit("RECOVERY_COMPLETED", {
+            ok: result.kind === "success" || result.kind === "no_effect",
+            strategy: decision.strategy.kind,
+            ...(result.detail !== undefined ? { detail: result.detail } : {}),
+        });
+        this.#status = "running";
+        return result;
+    }
+    async #applyRecoveryStrategy(task, strategy, snapshot, stepId) {
+        const events = this.#requireEvents();
+        switch (strategy.kind) {
+            case "reobserve":
+            case "retry_action":
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: strategy.reason };
+            case "bounded_wait":
+                await sleep(strategy.ms);
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: strategy.reason };
+            case "scroll_into_view":
+            case "dismiss_overlay": {
+                const target = this.#findOverlayDismiss(snapshot);
+                if (target) {
+                    const action = {
+                        op: "CLICK",
+                        ref: {
+                            index: target.index,
+                            nodeId: target.nodeId,
+                            pageToken: snapshot.pageToken,
+                            generation: snapshot.generation,
+                            labelHash: target.labelHash,
+                        },
+                    };
+                    const outcome = await this.#requireExecutor().execute({ action, decision: syntheticDecision("CLICK", "recovery"), snapshotId: snapshot.snapshotId, stepId }, snapshot);
+                    events.emit("DIALOG_HANDLED", { kind: "overlay", resolution: "clicked dismiss control" });
+                    if (outcome.ok)
+                        return { kind: "no_effect", pendingSnapshot: outcome.after, detail: "overlay dismissed" };
+                }
+                if (strategy.kind === "scroll_into_view") {
+                    const action = { op: "SCROLL_DOWN", amount: "small" };
+                    const outcome = await this.#requireExecutor().execute({ action, decision: syntheticDecision("SCROLL_DOWN", "recovery"), snapshotId: snapshot.snapshotId, stepId }, snapshot);
+                    return { kind: "no_effect", pendingSnapshot: outcome.after, detail: strategy.reason };
+                }
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: strategy.reason };
+            }
+            case "handle_dialog": {
+                const action = { op: "DISMISS_DIALOG" };
+                const outcome = await this.#requireExecutor().execute({ action, decision: syntheticDecision("DISMISS_DIALOG", "recovery"), snapshotId: snapshot.snapshotId, stepId }, snapshot);
+                events.emit("DIALOG_HANDLED", { kind: snapshot.blockingUi?.kind ?? "unknown", resolution: "dismiss" });
+                return { kind: "no_effect", pendingSnapshot: outcome.after, detail: "dialog dismissed" };
+            }
+            case "switch_tab": {
+                const target = snapshot.tabs.find((t) => !t.active);
+                if (target) {
+                    const action = { op: "SWITCH_TAB", tabId: target.id };
+                    const outcome = await this.#requireExecutor().execute({ action, decision: syntheticDecision("SWITCH_TAB", "recovery"), snapshotId: snapshot.snapshotId, stepId }, snapshot);
+                    return { kind: "no_effect", pendingSnapshot: outcome.after, detail: `switched to ${target.id}` };
+                }
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: "no other tab" };
+            }
+            case "fallback_provider":
+                this.#forceFallback = true;
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: strategy.reason };
+            case "human": {
+                const help = await this.#humanHelp(task, snapshot, {
+                    kind: "recovery",
+                    prompt: `The runtime could not recover automatically: ${strategy.reason}\nGoal: ${task.goal}\nPage: ${snapshot.url}`,
+                    completion: { criteria: { kind: "manual", description: "human resolved the failure" } },
+                });
+                if (help.resolution === "cancelled") {
+                    return { kind: "fatal", failure: new RuntimeError("HUMAN_HELP_TIMEOUT", "human help was not completed") };
+                }
+                return { kind: "no_effect", pendingSnapshot: await this.#observe(), detail: "human assistance" };
+            }
+            case "fail":
+                return { kind: "fatal", failure: new RuntimeError(strategy.code, strategy.reason) };
+            default:
+                return { kind: "fatal", failure: new RuntimeError("INTERNAL", "unknown recovery strategy") };
+        }
+    }
+    #findOverlayDismiss(snapshot) {
+        const blocking = snapshot.blockingUi;
+        return snapshot.nodes.find((n) => n.operations.includes("CLICK") &&
+            n.flags.visible &&
+            (blocking?.nodeIndexes.includes(n.index) ||
+                /\b(accept|allow|agree|ok|got it|close|dismiss|no thanks|not now|terima|tutup)\b/i.test(n.label)));
+    }
+    /* ─────────────────────────────── planning ─────────────────────────────── */
+    async #plan(task, reason, snapshot) {
+        const planner = this.#opts.providers.planner;
+        if (!planner || this.#planDisabled)
+            return;
+        const events = this.#requireEvents();
+        const budget = this.#requireBudget();
+        if (budget.snapshot.calls.planner >= budget.budgets.maxPlannerCalls) {
+            this.#planDisabled = true;
+            return;
+        }
+        events.emit("PLANNER_REQUESTED", { reason, step: this.#stepNumber });
+        try {
+            const output = await planner.plan({
+                runId: this.#runId,
+                goal: task.goal,
+                reason,
+                snapshotSummary: summarizeSnapshot(snapshot),
+                memory: this.#memory,
+                history: this.#history,
+                artifacts: this.#artifacts?.summaries() ?? [],
+                previousSubgoals: this.#subgoals,
+                budget: budget.snapshot,
+            });
+            budget.charge("planner", output.usage);
+            this.#subgoals = output.subgoals.map((s, i) => ({
+                id: s.id ?? `g${i + 1}`,
+                description: s.description,
+                ...(s.hints ? { hints: s.hints } : {}),
+                status: i === 0 ? "active" : "pending",
+            }));
+            this.#activeSubgoal = 0;
+            events.emit("PLANNER_RECEIVED", {
+                plan: { ...output, usage: undefined },
+                subgoalCount: this.#subgoals.length,
+            });
+            const first = this.#subgoals[0];
+            if (first)
+                events.emit("SUBGOAL_STARTED", { subgoal: first.description, index: 0 });
+        }
+        catch (err) {
+            const runtimeError = asRuntimeError(err);
+            this.#planDisabled = true;
+            events.emit("NOTE", {
+                text: `planner failed, continuing without a plan: ${runtimeError.message}`,
+                level: "warn",
+            });
+        }
+    }
+    /* ─────────────────────────────── helpers ──────────────────────────────── */
+    async #observe() {
+        const started = Date.now();
+        const snapshot = await this.#backend.observe(this.#sessionId);
+        this.#events?.emit("SNAPSHOT_CAPTURED", {
+            snapshotId: snapshot.snapshotId,
+            generation: snapshot.generation,
+            url: snapshot.url,
+            title: snapshot.title,
+            nodeCount: snapshot.nodes.length,
+            fingerprint: snapshot.fingerprint,
+            latencyMs: Date.now() - started,
+            ...(snapshot.blockingUi ? { blocking: snapshot.blockingUi.kind } : {}),
+        });
+        if (snapshot.injectedTexts.length > 0) {
+            this.#events?.emit("NOTE", {
+                text: `page contains ${snapshot.injectedTexts.length} instruction-like text fragment(s); treated as data`,
+                level: "warn",
+            });
+        }
+        if (snapshot.blockingUi && snapshot.blockingUi.nodeIndexes.length > 0) {
+            this.#events?.emit("BLOCKING_UI_DETECTED", {
+                kind: snapshot.blockingUi.kind,
+                ...(snapshot.blockingUi.title !== undefined ? { title: snapshot.blockingUi.title } : {}),
+                ...(snapshot.blockingUi.text !== undefined
+                    ? { text: snapshot.blockingUi.text.slice(0, 200) }
+                    : {}),
+            });
+        }
+        return snapshot;
+    }
+    async #waitIfPaused() {
+        while (this.#paused && !this.#cancelled)
+            await sleep(200);
+    }
+    #currentSubgoal() {
+        return this.#activeSubgoal >= 0 ? this.#subgoals[this.#activeSubgoal] : undefined;
+    }
+    #recordMemory(action, result, before) {
+        if (result.artifact) {
+            const type = result.artifact.documentType ? ` (${result.artifact.documentType})` : "";
+            addFact(this.#memory, `Artifact ${result.artifact.id} ${result.artifact.name}${type} downloaded and verified`, "browser_runtime", result.artifact.id);
+        }
+        if (!result.ok) {
+            const detail = result.verification.evidence[0]?.detail ?? "failed";
+            addFailedAttempt(this.#memory, `${describeAction(action)} failed: ${detail}`, this.#stepNumber);
+            return;
+        }
+        if (action.op === "CLICK") {
+            const node = before.nodes.find((n) => n.nodeId === action.ref.nodeId);
+            if (node)
+                addFact(this.#memory, `Clicked ${node.role} "${node.label}"`, "browser_runtime");
+        }
+        if (action.op === "SELECT") {
+            addFact(this.#memory, `Selected "${action.option.label}"`, "browser_runtime");
+        }
+    }
+    async #cleanup(result) {
+        const events = this.#events;
+        try {
+            if (this.#session) {
+                if (this.#screenshotPolicy === "always" ||
+                    (this.#screenshotPolicy === "on-failure" && result.status !== "completed")) {
+                    try {
+                        const shot = await this.#backend.screenshot?.(this.#sessionId, `${result.status}-${result.reason}`);
+                        if (shot) {
+                            events?.emit("SCREENSHOT_CAPTURED", {
+                                path: shot.path,
+                                reason: `run ${result.status}`,
+                                ...(shot.captureId !== undefined ? { captureId: shot.captureId } : {}),
+                            });
+                        }
+                    }
+                    catch (err) {
+                        events?.emit("NOTE", { text: `screenshot failed: ${String(err)}`, level: "warn" });
+                    }
+                }
+                events?.emit("SESSION_STOPPING", { reason: result.reason });
+                const report = await this.#backend.stopSession(this.#sessionId);
+                events?.emit("SESSION_STOPPED", {
+                    cleanup: {
+                        closedTabs: report.closedTabs,
+                        returnedTabs: report.returnedTabs,
+                        orphanLocks: report.orphanLocks,
+                        errors: report.errors,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            events?.emit("NOTE", { text: `cleanup error: ${String(err)}`, level: "error" });
+        }
+        finally {
+            this.#approvals.cancelAll("denied");
+            events?.setStepId(undefined);
+            events?.close();
+        }
+        return { ...result, tracePath: this.#paths?.eventsPath };
+    }
+    #buildResult(status, reason, startedAt, verification) {
+        const budget = this.#budget;
+        return {
+            runId: this.#runId,
+            status,
+            reason,
+            steps: this.#stepNumber,
+            ...(verification ? { verification } : this.#verificationFromEvents()
+                ? { verification: this.#verificationFromEvents() }
+                : {}),
+            artifacts: this.#artifacts?.summaries() ?? [],
+            durationMs: Date.now() - startedAt,
+            usage: {
+                decision: budget?.snapshot.calls.decision ?? 0,
+                planner: budget?.snapshot.calls.planner ?? 0,
+                text: budget?.snapshot.calls.text ?? 0,
+                vision: budget?.snapshot.calls.vision ?? 0,
+                costUsd: budget?.snapshot.costUsd ?? 0,
+            },
+            interventionCount: budget?.snapshot.humanHelpRequests ?? 0,
+            recoveryCount: budget?.snapshot.recoveryAttempts ?? 0,
+            notes: reason,
+        };
+    }
+    #verificationFromEvents() {
+        const events = this.#events?.events ?? [];
+        for (let i = events.length - 1; i >= 0; i -= 1) {
+            const event = events[i];
+            if (event?.type === "VERIFICATION_RESULT")
+                return event.payload.verification;
+        }
+        return undefined;
+    }
+    #requireEvents() {
+        if (!this.#events)
+            throw new Error("orchestrator is not running");
+        return this.#events;
+    }
+    #requireBudget() {
+        if (!this.#budget)
+            throw new Error("orchestrator is not running");
+        return this.#budget;
+    }
+    #requireExecutor() {
+        if (!this.#executor)
+            throw new Error("orchestrator is not running");
+        return this.#executor;
+    }
+    #requireHuman() {
+        if (!this.#human)
+            throw new Error("orchestrator is not running");
+        return this.#human;
+    }
+}
+/* ─────────────────────────────── pure helpers ─────────────────────────────── */
+const originOf = (url) => {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return "unknown";
+    }
+};
+const targetLabelOf = (action, snapshot) => {
+    const ref = "ref" in action ? action.ref : undefined;
+    if (ref) {
+        const node = snapshot.nodes.find((n) => n.nodeId === ref.nodeId);
+        if (node)
+            return `${node.label} ${node.placeholder ?? ""}`.trim();
+    }
+    if (action.op === "OPEN_TAB")
+        return action.url;
+    return undefined;
+};
+const optionLabelFromCandidate = (label) => {
+    const match = /→ option "([^"]*)"/.exec(label);
+    return match?.[1] ?? label;
+};
+const syntheticDecision = (operation, reason) => ({
+    operation,
+    operationProbabilities: {},
+    operationConfidence: 1,
+    latencyMs: 0,
+    provider: `runtime:${reason}`,
+});
+const stopBeforeMatch = (stopBefore, action, snapshot) => {
+    if (!stopBefore || stopBefore.length === 0)
+        return undefined;
+    const ref = "ref" in action ? action.ref : undefined;
+    const node = ref ? snapshot.nodes.find((n) => n.nodeId === ref.nodeId) : undefined;
+    const haystack = [
+        action.op,
+        describeAction(action),
+        node?.label ?? "",
+        node?.placeholder ?? "",
+        node?.value ?? "",
+        action.op === "OPEN_TAB" ? action.url : "",
+    ]
+        .join(" ")
+        .toLowerCase();
+    return stopBefore.find((pattern) => haystack.includes(pattern.toLowerCase()));
+};
+const numericSnapshot = (budget) => {
+    const s = budget.snapshot;
+    return {
+        steps: s.steps,
+        decisionCalls: s.calls.decision,
+        plannerCalls: s.calls.planner,
+        textCalls: s.calls.text,
+        visionCalls: s.calls.vision,
+        costUsd: s.costUsd,
+        durationMs: s.durationMs,
+        recoveryAttempts: s.recoveryAttempts,
+        humanHelpRequests: s.humanHelpRequests,
+    };
+};
+//# sourceMappingURL=orchestrator.js.map