@dungle-scrubs/harness-cli-normalizer 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kevin Frilot <kevinfrilot@icloud.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+# harness-cli-normalizer
+
+One stable interface to four coding-agent CLIs that survives their updates.
+
+[![CI](https://github.com/dungle-scrubs/harness-cli-normalizer/actions/workflows/ci.yml/badge.svg)](https://github.com/dungle-scrubs/harness-cli-normalizer/actions/workflows/ci.yml) [![npm](https://img.shields.io/npm/v/@dungle-scrubs/harness-cli-normalizer.svg)](https://www.npmjs.com/package/@dungle-scrubs/harness-cli-normalizer) [![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+harness-cli-normalizer describes each of four coding-agent CLIs (Claude Code, Codex, pi, and Muse) as pure data and normalizes their headless output into a single `HarnessEvent` stream. You write one consumer against that surface instead of a bespoke spawn-and-parse path for each agent. A separate execution layer drives any of them as a child process and emits the events. Today most teams hold these agents together by hand, one parser per CLI, and redo the work whenever an agent ships a new version.
+
+You reach for this when you are building on top of more than one coding agent: an orchestrator, an observer, a benchmark rig, or a way to switch which agent does a job. Each descriptor is pinned to the CLI version its facts were verified against, and a weekly check flags when a harness has shipped ahead of its descriptor. You learn drift is possible from a check, not from a crash.
+
+```bash
+pnpm add @dungle-scrubs/harness-cli-normalizer
+```
+
+## Install
+
+Requires Node 24 or newer. Install the public package from npm with your package manager:
+
+```bash
+pnpm add @dungle-scrubs/harness-cli-normalizer
+```
+
+The repository uses pnpm and Bun for development and its dual-runtime test lane. Consumers do not
+need either one unless their application runs on Bun.
+
+## Use it
+
+One-shot headless turn, the simplest path:
+
+```ts
+import {
+  claudeCode,
+  nodeRunnerDeps,
+  streamTurn,
+} from "@dungle-scrubs/harness-cli-normalizer";
+
+for await (const event of streamTurn(
+  claudeCode,
+  { prompt: "explain a monad in one sentence", cwd: process.cwd() },
+  nodeRunnerDeps(),
+)) {
+  if (event.kind === "message") console.log(event.text);
+  if (event.kind === "done") console.log(`exit: ${event.cause}`);
+}
+```
+
+Swap `claudeCode` for `codexCli`, `piCli`, or `museCode` and the consumer code does not change. The
+three layers are also available as `@dungle-scrubs/harness-cli-normalizer/knowledge`,
+`@dungle-scrubs/harness-cli-normalizer/interpretation`, and
+`@dungle-scrubs/harness-cli-normalizer/execution` for narrower imports.
+
+To watch the normalized stream render live against a real harness:
+
+```bash
+bun run demo claude "explain a monad in one sentence"
+bun run demo codex  "what is 2+2"
+bun run demo pi     "name three primes"
+bun run demo muse   "say hi"
+bun run demo --chat claude            # interactive session (claude only)
+```
+
+For a multi-turn session you drive yourself, `openSession` returns a handle whose `turns` you iterate and whose `send()` you call between turns. See `scripts/demo.ts` for the working pattern.
+
+## Concepts
+
+### Descriptors are data, not behavior
+
+Each harness is a frozen record of facts: its binary, its argv shapes, its stream flags, its session and resume grammar, its capability claims, and the CLI version those facts were checked against. You read a descriptor; you do not configure or subclass it. Adding a fifth harness means writing a new data file, not editing branching logic.
+
+### Three layers, one direction
+
+```
+knowledge (pure data) -> interpretation (pure functions) -> execution (child process)
+```
+
+`knowledge` and `interpretation` are 100% pure: no `node:` imports, no `process.env`, no clock, no randomness. Tests enforce this, not comments. Keep your own logic in the pure layers and reach `execution` only for actual process I/O. The execution layer never imports `child_process`; spawning, timing, and signalling arrive as injected primitives, so it runs the same on Node and Bun.
+
+### Version-pinning and drift
+
+Every descriptor carries a `verifiedAgainst` version, the anchor for all of its facts. A weekly CI job compares each harness's published version to its descriptor and opens a tracking issue when one has moved ahead. Trust a descriptor only at its pinned version, and bump `verifiedAgainst` only after re-running the capability checks locally.
+
+## Reference
+
+- Descriptors live in `src/knowledge/` (`claude-code.ts`, `codex.ts`, `pi.ts`, `muse.ts`), with shared types in `descriptor.ts`.
+- The normalized event surface is `HarnessEvent` in `src/execution/events.ts`: `identity`, `token`, `message`, `progress`, `tool`, `context`, `limit`, `error`, `done`.
+- Narrow or override a descriptor's facts with `parseOverrides` (`src/knowledge/overrides.ts`). An override a harness cannot satisfy throws `OverrideRefusalError` instead of producing a broken argv.
+- `DROPPABLE_KINDS` (`token`, `progress`, `context`) marks events safe to drop when you only need the full messages.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). The short version: run `pnpm check` before pushing, so lint, typecheck, vitest, and the bun test lane all pass. Keep the layer purity and chat-seam invariants intact, and do not edit files under `test/fixtures/`. Commits follow Conventional Commits.
+
+## Status
+
+Pre-1.0. Four harnesses are described (Claude Code, Codex, pi, Muse). Drift detection runs weekly in CI; re-verifying a descriptor's capability claims against a new CLI version is a local, manual step (`bun run smoke:seven`), not CI. Authentication and usage-limit signals are parsed from each harness's stream, but this library never holds or ships credentials; each harness authenticates under the end user's own session.
+
+## Prior art
+
+The four harness CLIs this normalizes: [Claude Code](https://www.npmjs.com/package/@anthropic-ai/claude-code), [Codex](https://www.npmjs.com/package/@openai/codex), [pi](https://www.npmjs.com/package/@earendil-works/pi-coding-agent), and Muse (installed from source, not on a registry).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/execution/channel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A single-consumer async channel with producer backpressure: push from
+ * producers (await the returned promise - past the high water mark it
+ * blocks until the consumer drains below low water, so OS pipe
+ * backpressure can reach a child process), iterate from EXACTLY ONE
+ * consumer, close to end iteration. A second concurrent iterator would
+ * overwrite the consumer wake and strand the first - it throws instead.
+ * push after close is a silent no-op by contract (the closer decided the
+ * stream is over; racing producers must not crash).
+ */
+export declare class AsyncChannel<T> implements AsyncIterable<T> {
+    private readonly highWater;
+    private readonly lowWater;
+    private items;
+    private head;
+    private closed;
+    private wake;
+    private producerWaiters;
+    private consuming;
+    private backpressureEnabled;
+    constructor(highWater?: number, lowWater?: number);
+    private get size();
+    push(item: T): Promise<void>;
+    close(): void;
+    /** Stop blocking producers without closing delivery. This is a terminal
+     * process state: the child has exited and output reads are being disposed,
+     * so only already-buffered pipe data can still be added. */
+    releaseBackpressure(): void;
+    get isClosed(): boolean;
+    private releaseProducers;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/execution/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/execution/channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAUpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,mBAAmB,CAAQ;IAEnC,YACmB,SAAS,SAAO,EAChB,QAAQ,SAAM,EAC7B;IAEJ,OAAO,KAAK,IAAI,GAEf;IAED,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ3B;IAED,KAAK,IAAI,IAAI,CAIZ;IAED;;gEAE4D;IAC5D,mBAAmB,IAAI,IAAI,CAG1B;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO,CAAC,gBAAgB;IAMjB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAsBhD;CACF"}

package/dist/execution/channel.js

@@ -0,0 +1,86 @@
+/**
+ * A single-consumer async channel with producer backpressure: push from
+ * producers (await the returned promise - past the high water mark it
+ * blocks until the consumer drains below low water, so OS pipe
+ * backpressure can reach a child process), iterate from EXACTLY ONE
+ * consumer, close to end iteration. A second concurrent iterator would
+ * overwrite the consumer wake and strand the first - it throws instead.
+ * push after close is a silent no-op by contract (the closer decided the
+ * stream is over; racing producers must not crash).
+ */
+export class AsyncChannel {
+    highWater;
+    lowWater;
+    items = [];
+    head = 0;
+    closed = false;
+    wake = null;
+    producerWaiters = [];
+    consuming = false;
+    backpressureEnabled = true;
+    constructor(highWater = 1024, lowWater = 256) {
+        this.highWater = highWater;
+        this.lowWater = lowWater;
+    }
+    get size() {
+        return this.items.length - this.head;
+    }
+    push(item) {
+        if (this.closed)
+            return Promise.resolve();
+        this.items.push(item);
+        this.wake?.();
+        if (this.backpressureEnabled && this.size > this.highWater) {
+            return new Promise((resolve) => this.producerWaiters.push(resolve));
+        }
+        return Promise.resolve();
+    }
+    close() {
+        this.closed = true;
+        this.wake?.();
+        this.releaseProducers();
+    }
+    /** Stop blocking producers without closing delivery. This is a terminal
+     * process state: the child has exited and output reads are being disposed,
+     * so only already-buffered pipe data can still be added. */
+    releaseBackpressure() {
+        this.backpressureEnabled = false;
+        this.releaseProducers();
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    releaseProducers() {
+        const waiters = this.producerWaiters;
+        this.producerWaiters = [];
+        for (const release of waiters)
+            release();
+    }
+    async *[Symbol.asyncIterator]() {
+        if (this.consuming) {
+            throw new Error("AsyncChannel is single-consumer; a second iterator would strand the first");
+        }
+        this.consuming = true;
+        while (true) {
+            if (this.size > 0) {
+                const item = this.items[this.head++];
+                if (this.head === this.items.length) {
+                    this.items = [];
+                    this.head = 0;
+                }
+                if (this.size < this.lowWater)
+                    this.releaseProducers();
+                if (item !== undefined)
+                    yield item;
+                continue;
+            }
+            if (this.closed)
+                return;
+            await new Promise((resolve) => {
+                this.wake = resolve;
+            });
+            this.wake = null;
+        }
+    }
+}
+//# sourceMappingURL=channel.js.map

package/dist/execution/channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.js","sourceRoot":"","sources":["../../src/execution/channel.ts"],"names":[],"mappings":"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"}

package/dist/execution/decode.d.ts

@@ -0,0 +1,16 @@
+import type { HarnessDescriptor } from "../knowledge/descriptor.js";
+import type { HarnessEvent } from "./events.js";
+export interface DecodeState {
+    lastSeenId: string | null;
+    limitSeen: boolean;
+    /** The id this turn expects (resume paths); rotation is classified
+     * against it. Null for fresh launches. */
+    requestedId: string | null;
+}
+export declare const freshDecodeState: (requestedId?: string | null) => DecodeState;
+export declare const decodeLine: (h: HarnessDescriptor, line: string, state: DecodeState, model: string) => HarnessEvent[];
+/** The parsed-record half of decodeLine, for pumps that already parsed the
+ * line once (a session pump inspects `type` before routing) - the hottest
+ * path must not JSON.parse every token delta twice. */
+export declare const decodeParsed: (h: HarnessDescriptor, raw: unknown, state: DecodeState, model: string) => HarnessEvent[];
+//# sourceMappingURL=decode.d.ts.map

package/dist/execution/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/execution/decode.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB;8CAC0C;IAC1C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,eAAO,MAAM,gBAAgB,iBAAiB,MAAM,GAAG,IAAI,KAAU,WAInE,CAAC;AAEH,eAAO,MAAM,UAAU,MAClB,iBAAiB,QACd,MAAM,SACL,WAAW,SACX,MAAM,KACZ,YAAY,EAcd,CAAC;AAEF;;uDAEuD;AACvD,eAAO,MAAM,YAAY,MACpB,iBAAiB,OACf,OAAO,SACL,WAAW,SACX,MAAM,KACZ,YAAY,EAsBd,CAAC"}

package/dist/execution/decode.js

@@ -0,0 +1,60 @@
+/**
+ * Stream-line decoding: one claude stream-json line in, zero or more
+ * HarnessEvents out. Stateful only through the explicit DecodeState the
+ * caller threads (identity dedupe per D-022). Unparseable lines on a
+ * structured stream are tolerated - scanned for walls, never fatal.
+ */
+import { capabilitiesOf } from "../interpretation/capabilities.js";
+import { contentEventsOf } from "../interpretation/content.js";
+import { decodeIdentity } from "../interpretation/identity.js";
+import { detectLimitInLine } from "../interpretation/limits.js";
+export const freshDecodeState = (requestedId = null) => ({
+    lastSeenId: null,
+    limitSeen: false,
+    requestedId,
+});
+export const decodeLine = (h, line, state, model) => {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        // Not structured output: the only signal a plain line can carry is a wall.
+        const code = detectLimitInLine(h, line);
+        if (code !== null) {
+            state.limitSeen = true;
+            return [{ kind: "limit", code, message: `limit wall detected (${code})` }];
+        }
+        return [];
+    }
+    return decodeParsed(h, raw, state, model);
+};
+/** The parsed-record half of decodeLine, for pumps that already parsed the
+ * line once (a session pump inspects `type` before routing) - the hottest
+ * path must not JSON.parse every token delta twice. */
+export const decodeParsed = (h, raw, state, model) => {
+    const events = [];
+    const decoded = decodeIdentity(h, raw, state.lastSeenId, state.requestedId);
+    if (decoded.sessionId !== null)
+        state.lastSeenId = decoded.sessionId;
+    if (decoded.identity !== null) {
+        events.push({
+            kind: "identity",
+            sessionId: decoded.identity,
+            authority: h.identity.authority,
+            capabilities: capabilitiesOf(h, model, "headless-turn"),
+        });
+    }
+    else if (decoded.outcome === "malformed" || decoded.outcome === "rotated") {
+        // The interpretation layer classified an identity anomaly; swallowing
+        // it would leave the runner waiting for an identity that already
+        // failed to arrive (or bind a rotated one).
+        events.push({ kind: "error", message: `identity ${decoded.outcome}` });
+    }
+    // Content (message/token/tool/error) is per-harness; identity above is
+    // descriptor-driven. contentEventsOf dispatches by harness name.
+    for (const content of contentEventsOf(h.name, raw))
+        events.push(content);
+    return events;
+};
+//# sourceMappingURL=decode.js.map

package/dist/execution/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/execution/decode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAYhE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,WAAW,GAAkB,IAAI,EAAe,EAAE,CAAC,CAAC;IACnF,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE,KAAK;IAChB,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,CAAoB,EACpB,IAAY,EACZ,KAAkB,EAClB,KAAa,EACG,EAAE;IAClB,IAAI,GAAY,CAAC;IACjB,IAAI,CAAC;QACH,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;IAAC,MAAM,CAAC;QACP,2EAA2E;QAC3E,MAAM,IAAI,GAAG,iBAAiB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QACxC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;YACvB,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,wBAAwB,IAAI,GAAG,EAAE,CAAC,CAAC;QAC7E,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAC5C,CAAC,CAAC;AAEF;;uDAEuD;AACvD,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,CAAoB,EACpB,GAAY,EACZ,KAAkB,EAClB,KAAa,EACG,EAAE;IAClB,MAAM,MAAM,GAAmB,EAAE,CAAC;IAClC,MAAM,OAAO,GAAG,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC5E,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI;QAAE,KAAK,CAAC,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IACrE,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,OAAO,CAAC,QAAQ;YAC3B,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,SAAS;YAC/B,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC;SACxD,CAAC,CAAC;IACL,CAAC;SAAM,IAAI,OAAO,CAAC,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC5E,sEAAsE;QACtE,iEAAiE;QACjE,4CAA4C;QAC5C,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,uEAAuE;IACvE,iEAAiE;IACjE,KAAK,MAAM,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,GAAG,CAAC;QAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/dist/execution/deps.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Injected runtime primitives (D-005): the execution layer never imports
+ * child_process, never calls process.kill, and never reads a wall clock -
+ * spawn, clock, and signalling arrive as data so Node/Bun is a real
+ * portability boundary and tests run against fakes deterministically.
+ */
+export interface SpawnedProcess {
+    readonly stdout: AsyncIterable<string | Uint8Array>;
+    readonly stderr: AsyncIterable<string | Uint8Array>;
+    /** Idempotently terminate stdout and stderr reads without signalling the
+     * child. An adapter MUST preserve chunks already buffered when disposal is
+     * requested, then settle the first read beyond that finite snapshot.
+     * Terminal cleanup owns process signalling separately. */
+    disposeOutput(): void;
+    /** Resolves with the exit code, or null when the process died to a
+     * signal without one. */
+    readonly exited: Promise<number | null>;
+    /** Present when the spawner opened a writable stdin (session mode needs
+     * it; one-shot turns close or inherit stdin instead). */
+    readonly stdin?: {
+        write(data: string): void;
+        end(): void;
+    };
+}
+export interface SpawnOptions {
+    readonly cwd?: string;
+    /** `pipe` opens a writable stdin (sessions require it); `inherit` hands
+     * the child the parent's fd 0; `close` gives it nothing (pi's rule). */
+    readonly stdin: "inherit" | "close" | "pipe";
+}
+export type TimerHandle = number;
+export interface Clock {
+    now(): number;
+    setTimeout(fn: () => void, ms: number): TimerHandle;
+    clearTimeout(handle: TimerHandle): void;
+}
+export type SignalName = "SIGTERM" | "SIGKILL";
+/** One structured line per boundary transition - spawn, exit, stall,
+ * redacted argv. Always-on baseline evidence; the host decides where it
+ * goes. */
+export type BoundaryLog = (event: Record<string, unknown>) => void;
+export interface RunnerDeps {
+    readonly spawn: (argv: readonly string[], opts: SpawnOptions) => SpawnedProcess;
+    readonly clock: Clock;
+    readonly signal: (proc: SpawnedProcess, sig: SignalName) => void;
+    /** Stall watchdog budget; armed ONLY for none-granularity invocations. */
+    readonly stallMs?: number;
+    readonly log?: BoundaryLog;
+    /** Host-minted correlation id; without it the runner falls back to a
+     * per-process monotonic counter (collides across processes). */
+    readonly turnId?: string;
+}
+//# sourceMappingURL=deps.d.ts.map

package/dist/execution/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../src/execution/deps.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;IACpD;;;8DAG0D;IAC1D,aAAa,IAAI,IAAI,CAAC;IACtB;6BACyB;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACxC;6DACyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,GAAG,IAAI,IAAI,CAAC;KACb,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;4EACwE;IACxE,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;CAC9C;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,MAAM,WAAW,KAAK;IACpB,GAAG,IAAI,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,WAAW,CAAC;IACpD,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CACzC;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAE/C;;WAEW;AACX,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;AAEnE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,YAAY,KAAK,cAAc,CAAC;IAChF,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IACjE,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC;IAC3B;oEACgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/execution/deps.js

@@ -0,0 +1,8 @@
+/**
+ * Injected runtime primitives (D-005): the execution layer never imports
+ * child_process, never calls process.kill, and never reads a wall clock -
+ * spawn, clock, and signalling arrive as data so Node/Bun is a real
+ * portability boundary and tests run against fakes deterministically.
+ */
+export {};
+//# sourceMappingURL=deps.js.map

package/dist/execution/deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.js","sourceRoot":"","sources":["../../src/execution/deps.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/execution/events.d.ts

@@ -0,0 +1,54 @@
+/**
+ * HarnessEvent: the runner's output vocabulary (PLAN.md Part 0). The
+ * normalizer owns these events and the parsing that produces them; it does
+ * NOT own the chat protocol - lucid maps events into frames downstream.
+ * Only `done` is terminal. A turn may emit MULTIPLE `error` events before
+ * it (a decoded mid-stream error, then a crash-exit stderr tail, etc.), so
+ * a consumer treats `error` as informational and waits for `done`.
+ *
+ * Event classes are load-bearing for backpressure: token/progress/context
+ * are droppable (coalescible, latest-wins); the rest are lossless. The
+ * split is DECLARED here because the normalizer emits the events; the
+ * coalescing policy that consumes it lives in the chat layer (lucid-v2).
+ * Under token granularity a turn's text arrives twice by design: as token
+ * deltas AND as the whole trailing message event - render one, never
+ * concatenate both.
+ */
+import type { CapabilityResult } from "../interpretation/capabilities.js";
+export type ExitCause = "clean" | "limit" | "crash" | "stall" | "killed";
+export type HarnessEvent = {
+    readonly kind: "identity";
+    readonly sessionId: string;
+    readonly authority: "caller-assigned" | "harness-minted";
+    readonly capabilities: CapabilityResult;
+} | {
+    readonly kind: "token";
+    readonly text: string;
+} | {
+    readonly kind: "message";
+    readonly role: string;
+    readonly text: string;
+} | {
+    readonly kind: "progress";
+    readonly label: string;
+} | {
+    readonly kind: "tool";
+    readonly name: string;
+    readonly input?: unknown;
+} | {
+    readonly kind: "context";
+    readonly usedPct: number;
+} | {
+    readonly kind: "limit";
+    readonly code: string;
+    readonly message: string;
+} | {
+    readonly kind: "error";
+    readonly message: string;
+} | {
+    readonly kind: "done";
+    readonly exitCode: number | null;
+    readonly cause: ExitCause;
+};
+export declare const DROPPABLE_KINDS: Set<string>;
+//# sourceMappingURL=events.d.ts.map

package/dist/execution/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/execution/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzE,MAAM,MAAM,YAAY,GACpB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;IACzD,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;CACzC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC3E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAE3F,eAAO,MAAM,eAAe,aAA4C,CAAC"}

package/dist/execution/events.js

@@ -0,0 +1,2 @@
+export const DROPPABLE_KINDS = new Set(["token", "progress", "context"]);
+//# sourceMappingURL=events.js.map

package/dist/execution/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/execution/events.ts"],"names":[],"mappings":"AAoCA,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC"}

package/dist/execution/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Execution layer: owns the process lifecycle for a harness session.
+ *
+ * It exposes openSession() and streamTurn(), which drive a CLI process via
+ * injected {spawn, clock, signal} primitives and emit HarnessEvent values.
+ * This module knows nothing about any chat protocol. Because it must run
+ * identically on Node and Bun, it never imports child_process and never calls
+ * process.kill directly outside the node-deps adapter - all process I/O and
+ * signalling flows through the injected primitives.
+ */
+export { AsyncChannel } from "./channel.js";
+export * from "./decode.js";
+export * from "./deps.js";
+export * from "./events.js";
+export { LINE_MAX, LineBuffer } from "./lines.js";
+export { nodeRunnerDeps } from "./node-deps.js";
+export * from "./open-session.js";
+export * from "./stream-turn.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/execution/index.js

@@ -0,0 +1,19 @@
+/**
+ * Execution layer: owns the process lifecycle for a harness session.
+ *
+ * It exposes openSession() and streamTurn(), which drive a CLI process via
+ * injected {spawn, clock, signal} primitives and emit HarnessEvent values.
+ * This module knows nothing about any chat protocol. Because it must run
+ * identically on Node and Bun, it never imports child_process and never calls
+ * process.kill directly outside the node-deps adapter - all process I/O and
+ * signalling flows through the injected primitives.
+ */
+export { AsyncChannel } from "./channel.js";
+export * from "./decode.js";
+export * from "./deps.js";
+export * from "./events.js";
+export { LINE_MAX, LineBuffer } from "./lines.js";
+export { nodeRunnerDeps } from "./node-deps.js";
+export * from "./open-session.js";
+export * from "./stream-turn.js";
+//# sourceMappingURL=index.js.map

package/dist/execution/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/execution/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/execution/lines.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Line assembly for process streams: chunks arrive torn at arbitrary BYTE
+ * boundaries, so the byte->string step must stream (a multibyte character
+ * split across chunks decodes whole, never as replacement bytes), and
+ * complete lines are only ever cut at '\n'. The pending partial is scanned
+ * incrementally (never re-split from the start) and bounded: a payload
+ * must not become parseable - or resident - by luck of where the pipe
+ * split it, so an over-long line flips to discard until its newline.
+ */
+export declare const LINE_MAX = 65536;
+export declare class LineBuffer {
+    private readonly decoder;
+    private pending;
+    private scanFrom;
+    private discarding;
+    push(chunk: string | Uint8Array): string[];
+    private ingest;
+    /** The final partial line at stream close, if any. */
+    flush(): string | null;
+}
+//# sourceMappingURL=lines.d.ts.map

package/dist/execution/lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","sourceRoot":"","sources":["../../src/execution/lines.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,QAAQ,QAAS,CAAC;AAE/B,qBAAa,UAAU;IAGrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,UAAU,CAAS;IAE3B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAAE,CAGzC;IAED,OAAO,CAAC,MAAM;IA2Bd,sDAAsD;IACtD,KAAK,IAAI,MAAM,GAAG,IAAI,CAQrB;CACF"}

package/dist/execution/lines.js

@@ -0,0 +1,70 @@
+/**
+ * Line assembly for process streams: chunks arrive torn at arbitrary BYTE
+ * boundaries, so the byte->string step must stream (a multibyte character
+ * split across chunks decodes whole, never as replacement bytes), and
+ * complete lines are only ever cut at '\n'. The pending partial is scanned
+ * incrementally (never re-split from the start) and bounded: a payload
+ * must not become parseable - or resident - by luck of where the pipe
+ * split it, so an over-long line flips to discard until its newline.
+ */
+export const LINE_MAX = 65_536;
+export class LineBuffer {
+    // Per-instance and stateful ({stream:true}): a shared decoder would carry
+    // partial-sequence state across two streams and corrupt both.
+    decoder = new TextDecoder();
+    pending = "";
+    scanFrom = 0;
+    discarding = false;
+    push(chunk) {
+        const text = typeof chunk === "string" ? chunk : this.decoder.decode(chunk, { stream: true });
+        return this.ingest(text);
+    }
+    ingest(text) {
+        this.pending += text;
+        const lines = [];
+        while (true) {
+            const at = this.pending.indexOf("\n", this.scanFrom);
+            if (at === -1)
+                break;
+            const line = this.pending.slice(0, at);
+            this.pending = this.pending.slice(at + 1);
+            this.scanFrom = 0;
+            if (this.discarding) {
+                // The truncated head of an over-long line ends here; drop it whole.
+                this.discarding = false;
+                continue;
+            }
+            // The bound applies to COMPLETE lines too - an oversized line whose
+            // newline arrived in the same chunk must not bypass it.
+            if (line.length <= LINE_MAX && !isBlank(line))
+                lines.push(line);
+        }
+        this.scanFrom = this.pending.length;
+        if (this.pending.length > LINE_MAX) {
+            this.pending = "";
+            this.scanFrom = 0;
+            this.discarding = true;
+        }
+        return lines;
+    }
+    /** The final partial line at stream close, if any. */
+    flush() {
+        const tail = this.decoder.decode();
+        if (tail !== "")
+            this.pending += tail;
+        const rest = this.discarding || isBlank(this.pending) ? null : this.pending;
+        this.pending = "";
+        this.scanFrom = 0;
+        this.discarding = false;
+        return rest;
+    }
+}
+const isBlank = (line) => {
+    for (let i = 0; i < line.length; i++) {
+        const c = line.charCodeAt(i);
+        if (c !== 32 && c !== 9 && c !== 13)
+            return false;
+    }
+    return true;
+};
+//# sourceMappingURL=lines.js.map

package/dist/execution/lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.js","sourceRoot":"","sources":["../../src/execution/lines.ts"],"names":[],"mappings":"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"}