@visual-z/xeno 0.6.0 → 0.7.0

package/src/core/session-exit.ts

@@ -0,0 +1,26 @@
+/** D8 / D11: terminal exit is a bounded projection of execution facts, never a replay. */
+import type { LogEvent } from "./events.ts";
+import { pendingToolCalls } from "./execution.ts";
+import { modelOutcome } from "./outcome.ts";
+
+export const DEFAULT_FULLSCREEN_EXIT_OUTPUT = "resume-hint";
+
+/** Terminal controls and arbitrarily large reason text do not own the shell surface. */
+export function exitLine(text: string, limit = 180): string {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim().slice(0, limit);
+}
+
+export function sessionExitStatus(events: readonly LogEvent[]): string {
+  const start = events.findLastIndex(event => event.t === "user");
+  const current = events.slice(Math.max(0, start));
+  const outcome = current.findLast(event => event.t === "outcome" || event.t === "user_bash");
+  if (outcome?.t === "outcome") return exitLine(`${outcome.outcome.status} · ${outcome.outcome.reason} · ${outcome.reason}`);
+  if (outcome?.t === "user_bash") return `${outcome.outcome.status} · ${outcome.outcome.reason} · command exit ${outcome.exit}`;
+  if (current.some(event => event.t === "interrupt")) return "cancelled · user interrupted";
+  const assistant = current.findLast(event => event.t === "assistant");
+  if (assistant?.t === "assistant" && !assistant.blocks.some(block => block.type === "tool_use") && pendingToolCalls(current).length === 0) {
+    const result = modelOutcome(assistant.stop_reason ?? null);
+    return result.reason === "model_end" ? "model finished · verification remains in session evidence" : `${result.status} · ${result.reason}`;
+  }
+  return start < 0 ? "session saved" : "unfinished · inspect recorded receipts before continuing";
+}

package/src/core/settings.ts

@@ -99,7 +99,7 @@ export const DISPLAY_SETTINGS = [
   { id: "images.blockImages", label: "Block image transmission", fallback: "off" },
   { id: "markdown.mermaid", label: "Mermaid diagrams", fallback: "streaming" },
   { id: "tuiMode", label: "TUI mode", fallback: "fullscreen" },
-  { id: "fullscreenExitOutput", label: "Fullscreen exit output", fallback: "transcript" },
+  { id: "fullscreenExitOutput", label: "Fullscreen exit output", fallback: "resume-hint" },
   { id: "fullscreenScrollbar", label: "Fullscreen scrollbar", fallback: "hidden" },
   { id: "fullscreenCopyOnSelect", label: "Copy on select", fallback: "on" },
   { id: "fullscreenWheelScrollLines", label: "Fullscreen wheel scroll lines", fallback: "auto" },

package/src/core/stall.ts

@@ -3,6 +3,7 @@ import type { LogEvent } from "./events.ts";
 import { pendingToolCalls } from "./execution.ts";
 import { exchangeProgressChecks } from "./evidence.ts";
 import { deriveProgress, type ProgressEvidence } from "./progress.ts";
+import { isProcessReceipt } from "./process-receipt.ts";
 
 // A conservative hypothesis: enough room to change method after a mid-budget
 // notice, while bounding repeated paid requests. Not a task-quality classifier.
@@ -12,18 +13,27 @@ export interface StallState {
   pending: readonly LogEvent[];
   pendingNode: number;
   consecutive: number;
+  unproductive: number;
+  failures: number;
+  emptyWaits: number;
   warned: boolean;
 }
 export function emptyStallState(): StallState {
-  return { evidence: [], pending: [], pendingNode: 0, consecutive: 0, warned: false };
+  return { evidence: [], pending: [], pendingNode: 0, consecutive: 0, unproductive: 0, failures: 0, emptyWaits: 0, warned: false };
 }
 export function finishStallExchange(state: StallState): StallState {
   const assistant = state.pending[0];
   if (assistant?.t !== "assistant" || pendingToolCalls(state.pending).length > 0) return state;
   if (!assistant.blocks.some((block) => block.type === "tool_use")) return { ...state, pending: [] };
   const progress = deriveProgress(state.evidence, state.pending, state.pendingNode, exchangeProgressChecks(state.pending));
+  const results = state.pending.filter(event => event.t === "tool_result");
+  const waits = new Set(assistant.blocks.flatMap(block => block.type === "tool_use" && block.name === "write_stdin" ? [block.call_id] : []));
   return { ...state, pending: [], evidence: progress.evidence,
-    consecutive: progress.progressed ? 0 : state.consecutive + 1, warned: progress.progressed ? false : state.warned };
+    consecutive: progress.progressed ? 0 : state.consecutive + 1,
+    unproductive: state.unproductive + (progress.progressed ? 0 : 1),
+    failures: state.failures + results.filter(result => !result.ok).length,
+    emptyWaits: state.emptyWaits + results.filter(result => waits.has(result.call_id) && isProcessReceipt(result.data) &&
+      result.data.running === true && result.data.cursor !== undefined && result.data.cursor.start === result.data.cursor.end).length };
 }
 
 /** Fold original events, never the retained projection where evidence can repeat. */
@@ -32,7 +42,7 @@ export function advanceStall(state: StallState, entries: readonly { node: number
   for (const { node, event } of entries) {
     if (event.t === "assistant" || event.t === "user" || event.t === "cut" || (event.t === "guidance" && event.reason === "stall")) {
       result = finishStallExchange(result);
-      if (event.t === "user") result = { ...result, pending: [], consecutive: 0, warned: false };
+      if (event.t === "user") result = { ...result, pending: [], consecutive: 0, unproductive: 0, failures: 0, emptyWaits: 0, warned: false };
       if (event.t === "assistant") result = { ...result, pending: [event], pendingNode: node };
       if (event.t === "guidance") result = { ...result, warned: true };
     } else if (result.pending.length > 0) result = { ...result, pending: [...result.pending, event] };
@@ -42,7 +52,9 @@ export function advanceStall(state: StallState, entries: readonly { node: number
 export function stallDecision(state: StallState, limit: number) {
   if (!Number.isSafeInteger(limit) || limit < 0 || limit === 1) throw new RangeError("stall limit must be zero or an integer of at least two");
   const current = finishStallExchange(state);
-  return { consecutive: current.consecutive,
-    stop: limit > 0 && current.consecutive >= limit,
-    warn: limit > 0 && current.consecutive >= Math.max(1, Math.floor(limit / 2)) && !current.warned };
+  // Reuse the existing conservative allowance. Novelty resets a streak, not
+  // the request's spent no-progress budget (research Q.26); failures are diagnostics.
+  return { consecutive: current.consecutive, unproductive: current.unproductive, failures: current.failures, emptyWaits: current.emptyWaits,
+    stop: limit > 0 && (current.consecutive >= limit || current.unproductive >= limit),
+    warn: limit > 0 && current.unproductive >= Math.max(1, Math.floor(limit / 2)) && !current.warned };
 }

package/src/core/stop-report.ts

@@ -0,0 +1,25 @@
+/** D8 / D11: summarize termination mechanically; assistant claims never become receipts. */
+import type { LogEvent } from "./events.ts";
+import { isProcessReceipt, latestProcessReceipt } from "./process-receipt.ts";
+import { exitLine } from "./session-exit.ts";
+
+export function stopReport(events: readonly LogEvent[], requests: number, limit: number, cause: string): string {
+  const start = events.findLastIndex(event => event.t === "user" && event.request === undefined);
+  const current = events.slice(Math.max(0, start));
+  const results = current.filter(event => event.t === "tool_result");
+  const failures = results.filter(event => !event.ok);
+  const exits = results.filter(event => event.effect?.kind === "command" && event.effect.exit === 0).length;
+  const ids = new Set<number>();
+  for (const event of current) {
+    if (event.t === "tool_result" && isProcessReceipt(event.data)) ids.add(event.data.session_id);
+    if (event.t === "process_exit") ids.add(event.session);
+  }
+  const running = [...ids].filter(id => latestProcessReceipt([{ node: 0, events: current }], id)?.receipt.running === true);
+  return [
+    `Stopped: ${exitLine(cause)} (${requests}/${limit} model requests).`,
+    `Recorded evidence: ${results.length} tool receipts; ${exits} successful command exits; ${failures.length} failed tool receipts. Task completion is not verified by this stop.`,
+    ...(failures.length ? [`Inspect failed receipts: ${failures.slice(-3).map(event => exitLine(event.id, 80)).join(", ")}.`] : []),
+    ...(running.length ? [`Last observed running: ${running.slice(0, 3).join(", ")}${running.length > 3 ? ` (+${running.length - 3})` : ""}; inspect the process receipt before replaying a command.`] : []),
+    "Next: inspect /state or the recorded tool output, then provide a focused continuation; completed commands should not be replayed just to recover their output.",
+  ].join("\n");
+}

package/src/runtime/exec-sessions.ts

@@ -30,7 +30,7 @@ import type { CommandArtifactReceipt } from "../core/command-artifacts.ts";
 
 /** Codex's default: long enough for most commands to finish in one call. */
 export const DEFAULT_YIELD_MS = 10_000;
-/** Bounds on one wait. A longer wait is a longer silence the model cannot act in. */
+/** Bounds on a foreground poll or input send. Owned observation waits have no polling deadline. */
 export const MIN_YIELD_MS = 100;
 export const MAX_YIELD_MS = 30_000;
 /**
@@ -66,6 +66,7 @@ interface Session {
   spoolPath: string;
   queue: Promise<unknown>;
   operations: Promise<unknown>;
+  outputListeners: Set<() => void>;
   final?: TakenOutput;
   captureError?: string;
   written: number;
@@ -128,6 +129,7 @@ export function closedSession(id: number, owner?: string): ClosedSession | undef
 }
 
 function append(session: Session, chunk: Uint8Array): void {
+  if (chunk.length === 0) return;
   const bytes = chunk.slice();
   session.queue = session.queue.then(async () => {
     let offset = 0;
@@ -136,6 +138,7 @@ function append(session: Session, chunk: Uint8Array): void {
       if (bytesWritten < 1) throw new Error("process output spool made no write progress");
       offset += bytesWritten; session.written += bytesWritten;
     }
+    for (const notify of session.outputListeners) notify();
   }).catch(error => {
     session.captureError = `process output capture failed: ${String(error)}`;
     stopSession(session, "cancelled");
@@ -161,7 +164,7 @@ export async function startSession(input: {
   const exited = new Promise<void>((resolve) => { resolveExit = resolve; });
   const session = {
     id: nextId++, ...(input.owner === undefined ? {} : { owner: input.owner }), command: input.command, cwd: input.cwd, tty: input.tty, source: input.source, started: performance.now(),
-    spool, spoolPath, queue: Promise.resolve(), operations: Promise.resolve(), written: 0, read: 0,
+    spool, spoolPath, queue: Promise.resolve(), operations: Promise.resolve(), outputListeners: new Set<() => void>(), written: 0, read: 0,
     exit: null, timeoutMs: input.timeoutMs, exited, drained: Promise.resolve(),
     ...(input.artifactObserver ? { artifactObserver: input.artifactObserver } : {}),
   } as Omit<Session, "pid" | "write" | "kill" | "timer"> as Session;
@@ -282,6 +285,38 @@ async function waitSession(session: Session, yieldMs: number, signal?: AbortSign
   await session.queue;
 }
 
+export interface ObservationWait {
+  /** Steering releases this observation wait without cancelling the owned command. */
+  wake?: AbortSignal;
+  onWaiting?: (active: boolean) => void;
+}
+
+/** OMP's job owner pattern: no paid model turn merely to observe elapsed time. */
+async function waitForObservation(session: Session, signal: AbortSignal | undefined, wait: ObservationWait): Promise<void> {
+  await session.queue;
+  let notify!: () => void;
+  const changed = new Promise<void>(resolve => { notify = resolve; });
+  session.outputListeners.add(notify);
+  signal?.addEventListener("abort", notify, { once: true });
+  wait.wake?.addEventListener("abort", notify, { once: true });
+  const pending = session.exit === null && session.read === session.written && !signal?.aborted && !wait.wake?.aborted;
+  try {
+    if (pending) {
+      wait.onWaiting?.(true);
+      await Promise.race([session.exited, changed]);
+    }
+  } finally {
+    session.outputListeners.delete(notify);
+    signal?.removeEventListener("abort", notify);
+    wait.wake?.removeEventListener("abort", notify);
+    if (pending) wait.onWaiting?.(false);
+  }
+  if (signal?.aborted) stopSession(session, "cancelled");
+  if (session.stopped !== undefined) await session.exited;
+  if (session.exit !== null) await drainExitedSession(session);
+  await session.queue;
+}
+
 /**
  * Bytes printed since the previous call, archived in full. A session whose
  * exit has now been reported is closed.
@@ -325,7 +360,7 @@ async function takeOutput(session: Session, outputStore: string, previewBytes: n
 
 /** One lease covers stdin, waiting, archival and cursor commit; cancellation can interrupt a queued wait. */
 export async function pollSession(session: Session, outputStore: string, previewBytes: number, yieldMs: number,
-  chars = "", signal?: AbortSignal): Promise<TakenOutput> {
+  chars = "", signal?: AbortSignal, wait?: ObservationWait): Promise<TakenOutput> {
   const cancel = () => stopSession(session, "cancelled");
   if (signal?.aborted) cancel(); else signal?.addEventListener("abort", cancel, { once: true });
   const result = session.operations.then(async () => {
@@ -337,7 +372,8 @@ export async function pollSession(session: Session, outputStore: string, preview
       if (session.exit !== null) throw new ToolFault("not_found", "process has exited; input was not sent; poll with empty chars", NOT_STARTED);
       session.write(chars);
     }
-    await waitSession(session, yieldMs, signal);
+    if (chars.length === 0 && wait) await waitForObservation(session, signal, wait);
+    else await waitSession(session, yieldMs, signal);
     return takeOutput(session, outputStore, previewBytes);
   });
   session.operations = result.catch(() => {});

package/src/runtime/images.ts

@@ -7,13 +7,17 @@ import { convertImageBytesToPng, convertToPng } from "../vendor/pi-rich/image-co
 import { putBlob, getBlobBytes } from "../store/blobs.ts";
 import { imageDescription, validImageRef, type ImageRef } from "../core/images.ts";
 import type { ContentBlock, Message } from "../core/project.ts";
+import { imageDimensions, modelImageSide, MAX_IMAGE_SOURCE_BYTES, MAX_IMAGE_SOURCE_PIXELS } from "../core/image-limits.ts";
 
 // Admission limit, not a context threshold: avoid reading arbitrarily large local binaries into WASM.
-const MAX_IMAGE_SOURCE_BYTES = 64 * 1024 * 1024;
 export async function attachImageBytes(bytes: Uint8Array, name: string, blobDir: string, autoResize = true): Promise<ImageRef> {
   if (bytes.byteLength > MAX_IMAGE_SOURCE_BYTES) throw new Error("Image exceeds the 64 MiB attachment limit");
   let mime = detectSupportedImageMimeType(bytes);
   if (!mime) throw new Error("Unsupported or malformed image: " + name);
+  const dimensions = imageDimensions(bytes, mime);
+  if (!dimensions) throw new Error("Cannot read image dimensions: " + name);
+  if (dimensions.width * dimensions.height > MAX_IMAGE_SOURCE_PIXELS) throw new Error("Image exceeds the 25 megapixel decode limit: " + name);
+  const maxSide = modelImageSide(dimensions);
   const originalBytes = bytes;
   if (mime === "image/bmp") {
     const converted = await convertImageBytesToPng(bytes);
@@ -21,7 +25,7 @@ export async function attachImageBytes(bytes: Uint8Array, name: string, blobDir:
     bytes = converted; mime = "image/png";
   }
   // Pi's disabled auto-resize setting preserves the input; decoding still verifies its dimensions.
-  const result = await resizeImage(bytes, mime, autoResize ? undefined : { maxWidth: Number.MAX_SAFE_INTEGER, maxHeight: Number.MAX_SAFE_INTEGER, maxBytes: Number.MAX_SAFE_INTEGER });
+  const result = await resizeImage(bytes, mime, autoResize ? { maxWidth: maxSide, maxHeight: maxSide } : { maxWidth: Number.MAX_SAFE_INTEGER, maxHeight: Number.MAX_SAFE_INTEGER, maxBytes: Number.MAX_SAFE_INTEGER });
   if (!result) throw new Error("Cannot decode or resize image: " + name);
   if (result.mimeType !== "image/png" && result.mimeType !== "image/jpeg" && result.mimeType !== "image/gif" && result.mimeType !== "image/webp") {
     throw new Error("Unsupported image encoding: " + result.mimeType);

package/src/runtime/loop.ts

@@ -43,7 +43,10 @@ import { randomUUID } from "node:crypto";
 import { pendingToolCalls } from "../core/execution.ts";
 import { declaredToolNames, recordedDeclarations } from "../core/tool-discovery.ts";
 import { DISCOVERY_TOOL, DISCOVERY_TOOL_NAME, currentDeferredTools, discoveryFingerprint, discoveryPermitted, searchDeferredTools } from "./tool-discovery.ts";
-import { executionOutcome, modelOutcome, type ExecutionOutcome } from "../core/outcome.ts";
+import { executionOutcome, modelOutcome, type ExecutionOutcome, type ExecutionReason } from "../core/outcome.ts";
+import { finalizationNotice, requestPhase } from "../core/request-budget.ts";
+import { stopReport } from "../core/stop-report.ts";
+import { supportsToolDisabling, type ProviderSendOptions } from "./provider-tool-policy.ts";
 import { commandCompletion } from "../core/command-contract.ts";
 import { ExecutionControl } from "./execution-control.ts";
 import { BranchJobs } from "./branch-jobs.ts";
@@ -153,7 +156,8 @@ export interface LoopEvent {
   outcome?: ExecutionOutcome;
   /** Q23: task evidence is separate from the execution outcome; rebuilt from original receipts. */
   request?: RequestState;
-  progress?: Extract<StreamDelta, { kind: "tool" | "retry" }> | { kind: "output"; text: string; name: string };
+  progress?: Extract<StreamDelta, { kind: "tool" | "retry" }> | { kind: "output"; text: string; name: string }
+    | { kind: "waiting"; session: number; active: boolean };
 }
 
 /**
@@ -356,6 +360,7 @@ export class Session {
   private readonly hostPending = new Set<Promise<NativeCommandResult>>();
   private stall: StallState | null = null;
   private recovery: RecoveryState | null = null;
+  private processWake = new AbortController();
   private pendingAdoption: number | null = null;
   private readonly allocatedEventIds = new Set<string>();
   private recordTail: Promise<void> = Promise.resolve();
@@ -377,8 +382,10 @@ export class Session {
     stallDecision(emptyStallState(), config.stallLimit ?? DEFAULT_STALL_LIMIT);
     validateOutputRecoveryLimit(config.outputRecoveryLimit ?? DEFAULT_OUTPUT_RECOVERY_LIMIT);
     schedulingWindow([], 0, config.maxParallelTools ?? 3);
+    requestPhase(0, config.maxTurns);
     this.allocation = allocation;
-    this.config = { ...config, ...(config.acceptanceContract ? { acceptanceContract: parseAcceptanceContract(config.acceptanceContract) } : {}), tools: { ...config.tools, execOwner: this.execOwner, historyCache: new HistoryCache() } };
+    this.config = { ...config, ...(config.acceptanceContract ? { acceptanceContract: parseAcceptanceContract(config.acceptanceContract) } : {}), tools: { ...config.tools, execOwner: this.execOwner, historyCache: new HistoryCache(),
+      processWait: { wake: () => this.processWake.signal } } };
     // A child or restored Session must never inherit another live invocation scope.
     delete this.config.tools.invoke;
     delete this.config.tools.invokeHost;
@@ -853,6 +860,9 @@ export class Session {
     pull?: (phase: Phase) => Promise<UserInput | null>,
   ): Promise<UserInput | null> {
     if (pull === undefined || this.isHalfRound()) return null;
+    // Rotate before pulling: an input queued during the async pull still wakes
+    // the next wait. A wake never cancels the process's lifetime signal.
+    this.processWake = new AbortController();
     const text = await pull("after_tools");
     if (text === null || typeof text === "string" && text.length === 0) return null;
     if (this.turnTools) this.config.tools = { ...this.turnTools };
@@ -1185,6 +1195,7 @@ export class Session {
   ): AsyncGenerator<LoopEvent> {
     if (this.cleanup || this.closing) throw new Error("session is draining or disposed");
     const owned = this.execution.begin(signal);
+    this.processWake = new AbortController();
     const savedTools = this.config.tools;
     this.turnTools = savedTools;
     this.config.tools = { ...savedTools };
@@ -1271,6 +1282,7 @@ export class Session {
       let overflowRetried = false;
       const requestStarted = this.clock.now();
       for (let turn = 0; turn < this.config.maxTurns; turn++) {
+        const phase = requestPhase(turn, this.config.maxTurns);
         completedThisTurn.length = 0;
         if (signal?.aborted) {
           yield* this.closeInterrupted(completedThisTurn);
@@ -1278,12 +1290,18 @@ export class Session {
         }
 
         if (yield* this.checkStall()) {
-          yield { kind: "done", reason: "stopped: consecutive tool exchanges without new evidence", outcome: executionOutcome("stalled") };
+          yield { kind: "done", reason: await this.terminationReport("no-progress allowance exhausted", turn), outcome: executionOutcome("stalled") };
+          return;
+        }
+        if (phase === "finalize" && !supportsToolDisabling(this.provider.config.spec.api)) {
+          yield { kind: "done", reason: await this.terminationReport("work budget exhausted; protocol cannot disable tools while preserving frozen definitions", turn), outcome: executionOutcome("max_turns") };
           return;
         }
         yield { kind: "turn_start", node: this.state.node };
 
-        if (this.config.guidance !== false) {
+        if (phase === "finalize") {
+          await this.record({ t: "guidance", id: this.clock.nextId(), at: this.clock.now(), reason: "budget", sources: [], text: finalizationNotice() });
+        } else if (this.config.guidance !== false) {
           const names = this.adviceNames();
           const guidance = (this.config.harnessReviews === false ? null : await this.recoveryGuidance(names)) ??
             continuationGuidance({ events: this.state.events, handoff: this.state.handoff,
@@ -1325,7 +1343,7 @@ export class Session {
 
         let result: Turn;
         try {
-          result = yield* this.awaitProvider(projected.messages, signal);
+          result = yield* this.awaitProvider(projected.messages, signal, phase === "finalize" ? { toolUse: "disabled" } : undefined);
         } catch (error) {
           // D11: retain a typed response receipt once, without anchoring rejected content or trusting arbitrary error fields.
           if (error instanceof FailedResponseError && error.usage !== undefined) this.state.usage.push({ ...error.usage });
@@ -1333,6 +1351,11 @@ export class Session {
             yield* this.closeInterrupted(completedThisTurn);
             return;
           }
+          if (phase === "finalize") {
+            yield { kind: "discard" };
+            yield { kind: "done", reason: await this.terminationReport("final response failed; no additional request was made", turn + 1), outcome: executionOutcome("provider_error") };
+            return;
+          }
           if (!(error instanceof Error) || !isContextOverflow(error.message, statusOf(error))) throw error;
           // The estimate said this fit and the provider says it does not: the
           // estimate is wrong for this content. The only projection that can
@@ -1423,6 +1446,16 @@ export class Session {
           (b): b is Extract<AssistantBlock, { type: "tool_use" }> => b.type === "tool_use",
         );
 
+        // Provider policy is a wire instruction, not authority. Pair every
+        // refused call, but never admit execution in the reserved final request.
+        if (phase === "finalize" && (calls.length > 0 || !isCompleteResponse(result.stopReason) ||
+            !result.blocks.some(block => block.type === "text" && block.text.trim()))) {
+          for (const item of await this.answerUnpairedTools("not executed: tools are disabled in the final request", "not_started"))
+            yield { kind: "tool_result", text: item.content, ok: false };
+          yield { kind: "done", reason: await this.terminationReport("request budget exhausted; final response did not provide a complete text answer", turn + 1), outcome: executionOutcome("max_turns") };
+          return;
+        }
+
         // N.12: syntactically valid arguments in an unfinished response are not
         // authorization to execute a partial batch. Pair without side effects.
         if (!isCompleteResponse(result.stopReason)) {
@@ -1563,7 +1596,7 @@ export class Session {
         }
       }
 
-      yield { kind: "done", reason: `hit maxTurns (${this.config.maxTurns})`, outcome: executionOutcome("max_turns") };
+      yield { kind: "done", reason: await this.terminationReport("request budget exhausted", this.config.maxTurns), outcome: executionOutcome("max_turns") };
     } finally {
       // If the consumer aborts and stops pulling, the generator is closed
       // without running the yield* closeInterrupted path. Pairing still
@@ -1581,6 +1614,7 @@ export class Session {
    */
   private async answerUnpairedTools(
     content = "interrupted: the user cancelled before this tool completed",
+    reason: ExecutionReason = "unknown",
   ): Promise<{ callId: string; content: string }[]> {
     const added: { callId: string; content: string }[] = [];
     for (const block of pendingToolCalls(this.state.events)) {
@@ -1595,7 +1629,7 @@ export class Session {
           ...(block.origin ? { origin: block.origin } : {}),
           ok: false,
           content: resultText,
-          outcome: executionOutcome("unknown"),
+          outcome: executionOutcome(reason),
         });
         added.push({ callId: block.call_id, content: resultText });
     }
@@ -1644,6 +1678,7 @@ export class Session {
   private async *awaitProvider(
     messages: readonly Message[],
     signal?: AbortSignal,
+    options?: ProviderSendOptions,
   ): AsyncGenerator<LoopEvent, Turn> {
     const hydrated = await hydrateImages(messages, this.config.blobDir ?? join(this.config.logDir, "blobs"),
       this.provider.config.spec.input?.includes("image") ?? false);
@@ -1665,7 +1700,7 @@ export class Session {
         default:
           return assertNever(delta, "onDelta");
       }
-    }));
+    }, options));
   }
 
   /**
@@ -1814,6 +1849,7 @@ export class Session {
       if (native) context = nativeCommandContext(context);
       const decoder = new TextDecoder();
       context.onOutput = chunk => emit({ kind: "progress", progress: { kind: "output", name: call.name, text: decoder.decode(chunk, { stream: true }) } });
+      context.onProcessWait = (session, active) => emit({ kind: "progress", progress: { kind: "waiting", session, active } });
       const broker = new ToolBroker<DeferredToolResult>({
         parallelLimit: this.config.maxParallelTools ?? 3,
         callId: () => `nested-${randomUUID()}`,
@@ -2720,14 +2756,23 @@ export class Session {
     }
     const decision = stallDecision(this.stall, limit);
     if (decision.stop) {
-      yield { kind: "stop_and_ask", reason: `${decision.consecutive} consecutive tool exchanges without new evidence or fresh verification; change the approach or provide new input` };
+      yield { kind: "stop_and_ask", reason: `${decision.unproductive} total tool exchanges without new evidence (${decision.consecutive} consecutive; ${decision.failures} failed receipts; ${decision.emptyWaits} empty waits); change the approach or provide new input` };
       return true;
     }
     if (decision.warn) await this.record({ t: "guidance", id: this.clock.nextId(), at: this.clock.now(), reason: "stall", sources: [],
-      text: `Harness: ${decision.consecutive} consecutive tool exchanges without new evidence or fresh verification. Change the method, run a meaningful check, or give the final result with unresolved limits. The harness will stop at ${limit} such exchanges. Notes and repeated observations do not count as progress.` });
+      text: `Harness: ${decision.unproductive} total tool exchanges without new evidence or fresh verification (${decision.consecutive} consecutive; ${decision.failures} failed receipts; ${decision.emptyWaits} empty waits). Change the method, run a meaningful check, or give the final result with unresolved limits. The harness will stop at ${limit} total unproductive exchanges. Novel observations reset the streak, not the spent allowance. Notes and repeated observations do not count as progress.` });
     return false;
   }
 
+  /** A steering signal releases only the wait; cancellation owns process termination. */
+  wakeProcessWaits(): void { this.processWake.abort(); }
+
+  private async terminationReport(cause: string, requests: number): Promise<string> {
+    const history = await readNodeHistory(this.config.logDir, this.state.node, undefined, "context");
+    if (!history.ok) throw new Error(history.error);
+    return stopReport(history.nodes.flatMap(part => part.events), requests, this.config.maxTurns, cause);
+  }
+
   /** N.8: build and check the replacement before committing a durable boundary. */
   /**
    * `overflowed` is the provider's own verdict that the current projection

package/src/runtime/oauth.ts

@@ -18,7 +18,7 @@ import { pollDeviceCode } from "./oauth-device.ts";
 import { parseDeviceAuthorization, parseOAuthTokens } from "../core/oauth-fields.ts";
 
 /** Matches package.json. Sent as User-Agent so the server can see who we are (D18). */
-export const XENO_VERSION = "0.6.0";
+export const XENO_VERSION = "0.7.0";
 
 /**
  * Minutes subtracted from server expiry so a request issued at the edge

package/src/runtime/openai-responses.ts

@@ -24,6 +24,7 @@ import { assertNever } from "../core/exhaustive.ts";
 import type { OnDelta, Provider, ProviderConfig, ToolSchema, Turn } from "./provider.ts";
 import { pushSse, HttpError, StreamError } from "./openai.ts";
 import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
+import type { ProviderSendOptions } from "./provider-tool-policy.ts";
 
 /** What this adapter parks in a thinking block's raw: the reasoning item, whole. */
 interface ResponsesRaw { responses_item: Record<string, unknown> }
@@ -266,19 +267,20 @@ export class OpenAIResponsesProvider implements Provider {
     this.onRetry = options.onRetry;
   }
 
-  send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
-    return withRetry(() => this.attempt(frozen, messages, node, signal, onDelta), this.retry, undefined,
+  send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta, options?: ProviderSendOptions): Promise<Turn> {
+    return withRetry(() => this.attempt(frozen, messages, node, signal, onDelta, options), this.retry, undefined,
       (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); onDelta?.({ kind: "retry", attempt, delayMs }); this.onRetry?.(attempt, delayMs, error); }, signal);
   }
 
-  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
+  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta, options?: ProviderSendOptions): Promise<Turn> {
     const started = Date.now();
     const baseUrl = this.config.spec.baseUrl;
     if (baseUrl === undefined) throw new Error(`model ${this.config.spec.id} has no baseUrl to send to`);
     const init: RequestInit = {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${this.apiKey}` },
-      body: JSON.stringify({ ...buildResponsesRequest(this.config, frozen, messages), stream: true }),
+      body: JSON.stringify({ ...buildResponsesRequest(this.config, frozen, messages), stream: true,
+        ...(options?.toolUse === "disabled" ? { tool_choice: "none" } : {}) }),
     };
     if (signal !== undefined) init.signal = signal;
     const response = await this.fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, init);

package/src/runtime/openai.ts

@@ -26,6 +26,7 @@ import { assertNever } from "../core/exhaustive.ts";
 import type { Provider, ProviderConfig, Turn, ToolSchema, OnDelta } from "./provider.ts";
 import { DEFAULT_COMPAT, type Compat, type Effort, type ModelSpec } from "./model.ts";
 import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
+import type { ProviderSendOptions } from "./provider-tool-policy.ts";
 
 /** One message as Chat Completions wants it. */
 export interface WireMessage {
@@ -48,6 +49,7 @@ export interface WireRequest {
   max_tokens?: number;
   max_completion_tokens?: number;
   tools?: unknown[];
+  tool_choice?: "none";
   thinking?: { type: "enabled" | "disabled" };
   reasoning_effort?: string;
 }
@@ -434,11 +436,12 @@ export class OpenAICompletionsProvider implements Provider {
     node: number,
     signal?: AbortSignal,
     onDelta?: OnDelta,
+    options?: ProviderSendOptions,
   ): Promise<Turn> {
     // The clock starts inside the retried request, so a reported duration is
     // one attempt rather than the sum of the ones that failed.
     return withRetry(
-      () => this.attempt(frozen, messages, node, signal, onDelta),
+      () => this.attempt(frozen, messages, node, signal, onDelta, options),
       this.retry,
       undefined,
       (attempt, delayMs, error) => {
@@ -456,6 +459,7 @@ export class OpenAICompletionsProvider implements Provider {
     node: number,
     signal?: AbortSignal,
     onDelta?: OnDelta,
+    options?: ProviderSendOptions,
   ): Promise<Turn> {
     const started = Date.now();
     const baseUrl = this.config.spec.baseUrl;
@@ -468,6 +472,7 @@ export class OpenAICompletionsProvider implements Provider {
       stream: true;
       stream_options?: { include_usage: true };
     } = { ...buildRequest(this.config, frozen, messages), stream: true };
+    if (options?.toolUse === "disabled") payload.tool_choice = "none";
     // Without include_usage an OpenAI-dialect stream never reports usage, and
     // the loop would treat the resulting zeros as a real prompt size. Servers
     // that 400 on the field opt out via Compat.supportsUsageInStreaming.

package/src/runtime/pi-provider.ts

@@ -23,6 +23,7 @@ import { FailedResponseError, type OnDelta, type Provider, type ProviderConfig,
 import { DEFAULT_RETRY, withRetry, type RetryPolicy } from "./retry.ts";
 import { HttpError, StreamError } from "./openai.ts";
 import type { UsageSample } from "./usage.ts";
+import { disablePayloadTools, type ProviderSendOptions } from "./provider-tool-policy.ts";
 
 const APIS: Record<Api, ProviderStreams> = {
   "anthropic-messages": anthropicMessagesApi(), "openai-completions": openAICompletionsApi(),
@@ -305,14 +306,14 @@ export class PiProvider implements Provider {
     this.config = config; this.apiKey = apiKey; this.options = options;
   }
 
-  send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
+  send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta, policy?: ProviderSendOptions): Promise<Turn> {
     // Bedrock's Pi adapter leaves retry ownership with the AWS SDK; never multiply that loop.
     const retry = this.options.retry ?? (this.config.spec.api === "bedrock-converse-stream" ? { ...DEFAULT_RETRY, maxRetries: 0 } : DEFAULT_RETRY);
-    return withRetry(() => this.attempt(frozen, messages, node, signal, onDelta), retry, undefined,
+    return withRetry(() => this.attempt(frozen, messages, node, signal, onDelta, policy), retry, undefined,
       (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); onDelta?.({ kind: "retry", attempt, delayMs }); this.options.onRetry?.(attempt, delayMs, error); }, signal);
   }
 
-  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
+  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta, policy?: ProviderSendOptions): Promise<Turn> {
     signal?.throwIfAborted();
     const started = Date.now();
     const request = providerRequest(this.config.spec, this.apiKey, this.options.effects, this.options.fetch, this.options.oauth);
@@ -342,7 +343,7 @@ export class PiProvider implements Provider {
         const next = mergePayload(payload, request.body);
         // Stateless Responses is required by D8: never replace the recomputable projection with server state.
         if (model.api.includes("responses")) { next["store"] = false; delete next["previous_response_id"]; }
-        return next;
+        return policy?.toolUse === "disabled" ? disablePayloadTools(model.api, next) : next;
       } };
     let completed: AssistantMessage | undefined;
     // Pi emits fragments; xeno's progress contract replaces the displayed argument buffer.

package/src/runtime/provider-tool-policy.ts

@@ -0,0 +1,33 @@
+/** D6: native request controls may change; frozen system and tool declarations may not. */
+import { assertNever } from "../core/exhaustive.ts";
+import type { Api } from "./model.ts";
+
+export interface ProviderSendOptions { toolUse: "disabled" }
+
+export function supportsToolDisabling(api: Api): boolean {
+  // Bedrock's SDK implements none by deleting toolConfig. It cannot preserve D6.
+  switch (api) {
+    case "anthropic-messages": case "openai-completions": case "openai-responses": case "azure-openai-responses": case "openai-codex-responses":
+    case "google-generative-ai": case "google-vertex": case "mistral-conversations": case "pi-messages": return true;
+    case "bedrock-converse-stream": return false;
+    default: return assertNever(api, "tool disabling capability");
+  }
+}
+const object = (value: unknown): Record<string, unknown> => value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+
+/** Called after provider body overrides, at the last native payload boundary. */
+export function disablePayloadTools(api: Api, payload: Record<string, unknown>): Record<string, unknown> {
+  switch (api) {
+    case "anthropic-messages": return { ...payload, tool_choice: { type: "none" } };
+    case "openai-completions": case "openai-responses": case "azure-openai-responses": case "openai-codex-responses":
+      return { ...payload, tool_choice: "none" };
+    case "google-generative-ai": case "google-vertex": {
+      const config = object(payload["config"]), toolConfig = object(config["toolConfig"]);
+      return { ...payload, config: { ...config, toolConfig: { ...toolConfig, functionCallingConfig: { mode: "NONE" } } } };
+    }
+    case "mistral-conversations": return { ...payload, toolChoice: "none" };
+    case "pi-messages": return { ...payload, options: { ...object(payload["options"]), toolChoice: "none" } };
+    case "bedrock-converse-stream": throw new Error("Bedrock cannot disable tools while preserving frozen definitions");
+    default: return assertNever(api, "tool disabling protocol");
+  }
+}