@e2e-dev/decision 0.2.0-nightly-20261009094406 → 0.2.0

package/dist/locator.d.ts

@@ -0,0 +1,38 @@
+import type { StepExecutorContext } from 'e2e';
+import type { Decision } from './decide.ts';
+import { type Point, type Screenshot } from './overlay.ts';
+import { type Gates } from './picks.ts';
+import { type DecisionRequest } from './questions.ts';
+/** Asks the decision model one request, or nothing once the step budget is spent. */
+export type AskDecision = (request: DecisionRequest) => Promise<Record<string, Decision> | undefined>;
+/** Where a drawn control is, or why the looks could not say. */
+export type Located = Point | {
+    readonly uncertain: string;
+};
+/**
+ * Locates drawn controls on the screenshot and remembers the ones a tap
+ * found: two looks per control, the column and row on the plain full
+ * screenshot, then again on a zoomed crop with a grid drawn on it. A tap
+ * that changed the pixels around it found its control; the same control on
+ * the same page is tapped there again with no new looks.
+ */
+export declare class PointLocator {
+    private readonly ctx;
+    private readonly ask;
+    private readonly gates;
+    /** Points that landed, by path and the control the text model named. */
+    private readonly landed;
+    /** The last point tap, settled against the next observation. */
+    private pending;
+    constructor(ctx: StepExecutorContext, ask: AskDecision, gates: Gates);
+    /** A point already known for this control on this page. */
+    known(path: string, wanted: string): Point | undefined;
+    /** Records a point tap, to be settled by the next observation. */
+    tapped(path: string, wanted: string, point: Point, screenshot: Screenshot): void;
+    /** Settles the last point tap against the newest pixels: changed means it landed. */
+    settle(screenshot: Screenshot | undefined): void;
+    /** Two looks for the control, or undefined once the budget is spent. */
+    locate(screenshot: Screenshot, path: string, wanted: string): Promise<Located | undefined>;
+    /** The column and row scores of a point request, gated like any answer. */
+    private scored;
+}

package/dist/locator.js

@@ -0,0 +1,91 @@
+import { CELL_TARGET, gridFor, pointOf, regionHash, withGrid, zoomAround } from './overlay.js';
+import { describe, gated, invalid, need } from './picks.js';
+import { pointRequest } from './questions.js';
+/**
+ * CSS pixels of the region the second look zooms into, and how much it is
+ * enlarged: wide enough to hold a first look one column off. A tighter
+ * third look was measured to drift on the runner's 768px capture.
+ */
+const ZOOM_BOX = 400;
+const ZOOM_FACTOR = 2;
+/** Columns and rows of the grid drawn on the zoomed region. */
+const ZOOM_CELLS = 8;
+/**
+ * Locates drawn controls on the screenshot and remembers the ones a tap
+ * found: two looks per control, the column and row on the plain full
+ * screenshot, then again on a zoomed crop with a grid drawn on it. A tap
+ * that changed the pixels around it found its control; the same control on
+ * the same page is tapped there again with no new looks.
+ */
+export class PointLocator {
+    ctx;
+    ask;
+    gates;
+    /** Points that landed, by path and the control the text model named. */
+    landed = new Map();
+    /** The last point tap, settled against the next observation. */
+    pending;
+    constructor(ctx, ask, gates) {
+        this.ctx = ctx;
+        this.ask = ask;
+        this.gates = gates;
+    }
+    /** A point already known for this control on this page. */
+    known(path, wanted) {
+        return this.landed.get(key(path, wanted));
+    }
+    /** Records a point tap, to be settled by the next observation. */
+    tapped(path, wanted, point, screenshot) {
+        this.pending = { key: key(path, wanted), point, before: regionHash(screenshot, point, ZOOM_BOX) };
+    }
+    /** Settles the last point tap against the newest pixels: changed means it landed. */
+    settle(screenshot) {
+        if (this.pending === undefined)
+            return;
+        const after = regionHash(screenshot, this.pending.point, ZOOM_BOX);
+        if (after !== undefined && after !== this.pending.before)
+            this.landed.set(this.pending.key, this.pending.point);
+        else
+            this.landed.delete(this.pending.key);
+        this.pending = undefined;
+    }
+    /** Two looks for the control, or undefined once the budget is spent. */
+    async locate(screenshot, path, wanted) {
+        const grid = gridFor(screenshot.width / screenshot.scale, screenshot.height / screenshot.scale, CELL_TARGET);
+        const coarse = await this.ask(pointRequest(this.ctx, path, screenshot, grid, 'This image is the full screenshot; no grid is drawn on it.', wanted));
+        if (coarse === undefined)
+            return undefined;
+        const first = this.scored(coarse);
+        if ('uncertain' in first)
+            return first;
+        const rough = pointOf(grid, first.x, first.y);
+        const zoom = zoomAround(screenshot, rough, ZOOM_BOX, ZOOM_FACTOR);
+        if (zoom === undefined)
+            return rough;
+        const side = zoom.screenshot.width;
+        const fine = { columns: ZOOM_CELLS, rows: ZOOM_CELLS, cellWidth: side / ZOOM_CELLS, cellHeight: side / ZOOM_CELLS };
+        const region = Math.round(side / ZOOM_FACTOR);
+        const framing = `This image is a ${ZOOM_FACTOR}x zoom of a ${region} by ${region} pixel region of the screen.`;
+        const closer = await this.ask(pointRequest(this.ctx, path, withGrid(zoom.screenshot, fine), fine, framing, wanted));
+        if (closer === undefined)
+            return undefined;
+        const second = this.scored(closer);
+        if ('uncertain' in second)
+            return second;
+        const inZoom = pointOf(fine, second.x, second.y);
+        return { x: Math.round(zoom.origin.x + inZoom.x / zoom.factor), y: Math.round(zoom.origin.y + inZoom.y / zoom.factor) };
+    }
+    /** The column and row scores of a point request, gated like any answer. */
+    scored(answers) {
+        const x = need(answers.x, 'x');
+        const y = need(answers.y, 'y');
+        if (x.score === undefined || y.score === undefined)
+            throw invalid('The decision model answered a point question without a score.');
+        if (!gated(x, this.gates) || !gated(y, this.gates))
+            return { uncertain: `x ${describe(x)}; y ${describe(y)}` };
+        return { x: x.score, y: y.score };
+    }
+}
+function key(path, wanted) {
+    return `${path}\0${wanted}`;
+}

package/dist/overlay.d.ts

@@ -0,0 +1,59 @@
+import type { ExecutorPixels } from 'e2e';
+/** Pixels as the decision model receives them: the runner's capture without its masking count. */
+export type Screenshot = Omit<ExecutorPixels, 'maskedRegionCount'>;
+/** A viewport point in CSS pixels. */
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * A grid over an image: at most ten columns and rows, one score level per
+ * column and row. Sizes are in the CSS pixels of the image's coordinates.
+ */
+export interface Grid {
+    readonly columns: number;
+    readonly rows: number;
+    readonly cellWidth: number;
+    readonly cellHeight: number;
+}
+/**
+ * Target cell size of a first look in CSS pixels. A 1280 by 720 viewport
+ * gets 10 columns of 128px and 9 rows of 80px; measured on gpt-6-luna over
+ * a drawn keypad, the probability-weighted column and row land within a
+ * column of every key.
+ */
+export declare const CELL_TARGET = 80;
+/**
+ * The grid for an image: as close to `cellTarget` CSS pixels per cell as
+ * the level cap allows. A 1280 by 720 viewport with an 80px target gets 10
+ * columns of 128px and 9 rows of 80px.
+ */
+export declare function gridFor(width: number, height: number, cellTarget: number): Grid;
+/** The point a column and row score name on a grid: the center of the scored position, inside the image. */
+export declare function pointOf(grid: Grid, column: number, row: number): Point;
+/** A zoomed crop: the image, and where its top-left corner sits in the screenshot's CSS pixels. */
+export interface Zoom {
+    readonly screenshot: Screenshot;
+    readonly origin: Point;
+    readonly factor: number;
+}
+/**
+ * The `box` by `box` CSS-pixel region around `center`, kept inside the
+ * screenshot and enlarged `factor` times (nearest neighbor), for a finer
+ * second look at a drawn control. Undefined when the pixels cannot be decoded.
+ */
+export declare function zoomAround(screenshot: Screenshot, center: Point, box: number, factor: number): Zoom | undefined;
+/**
+ * A hash of the `box` by `box` CSS-pixel region around `center`: what a tap
+ * there changed, read without the rest of the page. Undefined without
+ * pixels or when they cannot be decoded.
+ */
+export declare function regionHash(screenshot: Screenshot | undefined, center: Point, box: number): string | undefined;
+/**
+ * The screenshot with the grid's cell borders drawn on it. Measured on
+ * gpt-6-luna over a drawn keypad at the runner's 768px capture, the zoomed
+ * look lands within 30px of every key with the lines, and a cell number
+ * drawn in each corner only covered the glyphs it was meant to help find.
+ * Returns the input untouched when it cannot be decoded.
+ */
+export declare function withGrid(screenshot: Screenshot, grid: Grid): Screenshot;

package/dist/overlay.js

@@ -0,0 +1,121 @@
+import { PNG } from 'pngjs';
+import { fnv1a } from './hash.js';
+/** The Decisions API scores at most ten levels per question. */
+const MAX_LEVELS = 10;
+/**
+ * Target cell size of a first look in CSS pixels. A 1280 by 720 viewport
+ * gets 10 columns of 128px and 9 rows of 80px; measured on gpt-6-luna over
+ * a drawn keypad, the probability-weighted column and row land within a
+ * column of every key.
+ */
+export const CELL_TARGET = 80;
+/**
+ * The grid for an image: as close to `cellTarget` CSS pixels per cell as
+ * the level cap allows. A 1280 by 720 viewport with an 80px target gets 10
+ * columns of 128px and 9 rows of 80px.
+ */
+export function gridFor(width, height, cellTarget) {
+    const columns = Math.min(MAX_LEVELS, Math.max(1, Math.round(width / cellTarget)));
+    const rows = Math.min(MAX_LEVELS, Math.max(1, Math.round(height / cellTarget)));
+    return { columns, rows, cellWidth: width / columns, cellHeight: height / rows };
+}
+/** The point a column and row score name on a grid: the center of the scored position, inside the image. */
+export function pointOf(grid, column, row) {
+    const clamp = (value, max) => Math.min(max - 1, Math.max(0, Math.round(value)));
+    return {
+        x: clamp((column + 0.5) * grid.cellWidth, grid.columns * grid.cellWidth),
+        y: clamp((row + 0.5) * grid.cellHeight, grid.rows * grid.cellHeight),
+    };
+}
+/**
+ * The `box` by `box` CSS-pixel region around `center`, kept inside the
+ * screenshot and enlarged `factor` times (nearest neighbor), for a finer
+ * second look at a drawn control. Undefined when the pixels cannot be decoded.
+ */
+export function zoomAround(screenshot, center, box, factor) {
+    const png = decode(screenshot);
+    if (png === undefined)
+        return undefined;
+    const scale = screenshot.scale;
+    const cssWidth = png.width / scale;
+    const cssHeight = png.height / scale;
+    const side = Math.min(box, cssWidth, cssHeight);
+    const origin = {
+        x: Math.round(Math.max(0, Math.min(cssWidth - side, center.x - side / 2))),
+        y: Math.round(Math.max(0, Math.min(cssHeight - side, center.y - side / 2))),
+    };
+    const size = Math.round(side * factor);
+    const out = new PNG({ width: size, height: size });
+    for (let y = 0; y < size; y += 1) {
+        for (let x = 0; x < size; x += 1) {
+            const sx = Math.min(png.width - 1, Math.floor((origin.x + x / factor) * scale));
+            const sy = Math.min(png.height - 1, Math.floor((origin.y + y / factor) * scale));
+            const from = (sy * png.width + sx) * 4;
+            const to = (y * size + x) * 4;
+            out.data[to] = png.data[from] ?? 0;
+            out.data[to + 1] = png.data[from + 1] ?? 0;
+            out.data[to + 2] = png.data[from + 2] ?? 0;
+            out.data[to + 3] = 255;
+        }
+    }
+    return { screenshot: { mediaType: 'image/png', data: new Uint8Array(PNG.sync.write(out)), width: size, height: size, scale: 1 }, origin, factor };
+}
+/**
+ * A hash of the `box` by `box` CSS-pixel region around `center`: what a tap
+ * there changed, read without the rest of the page. Undefined without
+ * pixels or when they cannot be decoded.
+ */
+export function regionHash(screenshot, center, box) {
+    if (screenshot === undefined)
+        return undefined;
+    const zoom = zoomAround(screenshot, center, box, 1);
+    return zoom === undefined ? undefined : fnv1a([zoom.screenshot.data]);
+}
+/**
+ * The screenshot with the grid's cell borders drawn on it. Measured on
+ * gpt-6-luna over a drawn keypad at the runner's 768px capture, the zoomed
+ * look lands within 30px of every key with the lines, and a cell number
+ * drawn in each corner only covered the glyphs it was meant to help find.
+ * Returns the input untouched when it cannot be decoded.
+ */
+export function withGrid(screenshot, grid) {
+    const png = decode(screenshot);
+    if (png === undefined)
+        return screenshot;
+    const scale = screenshot.scale;
+    for (let row = 0; row < grid.rows; row += 1) {
+        for (let column = 0; column < grid.columns; column += 1) {
+            const x0 = Math.round(column * grid.cellWidth * scale);
+            const y0 = Math.round(row * grid.cellHeight * scale);
+            const x1 = Math.min(png.width, Math.round((column + 1) * grid.cellWidth * scale));
+            const y1 = Math.min(png.height, Math.round((row + 1) * grid.cellHeight * scale));
+            for (let x = x0; x < x1; x += 1) {
+                paint(png, x, y0, GRID);
+                paint(png, x, y1 - 1, GRID);
+            }
+            for (let y = y0; y < y1; y += 1) {
+                paint(png, x0, y, GRID);
+                paint(png, x1 - 1, y, GRID);
+            }
+        }
+    }
+    return { ...screenshot, data: new Uint8Array(PNG.sync.write(png)) };
+}
+function decode(screenshot) {
+    try {
+        return PNG.sync.read(Buffer.from(screenshot.data));
+    }
+    catch {
+        return undefined;
+    }
+}
+const GRID = [255, 0, 255];
+function paint(png, x, y, color) {
+    if (x < 0 || y < 0 || x >= png.width || y >= png.height)
+        return;
+    const offset = (y * png.width + x) * 4;
+    png.data[offset] = color[0];
+    png.data[offset + 1] = color[1];
+    png.data[offset + 2] = color[2];
+    png.data[offset + 3] = 255;
+}

package/dist/params.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from 'e2e';
+/** The step params minus secret projections, which travel only as handles. */
+export declare function nonSecretParams(params: Readonly<Record<string, JsonValue>> | undefined): Record<string, JsonValue>;

package/dist/params.js

@@ -0,0 +1,39 @@
+/** The step params minus secret projections, which travel only as handles. */
+export function nonSecretParams(params) {
+    const kept = {};
+    for (const [key, value] of Object.entries(params ?? {})) {
+        const cleaned = withoutSecret(value);
+        if (cleaned === undefined)
+            continue;
+        setKey(kept, key, cleaned);
+    }
+    return kept;
+}
+/** Removes secret-marker leaves at any depth. Undefined means the value itself was one. */
+function withoutSecret(value) {
+    if (Array.isArray(value))
+        return value.map((item) => withoutSecret(item) ?? null);
+    if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (record['kind'] === 'secret')
+            return undefined;
+        const kept = {};
+        for (const [key, item] of Object.entries(record)) {
+            const cleaned = withoutSecret(item);
+            if (cleaned === undefined)
+                continue;
+            setKey(kept, key, cleaned);
+        }
+        return kept;
+    }
+    return value;
+}
+/** Assigns an own property even for `__proto__`, which a plain assignment would not create. */
+function setKey(record, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(record, key, { value, enumerable: true, configurable: true, writable: true });
+    }
+    else {
+        record[key] = value;
+    }
+}

package/dist/picks.d.ts

@@ -0,0 +1,36 @@
+import { AgentError } from 'e2e/agent';
+import type { Decision } from './decide.ts';
+/** The gates every answer passes: the selected option's probability and the provider's confidence. */
+export interface Gates {
+    readonly minProbability: number;
+    readonly minConfidence: number;
+}
+/**
+ * What a target question settled: the offered value, with the answer that
+ * chose it when one was asked, or why the step cannot go on.
+ */
+export type Chosen<T> = {
+    readonly key: string;
+    readonly value: T;
+    readonly answer?: Decision;
+} | {
+    readonly blocked: string;
+};
+/**
+ * Resolves a target answer against what was offered. A lone offer needs no
+ * answer: the request never asked. The model's `none`, and an answer under
+ * the gates, block the step. Anything the request never offered is
+ * MODEL_OUTPUT_INVALID: our validation, never the provider's text.
+ */
+export declare function pick<T>(answer: Decision | undefined, offered: ReadonlyMap<string, T>, gates: Gates, what: string, operation: string): Chosen<T>;
+/** What a verdict question can settle on. */
+export type Verdict = 'holds' | 'fails' | 'inconclusive';
+/** The verdict answer, typed, or `below gate` when it fails the gates; a verdict never offered is MODEL_OUTPUT_INVALID. */
+export declare function verdictOf(answer: Decision | undefined, gates: Gates): Verdict | 'below gate';
+/** A model answer the request never offered: our validation, never the provider's text. */
+export declare function invalid(message: string): AgentError;
+/** Requires an answer the model returned; its absence is our bug or a broken transport. */
+export declare function need(answer: Decision | undefined, what: string): Decision;
+export declare function gated(decision: Decision, gates: Gates): boolean;
+/** How an answer reads in a verdict or a turn: `p=0.950, confidence 0.930`. */
+export declare function describe(decision: Decision): string;

package/dist/picks.js

@@ -0,0 +1,49 @@
+import { AgentError } from 'e2e/agent';
+import { NONE } from './questions.js';
+/**
+ * Resolves a target answer against what was offered. A lone offer needs no
+ * answer: the request never asked. The model's `none`, and an answer under
+ * the gates, block the step. Anything the request never offered is
+ * MODEL_OUTPUT_INVALID: our validation, never the provider's text.
+ */
+export function pick(answer, offered, gates, what, operation) {
+    if (answer === undefined) {
+        const [lone] = offered;
+        if (offered.size === 1 && lone !== undefined)
+            return { key: lone[0], value: lone[1] };
+        throw invalid(`The decision model returned no ${what} answer.`);
+    }
+    if (answer.choice === NONE)
+        return { blocked: `The decision model chose ${operation} but no ${what} for it (${describe(answer)}).` };
+    const value = offered.get(answer.choice);
+    if (value === undefined)
+        throw invalid(`The decision model chose an unavailable ${what}.`);
+    if (!gated(answer, gates))
+        return { blocked: `The ${what} is uncertain (${describe(answer)}).` };
+    return { key: answer.choice, value, answer };
+}
+const VERDICTS = new Set(['holds', 'fails', 'inconclusive']);
+/** The verdict answer, typed, or `below gate` when it fails the gates; a verdict never offered is MODEL_OUTPUT_INVALID. */
+export function verdictOf(answer, gates) {
+    const verdict = need(answer, 'verdict');
+    if (!VERDICTS.has(verdict.choice))
+        throw invalid('The decision model chose an unavailable verdict.');
+    return gated(verdict, gates) ? verdict.choice : 'below gate';
+}
+/** A model answer the request never offered: our validation, never the provider's text. */
+export function invalid(message) {
+    return new AgentError('MODEL_OUTPUT_INVALID', message);
+}
+/** Requires an answer the model returned; its absence is our bug or a broken transport. */
+export function need(answer, what) {
+    if (answer === undefined)
+        throw invalid(`The decision model returned no ${what} answer.`);
+    return answer;
+}
+export function gated(decision, gates) {
+    return decision.probability >= gates.minProbability && decision.confidence >= gates.minConfidence;
+}
+/** How an answer reads in a verdict or a turn: `p=0.950, confidence 0.930`. */
+export function describe(decision) {
+    return `p=${decision.probability.toFixed(3)}, confidence ${decision.confidence.toFixed(3)}`;
+}

package/dist/questions.d.ts

@@ -1,5 +1,13 @@
 import type { JsonValue, StepExecutorContext } from 'e2e';
-import type { ActionSpace } from './elements.ts';
+import { type ActionSpace, type Operation } from './elements.ts';
+import type { Grid, Screenshot } from './overlay.ts';
+/**
+ * The fallback every target question carries. A provider that finds no
+ * applicable target for an operation the step will not take (OpenAI refuses
+ * such a question outright) chooses this instead, and the step reads it as
+ * "not this operation".
+ */
+export declare const NONE = "none";
 /** One step of history the decision model reads. */
 export interface HistoryEntry {
     readonly action: string;
@@ -8,49 +16,62 @@ export interface HistoryEntry {
     readonly error?: string;
     readonly replayed?: true;
     readonly uncertain?: true;
+    /** What the engine reported for the action, when that tells the model something. */
+    readonly note?: string;
 }
-/** One choice question as the request sends it. */
-interface ChoiceQuestion {
+/** One question as the request sends it: a choice over named criteria, or a score over ordered levels. */
+export type Question = {
     readonly type: 'choice';
-    readonly instructions: Record<string, JsonValue>;
-    readonly criteria: Record<string, JsonValue | null>;
-}
+    readonly instructions: string;
+    readonly criteria: Record<string, string | null>;
+} | {
+    readonly type: 'score';
+    readonly instructions: string;
+    readonly criteria: readonly (string | null)[];
+};
 export interface DecisionRequest {
     readonly state: Record<string, JsonValue>;
-    readonly questions: Record<string, ChoiceQuestion>;
+    readonly questions: Record<string, Question>;
+    /** Masked viewport pixels the model sees beside the state, when vision is on and pixels were granted. */
+    readonly screenshot?: Screenshot;
 }
 /**
- * Builds one decide request: the operation question plus one target
- * question per operation with two or more targets, and a secret question
- * when two or more secrets are declared. Operations with no targets are
- * left out; a lone target dispatches with no question.
+ * Builds the operation request: one choice over the operations the screen
+ * offers, the controls, and the terminals. Every question states the goal
+ * and the recent actions in its own instructions: a classifier reads the
+ * question before the evidence.
  */
-export declare function decisionRequest(ctx: StepExecutorContext, space: ActionSpace, history: readonly HistoryEntry[], path: string): DecisionRequest;
-/** The step params minus secret projections, which travel only as handles. */
-export declare function nonSecretParams(params: Readonly<Record<string, JsonValue>> | undefined): Record<string, JsonValue>;
-/** Element index behind a target key (`7` for both `7` and `7:2`). */
-export declare function targetKeyIndex(key: string): string;
-/** Element table rows as plain records, shared by decision and verdict states. */
-export declare function elementRecords(space: ActionSpace): Record<string, JsonValue>[];
+export declare function operationRequest(ctx: StepExecutorContext, space: ActionSpace, history: readonly HistoryEntry[], path: string): DecisionRequest;
 /**
- * Builds an assertion verdict request: the goal, the page, and the element
- * table. No history: an assertion judges the screen alone.
+ * Builds the target request that follows a chosen operation: its target
+ * question when it has two or more targets, the destination question for a
+ * drag, and the secret question for a secret fill with two or more secrets
+ * declared. A lone target dispatches with no question, so the request may
+ * carry none. Every target question carries the `none` fallback, so a
+ * provider never has to refuse one. A dependent decision goes in its own
+ * request, as the Decisions API asks.
  */
-export declare function assertionRequest(goal: string, path: string, pageText: string, elements: readonly Record<string, JsonValue>[]): DecisionRequest;
-/** What a completion check reads: the task, its inputs, the screen, and what the step did. */
-export interface CompletionInput {
-    readonly goal: string;
-    readonly params: Record<string, JsonValue>;
-    readonly path: string;
-    readonly pageText: string;
-    readonly elements: readonly Record<string, JsonValue>[];
-    readonly history: readonly HistoryEntry[];
-}
+export declare function targetRequest(ctx: StepExecutorContext, space: ActionSpace, operation: Operation, history: readonly HistoryEntry[], path: string): DecisionRequest;
+/**
+ * Builds a point request: two score questions over the grid on the image,
+ * one for the column and one for the row of the control the goal needs
+ * (`target`, as the text model named it). The probability-weighted means
+ * give a point finer than any one cell. The state is the goal alone: the
+ * element table adds nothing to where a drawn control sits, and measured on
+ * gpt-6-luna it pulls the estimate off. A dependent decision goes in its own
+ * request, as the Decisions API asks. Sizes are in the pixels of the image
+ * the model sees: the runner hands over a downscaled capture, and a model
+ * told CSS sizes for a smaller image lands its estimate short.
+ */
+export declare function pointRequest(ctx: StepExecutorContext, path: string, image: Screenshot, grid: Grid, framing: string, target: string): DecisionRequest;
+/** Builds an assertion verdict request: the goal, the page, and the element table. The screen alone, no history. */
+export declare function assertionRequest(goal: string, path: string, space: ActionSpace | undefined, screenshot: Screenshot | undefined): DecisionRequest;
 /**
  * Builds a completion-check request: the goal with its non-secret params, the
- * page, the element table, and the actions the step took with the values it
- * typed. Rejected done/failed claims are left out (they are not actions), and
- * so is any model reasoning.
+ * page, and the element table in the state; the actions the step took, with
+ * the values it typed, in the question only. The same list in the state was
+ * measured on gpt-6-luna to pull a verdict toward inconclusive (holds 0.17
+ * with it, 0.51 without, on a checked checkbox). Rejected done/failed claims
+ * are left out (they are not actions), and so is any model reasoning.
  */
-export declare function completionRequest(input: CompletionInput): DecisionRequest;
-export {};
+export declare function completionRequest(ctx: StepExecutorContext, space: ActionSpace, history: readonly HistoryEntry[], path: string, screenshot: Screenshot | undefined): DecisionRequest;