e2e 0.16.0 → 0.18.0

package/README.md

@@ -7,6 +7,10 @@
   <a href="https://tester.army/discord"><img alt="Join the community on Discord" src="https://img.shields.io/badge/Join%20the%20community-5865F2.svg?style=for-the-badge&logo=discord&logoColor=white&labelColor=000000" /></a>
 </p>
 
+<p align="center">
+  <a href="https://www.star-history.com/tester-army/e2e"><picture><source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/badge?repo=tester-army/e2e&type=trending&theme=dark" /><img alt="GitHub Trending Repository of the Day" src="https://api.star-history.com/badge?repo=tester-army/e2e&type=trending" /></picture></a>
+</p>
+
 # e2e
 
 [e2e](https://tester.army/e2e?utm_source=e2e&utm_medium=github&utm_campaign=readme_intro) is an end-to-end testing framework for web and mobile apps. Describe a goal in natural language and an agent drives the app to reach it. Check the result with locators and assertions in the same test.
@@ -40,6 +44,11 @@ npx e2e init
 config and an example test. The
 [quickstart](https://e2e.tester.army/docs/quickstart) covers the rest.
 
+To see a finished setup in your stack, open
+[`examples/`](https://github.com/tester-army/e2e/tree/main/examples):
+Vite, Next.js, Expo, and SwiftUI, each a standalone project with a passing
+suite.
+
 ## Packages
 
 | Package | What it does |
@@ -50,6 +59,7 @@ config and an example test. The
 | [`@e2e-dev/github`](https://www.npmjs.com/package/@e2e-dev/github) | Reporter that posts results as a pull request comment. |
 | [`@e2e-dev/kernel`](https://www.npmjs.com/package/@e2e-dev/kernel) | Kernel hosted browsers for the web engine. |
 | [`@e2e-dev/eas`](https://www.npmjs.com/package/@e2e-dev/eas) | EAS Simulators hosted iOS simulators and Android emulators for the mobile engine. |
+| [`@e2e-dev/decision`](https://e2e.tester.army/docs/decision-models) | Decision-model executors for bounded semantic actions and assertions. |
 
 ## Documentation
 

package/dist/.build.json

@@ -1 +1 @@
-{"version":"0.16.0"}
+{"version":"0.18.0"}

package/dist/agent/act.js

@@ -29,6 +29,7 @@ import { projectPriorSteps, serializeLedger } from './ledger.js';
 import { instantiateLanguageModel } from './model/sdk.js';
 import { ObservationFeed } from './observation-feed.js';
 import { recordPolicyEvent } from './phases.js';
+import { appLocation } from '../cache/route.js';
 import { OperationQueue } from './operation-queue.js';
 import { StepAccounting } from './step-accounting.js';
 import { failedStepOutcome, StepTraceSession } from './step-cache.js';
@@ -199,7 +200,10 @@ class ActDispatch {
                         name: agent.executor.name,
                         ...(agent.executor.version === undefined ? {} : { version: agent.executor.version }),
                     },
+                    // Redacted already (`dispatchAgentStep`): the key digests the context the executor reads.
+                    agent: { name: agent.name, context: agent.agentContext },
                     redact: runtime.redact,
+                    redactCut: runtime.redactCut,
                     maxActions: this.accounting.maxActions,
                     stepIndex,
                 });
@@ -421,11 +425,10 @@ class ActDispatch {
         const feed = this.feed;
         return {
             get traceEligible() { return feed.traceEligible; },
-            observe: async (mode) => screenOf(await this.feed.probe(mode)),
+            observe: async (mode) => screenOf(await this.feed.probe(mode), this.runtime.app.base?.origin),
             actions: this.dispatcher.actions,
             signal: this.accounting.signal,
             remainingMs: () => this.accounting.remainingMs(),
-            redact: this.runtime.redact,
             replaying: (active) => {
                 this.runtime.steps.replaying(active);
                 this.accounting.replaying(active);
@@ -474,10 +477,10 @@ class ActDispatch {
     }
 }
 /** The replay engine's view of a capture: the nodes, and the viewport a recorded point is checked against. */
-function screenOf(observation) {
+function screenOf(observation, appOrigin) {
     const metadata = {
         viewport: { width: observation.viewport.width, height: observation.viewport.height },
-        ...(observation.path === undefined ? {} : { path: observation.path }),
+        ...(observation.location === undefined ? {} : { path: appLocation(observation.location, appOrigin) }),
     };
     return observation.kind === 'semantic'
         ? { ...metadata, kind: 'semantic', nodes: observation.nodes }

package/dist/agent/action-dispatcher.js

@@ -487,10 +487,10 @@ export class ActionDispatcher {
     }
     async runActionNow(name, body) {
         this.accounting.reserveAction();
-        const redact = this.runtime.redact;
+        const redaction = { redact: this.runtime.redact, redactCut: this.runtime.redactCut };
         let action;
         try {
-            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redact).summary }));
+            action = await instrumentPhase(this.runtime, { api: this.accounting.api, kind: 'engine', phase: 'agent.action', name }, body, (committed) => ({ detail: describeAction(committed, redaction).summary }));
         }
         catch (cause) {
             this.accounting.checkpoint(cause);
@@ -579,9 +579,8 @@ export class ActionDispatcher {
      * number picks the same one.
      */
     placementOf({ node, observation }) {
-        const redact = this.runtime.redact;
-        const within = containerKey(node.ref.id, observation.nodes, observation.parents, redact);
-        const position = describePosition(node, within, observation.nodes, { redact });
+        const within = containerKey(node.ref.id, observation.nodes, observation.parents);
+        const position = describePosition(node, within, observation.nodes);
         return {
             ...(within === undefined ? {} : { within }),
             ...(position === undefined ? {} : { position }),

package/dist/agent/actions.d.ts

@@ -8,51 +8,52 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
-import type { SemanticNode, ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import type { ViewportPoint, ViewportSize } from '../engine/surface.ts';
+import { type NodeRedaction, type RedactedNode } from './observation.ts';
 import { type NodeActionName, type PointActionName, type TraceTargetDescriptor, type TracePosition } from '../cache/trace.ts';
 import type { ScrollDirection } from '../types.ts';
 /** One committed grammar action, addressed by the node it actually ran against. */
 export type RecordableAction = ({
     readonly name: NodeActionName;
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
 } & Placement) | ({
     readonly name: 'type';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'typeSecret';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly secret: string;
 } & Placement) | ({
     readonly name: 'press';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly key: string;
 } & Placement) | ({
     readonly name: 'select';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly value: string;
 } & Placement) | ({
     readonly name: 'check';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly checked: boolean;
 } & Placement)
 /** Project-relative paths as the executor gave them; replay authorizes them again. */
  | ({
     readonly name: 'upload';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly paths: readonly string[];
 } & Placement)
 /** The dragged node with its placement, and where it was dropped, with its own. */
  | ({
     readonly name: 'drag';
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly destination: {
-        readonly node: SemanticNode;
+        readonly node: RedactedNode;
     } & Placement;
 } & Placement) | ({
     readonly name: 'scroll';
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     /** The share of the viewport the node covered when scrolled, 0 to 1 (`ScrollAction.spans`). */
     readonly spans?: number;
 } & Placement)
@@ -61,7 +62,7 @@ export type RecordableAction = ({
     readonly name: 'scrollUntil';
     readonly text: string;
     readonly direction: ScrollDirection;
-    readonly node?: SemanticNode;
+    readonly node?: RedactedNode;
     readonly spans?: number;
     /** How many pages it took; in the summary, never in the trace, since a replay pages for itself. */
     readonly screens: number;
@@ -92,7 +93,7 @@ export type RecordableAction = ({
     readonly name: PointActionName;
     readonly point: ViewportPoint;
     readonly viewport: ViewportSize;
-    readonly under?: SemanticNode;
+    readonly under?: RedactedNode;
 };
 /** Where the node sat when it was acted on: its container's key and its place among identical twins. */
 export interface Placement {
@@ -100,14 +101,17 @@ export interface Placement {
     readonly position?: TracePosition;
 }
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export declare function containerKey(id: string, nodes: ReadonlyMap<string, SemanticNode>, parents: ReadonlyMap<string, string>, redact: (text: string) => string): string | undefined;
+export declare function containerKey(id: string, nodes: ReadonlyMap<string, RedactedNode>, parents: ReadonlyMap<string, string>): string | undefined;
 /** Parent id of every non-root node, derived from the tree the node map indexes. */
-export declare function parentsOf(nodes: ReadonlyMap<string, SemanticNode>): ReadonlyMap<string, string>;
+export declare function parentsOf(nodes: ReadonlyMap<string, RedactedNode>): ReadonlyMap<string, string>;
 /** How one committed action reads back: where it acted, and what it did. */
 export interface DescribedAction {
     /**
@@ -124,13 +128,18 @@ export interface DescribedAction {
     /** Where a drag was dropped, described like its target; only a drag has one. */
     readonly destination?: TraceTargetDescriptor;
 }
-/** Describes one committed action for recording and for the live event. */
-export declare function describeAction(action: RecordableAction, redact: (text: string) => string): DescribedAction;
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export declare function describeAction(action: RecordableAction, redaction: NodeRedaction): DescribedAction;
 /**
  * Builds the durable descriptor for one resolved node: the semantic fields
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export declare function describeTarget(node: SemanticNode, redact: (text: string) => string): TraceTargetDescriptor | undefined;
+export declare function describeTarget(node: RedactedNode): TraceTargetDescriptor | undefined;

package/dist/agent/actions.js

@@ -8,32 +8,33 @@
  * the same descriptor projection. One owner for all three, so a recorded
  * summary, a live event line, and a relocation candidate can never drift.
  */
+import { redactNode } from './observation.js';
 import { bound, isNodeAction, MAX_TRACE_DESCRIPTOR_CHARS, MAX_TRACE_SUMMARY_CHARS, } from '../cache/trace.js';
 import { sanitizeText } from '../internal/errors.js';
-import { normalizeText } from '../internal/text.js';
+import { collapseText } from '../internal/text.js';
 /** Roles whose first text names the thing a control belongs to: a row's key, a list item's title. */
 const CONTAINER_ROLES = new Set(['row', 'listitem', 'article', 'group', 'region', 'dialog', 'tabpanel']);
 /** Longest container key kept. */
 const MAX_WITHIN_CHARS = 80;
 /**
- * The key of the nearest named container a node sits in — the first text of
- * its row or list item — when that key says more than the node's own name.
- * Ten rows each with a "Delete" button are ten identical descriptors; "Delete
- * in the row that starts with Budget draft" is one.
+ * The key of the nearest named container a node sits in, the first text of
+ * its row or list item or else the container's own label, when that key says
+ * more than the node's own name. Ten rows each with a "Delete" button are ten
+ * identical descriptors; "Delete in the row that starts with Budget draft" is
+ * one. A row whose only text is its own (`<li>Alpha <button><svg/></li>`)
+ * is keyed by it. Only the nearest container counts: the list around a row
+ * with no text names every row alike, so its key would tell no twin apart.
  */
-export function containerKey(id, nodes, parents, redact) {
+export function containerKey(id, nodes, parents) {
     const node = nodes.get(id);
     const own = node === undefined ? '' : squash(node.name ?? node.text ?? '');
     let cursor = parents.get(id);
     while (cursor !== undefined) {
         const container = nodes.get(cursor);
         if (container !== undefined && CONTAINER_ROLES.has(container.role ?? '')) {
-            const key = firstLeafText(container);
-            if (key !== undefined) {
-                const clean = bound(redact(sanitizeText(key)).replace(/\s+/g, ' ').trim(), MAX_WITHIN_CHARS);
-                return clean === '' || squash(clean) === own ? undefined : clean;
-            }
-            return undefined;
+            const key = firstLeafText(container) ?? ownLabel(container);
+            const clean = key === undefined ? '' : bound(collapseText(key), MAX_WITHIN_CHARS);
+            return clean === '' || squash(clean) === own ? undefined : clean;
         }
         cursor = parents.get(cursor);
     }
@@ -60,6 +61,11 @@ function firstLeafText(node) {
     }
     return undefined;
 }
+/** A container's own name or text, when it has one. */
+function ownLabel(node) {
+    const label = (node.name ?? node.text ?? '').trim();
+    return label === '' ? undefined : label;
+}
 function squash(text) {
     return text.replace(/\s+/g, ' ').trim().toLowerCase();
 }
@@ -74,16 +80,20 @@ const NODE_ACTION_PROSE = {
 };
 /** How each point verb reads: `tap the point (x, y)`, `hover over the point (x, y)`. */
 const POINT_ACTION_PROSE = { tapAt: 'tap', hoverAt: 'hover over' };
-/** Describes one committed action for recording and for the live event. */
-export function describeAction(action, redact) {
+/**
+ * Describes one committed action for recording and for the live event. Its
+ * nodes pass the ledger again as it is now: a secret resolved after the
+ * capture (inside the action itself) masks what the capture still shows.
+ */
+export function describeAction(action, redaction) {
     const target = 'node' in action
-        ? describePlaced(action.node, action, redact)
+        ? describePlaced(action.node, action, redaction)
         : 'point' in action
-            ? describePlaced(action.under, {}, redact)
+            ? describePlaced(action.under, {}, redaction)
             : undefined;
-    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redact) : undefined;
+    const destination = action.name === 'drag' ? describePlaced(action.destination.node, action.destination, redaction) : undefined;
     const where = describeForSummary(target);
-    const safe = (value) => quote(redact(sanitizeText(value)));
+    const safe = (value) => quote(redaction.redact(sanitizeText(value)));
     const prose = (() => {
         if (isNodeAction(action))
             return NODE_ACTION_PROSE[action.name](where);
@@ -134,13 +144,16 @@ export function describeAction(action, redact) {
     };
 }
 /** A node's durable descriptor with the placement it was acted on in; undefined for no node or nothing durable. */
-function describePlaced(node, placement, redact) {
-    const described = node === undefined ? undefined : describeTarget(node, redact);
+function describePlaced(node, placement, redaction) {
+    if (node === undefined)
+        return undefined;
+    const { children: _children, ...fields } = node;
+    const described = describeTarget(redactNode(fields, redaction));
     if (described === undefined)
         return undefined;
     return {
         ...described,
-        ...(placement.within === undefined ? {} : { within: bound(placement.within, MAX_WITHIN_CHARS) }),
+        ...(placement.within === undefined ? {} : { within: bound(redaction.redact(placement.within), MAX_WITHIN_CHARS) }),
         ...(placement.position === undefined ? {} : { position: placement.position }),
     };
 }
@@ -149,13 +162,14 @@ function describePlaced(node, placement, redact) {
  * replay re-finds it by, plus the engine's structural selector hint (kept as
  * provenance for tuned policies; the conservative relocator ignores it).
  * Values a secure node holds are never part of it — descriptors carry how a
- * node is named, not what it contains.
+ * node is named, not what it contains. The node was redacted with its
+ * observation (`redactNode`), each field in the one-line form read here too.
  */
-export function describeTarget(node, redact) {
+export function describeTarget(node) {
     const field = (value) => {
         if (value === undefined)
             return undefined;
-        const collapsed = normalizeText(redact(sanitizeText(value)));
+        const collapsed = collapseText(value);
         return collapsed === '' ? undefined : bound(collapsed, MAX_TRACE_DESCRIPTOR_CHARS);
     };
     const role = field(node.role);

package/dist/agent/ai-sdk.js

@@ -23,10 +23,11 @@ export function asSdkLanguageModel(instance) {
 }
 /**
  * The cache lives on `globalThis`, not in module state: config and test
- * modules load in an isolated tsx realm, so an executor constructed in config
- * code and the runner's own model plumbing would otherwise hold two separate
- * caches — and two separate `ai` module instances whose error classes fail
- * each other's instanceof checks. One slot, one SDK instance, every realm.
+ * modules may import a copy of e2e other than the runner's, so an executor
+ * constructed in config code and the runner's own model plumbing would
+ * otherwise hold two separate caches, and two separate `ai` module instances
+ * whose error classes fail each other's instanceof checks. One slot, one SDK
+ * instance, every copy.
  */
 const cacheSlot = realmSlot('e2e.ai-sdk.v1');
 function cache() {

package/dist/agent/error.js

@@ -1,5 +1,5 @@
 /** Runner-owned agent error classification. */
-import { classifyError, E2EError } from '../internal/errors.js';
+import { classifyError, E2EError, isE2EError } from '../internal/errors.js';
 /**
  * The single source of truth for the closed agent code set: exit/result class
  * for every code, the blocked category for codes a `blocked` verdict may
@@ -55,7 +55,7 @@ const MODEL_UNREACHABLE_CODES = new Set(Object.entries(AGENT_CODE_TABLE)
  * model was shown may be what went wrong.
  */
 export function isModelUnreachable(error) {
-    if (!(error instanceof E2EError) && !isAgentError(error))
+    if (!isE2EError(error))
         return false;
     return MODEL_UNREACHABLE_CODES.has(error.code);
 }
@@ -95,7 +95,7 @@ const AGENT_CODES = new Set(Object.keys(CATEGORY_BY_CODE));
 export function toAgentError(cause) {
     if (isAgentError(cause))
         return cause;
-    const classified = cause instanceof E2EError ? cause : classifyError(cause);
+    const classified = classifyError(cause);
     if (AGENT_CODES.has(classified.code)) {
         return new AgentError(classified.code, classified.message, { cause });
     }

package/dist/agent/invocation.js

@@ -104,14 +104,13 @@ export class Invocation {
     /** Captures one raw observation through the shared race-hardened path. */
     captureObservation(pixels) {
         return retryingObserve({
-            observe: (operation) => this.session.observe(operation, {
-                pixels,
-                pixelFallback: this.options.vision !== false && !this.runtime.exposure.withholdsPixels,
-            }),
+            observe: (operation, pixelFallback) => this.session.observe(operation, { pixels, pixelFallback }),
             operation: () => this.operation(),
             guard: (cause) => this.checkDeadline(cause),
             signal: this.runtime.engine.signal,
             api: this.options.api,
+            fallback: this.options.vision !== false,
+            tainted: () => this.runtime.exposure.withholdsPixels,
         });
     }
     /**

package/dist/agent/model/sdk.js

@@ -9,6 +9,7 @@
 import { withHint } from '../../internal/errors.js';
 import { missingModelError } from '../../config/agent.js';
 import { aiSdk, asSdkLanguageModel, loadAiSdk } from '../ai-sdk.js';
+import { MODEL_REQUEST_HEADERS } from '../../internal/client-identity.js';
 import { packageVersion } from '../../internal/package-version.js';
 import { AgentError } from '../error.js';
 import { isContextOverflow } from './overflow.js';
@@ -75,6 +76,7 @@ export function createModelAdapter(model, agentName = 'default') {
                 maxOutputTokens: call.maxOutputTokens,
                 ...(providerOptions === undefined ? {} : { providerOptions: providerOptions }),
                 maxRetries: TRANSPORT_RETRIES,
+                headers: MODEL_REQUEST_HEADERS,
                 abortSignal: call.signal,
                 timeout: call.timeoutMs,
             };

package/dist/agent/model/tool-choice.d.ts

@@ -33,6 +33,15 @@ export declare function isForcedToolChoiceDowngraded(warning: {
 export declare function isForcedToolCallSkipped(error: unknown): error is {
     readonly content?: readonly unknown[];
 };
+/**
+ * Whether a turn forced to call `complete_step` called other tools only. The
+ * AI SDK throws `AI_ToolChoiceViolationError` for that too, with the reply's
+ * raw content; it is the model breaking the protocol, as when it names a tool
+ * the turn does not offer, not the provider failing.
+ */
+export declare function isForcedToolCallMismatched(error: unknown): error is {
+    readonly content: readonly unknown[];
+};
 /**
  * Whether a provider failure says the model does not accept a forced tool
  * choice. Reads the message and the raw response body of the error and of

package/dist/agent/model/tool-choice.js

@@ -42,6 +42,20 @@ export function isForcedToolCallSkipped(error) {
     const record = error;
     return record.name === 'AI_ToolChoiceViolationError' && record.finishReason === 'stop';
 }
+/**
+ * Whether a turn forced to call `complete_step` called other tools only. The
+ * AI SDK throws `AI_ToolChoiceViolationError` for that too, with the reply's
+ * raw content; it is the model breaking the protocol, as when it names a tool
+ * the turn does not offer, not the provider failing.
+ */
+export function isForcedToolCallMismatched(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const record = error;
+    return (record.name === 'AI_ToolChoiceViolationError' &&
+        Array.isArray(record.content) &&
+        record.content.some((part) => typeof part === 'object' && part !== null && 'type' in part && part.type === 'tool-call'));
+}
 /** Longest cause chain walked; a wrapped error rarely nests deeper. */
 const MAX_CAUSE_DEPTH = 8;
 /**

package/dist/agent/observation-feed.d.ts

@@ -7,24 +7,23 @@
  * executor's redacted view of a capture. Nothing else in the step observes
  * the engine; the dispatcher and the pixel tier ask the feed.
  */
-import type { SemanticNode } from '../engine/surface.ts';
 import type { StepAgentDetails } from '../run/steps.ts';
 import { AgentError } from './error.ts';
 import type { ExecutorObservation, ExecutorObserveOptions, ExecutorTarget } from './executor.ts';
 import type { AgentContext } from './invocation.ts';
-import { type AgentObservation, type SemanticAgentObservation } from './observation.ts';
+import { type AgentObservation, type RedactedNode, type SemanticAgentObservation } from './observation.ts';
 import type { OperationQueue } from './operation-queue.ts';
 import { type SettleMode } from './settle-policy.ts';
 import type { StepAccounting } from './step-accounting.ts';
 /** A target resolved to a node of the observation it was found in. */
 export interface Resolved {
-    readonly node: SemanticNode;
+    readonly node: RedactedNode;
     readonly observation: SemanticAgentObservation;
 }
 /** What a target names on the newest screen: the id as the screen lists it, the node or nothing, and the screen looked at. */
 export interface Lookup {
     readonly id: string;
-    readonly node: SemanticNode | undefined;
+    readonly node: RedactedNode | undefined;
     readonly observation: SemanticAgentObservation;
 }
 export interface ObservationFeedOptions {
@@ -116,8 +115,8 @@ export declare class ObservationFeed {
      * through the queued observe: this runs inside a queued action body, and a
      * queued observation would wait on its own caller.
      */
-    relocate(stale: SemanticNode): Promise<{
-        node: SemanticNode;
+    relocate(stale: RedactedNode): Promise<{
+        node: RedactedNode;
         observation: SemanticAgentObservation;
     } | undefined>;
     /**

package/dist/agent/observation-feed.js

@@ -132,7 +132,7 @@ export class ObservationFeed {
             ...metadata,
             text: observation.text,
             truncated: observation.truncated,
-            ...(options.tree === true ? { tree: projectTree(observation.tree, this.runtime.redact, this.runtime.app.base?.origin) } : {}),
+            ...(options.tree === true ? { tree: projectTree(observation.tree, this.runtime.app.base?.origin) } : {}),
             ...pixels,
         };
     }
@@ -197,8 +197,7 @@ export class ObservationFeed {
      * queued observation would wait on its own caller.
      */
     async relocate(stale) {
-        const options = { redact: this.runtime.redact };
-        const descriptor = describeTarget(stale, options.redact);
+        const descriptor = describeTarget(stale);
         if (descriptor === undefined)
             return undefined;
         this.accounting.checkpoint();
@@ -206,7 +205,7 @@ export class ObservationFeed {
         this.publish(observation);
         if (observation.kind === 'pixels')
             return undefined;
-        const relocated = relocateDescriptor(descriptor, observation.nodes, options);
+        const relocated = relocateDescriptor(descriptor, observation.nodes);
         if (relocated.kind !== 'found')
             return undefined;
         const node = observation.nodes.get(relocated.id);
@@ -307,14 +306,13 @@ export class ObservationFeed {
     async capture(pixels) {
         this.opening = undefined;
         const raw = await retryingObserve({
-            observe: (operation) => this.runtime.engine.session.observe(operation, {
-                pixels,
-                pixelFallback: !this.runtime.exposure.withholdsPixels,
-            }),
+            observe: (operation, pixelFallback) => this.runtime.engine.session.observe(operation, { pixels, pixelFallback }),
             operation: () => this.accounting.operation(),
             guard: (cause) => this.accounting.checkpoint(cause),
             signal: this.runtime.engine.signal,
             api: this.accounting.api,
+            fallback: true,
+            tainted: () => this.runtime.exposure.withholdsPixels,
         });
         if (raw.kind === 'pixels') {
             this.semanticHistory = false;
@@ -376,11 +374,10 @@ export class ObservationFeed {
         const earlier = this.lastSeen(id)?.node;
         if (earlier === undefined)
             return undefined;
-        const options = { redact: this.runtime.redact };
-        const descriptor = describeTarget(earlier, options.redact);
+        const descriptor = describeTarget(earlier);
         if (descriptor === undefined)
             return undefined;
-        const relocated = relocateDescriptor(descriptor, latest.nodes, options);
+        const relocated = relocateDescriptor(descriptor, latest.nodes);
         return relocated.kind === 'found' ? latest.nodes.get(relocated.id) : undefined;
     }
 }