lua-cli 3.47.0 → 3.49.0

package/dist/api-exports.d.ts

@@ -199,6 +199,9 @@ declare interface AgentInvocationEffects {
     /** Set once per run when the agent reported it could not finish. Trusted
      *  side channel: the run's own account of why, not a regex over its prose. */
     blocker?: TaskRunBlocker;
+    /** BAC-1974: set when an unattended task run reported it had nothing to tell
+     *  the user. Same vocabulary as a workflow's declared `neutral` outcome (BAC-1949). */
+    declaredOutcome?: 'neutral';
 }
 
 export declare interface AgentInvocationInput {
@@ -374,6 +377,8 @@ declare interface AgentInvocationMeter {
      * to force the heavy tier (`hasDocProcessingTool`), so the workflow price must see them too.
      */
     toolNames?: string[];
+    /** The per-step prompt components the usage event's `contextSteps` carries — the prompt-size tier reads them. */
+    contextSteps?: LlmContextStep[];
     byok?: boolean;
     chargedCredits?: boolean;
     /**
@@ -386,6 +391,11 @@ declare interface AgentInvocationMeter {
      * that advertises no reasoning) — a non-effort turn's meter is byte-identical to today's.
      */
     effortApplied?: ReasoningEffort;
+    /**
+     * BAC-1976 — how many model steps the turn ran (`fullOutput.steps.length`), so the workflow worker can tell a
+     * step that hit the agent step cap from a clean finish. Server-owned like `effortApplied`; absent when unknown.
+     */
+    modelSteps?: number;
 }
 
 declare interface AgentInvocationOutput {
@@ -1933,23 +1943,542 @@ export declare interface BatchingConfig {
     serializeProcessing?: boolean;
 }
 
+export declare const Browser: BrowserApi;
+
+/**
+ * The full command surface (mirrors the desktop bridge's registry). Grouped the
+ * way the agent-browser CLI groups them so the surface is complete without
+ * 50+ near-duplicate names.
+ */
+declare const BROWSER_COMMANDS: readonly [{
+    readonly name: "health";
+    readonly description: "Check the local browser engine is installed and responsive.";
+}, {
+    readonly name: "session_open";
+    readonly description: "Open/attach a browser session (its own cookies/auth). Args: url?, headed?, profile?, confirmActions?. Only use the browser when the user explicitly asked for it, or said yes when you asked.";
+}, {
+    readonly name: "navigate";
+    readonly description: "Navigate the session to a URL. Args: url, waitUntil?. Only use the browser when the user explicitly asked for it, or said yes when you asked.";
+}, {
+    readonly name: "back";
+    readonly description: "Go back in history.";
+}, {
+    readonly name: "forward";
+    readonly description: "Go forward in history.";
+}, {
+    readonly name: "reload";
+    readonly description: "Reload the current page.";
+}, {
+    readonly name: "pushstate";
+    readonly description: "SPA client-side navigation. Args: url.";
+}, {
+    readonly name: "close";
+    readonly description: "Close the session’s browser.";
+}, {
+    readonly name: "read";
+    readonly description: "Read one page in a fresh session that is closed afterwards: open the URL, wait, return its title and content. Args: url, waitFor?(load|networkidle|selector), selector?, format?(text|html|markdown), timeoutMs?.";
+}, {
+    readonly name: "snapshot";
+    readonly description: "Accessibility-tree snapshot with element refs (@e1…) — see what to click/fill. Args: interactiveOnly?, selector?, urls?, compact?, depth?.";
+}, {
+    readonly name: "get";
+    readonly description: "Read from the page. Args: what(text|html|value|attr|title|url|count|box|styles), selector?, attr?.";
+}, {
+    readonly name: "is";
+    readonly description: "Check element state. Args: check(visible|enabled|checked), selector.";
+}, {
+    readonly name: "click";
+    readonly description: "Click an element. Args: selector(@eN or CSS), newTab?.";
+}, {
+    readonly name: "dblclick";
+    readonly description: "Double-click an element. Args: selector.";
+}, {
+    readonly name: "fill";
+    readonly description: "Clear and fill a field. Args: selector, text.";
+}, {
+    readonly name: "type";
+    readonly description: "Type into an element. Args: selector, text.";
+}, {
+    readonly name: "press";
+    readonly description: "Press a key/chord (Enter, Control+a). Args: key.";
+}, {
+    readonly name: "hover";
+    readonly description: "Hover an element. Args: selector.";
+}, {
+    readonly name: "focus";
+    readonly description: "Focus an element. Args: selector.";
+}, {
+    readonly name: "select";
+    readonly description: "Select a dropdown option. Args: selector, value.";
+}, {
+    readonly name: "check";
+    readonly description: "Check a checkbox. Args: selector.";
+}, {
+    readonly name: "uncheck";
+    readonly description: "Uncheck a checkbox. Args: selector.";
+}, {
+    readonly name: "scroll";
+    readonly description: "Scroll. Args: direction(up|down|left|right), px?, selector?.";
+}, {
+    readonly name: "scrollintoview";
+    readonly description: "Scroll an element into view. Args: selector.";
+}, {
+    readonly name: "drag";
+    readonly description: "Drag and drop. Args: source, target.";
+}, {
+    readonly name: "upload";
+    readonly description: "Upload local file(s) to a file input. Args: selector, files[].";
+}, {
+    readonly name: "find";
+    readonly description: "Act by semantic locator. Args: by(role|text|label|placeholder|alt|title|testid), query, action(click|fill|type|hover|focus|check|uncheck|text), value?, name?, exact?.";
+}, {
+    readonly name: "act";
+    readonly description: "Act on the page: ref+action (deterministic) or natural-language instruction (engine AI). Args: ref?, action?, value?, instruction?.";
+}, {
+    readonly name: "extract";
+    readonly description: "Extract data by natural-language instruction (engine AI). Args: instruction.";
+}, {
+    readonly name: "wait";
+    readonly description: "Wait for a condition. Provide one of: selector(+state), ms, text, url, load, fn.";
+}, {
+    readonly name: "tab";
+    readonly description: "Manage tabs. Args: action(list|new|switch|close), target?, url?, label?.";
+}, {
+    readonly name: "window_new";
+    readonly description: "Open a new browser window. Args: url?.";
+}, {
+    readonly name: "frame";
+    readonly description: "Switch frame context. Args: target(@eN | CSS | \"main\").";
+}, {
+    readonly name: "screenshot";
+    readonly description: "Screenshot the page. Args: fullPage?, path?.";
+}, {
+    readonly name: "pdf";
+    readonly description: "Save the page as PDF. Args: path.";
+}, {
+    readonly name: "cookies";
+    readonly description: "Manage cookies. Args: action(get|set|clear), name?, value?.";
+}, {
+    readonly name: "storage";
+    readonly description: "Manage web storage. Args: area(local|session), action(get|set|clear), key?, value?.";
+}, {
+    readonly name: "set";
+    readonly description: "Configure the browser. Args: setting(viewport|device|geo|headers|credentials|media), args[].";
+}, {
+    readonly name: "download";
+    readonly description: "Download a file (click a selector to trigger, or wait for one). Args: selector?, path?.";
+}, {
+    readonly name: "clipboard";
+    readonly description: "Clipboard. Args: action(read|write|copy|paste), text?.";
+}, {
+    readonly name: "auth";
+    readonly description: "Use a saved login profile. Args: action(login|list|show), name?. (Credentials are saved via the desktop, never the agent.)";
+}, {
+    readonly name: "confirm";
+    readonly description: "Approve a pending confirmation_required action. Args: id.";
+}, {
+    readonly name: "deny";
+    readonly description: "Reject a pending confirmation_required action. Args: id.";
+}, {
+    readonly name: "network";
+    readonly description: "Inspect/control network. Args: action(route|unroute|requests|har) + relevant fields.";
+}, {
+    readonly name: "console";
+    readonly description: "View browser console messages. Args: clear?.";
+}, {
+    readonly name: "errors";
+    readonly description: "View uncaught page JS errors. Args: clear?.";
+}, {
+    readonly name: "mouse";
+    readonly description: "Low-level mouse. Args: action(move|down|up|wheel), x?, y?, button?, dy?, dx?.";
+}, {
+    readonly name: "keyboard";
+    readonly description: "Low-level keyboard at focus. Args: action(type|inserttext|keydown|keyup), text?, key?.";
+}, {
+    readonly name: "state";
+    readonly description: "Persist/restore storage+auth state to a file. Args: action(save|load|list|clear), path?.";
+}];
+
+declare const BROWSER_ERROR_NAME = "BrowserError";
+
+declare const BROWSER_EXECUTE_STATUSES: readonly ["completed", "failed", "stopped"];
+
+declare const BROWSER_EXECUTE_STOP_REASONS: readonly ["done", "model_failed", "max_steps", "cost_cap", "timeout", "confirmation_required", "invalid_action", "repeated_action", "schema_mismatch", "browser_error", "cancelled", "error"];
+
+declare const BROWSER_FALLBACKS: readonly ["browser-use", "none"];
+
+declare const BROWSER_LOG_CONTENT_MODES: readonly ["summary", "full", "none"];
+
+declare const BROWSER_READ_FORMATS: readonly ["text", "html", "markdown"];
+
+declare const BROWSER_READ_LOAD_STATES: readonly ["load", "networkidle"];
+
+declare const BROWSER_READ_LOGIN_BLOCKER = "login_required";
+
+declare const BROWSER_SCREENSHOT_POLICIES: readonly ["always", "onError", "never"];
+
+export declare interface BrowserApi extends BrowserStepwiseApi {
+    read(url: string, options?: BrowserApiReadOptions): Promise<BrowserReadResult>;
+    execute(input: BrowserExecuteInput): Promise<BrowserExecuteResult>;
+}
+
+export declare type BrowserApiReadOptions = BrowserReadOptions & BrowserProfileOption;
+
+export declare interface BrowserCommandInputs {
+    health: BrowserSessionInput;
+    session_open: BrowserSessionInput & {
+        url?: string;
+        headed?: boolean;
+        profile?: string;
+        confirmActions?: string[];
+    };
+    navigate: UrlInput & {
+        waitUntil?: LoadState;
+    };
+    back: BrowserSessionInput;
+    forward: BrowserSessionInput;
+    reload: BrowserSessionInput;
+    pushstate: UrlInput;
+    close: BrowserSessionInput;
+    snapshot: BrowserSessionInput & {
+        interactiveOnly?: boolean;
+        selector?: string;
+        urls?: boolean;
+        compact?: boolean;
+        depth?: number;
+    };
+    get: BrowserSessionInput & {
+        what: 'text' | 'html' | 'value' | 'attr' | 'title' | 'url' | 'count' | 'box' | 'styles';
+        selector?: string;
+        attr?: string;
+    };
+    is: SelectorInput & {
+        check: 'visible' | 'enabled' | 'checked';
+    };
+    click: SelectorInput & {
+        newTab?: boolean;
+    };
+    dblclick: SelectorInput;
+    fill: SelectorTextInput;
+    type: SelectorTextInput;
+    press: BrowserSessionInput & {
+        key: string;
+    };
+    hover: SelectorInput;
+    focus: SelectorInput;
+    select: SelectorInput & {
+        value: string;
+    };
+    check: SelectorInput;
+    uncheck: SelectorInput;
+    scroll: BrowserSessionInput & {
+        direction: 'up' | 'down' | 'left' | 'right';
+        px?: number;
+        selector?: string;
+    };
+    scrollintoview: SelectorInput;
+    drag: BrowserSessionInput & {
+        source: string;
+        target: string;
+    };
+    upload: SelectorInput & {
+        files: string[];
+    };
+    find: BrowserSessionInput & {
+        by: 'role' | 'text' | 'label' | 'placeholder' | 'alt' | 'title' | 'testid';
+        query: string;
+        action: 'click' | 'fill' | 'type' | 'hover' | 'focus' | 'check' | 'uncheck' | 'text';
+        value?: string;
+        name?: string;
+        exact?: boolean;
+    };
+    act: BrowserSessionInput & {
+        ref?: string;
+        action?: string;
+        value?: string;
+        instruction?: string;
+    };
+    extract: BrowserSessionInput & {
+        instruction: string;
+    };
+    wait: BrowserSessionInput & {
+        selector?: string;
+        state?: 'visible' | 'hidden';
+        ms?: number;
+        text?: string;
+        url?: string;
+        load?: LoadState;
+        fn?: string;
+    };
+    tab: BrowserSessionInput & {
+        action: 'list' | 'new' | 'switch' | 'close';
+        target?: string;
+        url?: string;
+        label?: string;
+    };
+    window_new: BrowserSessionInput & {
+        url?: string;
+    };
+    frame: BrowserSessionInput & {
+        target: string;
+    };
+    screenshot: BrowserSessionInput & {
+        fullPage?: boolean;
+        path?: string;
+    };
+    pdf: BrowserSessionInput & {
+        path: string;
+    };
+    cookies: BrowserSessionInput & {
+        action: 'get' | 'set' | 'clear';
+        name?: string;
+        value?: string;
+    };
+    storage: BrowserSessionInput & {
+        area: 'local' | 'session';
+        action: 'get' | 'set' | 'clear';
+        key?: string;
+        value?: string;
+    };
+    set: BrowserSessionInput & {
+        setting: 'viewport' | 'device' | 'geo' | 'headers' | 'credentials' | 'media' | 'offline';
+        args: Array<string | number>;
+    };
+    download: BrowserSessionInput & {
+        selector?: string;
+        path?: string;
+    };
+    clipboard: BrowserSessionInput & {
+        action: 'read' | 'write' | 'copy' | 'paste';
+        text?: string;
+    };
+    auth: BrowserSessionInput & {
+        action: 'login' | 'list' | 'show';
+        name?: string;
+    };
+    confirm: IdInput;
+    deny: IdInput;
+    network: BrowserSessionInput & {
+        action: 'route' | 'unroute' | 'requests' | 'har';
+        url?: string;
+        abort?: boolean;
+        body?: string;
+        resourceType?: string;
+        filter?: string;
+        type?: string;
+        method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+        status?: string;
+        requestId?: string;
+    };
+    console: ClearInput;
+    errors: ClearInput;
+    mouse: BrowserSessionInput & {
+        action: 'move' | 'down' | 'up' | 'wheel';
+        x?: number;
+        y?: number;
+        button?: 'left' | 'right' | 'middle';
+        dy?: number;
+        dx?: number;
+    };
+    keyboard: BrowserSessionInput & {
+        action: 'type' | 'inserttext' | 'keydown' | 'keyup';
+        text?: string;
+        key?: string;
+    };
+    state: BrowserSessionInput & {
+        action: 'save' | 'load' | 'list' | 'clear';
+        path?: string;
+    };
+}
+
+declare type BrowserCommandMethod<I> = {} extends I ? (input?: I) => Promise<BrowserCommandResult> : (input: I) => Promise<BrowserCommandResult>;
+
+/** Union of every command name. */
+declare type BrowserCommandName = (typeof BROWSER_COMMANDS)[number]['name'];
+
+declare interface BrowserCommandOutput {
+    /**
+     * Which engine served the command. `none` = a precondition failed before any
+     * engine ran (e.g. missing agentId, or a local-only policy with no device) —
+     * so callers don't mistake it for a failed cloud attempt.
+     */
+    engine: 'local' | 'cloud-agent-browser' | 'cloud' | 'none';
+    data?: unknown;
+    error?: string;
+    code?: string;
+}
+
+export declare interface BrowserCommandResult extends BrowserCommandOutput {
+    code?: BrowserErrorCode | (string & {});
+}
+
+/**
+ * Which engine a browser command may run on. `auto` (default) prefers the local
+ * desktop Device and falls back to the cloud; `agent-browser` is local-only (no
+ * paid cloud fallback); `browser-use` is cloud-only. Mirrors
+ * `BrowserSwitchConfig.engine` on the dev-facing switch.
+ */
+declare type BrowserEngine = 'auto' | 'agent-browser' | 'browser-use';
+
+export declare type BrowserErrorCode = 'BROWSER_DISABLED' | 'BROWSER_UNAVAILABLE' | 'BROWSER_RUN_SCOPE_MISSING' | 'BROWSER_WORKER_NOT_CONFIGURED' | 'BROWSER_DOMAIN_NOT_ALLOWED' | 'BROWSER_PROFILE_NOT_FOUND' | 'session_lost' | 'unreachable' | BrowserWorkerErrorCode;
+
+export declare interface BrowserErrorFields {
+    name: typeof BROWSER_ERROR_NAME;
+    /** `'http_error'`: the page answered an HTTP error status with nothing to read; see `status`. */
+    code: BrowserErrorCode;
+    /** HTTP status of the page's main document, when the error is an `'http_error'` and the status is known. */
+    status?: number;
+}
+
+export declare interface BrowserExecuteInput {
+    task: string;
+    sessionKey?: string;
+    url?: string;
+    startUrl?: string;
+    schema?: Record<string, unknown>;
+    maxSteps?: number;
+    maxCostUsd?: number;
+    model?: string;
+    timeoutMs?: number;
+    allowAnyDomain?: boolean;
+    allowedDomains?: string[];
+    browser?: string;
+}
+
+export declare interface BrowserExecutePendingAction {
+    category: string;
+    action: string;
+    url?: string;
+    confirmationId?: string;
+}
+
+export declare interface BrowserExecuteResult {
+    status: BrowserExecuteStatus;
+    output: unknown;
+    steps: number;
+    stopReason?: BrowserExecuteStopReason;
+    costUsd?: number;
+    finalUrl?: string;
+    engine: BrowserCommandOutput['engine'];
+    error?: string;
+    code?: string;
+    pendingAction?: BrowserExecutePendingAction;
+    history?: BrowserExecuteStep[];
+    liveUrl?: string;
+    sessionKey?: string;
+    detail?: string;
+    navigationScope?: string[];
+}
+
+export declare type BrowserExecuteStatus = (typeof BROWSER_EXECUTE_STATUSES)[number];
+
+export declare interface BrowserExecuteStep {
+    step: number;
+    intent: string;
+    action: string;
+    url?: string;
+    ok: boolean;
+    error?: string;
+}
+
+export declare type BrowserExecuteStopReason = (typeof BROWSER_EXECUTE_STOP_REASONS)[number];
+
+declare type BrowserFallback = (typeof BROWSER_FALLBACKS)[number];
+
+declare type BrowserLogContent = (typeof BROWSER_LOG_CONTENT_MODES)[number];
+
+export declare interface BrowserProfileOption {
+    browser?: string;
+}
+
+export declare type BrowserReadFormat = (typeof BROWSER_READ_FORMATS)[number];
+
+export declare type BrowserReadLoadState = (typeof BROWSER_READ_LOAD_STATES)[number];
+
+export declare interface BrowserReadOptions {
+    /** Wait before reading: `'load'`, `'networkidle'`, or a CSS selector that must appear. */
+    waitFor?: BrowserReadLoadState | (string & {});
+    /**
+     * CSS selector to read (default `'body'`). Every match is read, in document order, with matches joined by a
+     * blank line and empty matches skipped, up to the content cap. On the Lua cloud browser this holds for
+     * `'text'` and `'markdown'`; `'html'` returns the inner HTML of the first match. On the desktop browser every
+     * format reads the first match. `matches` on the result says how many elements matched.
+     */
+    selector?: string;
+    /**
+     * `'text'` (default) or `'html'`. `'markdown'` is accepted but returns plain text for now, and the result
+     * says `format: 'text'`.
+     */
+    format?: BrowserReadFormat;
+    /** Budget for the whole read in ms (1000 to 100000, default 60000). */
+    timeoutMs?: number;
+    sessionKey?: string;
+}
+
+export declare interface BrowserReadResult {
+    /** The URL you asked for. */
+    url: string;
+    /** The URL the page ended on after redirects. */
+    finalUrl: string;
+    title: string;
+    content: string;
+    format: 'text' | 'html';
+    /** True when `content` hit the content cap or not every match was read. */
+    truncated: boolean;
+    /**
+     * HTTP status of the page's main document, e.g. `200` or `404`. A 404 page that has a body is still read, so
+     * check this before trusting `content`. Absent when the browser could not observe the response.
+     */
+    status?: number;
+    /** How many elements matched `selector`, when a selector other than `'body'` was given. */
+    matches?: number;
+    /** Set when the page is a wall rather than the content you asked for. */
+    blocked?: true;
+    /** `'login_required'`: the URL redirected to a sign-in page, so the content needs a signed-in session. */
+    blocker?: typeof BROWSER_READ_LOGIN_BLOCKER;
+    blockerKind?: 'login';
+    /** What to do about the wall. */
+    blockerGuidance?: string;
+}
+
+declare type BrowserScreenshotPolicy = (typeof BROWSER_SCREENSHOT_POLICIES)[number];
+
+export declare interface BrowserSessionInput extends BrowserProfileOption {
+    sessionKey?: string;
+}
+
+export declare type BrowserStepwiseApi = {
+    [K in BrowserStepwiseCommandName]: BrowserCommandMethod<BrowserCommandInputs[K]>;
+};
+
+export declare type BrowserStepwiseCommandName = Exclude<BrowserCommandName, 'read'>;
+
 /**
  * Browser switch config (LuaBrowser). `browser: true` is the zero-code form —
- * the agent gets browser tools injected, like `searchWeb`, routed to the user's
- * local browser (desktop) or the Browser-Use cloud fallback. The object form
- * adds optional policy.
+ * the agent gets browser tools and the `Browser` global, routed to the user's
+ * desktop browser when it is online, else the Lua cloud browser. The object
+ * form adds optional policy.
  */
 export declare interface BrowserSwitchConfig {
-    /** Preferred engine; 'auto' lets the platform pick local (desktop) vs cloud. */
+    /** 'auto' (default): desktop when online, else the Lua cloud browser. 'agent-browser': desktop or Lua cloud, never Browser-Use. 'browser-use': Browser-Use only. */
     engine?: 'auto' | 'browser-use' | 'agent-browser';
-    /** Egress allowlist — domains the browser may navigate/sub-request. */
+    fallback?: 'browser-use' | 'none';
+    proxyCountry?: string;
+    /** Hosts the browser may open; checked before every command that opens a URL. On the Lua cloud browser it also applies to redirects and everything a page loads. */
     allowedDomains?: string[];
-    /** Names of vault credential entries the agent may use (never raw secrets). */
+    confirmActions?: string[];
+    logContent?: BrowserLogContent;
+    screenshots?: BrowserScreenshotPolicy;
+    /** Accepted but not enforced yet. */
     credentials?: string[];
-    /** Hard cap on a single browser session's duration (cost control). */
+    /** Lua cloud browser session length in minutes: default 10, at most 60 (a larger value is cut to 60). */
     maxSessionMinutes?: number;
+    /** Lua cloud browser idle timeout in seconds: default 120, at most 900 (a larger value is cut to 900). */
+    idleTimeoutSeconds?: number;
 }
 
+declare type BrowserWorkerErrorCode = 'unauthorized' | 'invalid_request' | 'invalid_argument' | 'policy_mismatch' | 'unsupported' | 'blocked_scheme' | 'blocked_private_host' | 'blocked_domain' | 'session_cap' | 'session_not_on_this_pod' | 'no_page' | 'draining' | 'timeout' | 'engine_unavailable' | 'engine_error' | 'http_error';
+
 /** What `.commit()` hands to `LuaWorkflow` — internal; never `new LuaWorkflow({...})` by users. */
 declare interface BuiltWorkflow {
     config: LuaWorkflowConfig;
@@ -2398,6 +2927,8 @@ export declare interface ChatHistoryMessage {
         agentId: string;
         name?: string;
     };
+    /** On a user message: the id the client gave the turn when it sent it, so it can tell which of its sends arrived. */
+    clientTurnId?: string;
     /**
      * Permanent recording for a voice-note turn (Lua Desktop). Populated by the
      * admin threads history endpoint from the row's `content.metadata.audio` — a
@@ -2419,6 +2950,24 @@ export declare type ChatMessage = TextMessage | ImageMessage | FileMessage;
 /** wave 2 U33 — the typed refusal `Integrations.checkAsUser` raises outside a live chat turn. */
 export declare function checkAsUserRequiresUser(): Error;
 
+export declare interface ChoiceAnswer<L extends string = string> {
+    type: 'choice';
+    choice: L;
+    confidence: number;
+    probabilities: Record<L, number>;
+    uncertain: boolean;
+}
+
+export declare interface ChoiceQuestion<L extends string = string> {
+    type: 'choice';
+    instructions: string;
+    options: Record<L, string>;
+}
+
+declare interface ClearInput extends BrowserSessionInput {
+    clear?: boolean;
+}
+
 /**
  * U6 (wave 2) — connection inspection, account pinning and capability checks; U33 — the same checks run
  * with the CONVERSATION USER's principal. Owner: U6 (catalogue, list, pin, check, cleanup); U33 owns only
@@ -3013,6 +3562,143 @@ export declare class DataEntryInstance {
 
 export { DatasetRef }
 
+declare const DECISION_ERROR_CODES: {
+    readonly INVALID: "decision_invalid";
+    readonly TIMEOUT: "decision_timeout";
+    readonly REJECTED: "decision_rejected";
+    readonly UNAVAILABLE: "decision_unavailable";
+    readonly DISABLED: "decision_disabled";
+    readonly INSUFFICIENT_CREDITS: "decision_insufficient_credits";
+    readonly NOT_FOUND: "decision_not_found";
+};
+
+declare const DECISION_PROVIDERS: readonly ["jev", "openai"];
+
+declare const DECISION_ROUTING_RULES: readonly ["pinned", "images", "region", "zero_retention", "default", "fallback"];
+
+export declare type DecisionAnswer = OddsAnswer | ChoiceAnswer | ScoreAnswer | RefusedAnswer;
+
+export declare type DecisionAnswerFor<Q extends DecisionQuestion> = Q extends ChoiceQuestion<infer L> ? ChoiceAnswer<L> | RefusedAnswer : Q extends ScoreQuestion ? ScoreAnswer | RefusedAnswer : OddsAnswer | RefusedAnswer;
+
+export declare type DecisionAnswers<Q extends DecisionQuestions> = {
+    [K in keyof Q]: DecisionAnswerFor<Q[K]>;
+};
+
+export declare interface DecisionDefinition<Q extends DecisionQuestions = DecisionQuestions> extends DecisionOptions {
+    name: string;
+    description?: string;
+    questions: Q;
+}
+
+export declare interface DecisionError extends Error {
+    readonly code: DecisionErrorFields['code'];
+    readonly provider?: DecisionProvider;
+    readonly upstreamStatus?: number;
+    readonly decisionId?: string;
+}
+
+export declare const DecisionError: new (message: string, fields: DecisionErrorFields) => DecisionError;
+
+export declare type DecisionErrorCode = (typeof DECISION_ERROR_CODES)[keyof typeof DECISION_ERROR_CODES];
+
+export declare interface DecisionErrorFields {
+    code: DecisionErrorCode | (string & {});
+    provider?: DecisionProvider;
+    upstreamStatus?: number;
+    decisionId?: string;
+}
+
+declare type DecisionFallback = DecisionProvider | 'none';
+
+declare interface DecisionFallbackInfo {
+    from: DecisionProvider;
+    reason: string;
+}
+
+declare interface DecisionImage {
+    data: string;
+    mimeType: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+}
+
+declare type DecisionLogState = 'summary' | 'full' | 'none';
+
+export declare interface DecisionOptions {
+    provider?: DecisionProviderChoice;
+    model?: string;
+    fallback?: DecisionFallback;
+    region?: DecisionRegion;
+    zeroRetention?: boolean;
+    minConfidence?: number;
+    timeoutMs?: number;
+    cache?: {
+        ttlSeconds: number;
+    };
+    logState?: DecisionLogState;
+}
+
+export declare type DecisionProvider = (typeof DECISION_PROVIDERS)[number];
+
+declare type DecisionProviderChoice = DecisionProvider | 'auto';
+
+export declare type DecisionQuestion = OddsQuestion | ChoiceQuestion | ScoreQuestion;
+
+export declare type DecisionQuestions = Record<string, DecisionQuestion>;
+
+declare type DecisionRegion = 'eu';
+
+export declare interface DecisionRequest<Q extends DecisionQuestions = DecisionQuestions> extends DecisionOptions {
+    state: DecisionState;
+    images?: DecisionImage[];
+    questions: Q;
+}
+
+export declare interface DecisionResult<Q extends DecisionQuestions = DecisionQuestions> {
+    decisionId: string;
+    answers: DecisionAnswers<Q>;
+    provider: DecisionProvider;
+    model: string;
+    rule: DecisionRoutingRule;
+    usage: DecisionUsage;
+    durationMs: number;
+    cached: boolean;
+    fallback?: DecisionFallbackInfo;
+    decisionName?: string;
+    decisionVersion?: string;
+}
+
+declare type DecisionRoutingRule = (typeof DECISION_ROUTING_RULES)[number];
+
+export declare type DecisionRunOptions = Omit<DecisionRunRequest, 'name' | 'state'>;
+
+declare interface DecisionRunRequest extends DecisionOptions {
+    name: string;
+    state: DecisionState;
+    images?: DecisionImage[];
+}
+
+export declare const Decisions: DecisionsApi;
+
+export declare interface DecisionsApi {
+    ask<Q extends DecisionQuestions>(request: DecisionRequest<Q>): Promise<DecisionResult<Q>>;
+    ask<Q extends DecisionQuestion>(state: DecisionState, question: Q, options?: DecisionOptions): Promise<DecisionAnswerFor<Q>>;
+    run<Q extends DecisionQuestions = DecisionQuestions>(name: string, state: DecisionState, options?: DecisionRunOptions): Promise<DecisionResult<Q>>;
+    odds(instructions: string, criteria?: OddsQuestion['criteria']): OddsQuestion;
+    choice<L extends string>(instructions: string, options: Record<L, string>): ChoiceQuestion<L>;
+    score(instructions: string, levels: ReadonlyArray<string | ScoreLevel>): ScoreQuestion;
+}
+
+export declare type DecisionState = string | string[] | {
+    [key: string]: unknown;
+};
+
+declare interface DecisionUsage {
+    inputTokens: number | null;
+}
+
+export declare function defineBrowser(config: LuaBrowserConfig): LuaBrowser;
+
+export declare function defineDecision<Q extends DecisionQuestions>(config: LuaDecisionConfig<Q>): LuaDecision<Q>;
+
 /**
  * Define a device that an agent can communicate with.
  *
@@ -3941,6 +4627,11 @@ declare abstract class HttpClient {
      * @protected
      */
     protected httpDelete<T>(url: string, headers?: Record<string, string>, overrides?: RequestOverrides): Promise<ApiResponse<T>>;
+    /**
+     * A DELETE with a JSON body, sent once (no retries): for a destructive call that carries a
+     * single-use secret (a confirmation code), where a blind retry could only spend it again.
+     */
+    protected httpDeleteOnce<T>(url: string, data?: any, headers?: Record<string, string>, overrides?: RequestOverrides): Promise<ApiResponse<T>>;
     /**
      * Performs an HTTP PATCH request
      * @param url - The relative URL path to request (will be appended to baseUrl)
@@ -3989,6 +4680,10 @@ declare interface IdentifiedEntity {
     _id?: string;
 }
 
+declare interface IdInput extends BrowserSessionInput {
+    id: string;
+}
+
 export declare interface ImageMessage {
     type: 'image';
     image: string;
@@ -4379,6 +5074,8 @@ declare interface Job {
     updatedAt: string;
     dynamic?: boolean;
     userId?: string;
+    /** The full chat thread id (base[:suffix]) the job was created in, set by the platform when Jobs.create ran inside a chat turn. Read-only; absent for jobs created outside a chat turn and for every earlier job. */
+    originThreadId?: string;
     metadata?: Record<string, any>;
     versions: JobVersion[];
     lastExecution?: JobExecution;
@@ -4866,6 +5563,50 @@ export declare const lit: <const V extends string | number | boolean | null>(v:
 
 export { Literal }
 
+/**
+ * LUA-724 (PR 7) — the billed turn's pricing inputs, exactly as chat's settlement event carries
+ * them (`chat.service.trackLlmInferenceUsage`): the model that ACTUALLY served the turn (the
+ * resolver's code, not the caller's pin), the de-paged `contextInputTokens` (largest single
+ * step's prompt — never the whole-turn sum), the tool-call COUNT, and whether the turn ran on
+ * the org's own key. `chargedCredits` echoes the gate's answer (true ⇒ the legacy pool deducted
+ * in real time; false ⇒ seat org / free turn — settlement meters it).
+ *
+ * Stamped by the serving pod ONLY on internal-auth turns that carry a billing `operationId`
+ * (the workflow agent-step loopback), as the enumerable `luaMeter` top-level field of the
+ * generate envelope — never on a Bearer turn, so the public wire is byte-identical. The
+ * workflow executor prices the step's `run.budget.spent` from it with `priceModelCall`.
+ */
+/**
+ * WJB-B1 (BAC-668, decision D1) — one ReAct step's prompt components, as the provider reported them:
+ * `inputTokens` the step's UNCACHED prompt, `cacheReadTokens` the tokens served from cache,
+ * `cacheCreationTokens` the flat write total with `cacheCreationTokens5m` / `cacheCreationTokens1h` its TTL
+ * split when the provider exposed one (the streaming chat path usually does not — a weighted chat step then
+ * weights READS alone). Names mirror `LlmUsageData`'s turn-level members, so one vocabulary describes the
+ * turn and its steps.
+ *
+ * DECLARED HERE, not in `@lua/shared-schemas`, deliberately. The chat hot-path util that builds these
+ * (`lua-core/src/utils/turn-signals.util.ts`) must not take a Nest-bearing runtime import: shared-schemas'
+ * dist requires `@nestjs/mongoose` at load, and nine `chat.controller.*.spec.ts` suites partially mock
+ * `@nestjs/common`, so importing the VALUE below from there turned them into
+ * `common_1.Module is not a function`. `@lua/shared-types` requires no Nest at all; shared-schemas
+ * re-exports both members, so `LlmUsageData.contextSteps` still reads as a member of that file.
+ */
+declare interface LlmContextStep {
+    inputTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    cacheCreationTokens5m?: number;
+    cacheCreationTokens1h?: number;
+    /** The step's output tokens. Cost only: settlement never reads it. */
+    outputTokens?: number;
+    /** As the provider reported them: outside `outputTokens` on Gemini, a subset of it on OpenAI. Cost only. */
+    reasoningTokens?: number;
+    /** The model id the provider says served the step (a fallback leg names itself here). Cost only. */
+    model?: string;
+}
+
+declare type LoadState = 'load' | 'domcontentloaded' | 'networkidle';
+
 /**
  * Structured logging: `log.debug/info/warn/error(message, fields?)`.
  *
@@ -4993,9 +5734,11 @@ export declare class LuaAgent {
     private readonly devices;
     private readonly deviceTriggers;
     private readonly voices?;
+    private readonly decisions;
     private readonly batching?;
     private readonly governance?;
     private readonly browser?;
+    private readonly browsers?;
     /**
      * Creates a new LuaAgent instance.
      *
@@ -5033,6 +5776,8 @@ export declare class LuaAgent {
     getBatching(): BatchingConfig | undefined;
     getDevices(): LuaDevice[];
     getVoices(): LuaVoice[] | undefined;
+    getBrowsers(): LuaBrowser[] | undefined;
+    getDecisions(): LuaDecision[];
 }
 
 export declare interface LuaAgentConfig {
@@ -5090,17 +5835,19 @@ export declare interface LuaAgentConfig {
      * single-element array — `voices: [supportVoice]`.
      */
     voices?: LuaVoice[];
+    decisions?: LuaDecision[];
     /** Per-agent message batching/debounce configuration. Overrides platform env var defaults. */
     batching?: BatchingConfig;
     /** Governance policy configuration. When set, tool calls, preprocessors, and postprocessors are governed. */
     governance?: GovernanceConfig;
     /**
-     * Browser switch (LuaBrowser). `true` turns on browser tools with platform
-     * defaults; an object adds policy (engine, allowedDomains, credentials,
-     * maxSessionMinutes). Off by default — a browser session costs money and
+     * Browser switch (LuaBrowser). `true` turns on browser tools and the
+     * `Browser` global with platform defaults; an object adds policy (see
+     * `BrowserSwitchConfig`). Off by default — a browser session costs money and
      * carries risk, so it's opt-in (unlike always-on searchWeb).
      */
     browser?: boolean | BrowserSwitchConfig;
+    browsers?: LuaBrowser[];
 }
 
 /**
@@ -5128,6 +5875,64 @@ export declare type LuaAgentModel = string | ((request: LuaRequest) => string |
 /** The signed-in person a route runs for (never an API key, never anonymous). */
 export declare type LuaAuth = WebRouteAuth;
 
+export declare class LuaBrowser {
+    readonly name: string;
+    readonly description?: string;
+    readonly engine: LuaBrowserSettings['engine'];
+    readonly fallback: LuaBrowserSettings['fallback'];
+    readonly proxyCountry: LuaBrowserSettings['proxyCountry'];
+    readonly allowedDomains: LuaBrowserSettings['allowedDomains'];
+    readonly confirmActions: LuaBrowserSettings['confirmActions'];
+    readonly maxSessionMinutes: LuaBrowserSettings['maxSessionMinutes'];
+    readonly idleTimeoutSeconds: LuaBrowserSettings['idleTimeoutSeconds'];
+    readonly maxConcurrentSessions: LuaBrowserSettings['maxConcurrentSessions'];
+    readonly screenshots: LuaBrowserSettings['screenshots'];
+    readonly logContent: LuaBrowserSettings['logContent'];
+    readonly persist: LuaBrowserSettings['persist'];
+    readonly credentials: LuaBrowserSettings['credentials'];
+    constructor(config: LuaBrowserConfig);
+}
+
+export declare interface LuaBrowserConfig extends LuaBrowserSettings {
+    name: string;
+    description?: string;
+}
+
+export declare interface LuaBrowserSettings {
+    engine?: BrowserEngine;
+    fallback?: BrowserFallback;
+    proxyCountry?: string;
+    allowedDomains?: string[];
+    confirmActions?: string[];
+    maxSessionMinutes?: number;
+    idleTimeoutSeconds?: number;
+    maxConcurrentSessions?: number;
+    screenshots?: BrowserScreenshotPolicy;
+    logContent?: BrowserLogContent;
+    persist?: boolean;
+    credentials?: string[];
+}
+
+export declare class LuaDecision<Q extends DecisionQuestions = DecisionQuestions> {
+    readonly name: string;
+    readonly description?: string;
+    readonly questions: Q;
+    readonly provider?: DecisionProviderChoice;
+    readonly model?: string;
+    readonly fallback?: DecisionFallback;
+    readonly region?: DecisionRegion;
+    readonly zeroRetention?: boolean;
+    readonly minConfidence?: number;
+    readonly timeoutMs?: number;
+    readonly cache?: {
+        ttlSeconds: number;
+    };
+    readonly logState?: DecisionLogState;
+    constructor(config: LuaDecisionConfig<Q>);
+}
+
+export declare type LuaDecisionConfig<Q extends DecisionQuestions = DecisionQuestions> = DecisionDefinition<Q>;
+
 /**
  * LuaDevice class — represents an external device that an agent can communicate with.
  *
@@ -5855,7 +6660,7 @@ export declare interface LuaTriggerConfig<T = any> {
  *
  * export default new LuaVoice({
  *   name: 'support-line',
- *   llm: 'openai/gpt-5.2-chat-latest',
+ *   llm: 'openai/chat-latest',
  *   stt: 'deepgram/nova-3',
  *   tts: { model: 'cartesia/sonic-3', voice: '9626c31c-bec5-4cca-baa8-f8ba9e84c8bc' },
  *   vad: 'silero',
@@ -5955,7 +6760,7 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     llm: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -5970,13 +6775,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }>, z.ZodObject<{
@@ -5991,15 +6796,15 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -6011,17 +6816,17 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
-    }, {
-        kind: "realtime";
         provider: "openai" | "google" | "xai";
+        kind: "realtime";
+    }, {
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     }>]>;
     stt: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -6036,13 +6841,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }>, z.ZodObject<{
@@ -6057,15 +6862,15 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -6077,17 +6882,17 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
-    }, {
-        kind: "realtime";
         provider: "openai" | "google" | "xai";
+        kind: "realtime";
+    }, {
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     }>]>>;
     tts: z.ZodOptional<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
         kind: z.ZodLiteral<"inference">;
-        /** Provider-prefixed model id (e.g. `'openai/gpt-5.2-chat-latest'`). */
+        /** Provider-prefixed model id (e.g. `'openai/chat-latest'`). */
         model: z.ZodString;
         /**
          * TTS-only — provider voice id. Inference's TTS API takes voice
@@ -6102,13 +6907,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }, {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     }>, z.ZodObject<{
@@ -6123,15 +6928,15 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }, {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     }>, z.ZodObject<{
         kind: z.ZodLiteral<"realtime">;
         provider: z.ZodEnum<["openai", "google", "xai"]>;
@@ -6143,13 +6948,13 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
          */
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
-    }, {
-        kind: "realtime";
         provider: "openai" | "google" | "xai";
+        kind: "realtime";
+    }, {
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     }>]>>;
     vad: z.ZodOptional<z.ZodString>;
     vadOptions: z.ZodOptional<z.ZodObject<{
@@ -6308,52 +7113,52 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     excludeTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     llm: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     };
     name?: string | undefined;
     vad?: string | undefined;
     stt?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     volume?: number | undefined;
     tts?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     vadOptions?: {
         minSpeechDuration?: number | undefined;
@@ -6402,52 +7207,52 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     excludeTools?: string[] | undefined;
 }, {
     llm: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     };
     name?: string | undefined;
     vad?: string | undefined;
     stt?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     volume?: number | undefined;
     tts?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     vadOptions?: {
         minSpeechDuration?: number | undefined;
@@ -6496,52 +7301,52 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     excludeTools?: string[] | undefined;
 }>, {
     llm: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     };
     name?: string | undefined;
     vad?: string | undefined;
     stt?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     volume?: number | undefined;
     tts?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     vadOptions?: {
         minSpeechDuration?: number | undefined;
@@ -6590,52 +7395,52 @@ declare const LuaVoiceConfigSchema: z.ZodEffects<z.ZodObject<{
     excludeTools?: string[] | undefined;
 }, {
     llm: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     };
     name?: string | undefined;
     vad?: string | undefined;
     stt?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     volume?: number | undefined;
     tts?: {
-        kind: "inference";
         model: string;
+        kind: "inference";
         voice?: string | undefined;
         options?: Record<string, unknown> | undefined;
     } | {
-        kind: "plugin";
+        options: Record<string, unknown>;
         provider: "deepgram" | "elevenlabs";
+        kind: "plugin";
         class: "LLM" | "STT" | "STTv2" | "TTS";
-        options: Record<string, unknown>;
     } | {
-        kind: "realtime";
-        provider: "openai" | "google" | "xai";
         options: Record<string, unknown>;
+        provider: "openai" | "google" | "xai";
+        kind: "realtime";
     } | undefined;
     vadOptions?: {
         minSpeechDuration?: number | undefined;
@@ -7090,7 +7895,9 @@ export declare type LuaWorkflowBuildCode = 'duplicate-step-id' | 'unknown-step-r
 /** BAC-2062: the builder mirror of the BAC-619 validator codes: a `waitForSignal` name a delivery refuses. */
 | 'signal-name-invalid'
 /** BAC-2062: a numeric approval / waitForSignal `timeoutHours` outside 1..720. */
-| 'timeout-hours-out-of-range' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
+| 'timeout-hours-out-of-range' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope'
+/** BAC-2341: a `concurrencyKey` declared without `concurrencyPolicy:'forbid'` (the server's 400 twin). */
+| 'concurrency-key-requires-forbid' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
 
 export declare interface LuaWorkflowBuilder {
     then(step: StepRef): this;
@@ -7157,6 +7964,11 @@ export declare interface LuaWorkflowConfig {
     stateSchema?: ZodType;
     /** 'forbid' = jobs-style overlap guard per workflow (D21-r1) — every start path gets 409 `RUNS_IN_FLIGHT`. */
     concurrencyPolicy?: 'allow' | 'forbid';
+    /**
+     * Scope the `forbid` overlap guard per correlation key instead of workflow-wide. Requires `concurrencyPolicy:'forbid'`;
+     * absent means workflow-wide. Rides the manifest and the push body, not the graph envelope or `graphHash`.
+     */
+    concurrencyKey?: 'correlationKey';
     /** Who may READ this workflow's run outputs beyond `workflows:read-outputs` holders (B44). Envelope member outside `graphHash`. */
     outputVisibility?: WorkflowOutputVisibility;
     /**
@@ -7463,6 +8275,20 @@ export declare const notExists: (ref: TypedRef<unknown>) => LuaPredicate;
 
 export declare const notIn: <T extends string | number | boolean | null>(v: TypedRef<T>, set: T[]) => LuaPredicate;
 
+export declare interface OddsAnswer {
+    type: 'odds';
+    odds: number;
+}
+
+export declare interface OddsQuestion {
+    type: 'odds';
+    instructions: string;
+    criteria?: {
+        yes?: string;
+        no?: string;
+    };
+}
+
 export declare const or: (...args: LuaPredicate[]) => LuaPredicate;
 
 /**
@@ -8447,6 +9273,10 @@ declare const REASONING_EFFORT_VALUES: readonly ["off", "minimal", "low", "mediu
 
 declare type ReasoningEffort = (typeof REASONING_EFFORT_VALUES)[number];
 
+export declare interface RefusedAnswer {
+    type: 'refused';
+}
+
 export declare type ReplyChannel = 'whatsapp' | 'sms' | 'email' | 'webchat' | 'slack';
 
 declare interface RequestCredential {
@@ -8580,6 +9410,26 @@ declare interface ScopedPromoteFields {
     agentVersion?: number;
 }
 
+export declare interface ScoreAnswer {
+    type: 'score';
+    score: number;
+    level: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+    uncertain: boolean;
+}
+
+export declare interface ScoreLevel {
+    label: string;
+    description: string;
+}
+
+export declare interface ScoreQuestion {
+    type: 'score';
+    instructions: string;
+    levels: ReadonlyArray<string | ScoreLevel>;
+}
+
 /**
  * Response from product search.
  */
@@ -8776,6 +9626,14 @@ export declare interface SecretTestOutcome {
 
 export declare type SecretTestResult = (typeof SECRET_TEST_RESULTS)[number];
 
+declare interface SelectorInput extends BrowserSessionInput {
+    selector: string;
+}
+
+declare interface SelectorTextInput extends SelectorInput {
+    text: string;
+}
+
 declare interface SendTemplateButtonValue {
     sub_type: WhatsAppTemplateButtonType;
     index: string;
@@ -9393,7 +10251,7 @@ export declare const Templates: {
 };
 
 /** Recorded effect kinds (DOC2 §7 seam table; `fetch` is sandbox egress record mode, §9.1). */
-declare const TEST_EFFECT_KINDS: readonly ["channel.send", "whatsapp.template", "whatsapp.reaction", "whatsapp.phone_request", "email.send", "inbox.push", "voice.call", "passthrough", "mcp.tool", "supervision.write", "user.update_name", "browser.action", "jobs.create", "fetch", "refused", "metrics.record", "threads.open", "threads.follow_up", "secrets.request", "connection_request.create", "connection_request.reconnect", "connection_request.cancel", "ai.generate"];
+declare const TEST_EFFECT_KINDS: readonly ["channel.send", "whatsapp.template", "whatsapp.reaction", "whatsapp.phone_request", "email.send", "inbox.push", "voice.call", "passthrough", "mcp.tool", "supervision.write", "user.update_name", "browser.action", "jobs.create", "fetch", "refused", "metrics.record", "threads.open", "threads.follow_up", "secrets.request", "connection_request.create", "connection_request.reconnect", "connection_request.cancel", "ai.generate", "decisions.ask"];
 
 declare type TestEffectKind = (typeof TEST_EFFECT_KINDS)[number];
 
@@ -9747,6 +10605,10 @@ declare interface UpdateJobVersionDTO {
     metadata?: Record<string, any>;
 }
 
+declare interface UrlInput extends BrowserSessionInput {
+    url: string;
+}
+
 /**
  * Function type for resolving URL at runtime.
  * Use env() inside to access agent environment variables.