@yaag/runtime 0.1.0

package/src/ask-exchange.ts

@@ -0,0 +1,291 @@
+import { AskActivityTracker } from "./ask-activity.ts";
+import { AskEvents } from "./ask-exchange-events.ts";
+import type { AskExchangeOptions } from "./ask-exchange-options.ts";
+import { askHash, askMarkerContext, structuredOutputContract } from "./ask-hash.ts";
+import { AskLimit } from "./ask-limit.ts";
+import { resolvePlaybackAskOutput } from "./ask-output.ts";
+import { AskOutputSteering } from "./ask-output-steering.ts";
+import { AskOutputTail } from "./ask-output-tail.ts";
+import { awaitAskSettlement } from "./ask-settlement.ts";
+import { AskTurn } from "./ask-turn.ts";
+import {
+  type AskLimitOutcome,
+  type AskStalledOutcome,
+  agentError,
+  askLimitError,
+  askStalledError,
+  isYaagError,
+} from "./errors.ts";
+import { FrameGapTracker } from "./frame-gap.ts";
+import { IdleKillSignal, IdleWatch } from "./idle-watch.ts";
+import { NodeTracker } from "./node-tracker.ts";
+import type { AskPlayback } from "./transport.ts";
+
+export type { AskExchangeOptions } from "./ask-exchange-options.ts";
+/** Runs one Ask's transport exchange, including controls and structured-output correction. */
+export async function exchangeAsk(options: AskExchangeOptions): Promise<unknown> {
+  return new AskExchange(options).run();
+}
+class AskExchange {
+  readonly #options: AskExchangeOptions;
+  readonly #turn = new AskTurn();
+  readonly #events: AskEvents;
+  #limit: AskLimit | null = null;
+  #idle: IdleWatch | null = null;
+  #gap: FrameGapTracker | null = null;
+  #activity: AskActivityTracker | null = null;
+  #output: AskOutputTail | null = null;
+  #nodes: NodeTracker | null = null;
+  #playback: AskPlayback | undefined;
+  #began = false;
+  #outcome: AskLimitOutcome | undefined;
+  #stalled: AskStalledOutcome | undefined;
+  #invalidOutput: { readonly kind: "invalid_output"; readonly steeringEfforts: number } | undefined;
+  #onSettled: () => void = () => {};
+  #controlFailure: Promise<never> = new Promise<never>(() => {});
+  #timeoutDeadline: number | undefined;
+  #maxFrameGapMs: number | undefined;
+  constructor(options: AskExchangeOptions) {
+    this.#options = options;
+    this.#events = new AskEvents(options.emit, options.agent, options.index);
+  }
+
+  async run(): Promise<unknown> {
+    const startedAt = Date.now();
+    try {
+      const result = await this.#exchange();
+      this.#events.end(Date.now() - startedAt, true, this.#maxFrameGapMs);
+      return result;
+    } catch (error) {
+      if (this.#began) this.#events.end(Date.now() - startedAt, false, this.#maxFrameGapMs);
+      throw error;
+    }
+  }
+
+  async #exchange(): Promise<unknown> {
+    try {
+      this.#begin();
+      const settled = this.#armSettlement();
+      this.#timeoutDeadline = this.#deadline();
+      await this.#sendPrompt();
+      await this.#verify(settled);
+      const abortSettled =
+        this.#playback?.awaitsAbortSettlement === true ? this.#armSettlement() : undefined;
+      let result: unknown;
+      let outputError: unknown;
+      try {
+        result = await this.#resolveOutput(await this.#lastAssistantText());
+      } catch (error) {
+        if (abortSettled === undefined) throw error;
+        outputError = error;
+      }
+      if (abortSettled !== undefined) await this.#verify(abortSettled, true);
+      if (outputError !== undefined) throw outputError;
+      return result;
+    } catch (error) {
+      this.#recordInvalidOutput(error);
+      throw error;
+    } finally {
+      this.#cleanup();
+    }
+  }
+
+  #begin(): void {
+    const outputContract = structuredOutputContract(this.#options.ask);
+    const identity = {
+      spawnOptions: this.#options.spawnOptions,
+      index: this.#options.index,
+      prompt: this.#options.prompt,
+      ask: this.#options.ask,
+      ...(outputContract === undefined ? {} : { outputContract }),
+    };
+    const playback = this.#options.transport.beginAsk({
+      index: this.#options.index,
+      hash: askHash(identity),
+      ...(outputContract === undefined ? {} : outputContract),
+      ...(this.#options.definitionName === undefined
+        ? {}
+        : { definitionName: this.#options.definitionName, context: askMarkerContext(identity) }),
+    });
+    this.#began = true;
+    this.#playback = playback;
+    this.#events.start(this.#options.prompt, playback !== undefined);
+    this.#gap = playback === undefined ? new FrameGapTracker() : null;
+    this.#activity = playback === undefined ? new AskActivityTracker(this.#events.activity) : null;
+    this.#output =
+      playback === undefined ? new AskOutputTail({ report: this.#events.output }) : null;
+    // Deliberately not gated on live execution, unlike the trackers above: a
+    // Nested Node is decoded from recorded Agent frames only, so playback must
+    // re-derive the identical `node_update` stream (ADR-0013, spec §3).
+    this.#nodes = new NodeTracker({ report: this.#events.node });
+    this.#limit = playback === undefined ? this.#createLimit() : null;
+    this.#idle = playback === undefined ? this.#createIdleWatch() : null;
+    this.#observe();
+    this.#limit?.start();
+    this.#idle?.start();
+    this.#gap?.start();
+    this.#controlFailure = this.#createControlFailure();
+  }
+
+  #createLimit(): AskLimit {
+    return new AskLimit({
+      ask: this.#options.ask,
+      durationGraceMs: this.#options.askLimitGraceMs,
+      command: async (frame) => (await this.#options.connection.command(frame)).success,
+    });
+  }
+
+  #createIdleWatch(): IdleWatch | null {
+    if (this.#options.ask.idleMs === undefined) return null;
+    return new IdleWatch({
+      idleMs: this.#options.ask.idleMs,
+      ...(this.#options.idleAbortSettleMs === undefined
+        ? {}
+        : { abortSettleMs: this.#options.idleAbortSettleMs }),
+      command: async (frame) => (await this.#options.connection.command(frame)).success,
+    });
+  }
+
+  #observe(): void {
+    this.#options.connection.observe((frame) => {
+      this.#turn.observe(frame);
+      this.#limit?.observe(frame);
+      if (frame.type !== "agent_settled" || this.#idle?.tripped) this.#idle?.observe(frame);
+      this.#gap?.observe();
+      this.#activity?.observe(frame);
+      this.#output?.observe(frame);
+      this.#nodes?.observe(frame);
+      if (this.#playback === undefined) this.#options.usage.observe(frame);
+      if (this.#turn.settled) this.#onSettled();
+    });
+  }
+
+  #createControlFailure(): Promise<never> {
+    const controls = [this.#limit?.failed, this.#idle?.failed, this.#idle?.killed].filter(
+      (promise): promise is Promise<never> => promise !== undefined,
+    );
+    return Promise.race(controls.length === 0 ? [new Promise<never>(() => {})] : controls).catch(
+      (error: unknown) => {
+        if (error instanceof IdleKillSignal)
+          throw askStalledError(this.#options.agent, error.outcome);
+        throw this.#failed(error instanceof Error ? error.message : "limit control command failed");
+      },
+    );
+  }
+
+  #armSettlement(): Promise<void> {
+    this.#turn.rearm();
+    return new Promise<void>((resolve) => {
+      this.#onSettled = resolve;
+    });
+  }
+
+  #deadline(): number | undefined {
+    return this.#options.ask.timeoutMs === undefined
+      ? undefined
+      : Date.now() + this.#options.ask.timeoutMs;
+  }
+
+  async #sendPrompt(): Promise<void> {
+    const response = await this.#options.connection.command({
+      type: "prompt",
+      message: this.#options.prompt,
+    });
+    if (!response.success) throw this.#failed(response.error ?? "prompt was rejected");
+  }
+
+  #failed(message: string): Error {
+    return agentError(this.#options.agent, "AGENT_FAILED", message);
+  }
+
+  async #verify(settled: Promise<void>, ignoreAbortFailure = false): Promise<void> {
+    await awaitAskSettlement({
+      settled,
+      closed: this.#options.connection.closed,
+      timeoutMs:
+        this.#timeoutDeadline === undefined
+          ? undefined
+          : Math.max(0, this.#timeoutDeadline - Date.now()),
+      controlFailure: this.#controlFailure,
+      error: (code, message) => agentError(this.#options.agent, code, message),
+      close: this.#options.close,
+    });
+    this.#outcome = this.#playback?.limit ?? this.#limit?.abortOutcome ?? undefined;
+    if (this.#outcome !== undefined) throw askLimitError(this.#options.agent, this.#outcome);
+    this.#stalled = this.#playback?.stalled ?? this.#idle?.result ?? undefined;
+    if (this.#stalled !== undefined) throw askStalledError(this.#options.agent, this.#stalled);
+    const failure = this.#turn.failure();
+    if (failure !== null && !ignoreAbortFailure) throw this.#failed(failure);
+  }
+
+  async #lastAssistantText(): Promise<string> {
+    const response = await this.#options.connection.command({ type: "get_last_assistant_text" });
+    const text: unknown = response.data?.text;
+    if (typeof text !== "string" || text.trim() === "") {
+      throw this.#failed("agent settled without producing any text");
+    }
+    return text;
+  }
+
+  async #resolveOutput(text: string): Promise<unknown> {
+    if (!("outputSchema" in this.#options.ask)) return text;
+    if (this.#playback !== undefined) {
+      return resolvePlaybackAskOutput(
+        this.#options.agent,
+        this.#options.ask.outputSchema,
+        text,
+        this.#playback.outcome,
+      );
+    }
+    return new AskOutputSteering({
+      agent: this.#options.agent,
+      schema: this.#options.ask.outputSchema,
+      maxSteers: this.#options.ask.maxSteers,
+      beginCorrection: () => this.#limit?.enterOutputCorrection() ?? true,
+      wrappingUp: () => this.#limit?.tripped ?? false,
+      correct: async (message) => this.#correct(message),
+      abort: async () => this.#abort(),
+    }).resolve(text);
+  }
+
+  // A follow-up prompt within the same logical Ask: real pi parks a post-settlement
+  // steer behind queue_update and never starts a correction turn (ADR-0027 amendment).
+  async #correct(message: string): Promise<string> {
+    try {
+      const settled = this.#armSettlement();
+      const response = await this.#options.connection.command({ type: "prompt", message });
+      if (!response.success) throw this.#failed(response.error ?? "correction prompt was rejected");
+      await this.#verify(settled);
+      return await this.#lastAssistantText();
+    } finally {
+      this.#limit?.leaveOutputCorrection();
+    }
+  }
+
+  async #abort(): Promise<void> {
+    const settled = this.#armSettlement();
+    const response = await this.#options.connection.command({ type: "abort" });
+    if (!response.success) throw this.#failed(response.error ?? "abort was rejected");
+    await this.#verify(settled, true);
+  }
+
+  #recordInvalidOutput(error: unknown): void {
+    if (this.#playback === undefined && isYaagError(error) && error.code === "ASK_INVALID_OUTPUT")
+      this.#invalidOutput = { kind: "invalid_output", steeringEfforts: error.steeringEfforts ?? 0 };
+  }
+
+  #cleanup(): void {
+    this.#maxFrameGapMs = this.#gap?.maxGapMs;
+    this.#stalled ??= this.#idle?.result ?? undefined;
+    this.#limit?.cleanup();
+    this.#idle?.cleanup();
+    this.#output?.close();
+    this.#options.connection.observe(null);
+    if (!this.#began) return;
+    try {
+      this.#options.transport.finishAsk(this.#outcome, this.#stalled, this.#invalidOutput);
+    } catch {
+      // Recording must not hide the Ask outcome it was observing.
+    }
+  }
+}

package/src/ask-hash.ts

@@ -0,0 +1,86 @@
+import type { TSchema } from "typebox";
+import { type AskOutputContract, createAskOutputContract } from "./ask-contract-identity.ts";
+import type { AskMarkerContext } from "./transport.ts";
+import type { AskOptions, SpawnOptions, StructuredAskOptions } from "./types.ts";
+
+/** The combined option shape used internally after Definition defaults merge. */
+export type EffectiveAskOptions = AskOptions | StructuredAskOptions<TSchema>;
+
+/** Inputs that identify an Ask in a Cassette. */
+export interface AskHashOptions {
+  readonly spawnOptions: SpawnOptions;
+  readonly index: number;
+  readonly prompt: string;
+  /** Soft-limit behavior and structured output contract, unlike timeoutMs, identify replay. */
+  readonly ask?: EffectiveAskOptions;
+  /** Precomputed once so marker metadata and hashing cannot drift. */
+  readonly outputContract?: AskOutputContract;
+}
+
+/**
+ * Identity of one Ask: sha256 over the prompt and behavioral Agent/Ask options.
+ *
+ * The optional canonical output schema, explicit steer bound, and extraction
+ * policy identify schema-bearing Asks. `timeoutMs` remains excluded.
+ */
+export function askHash(options: AskHashOptions): string {
+  const { spawnOptions, index, prompt, ask } = options;
+  const outputContract = options.outputContract ?? structuredOutputContract(ask);
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(
+    JSON.stringify({
+      cwd: spawnOptions.cwd ?? null,
+      model: spawnOptions.model ?? null,
+      systemPrompt: spawnOptions.systemPrompt ?? null,
+      ...(spawnOptions.thinking === undefined ? {} : { thinking: spawnOptions.thinking }),
+      ...(spawnOptions.appendSystemPrompt === undefined
+        ? {}
+        : { appendSystemPrompt: spawnOptions.appendSystemPrompt }),
+      ...(spawnOptions.worktree === true ? { worktree: true } : {}),
+      index,
+      prompt,
+      ...(ask?.maxTurns === undefined ? {} : { maxTurns: ask.maxTurns }),
+      ...(ask?.maxToolCalls === undefined ? {} : { maxToolCalls: ask.maxToolCalls }),
+      ...(ask?.maxDurationMs === undefined ? {} : { maxDurationMs: ask.maxDurationMs }),
+      ...(ask?.idleMs === undefined ? {} : { idleMs: ask.idleMs }),
+      ...(ask?.wrapUpPrompt === undefined ? {} : { wrapUpPrompt: ask.wrapUpPrompt }),
+      ...(outputContract === undefined ? {} : outputContract),
+    }),
+  );
+  return hasher.digest("hex");
+}
+
+/**
+ * Retains Ask hash inputs for Definition-backed Cassette divergence diagnostics.
+ *
+ * `timeoutMs` remains excluded. Structured output schemas, explicit steer bounds,
+ * and extraction policy are retained because they participate in `askHash`.
+ */
+export function askMarkerContext({
+  spawnOptions,
+  prompt,
+  ask,
+  outputContract = structuredOutputContract(ask),
+}: AskHashOptions): AskMarkerContext {
+  const { name: _name, worktree: _worktree, ...spawn } = spawnOptions;
+  return {
+    prompt,
+    spawn: { ...spawn, ...(_worktree === true ? { worktree: true } : {}) },
+    ask: {
+      ...(ask?.maxTurns === undefined ? {} : { maxTurns: ask.maxTurns }),
+      ...(ask?.maxToolCalls === undefined ? {} : { maxToolCalls: ask.maxToolCalls }),
+      ...(ask?.maxDurationMs === undefined ? {} : { maxDurationMs: ask.maxDurationMs }),
+      ...(ask?.idleMs === undefined ? {} : { idleMs: ask.idleMs }),
+      ...(ask?.wrapUpPrompt === undefined ? {} : { wrapUpPrompt: ask.wrapUpPrompt }),
+      ...(outputContract === undefined ? {} : outputContract),
+    },
+  };
+}
+
+/** Creates structured identity only when the Ask explicitly carries a schema. */
+export function structuredOutputContract(
+  ask: EffectiveAskOptions | undefined,
+): AskOutputContract | undefined {
+  if (ask === undefined || !("outputSchema" in ask)) return undefined;
+  return createAskOutputContract(ask.outputSchema, ask.maxSteers);
+}

package/src/ask-limit.ts

@@ -0,0 +1,189 @@
+import type { AskLimitKind, AskLimitOutcome } from "./errors.ts";
+import type { Frame } from "./transport.ts";
+import type { AskOptions } from "./types.ts";
+
+/** The message sent when an Ask uses its allotted soft budget. */
+export const DEFAULT_WRAP_UP_PROMPT = "Please wrap up now and provide your final answer.";
+/** Fixed time allowed to conclude after a duration limit trips. */
+export const ASK_LIMIT_DURATION_GRACE_MS = 5_000;
+
+export interface AskLimitOptions {
+  readonly ask: AskOptions;
+  readonly command: (frame: Frame) => Promise<boolean>;
+  readonly durationGraceMs?: number;
+  readonly now?: () => number;
+}
+
+/**
+ * Per-Ask soft-limit controller.
+ *
+ * A budget trips at equality. The triggering turn is allowed to finish and one
+ * later `turn_start` is grace, because pi delivers steering between turns.
+ */
+export class AskLimit {
+  readonly #ask: AskOptions;
+  readonly #command: (frame: Frame) => Promise<boolean>;
+  readonly #durationGraceMs: number;
+  readonly #now: () => number;
+  readonly #failure: Promise<string>;
+  #rejectFailure: (reason: string) => void = () => {};
+  #startedAt = 0;
+  #monitoring = false;
+  #completed = false;
+  #correctingOutput = false;
+  #turns = 0;
+  #toolCalls = 0;
+  #trip: AskLimitOutcome | null = null;
+  #turnsAtSteer = 0;
+  #aborted = false;
+  #durationTimer: ReturnType<typeof setTimeout> | undefined;
+  #graceTimer: ReturnType<typeof setTimeout> | undefined;
+
+  constructor(options: AskLimitOptions) {
+    this.#ask = options.ask;
+    this.#command = options.command;
+    this.#durationGraceMs = options.durationGraceMs ?? ASK_LIMIT_DURATION_GRACE_MS;
+    this.#now = options.now ?? Date.now;
+    this.#failure = new Promise<string>((_resolve, reject) => {
+      this.#rejectFailure = reject;
+    });
+    // Commands can fail before the Ask starts awaiting this race.
+    void this.#failure.catch(() => {});
+  }
+
+  /** Starts wall-clock accounting immediately before the prompt command is sent. */
+  start(): void {
+    this.#startedAt = this.#now();
+    if (this.#ask.maxDurationMs === undefined) return;
+    this.#durationTimer = setTimeout(() => {
+      this.#tripLimit("durationMs", this.#now() - this.#startedAt);
+    }, this.#ask.maxDurationMs);
+  }
+
+  /** Observes frames without changing their interpretation for the Ask itself. */
+  observe(frame: Frame): void {
+    if (this.#completed) return;
+    if (!this.#monitoring) {
+      if (frame.type === "agent_start") this.#monitoring = true;
+      return;
+    }
+    if (this.#correctingOutput) return;
+    if (frame.type === "turn_start") {
+      this.#turns += 1;
+      if (this.#trip !== null) {
+        if (this.#turns > this.#turnsAtSteer + 1) this.#abort();
+      } else if (this.#ask.maxTurns !== undefined && this.#turns >= this.#ask.maxTurns) {
+        this.#tripLimit("turns", this.#turns);
+      }
+      return;
+    }
+    if (
+      frame.type === "tool_execution_start" &&
+      this.#trip === null &&
+      this.#ask.maxToolCalls !== undefined
+    ) {
+      this.#toolCalls += 1;
+      if (this.#toolCalls >= this.#ask.maxToolCalls) this.#tripLimit("toolCalls", this.#toolCalls);
+      return;
+    }
+    if (frame.type === "tool_execution_start") this.#toolCalls += 1;
+  }
+
+  /**
+   * Enters one output-contract correction effort when no limit is wrapping up.
+   *
+   * Returns false after a limit has tripped, so callers never reopen its grace
+   * window with a validator steer.
+   */
+  enterOutputCorrection(): boolean {
+    if (this.#completed || this.#trip !== null) return false;
+    this.#correctingOutput = true;
+    return true;
+  }
+
+  /** Leaves an output-contract correction effort after its text was retrieved. */
+  leaveOutputCorrection(): void {
+    this.#correctingOutput = false;
+  }
+
+  /** Cancels timers when the whole logical Ask reaches a terminal result. */
+  settled(): void {
+    if (this.#completed) return;
+    this.#completed = true;
+    this.#correctingOutput = false;
+    clearTimeout(this.#durationTimer);
+    clearTimeout(this.#graceTimer);
+    this.#durationTimer = undefined;
+    this.#graceTimer = undefined;
+  }
+
+  /** Cancels timers on every other Ask exit path. Idempotent. */
+  cleanup(): void {
+    this.settled();
+  }
+
+  /** Rejects when a steer or abort RPC is refused. */
+  get failed(): Promise<never> {
+    return this.#failure.then(
+      () => {
+        throw new Error("unreachable");
+      },
+      (error: unknown) => Promise.reject(error),
+    );
+  }
+
+  /** True once a limit has sent its wrap-up steer and owns the grace window. */
+  get tripped(): boolean {
+    return this.#trip !== null;
+  }
+
+  /** Present only after yaag itself has sent the limit abort command. */
+  get abortOutcome(): AskLimitOutcome | null {
+    return this.#aborted ? this.#trip : null;
+  }
+
+  #tripLimit(kind: AskLimitKind, count: number): void {
+    if (this.#completed || this.#trip !== null) return;
+    this.#trip = { kind, count };
+    this.#turnsAtSteer = this.#turns;
+    void this.#send({ type: "steer", message: this.#ask.wrapUpPrompt ?? DEFAULT_WRAP_UP_PROMPT });
+    if (kind === "durationMs") {
+      this.#graceTimer = setTimeout(() => this.#abort(), this.#durationGraceMs);
+    }
+  }
+
+  #abort(): void {
+    if (this.#completed || this.#aborted || this.#trip === null) return;
+    void this.#sendAbort();
+  }
+
+  async #sendAbort(): Promise<void> {
+    if (this.#completed || this.#aborted || this.#trip === null) return;
+    // `command()` writes synchronously; latch before its response can race settlement.
+    this.#aborted = true;
+    try {
+      if (!(await this.#command({ type: "abort" }))) {
+        this.#rejectFailure("limit control command was rejected");
+        return;
+      }
+    } catch (error) {
+      this.#rejectFailure(
+        error instanceof Error
+          ? `limit control command failed: ${error.message}`
+          : "limit control command failed",
+      );
+    }
+  }
+
+  async #send(frame: Frame): Promise<void> {
+    try {
+      if (!(await this.#command(frame))) this.#rejectFailure("limit control command was rejected");
+    } catch (error) {
+      this.#rejectFailure(
+        error instanceof Error
+          ? `limit control command failed: ${error.message}`
+          : "limit control command failed",
+      );
+    }
+  }
+}

package/src/ask-output-steering.ts

@@ -0,0 +1,69 @@
+import type { TSchema } from "typebox";
+import {
+  formatAskOutputCorrection,
+  invalidAskOutputError,
+  validateAskOutput,
+} from "./ask-output.ts";
+
+/** The per-Ask bound when a structured Ask omits `maxSteers`. */
+export const DEFAULT_MAX_STEERS = 3;
+
+export interface AskOutputSteeringOptions {
+  readonly agent: string;
+  readonly schema: TSchema;
+  readonly maxSteers: number | undefined;
+  /** Atomically enters a correction effort, or false after a limit starts wrap-up. */
+  readonly beginCorrection: () => boolean;
+  /** True once a soft limit has sent its wrap-up steer. */
+  readonly wrappingUp: () => boolean;
+  /** Re-arms settlement tracking, sends the steer, and returns its settled text. */
+  readonly correct: (message: string) => Promise<string>;
+  /** Re-arms settlement tracking, sends abort, and waits for its settlement. */
+  readonly abort: () => Promise<void>;
+}
+
+/**
+ * Validates structured output and corrects it without creating another logical Ask.
+ *
+ * Control-command failures propagate from `correct` or `abort` as Agent failures,
+ * rather than being reported as invalid-output exhaustion.
+ */
+export class AskOutputSteering {
+  readonly #agent: string;
+  readonly #schema: TSchema;
+  readonly #maxSteers: number;
+  readonly #beginCorrection: () => boolean;
+  readonly #wrappingUp: () => boolean;
+  readonly #correct: (message: string) => Promise<string>;
+  readonly #abort: () => Promise<void>;
+
+  constructor(options: AskOutputSteeringOptions) {
+    this.#agent = options.agent;
+    this.#schema = options.schema;
+    this.#maxSteers = options.maxSteers ?? DEFAULT_MAX_STEERS;
+    this.#beginCorrection = options.beginCorrection;
+    this.#wrappingUp = options.wrappingUp;
+    this.#correct = options.correct;
+    this.#abort = options.abort;
+  }
+
+  /** Resolves a valid parsed value or rejects after the abort settlement on exhaustion. */
+  async resolve(text: string): Promise<unknown> {
+    let efforts = 0;
+    let result = validateAskOutput(text, this.#schema);
+    while (!result.ok && efforts < this.#maxSteers) {
+      if (!this.#beginCorrection()) throw this.#invalidAfterWrapUp(result.errors);
+      efforts += 1;
+      text = await this.#correct(formatAskOutputCorrection(result.errors));
+      result = validateAskOutput(text, this.#schema);
+    }
+    if (result.ok) return result.value;
+    if (this.#wrappingUp()) throw this.#invalidAfterWrapUp(result.errors);
+    await this.#abort();
+    throw invalidAskOutputError(this.#agent, { steeringEfforts: efforts, errors: result.errors });
+  }
+
+  #invalidAfterWrapUp(errors: readonly string[]): Error {
+    return invalidAskOutputError(this.#agent, { steeringEfforts: 0, errors });
+  }
+}