@dungle-scrubs/harness-cli-normalizer 0.6.4 → 0.6.6

package/src/execution/context-inspection.ts

@@ -1,5 +1,8 @@
 import type { ContextInspection } from "../interpretation/context-inspection.js";
-import { createContextProbe } from "../interpretation/context-inspection.js";
+import {
+  createContextProbe,
+  settledContextInspection,
+} from "../interpretation/context-inspection.js";
 import { detectAuthFailureInLine, detectLimitInLine } from "../interpretation/limits.js";
 import type { HarnessDescriptor } from "../knowledge/descriptor.js";
 
@@ -10,7 +13,7 @@ import { LineBuffer } from "./lines.js";
 import { KILL_GRACE_MS, superviseTermination } from "./supervisor.js";
 
 export interface ContextInspectionOptions {
-  /** Already validated, version-bound ephemeral argv. The CLI adapter owns
+  /** Already validated, executable-bound ephemeral argv. The CLI adapter owns
    * no-persistence and fork-on-resume enforcement before this layer runs. */
   readonly argv: readonly string[];
   readonly cwd?: string;
@@ -53,11 +56,14 @@ export async function inspectContext(
     return { status: "unavailable", reason: "transport" };
   }
   let finished = false;
+  const outcome: { accounting: ContextInspection } = {
+    accounting: { status: "unavailable", reason: "transport" },
+  };
   let exited = false;
   let exitCode: number | null = null;
   let nativeFailure: "auth" | "limit" | null = null;
   let disposalTimer: TimerHandle | undefined;
-  const result = deferred<ContextInspection>();
+  const result = deferred<void>();
   const stopped = deferred<boolean>();
   const signal = (kind: "SIGTERM" | "SIGKILL"): void => {
     try {
@@ -68,18 +74,17 @@ export async function inspectContext(
   };
   const termination = superviseTermination(deps.clock, signal);
   const finish = (value: ContextInspection): void => {
+    if (!finished || (outcome.accounting.status === "available" && value.status === "unavailable"))
+      outcome.accounting = value;
     if (finished) return;
     finished = true;
-    result.resolve(value);
+    result.resolve();
     try {
       child.stdin?.end();
     } catch {
       /* A broken pipe still needs cleanup. */
     }
-    if (exited) {
-      stopped.resolve(true);
-      return;
-    }
+    if (exited) return;
     termination.escalate();
     disposalTimer = deps.clock.setTimeout(() => {
       child.disposeOutput();
@@ -99,9 +104,9 @@ export async function inspectContext(
     }
   };
   const onLine = (line: string): void => {
-    if (finished) return;
+    if (finished && outcome.accounting.status !== "available") return;
     const action = probe.accept(line);
-    if (action?.kind === "send") write(action.line);
+    if (action?.kind === "send" && !finished) write(action.line);
     else if (action?.kind === "complete") finish(action.accounting);
   };
   const deadline = deps.clock.setTimeout(
@@ -111,14 +116,16 @@ export async function inspectContext(
   const abort = (): void => finish({ status: "unavailable", reason: "cancelled" });
   options.signal?.addEventListener("abort", abort, { once: true });
   const stdout = (async (): Promise<void> => {
-    const lines = new LineBuffer(CONTEXT_TRANSPORT_MAX + 65_536);
+    const lines = new LineBuffer(CONTEXT_TRANSPORT_MAX + 65_536, () =>
+      finish({ status: "unavailable", reason: "transport-limit" }),
+    );
     try {
       for await (const chunk of child.stdout) {
-        if (!finished) for (const line of lines.push(chunk)) onLine(line);
+        for (const line of lines.push(chunk)) onLine(line);
       }
       const tail = lines.flush();
       if (tail !== null) onLine(tail);
-      finish({ status: "unavailable", reason: "transport" });
+      if (!finished) finish({ status: "unavailable", reason: "transport" });
     } catch {
       finish({ status: "unavailable", reason: "transport" });
     }
@@ -142,36 +149,34 @@ export async function inspectContext(
   void child.exited.then(async (code) => {
     exited = true;
     exitCode = code;
-    if (code !== null && code !== 0) finish({ status: "unavailable", reason: "transport" });
+    if (!finished && code !== null && code !== 0)
+      finish({ status: "unavailable", reason: "transport" });
     termination.settle();
     if (disposalTimer !== undefined) deps.clock.clearTimeout(disposalTimer);
     // Exit can precede the final bytes reaching the runtime's read buffer.
     // Drain naturally first; inherited pipes get a bounded disposal fallback.
     let drainTimer: TimerHandle | undefined;
-    await Promise.race([
-      Promise.all([stdout, stderr]),
-      new Promise<void>((resolve) => {
-        drainTimer = deps.clock.setTimeout(resolve, KILL_GRACE_MS);
+    const drained = await Promise.race([
+      Promise.all([stdout, stderr]).then(() => true),
+      new Promise<boolean>((resolve) => {
+        drainTimer = deps.clock.setTimeout(() => resolve(false), KILL_GRACE_MS);
       }),
     ]);
     if (drainTimer !== undefined) deps.clock.clearTimeout(drainTimer);
     child.disposeOutput();
-    stopped.resolve(true);
+    stopped.resolve(drained);
   });
   write(probe.initial);
   // Abort can arrive during spawn or listener registration.
   if (options.signal?.aborted) abort();
-  const value = await result.promise;
+  await result.promise;
   deps.clock.clearTimeout(deadline);
-  options.signal?.removeEventListener("abort", abort);
   const clean = await stopped.promise;
-  if (clean) await Promise.all([stdout, stderr]);
-  if (!clean) return { status: "unavailable", reason: "cleanup" };
-  if (value.status === "unavailable" && value.reason === "transport") {
-    return {
-      status: "unavailable",
-      reason: nativeFailure ?? (exitCode !== null && exitCode !== 0 ? "native-exit" : "transport"),
-    };
-  }
-  return value;
+  options.signal?.removeEventListener("abort", abort);
+  return settledContextInspection({
+    accounting: outcome.accounting,
+    clean,
+    exitCode,
+    nativeFailure,
+  });
 }

package/src/execution/lines.ts

@@ -11,7 +11,10 @@
 export const LINE_MAX = 65_536;
 
 export class LineBuffer {
-  constructor(private readonly limit = LINE_MAX) {}
+  constructor(
+    private readonly limit = LINE_MAX,
+    private readonly onOverflow?: () => void,
+  ) {}
   // Per-instance and stateful ({stream:true}): a shared decoder would carry
   // partial-sequence state across two streams and corrupt both.
   private readonly decoder = new TextDecoder();
@@ -44,6 +47,7 @@ export class LineBuffer {
     if (this.pending.length + text.length > this.limit) {
       this.pending = "";
       this.discarding = true;
+      this.onOverflow?.();
     } else this.pending += text;
   }
 

package/src/interpretation/context-inspection.ts

@@ -1,6 +1,7 @@
 import type { HarnessDescriptor } from "../knowledge/descriptor.js";
 import type { SpawnArgvOptions } from "./argv.js";
 import { buildSpawnArgv } from "./argv.js";
+import { contentEventsOf } from "./content.js";
 import { ArgvRefusalError } from "./refusal.js";
 import { asRecord } from "./shape.js";
 
@@ -16,7 +17,7 @@ export function buildContextInspectionArgv(
       harness: harness.name,
       issue: "invalid-option-value",
       option: "context",
-      supported: ["verified native context adapter without native passthrough"],
+      supported: ["supported native context adapter without native passthrough"],
     });
   }
   return [
@@ -74,6 +75,32 @@ export type ContextInspection =
 const positive = (value: unknown): value is number =>
   typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 
+/** Cleanup and caller interruption take precedence. Otherwise a recognized
+ * native failure explains a failed exchange more precisely than its framing. */
+export function settledContextInspection(facts: {
+  readonly accounting: ContextInspection;
+  readonly clean: boolean;
+  readonly exitCode: number | null;
+  readonly nativeFailure: "auth" | "limit" | null;
+}): ContextInspection {
+  const { accounting, clean, exitCode, nativeFailure } = facts;
+  if (!clean) return { status: "unavailable", reason: "cleanup" };
+  if (
+    accounting.status === "unavailable" &&
+    (accounting.reason === "cancelled" || accounting.reason === "timeout")
+  )
+    return accounting;
+  if (nativeFailure !== null) return { status: "unavailable", reason: nativeFailure };
+  if (
+    accounting.status === "unavailable" &&
+    accounting.reason === "transport" &&
+    exitCode !== null &&
+    exitCode !== 0
+  )
+    return { status: "unavailable", reason: "native-exit" };
+  return accounting;
+}
+
 /** Normalize only a complete native response. A window alone says nothing
  * about remaining capacity, and invalid compaction data must not increase it. */
 export function contextInspectionOf(input: unknown): ContextInspection {
@@ -135,7 +162,6 @@ export function createContextProbe(inputId: string, prompt: string): ContextProb
     initial: control(initializeId, { subtype: "initialize", hooks: null }),
     staged,
     accept(line) {
-      if (phase === "finished") return null;
       let decoded: unknown;
       try {
         decoded = JSON.parse(line);
@@ -144,7 +170,46 @@ export function createContextProbe(inputId: string, prompt: string): ContextProb
         return { kind: "complete", accounting: { status: "unavailable", reason: "protocol" } };
       }
       const frame = asRecord(decoded);
-      if (frame === null || Array.isArray(decoded)) return null;
+      const failure = contentEventsOf("claude", decoded).find(
+        (event) => event.kind === "limit" || (event.kind === "error" && event.terminal),
+      );
+      if (failure) {
+        phase = "finished";
+        return {
+          kind: "complete",
+          accounting: {
+            status: "unavailable",
+            reason: failure.kind === "limit" ? "limit" : "native-exit",
+          },
+        };
+      }
+      const content = asRecord(frame?.message)?.content;
+      const toolResult =
+        frame?.type === "user" &&
+        (frame.parent_tool_use_id != null ||
+          (Array.isArray(content) &&
+            content.some((block) => asRecord(block)?.type === "tool_result")));
+      const allowed =
+        frame !== null &&
+        !Array.isArray(decoded) &&
+        !toolResult &&
+        (frame.type === "user" ||
+          frame.type === "control_response" ||
+          frame.type === "command_lifecycle" ||
+          (frame.type === "system" &&
+            ["init", "hook_started", "hook_progress", "hook_response"].includes(
+              String(frame.subtype),
+            )) ||
+          (frame.type === "result" && frame.subtype === "success" && frame.num_turns === 0) ||
+          (frame.type === "rate_limit_event" &&
+            ["allowed", "allowed_warning"].includes(
+              String(asRecord(frame.rate_limit_info)?.status),
+            )));
+      if (!allowed || frame === null) {
+        phase = "finished";
+        return { kind: "complete", accounting: { status: "unavailable", reason: "protocol" } };
+      }
+      if (phase === "finished") return null;
       if (phase === "ack" && frame.type === "user" && frame.uuid === inputId) {
         phase = "usage";
         return { kind: "send", line: control(usageId, { subtype: "get_context_usage" }) };
@@ -154,7 +219,11 @@ export function createContextProbe(inputId: string, prompt: string): ContextProb
         return null;
       const expected = phase === "initialize" ? initializeId : phase === "usage" ? usageId : null;
       if (expected === null || response.request_id !== expected) return null;
-      if (response.subtype !== "success") {
+      if (
+        response.subtype !== "success" ||
+        (phase === "initialize" &&
+          (asRecord(response.response) === null || Array.isArray(response.response)))
+      ) {
         phase = "finished";
         return { kind: "complete", accounting: { status: "unavailable", reason: "protocol" } };
       }

package/src/knowledge/claude-code.ts

@@ -41,6 +41,7 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
     idFlag: "--session-id",
   },
   resume: {
+    admission: { kind: "invocation", modes: ["headless-turn"] },
     // A-005: claude resumes are id-stable - the caller-assigned id survives
     // every resume, so there is no rotation handling and forking is only the
     // explicit --fork-session flag (deliberate branching, never a default).
@@ -151,6 +152,10 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
     object: "context_window",
     usedPctField: "used_percentage",
   },
+  nativeContextManagement: {
+    kind: "native-session-auto-compaction",
+    modes: ["headless-turn"],
+  },
   contextInspection: {
     kind: "claude-control-v1",
     flags: [...STREAM_INPUT_FLAGS, "--no-session-persistence", "--replay-user-messages"],

package/src/knowledge/codex.ts

@@ -1,8 +1,7 @@
 /**
  * The codex descriptor: facts about the `codex` CLI as data, verified
- * against codex-cli 0.147.0 and lucid v1's registry. Descriptor groundwork
- * only (D-003): not exercised through the chat protocol until the claude
- * vertical slice is green.
+ * against codex-cli 0.153.4. Native capability and question recordings
+ * live in test/fixtures/codex-0.153.4.
  */
 import { deepFreeze, type HarnessDescriptor, UUID_SHAPE } from "./descriptor.js";
 import { SHARED_AUTH_MATCHERS, SHARED_LIMIT_MATCHERS } from "./matchers.js";
@@ -10,7 +9,7 @@ import { SHARED_AUTH_MATCHERS, SHARED_LIMIT_MATCHERS } from "./matchers.js";
 export const codexCli: HarnessDescriptor = deepFreeze({
   name: "codex",
   bin: "codex",
-  verifiedAgainst: "0.147.0",
+  verifiedAgainst: "0.153.4",
   versionSource: { kind: "npm", package: "@openai/codex" },
   launch: {
     // exec --json emits structured item events; without --json, identity
@@ -84,6 +83,8 @@ export const codexCli: HarnessDescriptor = deepFreeze({
   },
   contextHook: null,
   contextInspection: null,
+  // Codex 0.153.4 core/session/turn.rs runs native automatic compaction.
+  nativeContextManagement: { kind: "auto-compaction", modes: ["headless-turn"] },
   // Valid only in the `exec resume` context: `codex exec resume --last`.
   resumeLast: { flag: "--last" },
   // codex exec appends piped stdin as a <stdin> block and can block on an
@@ -108,7 +109,12 @@ export const codexCli: HarnessDescriptor = deepFreeze({
   // records a model id - absence of evidence, not an unset field.
   escalation: {
     supported: true,
-    observedOn: { harness: "codex", model: "", version: "0.146.1", date: "2026-08-19" },
+    observedOn: {
+      harness: "codex",
+      model: "gpt-6-astra",
+      version: "0.153.4",
+      date: "2026-09-08",
+    },
   },
   turnOptions: {
     // Codex config reference; accepted as an integer on CLI 0.153.4.

package/src/knowledge/descriptor.ts

@@ -338,6 +338,12 @@ export interface HarnessDescriptor {
    * anywhere else (the v1 first-UUID-wins scar: a UUID inside quoted prompt
    * text was returned as the session id, and resuming it started a stranger). */
   readonly resume: {
+    /** Declared invocation support by mode, not proof that a saved session exists.
+     * Omitted retains the verification-version admission policy. */
+    readonly admission?: {
+      readonly kind: "invocation";
+      readonly modes: readonly HarnessMode[];
+    };
     readonly style: ResumeStyle;
     readonly flag: string;
     readonly aliases: readonly string[];
@@ -456,13 +462,20 @@ export interface HarnessDescriptor {
     readonly object: string;
     readonly usedPctField: string;
   } | null;
-  /** Disposable native context accounting, verified at verifiedAgainst.
+  /** Disposable native context accounting; the exchange validates support.
    * Null is unknown support, never a model-window estimate. */
   readonly contextInspection: {
     readonly flags: readonly string[];
     readonly forkFlag: string;
     readonly kind: "claude-control-v1";
   } | null;
+  /** Curated native context handling, not a count or enabled-state observation.
+   * Native-session handling covers the native session; callers must prepare
+   * imported history. Disabled native compaction is not detected here. */
+  readonly nativeContextManagement: {
+    readonly kind: "auto-compaction" | "native-session-auto-compaction";
+    readonly modes: readonly HarnessMode[];
+  } | null;
   /** Resume-most-recent support (codex --last), or null. The race it opens
    * is owned by the corroboration ranking in interpretation. */
   readonly resumeLast: { readonly flag: string } | null;

package/src/knowledge/muse.ts

@@ -78,6 +78,7 @@ export const museCode: HarnessDescriptor = deepFreeze({
   },
   contextHook: null,
   contextInspection: null,
+  nativeContextManagement: null,
   // `muse resume --last` exists (muse resume --help).
   resumeLast: { flag: "--last" },
   stdin: "inherit",

package/src/knowledge/pi.ts

@@ -116,6 +116,7 @@ export const piCli: HarnessDescriptor = deepFreeze({
   },
   contextHook: null,
   contextInspection: null,
+  nativeContextManagement: null,
   resumeLast: null,
   stdin: "close-required",
   presence: {