@visual-z/xeno 0.8.1 → 0.8.3

package/src/runtime/exec-sessions.ts

@@ -23,6 +23,8 @@ import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { commandArgv, commandEnvironment, COMMAND_TERMINATION_GRACE_MS } from "../core/command-contract.ts";
 import { archiveObservation, type ArchivedObservation } from "../store/observations.ts";
+import { configDir } from "../store/config.ts";
+import { xenoBinDir } from "../store/tool-binaries.ts";
 import { ToolFault, NOT_STARTED } from "../core/tool-failure.ts";
 import { processReceipt, retainProcessReceipts, type ProcessReceipt, type ProcessSource } from "../core/process-receipt.ts";
 import type { CommandArtifactObserver } from "./command-artifacts.ts";
@@ -44,6 +46,19 @@ export function yieldWait(value: unknown): { ms: number; note: string } {
   const ms = Math.min(MAX_YIELD_MS, Math.max(MIN_YIELD_MS, requested));
   return { ms, note: ms === requested ? "" : ` · yield_time_ms ${requested} clamped to ${ms}` };
 }
+/**
+ * Bounds on one owned empty wait's window, copied from Codex's empty
+ * `write_stdin` (MIN_EMPTY_YIELD_TIME_MS, DEFAULT_MAX_BACKGROUND_TERMINAL_TIMEOUT_MS),
+ * not measured. The floor is what stops a chatty process from waking the
+ * model every line: below it, a 100 ms request brings the per-line wakeups back.
+ */
+export const MIN_EMPTY_YIELD_MS = 5_000;
+export const MAX_EMPTY_YIELD_MS = 300_000;
+export function emptyYieldWait(value: unknown): { ms: number; note: string } {
+  const requested = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_YIELD_MS;
+  const ms = Math.min(MAX_EMPTY_YIELD_MS, Math.max(MIN_EMPTY_YIELD_MS, requested));
+  return { ms, note: ms === requested ? "" : ` · yield_time_ms ${requested} clamped to ${ms}` };
+}
 /**
  * Concurrent sessions. An assumption, not a measurement: comfortably above a
  * server + watcher + REPL, low enough that a runaway loop of starts is refused
@@ -59,6 +74,12 @@ export const CLOSED_RECEIPT_AGE_MS = 10 * 60_000;
 type TakenOutput = {
   stored: ArchivedObservation; receipt: ProcessReceipt; wallMs: number;
   exit: number | null; stopped?: "timeout" | "cancelled";
+  /**
+   * Input that arrived after the process exited and was not written:
+   * "control" for interrupt/EOF, whose intent the exit already satisfied;
+   * "refused" for real input, which the caller must report as not sent.
+   */
+  unsent?: "control" | "refused";
 };
 type ClosedSession = { owner?: string; id: number; endedAt: number; receipt: ProcessReceipt };
 
@@ -77,7 +98,6 @@ interface Session {
   spoolPath: string;
   queue: Promise<unknown>;
   operations: Promise<unknown>;
-  outputListeners: Set<() => void>;
   final?: TakenOutput;
   captureError?: string;
   written: number;
@@ -149,7 +169,6 @@ 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");
@@ -170,12 +189,12 @@ export async function startSession(input: {
   await mkdir(input.spoolDir, { recursive: true });
   const spoolPath = join(input.spoolDir, `.${randomUUID()}.session`);
   const spool = await open(spoolPath, "w+", 0o600);
-  const env = commandEnvironment(process.env);
+  const env = commandEnvironment(process.env, xenoBinDir(configDir()));
   let resolveExit!: () => void;
   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(), outputListeners: new Set<() => void>(), written: 0, read: 0,
+    spool, spoolPath, queue: Promise.resolve(), operations: Promise.resolve(), 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;
@@ -300,26 +319,42 @@ export interface ObservationWait {
   /** Steering releases this observation wait without cancelling the owned command. */
   wake?: AbortSignal;
   onWaiting?: (active: boolean) => void;
+  /** One window; output is delivered at a window's end, never as it arrives. */
+  windowMs: number;
 }
 
-/** OMP's job owner pattern: no paid model turn merely to observe elapsed time. */
+/**
+ * OMP's job owner pattern: no paid model turn merely to observe elapsed time.
+ * Exit, timeout, cancellation and steering end the wait at once. Output does
+ * not: it is collected until the window ends, and a window with nothing new
+ * rolls into the next. Waking per byte made a process that prints a warning
+ * every few seconds cost one model request per line (session mv4wyiyg-lebu,
+ * fix-owned-wait-coalesce-output); Codex collects to the deadline the same way.
+ */
 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;
+  let interrupt!: () => void;
+  const interrupted = new Promise<void>(resolve => { interrupt = resolve; });
+  signal?.addEventListener("abort", interrupt, { once: true });
+  wait.wake?.addEventListener("abort", interrupt, { once: true });
+  const ended = () => session.exit !== null || signal?.aborted === true || wait.wake?.aborted === true;
+  const pending = !ended();
+  let timer: ReturnType<typeof setTimeout> | undefined;
   try {
     if (pending) {
       wait.onWaiting?.(true);
-      await Promise.race([session.exited, changed]);
+      while (!ended()) {
+        const deadline = new Promise<void>(resolve => { timer = setTimeout(resolve, wait.windowMs); });
+        await Promise.race([session.exited, interrupted, deadline]);
+        clearTimeout(timer);
+        await session.queue;
+        if (session.written > session.read) break;
+      }
     }
   } finally {
-    session.outputListeners.delete(notify);
-    signal?.removeEventListener("abort", notify);
-    wait.wake?.removeEventListener("abort", notify);
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", interrupt);
+    wait.wake?.removeEventListener("abort", interrupt);
     if (pending) wait.onWaiting?.(false);
   }
   if (signal?.aborted) stopSession(session, "cancelled");
@@ -369,6 +404,17 @@ async function takeOutput(session: Session, outputStore: string, previewBytes: n
   return taken;
 }
 
+/**
+ * Input made only of Ctrl-C / Ctrl-D. Sent to a process that has already
+ * exited, it asks for something the exit already did (stop, end of input), so
+ * it is answered as a poll rather than refused -- otherwise the exit and the
+ * unread tail wait for a second call the model may never make (ticket session
+ * mv4ugd29, write-stdin-exited card).
+ */
+export function isControlInput(chars: string): boolean {
+  return chars.length > 0 && /^[\u0003\u0004]+$/.test(chars);
+}
+
 /** 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, wait?: ObservationWait): Promise<TakenOutput> {
@@ -376,16 +422,20 @@ export async function pollSession(session: Session, outputStore: string, preview
   if (signal?.aborted) cancel(); else signal?.addEventListener("abort", cancel, { once: true });
   const result = session.operations.then(async () => {
     if (session.final) {
-      if (chars.length > 0) throw new ToolFault("not_found", "process is closed; input was not sent", NOT_STARTED);
+      if (chars.length > 0 && !isControlInput(chars)) throw new ToolFault("not_found", "process is closed; input was not sent", NOT_STARTED);
       return { ...session.final, receipt: { ...session.final.receipt, replayed: true } };
     }
+    // An exit not yet reported is still delivered with any late input: the
+    // input is never written, but the exit and unread output are not withheld.
+    let unsent: TakenOutput["unsent"];
     if (chars.length > 0) {
-      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);
+      if (session.exit !== null) unsent = isControlInput(chars) ? "control" : "refused";
+      else session.write(chars);
     }
     if (chars.length === 0 && wait) await waitForObservation(session, signal, wait);
     else await waitSession(session, yieldMs, signal);
-    return takeOutput(session, outputStore, previewBytes);
+    const taken = await takeOutput(session, outputStore, previewBytes);
+    return unsent === undefined ? taken : { ...taken, unsent };
   });
   session.operations = result.catch(() => {});
   try { return await result; }

package/src/runtime/history-tools.ts

@@ -2,7 +2,7 @@
 import { join } from "node:path";
 import { deriveHandoff } from "../core/derive.ts";
 import type { Handoff } from "../core/handoff.ts";
-import { HISTORY_SECTIONS, historyPage, type HistorySection } from "../core/history.ts";
+import { HISTORY_SECTIONS, historyPage, userTurnImages, type HistorySection } from "../core/history.ts";
 import { historyEntries, historyHits, historyIndex, queryHistory, type HistoryEntry } from "../core/history-query.ts";
 import { resourceKey } from "../core/evidence-links.ts";
 import { canonicalValue } from "../core/continuation.ts";
@@ -87,7 +87,12 @@ export async function runHistoryTool(logDir: string, currentNode: number, ctx: T
     if (typeof args["event"] === "string") {
       const found = indexed.byEvent.get(args["event"]);
       if (!found) throw new ToolFault("not_found", "event is not readable in the active ancestry", READ_ATTEMPTED);
-      return historyValue(ctx, found);
+      // A carried user turn names its images by digest only (D8). Reading the
+      // original turn reattaches them as a tool result, so their image tokens are
+      // paid once, when asked for, instead of in every later handoff.
+      const original = found.kind === "user" ? history.nodes.flatMap(part => part.events).find(event => event.id === found.event) : undefined;
+      const images = original?.t === "user" ? original.images ?? [] : [];
+      return { ...await historyValue(ctx, found), ...(images.length ? { images } : {}) };
     }
     if (typeof args["query"] === "string" || args["recent"] === true || typeof args["resource"] === "string" || typeof args["work_id"] === "string") {
       const query = typeof args["query"] === "string" ? args["query"] : "";
@@ -144,6 +149,11 @@ export async function runHistoryTool(logDir: string, currentNode: number, ctx: T
       if (part.node === node) break;
     }
     if (full === null) throw new ToolFault("not_found", "empty history", READ_ATTEMPTED);
+    // Pages match a v3 carried suffix: user turns name their images by digest (D8).
+    if (args["section"] === "user_turns") {
+      const at = history.nodes.findIndex(part => part.node === node);
+      full = { ...full, user_turns: userTurnImages(full.user_turns, history.nodes.slice(0, at + 1)) };
+    }
     const page = historyPage(full, args["section"] as HistorySection,
       typeof args["offset"] === "number" ? args["offset"] : 0,
       typeof args["limit"] === "number" ? Math.min(args["limit"], 100) : 20);