taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/application/generation/generation-step-executor.d.ts

@@ -2,12 +2,15 @@ import { type PendingConfirmation } from "../../domain/generation.js";
 import { type JourneyStep } from "../../domain/journey.js";
 import { type ProposedStep } from "../../domain/proposed-step.js";
 import { type RuntimeSnapshot } from "../../domain/runtime-snapshot.js";
-import type { AdbPort } from "../../ports/adb.js";
-import type { AndroidCliPort } from "../../ports/android-cli.js";
 import type { Clock } from "../../ports/clock.js";
+import type { RuntimeSessionOpener } from "../../ports/runtime-backend.js";
+import type { RuntimeSessionPortViews, RuntimeSessionPortViewsFactory } from "../../ports/runtime-session-ports.js";
 import type { GenerationSessionStore } from "../../ports/generation-session-store.js";
+import type { UiSnapshotProvider } from "../../ports/ui-snapshot.js";
+import type { ExternalFlowResolution } from "../journey/external-flow-resolver.js";
 import { type IdleConfig } from "../wait/idle-waiter.js";
 import type { SnapshotReobservationGuard } from "./runtime-observer.js";
+import type { CollectedRuntimeState, RuntimeObservation } from "./runtime-observer.js";
 export type GenerationCandidateSource = "planner" | "manualOverride";
 export interface GenerationStepExecutionInput {
     generationId: string;
@@ -19,34 +22,93 @@ export interface GenerationStepExecutionInput {
 export interface GenerationStepFailure {
     code: string;
     message: string;
+    details?: unknown;
+}
+export interface GenerationStepTiming {
+    freshnessCheckMs: number;
+    evidenceSetupMs: number;
+    logcatStartMs: number;
+    preActionObservationMs: number;
+    actionExecutionMs: number;
+    idleWaitMs: number;
+    postActionObservationMs: number;
+    expectationMs: number;
+    logcatStopMs: number;
+    totalMs: number;
+    nextObservationMs?: number | undefined;
 }
 export type GenerationStepExecutionResult = {
     status: "succeeded";
     step: JourneyStep;
+    timing?: GenerationStepTiming | undefined;
+    nextObservation?: RuntimeObservation | undefined;
+    nextObservationFailure?: GenerationStepFailure | undefined;
 } | {
     status: "failed";
     failure: GenerationStepFailure;
+    timing?: GenerationStepTiming | undefined;
 } | {
     status: "cancelled";
     failure: GenerationStepFailure;
+    timing?: GenerationStepTiming | undefined;
 };
 export interface GenerationStepExecutorDependencies {
     store: Pick<GenerationSessionStore, "read" | "beginStep" | "completeStep" | "update" | "writeEvidence" | "writeTextEvidence">;
-    freshnessGuard: Pick<SnapshotReobservationGuard, "assertFresh">;
-    adb: AdbPort;
-    androidCli: AndroidCliPort;
+    freshnessGuard?: Pick<SnapshotReobservationGuard, "assertFresh"> | undefined;
+    createFreshnessGuard?: ((uiSnapshotProvider: UiSnapshotProvider, views: RuntimeSessionPortViews) => Pick<SnapshotReobservationGuard, "assertFresh">) | undefined;
+    views?: RuntimeSessionPortViews | undefined;
+    sessions?: RuntimeSessionOpener | undefined;
+    sessionPorts?: RuntimeSessionPortViewsFactory | undefined;
+    uiSnapshotProvider?: UiSnapshotProvider | undefined;
+    uiCacheEnabled?: boolean | undefined;
     clock: Clock;
     idle: IdleConfig;
     now: () => Date;
     generateAttemptId: () => string;
+    projectRoot: string;
+    externalFlowResolver?: {
+        resolve: (input: {
+            projectRoot: string;
+            name: string;
+        }) => Promise<ExternalFlowResolution>;
+    } | undefined;
     clearApprovedConfirmation: (generationId: string, challenge: PendingConfirmation) => Promise<void>;
+    observeNext?: (input: {
+        generationId: string;
+        runtime: CollectedRuntimeState;
+        signal?: AbortSignal | undefined;
+    }) => Promise<RuntimeObservation>;
 }
 export declare class GenerationStepExecutor {
     private readonly dependencies;
     private readonly riskEvaluator;
+    private currentViewport;
+    private currentUiSnapshot;
     constructor(dependencies: GenerationStepExecutorDependencies);
+    private boundUiSnapshotProvider;
+    private boundViews;
+    private requireCurrentViewport;
+    private requireCurrentUiSnapshot;
+    private captureLayout;
     readonly execute: (input: GenerationStepExecutionInput) => Promise<GenerationStepExecutionResult>;
+    /**
+     * The freshness guard captured this Layout and proved it equals the
+     * authoritative binding hash, and nothing mutates the device between that
+     * capture and the pre-action observation, so re-capturing it would only
+     * repeat the most expensive device call of the step.
+     */
+    private adoptFreshSnapshotUi;
+    /**
+     * The post-action runtime after a passing expectation: an `element`
+     * expectation already observed it, and a proven `activity` expectation on
+     * the post-action Activity adds nothing to re-observe. Otherwise the
+     * settled foreground is observed again.
+     */
+    private settledExpectationRuntime;
     private observeLive;
     private assertForegroundIdentity;
     private markRecovery;
+    /** Resolves and validates the bound External Flow for the escaped app. */
+    private resolveExternalFlow;
+    private externalStepRunner;
 }