@yaag/runtime 0.1.0

package/src/extension-source.ts

@@ -0,0 +1,60 @@
+/**
+ * Parses pi package specifiers (`npm:`, `git:`) used as extension declarations.
+ *
+ * A declaration that carries neither prefix is a filesystem path and is reported
+ * as `{ kind: "path" }` so the caller keeps its existing resolution behaviour.
+ */
+export type ExtensionSource =
+  | { readonly kind: "path" }
+  | { readonly kind: "npm"; readonly packageName: string }
+  | { readonly kind: "git"; readonly host: string; readonly owner: string; readonly repo: string };
+
+/** An extension declared as a pi package specifier rather than a filesystem path. */
+export type InstalledExtensionSource = Exclude<ExtensionSource, { kind: "path" }>;
+
+/**
+ * Classifies one extension declaration.
+ *
+ * Throws when an `npm:`/`git:` prefix is present but the remainder is not a
+ * package name or a `<host>/<owner>/<repo>` triple.
+ */
+export function parseExtensionSource(declaration: string): ExtensionSource {
+  if (declaration.startsWith("npm:")) {
+    return { kind: "npm", packageName: parsePackageName(declaration) };
+  }
+  if (declaration.startsWith("git:")) return parseGitSource(declaration);
+  return { kind: "path" };
+}
+
+function parsePackageName(declaration: string): string {
+  const spec = declaration.slice("npm:".length);
+  if (spec === "") throw new Error(`extension "${declaration}" has no package name`);
+  const scoped = spec.startsWith("@");
+  const versionAt = spec.indexOf("@", scoped ? 1 : 0);
+  const name = versionAt === -1 ? spec : spec.slice(0, versionAt);
+  if (name === "" || (scoped && !name.includes("/"))) {
+    throw new Error(`extension "${declaration}" has no package name`);
+  }
+  return name;
+}
+
+function parseGitSource(declaration: string): ExtensionSource {
+  const location = normalizeGitLocation(declaration.slice("git:".length));
+  const segments = location.split("/").filter((segment) => segment !== "");
+  if (segments.length < 3) {
+    throw new Error(`extension "${declaration}" is not a git <host>/<owner>/<repo> reference`);
+  }
+  const [host, owner, repo] = segments.slice(segments.length - 3);
+  if (host === undefined || owner === undefined || repo === undefined) {
+    throw new Error(`extension "${declaration}" is not a git <host>/<owner>/<repo> reference`);
+  }
+  return { kind: "git", host, owner, repo: repo.replace(/\.git$/, "") };
+}
+
+function normalizeGitLocation(location: string): string {
+  // pi accepts the same repo as https://, ssh:// and scp-style `git@host:owner/repo`
+  // (docs/packages.md); all three land in the same ~/.pi/agent/git checkout.
+  const withoutScheme = location.replace(/^[a-z+]+:\/\//, "");
+  const withoutUser = withoutScheme.replace(/^[^@/]+@/, "");
+  return withoutUser.replace(":", "/");
+}

package/src/fake-transport.ts

@@ -0,0 +1,240 @@
+import { DEFAULT_WRAP_UP_PROMPT } from "./ask-limit.ts";
+import { FrameQueue } from "./frame-queue.ts";
+import { parseFrame } from "./jsonl.ts";
+import type { AgentStats, AgentTransport, AskMarker, Frame } from "./transport.ts";
+
+/**
+ * Scripted frame playback for one prompt sent through a FakeTransport.
+ *
+ * Abort frames play only after that prompt's abort command.
+ */
+export interface FakePromptScript {
+  /** Frames the Agent emits in response to this prompt, in recorded order. */
+  readonly frames?: readonly Frame[];
+  /** Scripts selected in order by correction follow-up `prompt` commands. */
+  readonly corrections?: readonly FakePromptScript[];
+  /** Script selected by the configured or default soft-limit wrap-up steer, when provided. */
+  readonly wrapUp?: FakePromptScript;
+  /** Prompt that selects `wrapUp`; falls back to the runtime default when omitted. */
+  readonly wrapUpPrompt?: string;
+  /** Frames emitted after yaag sends an abort command. */
+  readonly abortFrames?: readonly Frame[];
+  /** Delay before each scripted frame, for clock-driven tests. */
+  readonly frameDelayMs?: number;
+  /** Delay before each abort-specific frame, for abort-settlement tests. */
+  readonly abortFrameDelayMs?: number;
+  /** Payload of `get_last_assistant_text`; null means the `{}` pi returns on failure. */
+  readonly lastText?: string | null;
+  /** Makes this script's prompt RPC response fail, before any frame playback. */
+  readonly promptError?: string;
+}
+
+/**
+ * Configures a FakeTransport with one shorthand script or ordered per-prompt scripts.
+ *
+ * Control-command failures apply across the configured playback.
+ */
+export interface FakeTransportOptions extends FakePromptScript {
+  /** One script per Ask's initial prompt, used in order; preserves the single-script shorthand above. */
+  readonly scripts?: readonly FakePromptScript[];
+  /** Makes a steer RPC response fail without embedding a limit decision in playback. */
+  readonly steerError?: string;
+  /** Makes an abort RPC response fail without embedding a limit decision in playback. */
+  readonly abortError?: string;
+  readonly stats?: AgentStats;
+  /** pi can answer a command after `agent_settled` — it is last among events only. */
+  readonly promptResponse?: "immediate" | "after-settle";
+  /** Ends the frame stream once playback finishes, as a dying process would. */
+  readonly dieAfterFrames?: boolean;
+}
+
+/**
+ * Test implementation of the transport seam that plays scripted recorded or synthetic frames.
+ *
+ * It encodes real pi (0.84.1) post-settlement semantics: an Ask's initial prompt
+ * selects the next top-level script, each later prompt within the same Ask selects
+ * the next correction script, and a non-wrap-up steer is acknowledged but only
+ * queued (`queue_update`) — it never plays frames or settles.
+ * It never spawns or closes a real Agent process.
+ */
+export class FakeTransport implements AgentTransport {
+  readonly model = "test/model";
+  /** Everything the runtime wrote, in order. */
+  readonly sent: Frame[] = [];
+  readonly asks: AskMarker[] = [];
+  readonly #queue = new FrameQueue();
+  readonly #options: FakeTransportOptions;
+  #closed = false;
+  #closeCalls = 0;
+  #closing: Promise<AgentStats> | null = null;
+  #scriptIndex = 0;
+  // A fresh Agent's first prompt is always an Ask's initial prompt, even when a
+  // wrapping transport hides beginAsk from this fake.
+  #initialPromptPending = true;
+  #correctionIndex = 0;
+  #corrections: readonly FakePromptScript[] = [];
+  #currentScript: FakePromptScript | null = null;
+  #playback: Promise<void> = Promise.resolve();
+
+  constructor(options: FakeTransportOptions = {}) {
+    this.#options = options;
+  }
+
+  send(frame: Frame): void {
+    this.sent.push(frame);
+    if (frame.type === "prompt") void this.#answerPrompt(frame);
+    if (frame.type === "steer") void this.#answerSteer(frame);
+    if (frame.type === "abort") void this.#answerAbort(frame);
+    if (frame.type === "get_last_assistant_text") this.#answerLastText(frame);
+  }
+
+  frames(): AsyncIterable<Frame> {
+    return this.#queue.frames();
+  }
+
+  beginAsk(marker: AskMarker): undefined {
+    this.asks.push(marker);
+    this.#initialPromptPending = true;
+    return undefined;
+  }
+
+  finishAsk(): void {
+    // This live test transport does not persist Ask outcomes.
+  }
+
+  /** True once the runtime shut this Agent down. */
+  get closed(): boolean {
+    return this.#closed;
+  }
+
+  /** Number of times this fake actually began close work. */
+  get closeCalls(): number {
+    return this.#closeCalls;
+  }
+
+  close(): Promise<AgentStats> {
+    if (this.#closing === null) {
+      this.#closeCalls += 1;
+      this.#closed = true;
+      this.#queue.end();
+      this.#closing = Promise.resolve(
+        this.#options.stats ?? {
+          tokens: { input: 30, output: 12, cacheRead: 0, cacheWrite: 0, total: 42 },
+          cost: 0.001,
+        },
+      );
+    }
+    return this.#closing;
+  }
+
+  /** Simulates the process dying: the frame stream just ends. */
+  die(): void {
+    this.#queue.end();
+  }
+
+  async #answerPrompt(frame: Frame): Promise<void> {
+    const script = this.#selectPromptScript();
+    const error = script.promptError ?? this.#options.promptError;
+    const response = {
+      type: "response",
+      command: "prompt",
+      id: frame.id,
+      success: error === undefined,
+      ...(error === undefined ? {} : { error }),
+    };
+    if (this.#options.promptResponse !== "after-settle") this.#queue.push(response);
+    await this.#enqueue(script.frames, script.frameDelayMs);
+    if (this.#options.promptResponse === "after-settle") this.#queue.push(response);
+    if (this.#options.dieAfterFrames) this.#queue.end();
+  }
+
+  /** An Ask's initial prompt takes the next top-level script; later prompts are corrections. */
+  #selectPromptScript(): FakePromptScript {
+    if (this.#initialPromptPending) {
+      this.#initialPromptPending = false;
+      const script = this.#options.scripts?.[this.#scriptIndex++] ?? this.#options;
+      this.#currentScript = script;
+      this.#correctionIndex = 0;
+      this.#corrections = script.corrections ?? [];
+      return script;
+    }
+    const script = this.#corrections[this.#correctionIndex++];
+    if (script !== undefined) this.#currentScript = script;
+    return script ?? {};
+  }
+
+  async #answerSteer(frame: Frame): Promise<void> {
+    this.#answerControl(frame, this.#options.steerError);
+    if (this.#options.steerError !== undefined) return;
+    if (this.#isWrapUp(frame)) {
+      const script = this.#currentScript?.wrapUp;
+      if (script === undefined) return;
+      this.#currentScript = script;
+      await this.#enqueue(script.frames, script.frameDelayMs);
+      return;
+    }
+    // pi 0.84.1 parks a steer sent between turns: acknowledged, queued, never played.
+    this.#queue.push({ type: "queue_update" });
+  }
+
+  #isWrapUp(frame: Frame): boolean {
+    return frame.message === (this.#currentScript?.wrapUpPrompt ?? DEFAULT_WRAP_UP_PROMPT);
+  }
+
+  #answerControl(frame: Frame, error?: string): void {
+    this.#queue.push({
+      type: "response",
+      command: frame.type,
+      id: frame.id,
+      success: error === undefined,
+      ...(error === undefined ? {} : { error }),
+    });
+  }
+
+  async #answerAbort(frame: Frame): Promise<void> {
+    this.#answerControl(frame, this.#options.abortError);
+    await this.#enqueue(
+      this.#currentScript?.abortFrames,
+      this.#currentScript?.abortFrameDelayMs ?? this.#currentScript?.frameDelayMs,
+    );
+  }
+
+  #enqueue(frames: readonly Frame[] | undefined, delayMs?: number): Promise<void> {
+    const playback = this.#playback.then(() => this.#play(frames, delayMs));
+    this.#playback = playback.catch(() => {});
+    return playback;
+  }
+
+  async #play(frames: readonly Frame[] | undefined, delayMs?: number): Promise<void> {
+    for (const recorded of frames ?? []) {
+      if (delayMs === undefined) await Promise.resolve();
+      else await Bun.sleep(delayMs);
+      if (this.#closed) return;
+      this.#queue.push(recorded);
+    }
+  }
+
+  #answerLastText(frame: Frame): void {
+    const text = this.#currentScript?.lastText ?? this.#options.lastText;
+    this.#queue.push({
+      type: "response",
+      command: "get_last_assistant_text",
+      id: frame.id,
+      success: true,
+      data: text === null || text === undefined ? {} : { text },
+    });
+  }
+}
+
+/**
+ * Loads and parses a named JSONL frame fixture from the runtime fixtures directory.
+ *
+ * Rejects when the fixture cannot be read or contains an invalid frame.
+ */
+export async function recordedFrames(name: string): Promise<Frame[]> {
+  const text = await Bun.file(`${import.meta.dir}/fixtures/${name}.jsonl`).text();
+  return text
+    .split("\n")
+    .map(parseFrame)
+    .filter((frame): frame is Frame => frame !== null);
+}

package/src/frame-gap.ts

@@ -0,0 +1,41 @@
+/**
+ * Per-Ask frame-gap telemetry: the largest silence between two consecutive
+ * Agent frames (ADR-0020 — measure before enforcing idle thresholds).
+ *
+ * The first gap is measured from prompt send (`start()`) to the first frame;
+ * later gaps are inter-arrival. Live-only: Cassette playback creates no tracker,
+ * because replayed frames arrive instantly and their gaps mean nothing.
+ */
+export interface FrameGapOptions {
+  /** Injectable clock, so tests need no real timers. Defaults to `Date.now`. */
+  readonly now?: () => number;
+}
+
+/** Tracks the maximum inter-frame gap of one Ask. No per-frame allocation. */
+export class FrameGapTracker {
+  readonly #now: () => number;
+  #lastAt = 0;
+  #maxGapMs = 0;
+
+  constructor(options: FrameGapOptions = {}) {
+    this.#now = options.now ?? Date.now;
+  }
+
+  /** Marks prompt send. Call once, before the prompt command. */
+  start(): void {
+    this.#lastAt = this.#now();
+  }
+
+  /** Records one frame arrival, widening the maximum gap if this one is larger. */
+  observe(): void {
+    const at = this.#now();
+    const gap = at - this.#lastAt;
+    if (gap > this.#maxGapMs) this.#maxGapMs = gap;
+    this.#lastAt = at;
+  }
+
+  /** The largest gap observed so far, in milliseconds; 0 when no frame arrived. */
+  get maxGapMs(): number {
+    return this.#maxGapMs;
+  }
+}

package/src/frame-queue.ts

@@ -0,0 +1,52 @@
+import type { Frame } from "./transport.ts";
+
+/**
+ * A single-consumer queue turning pushed frames into an async iterable.
+ *
+ * The live transport reads its child's stdout once — intercepting the responses
+ * to its own commands — and republishes the rest here, so the layer above sees
+ * one ordered stream regardless of when it starts iterating.
+ */
+export class FrameQueue {
+  #buffered: Frame[] = [];
+  #waiting: ((frame: Frame | null) => void) | null = null;
+  #ended = false;
+
+  push(frame: Frame): void {
+    if (this.#ended) return;
+    const waiter = this.#waiting;
+    if (waiter) {
+      this.#waiting = null;
+      waiter(frame);
+      return;
+    }
+    this.#buffered.push(frame);
+  }
+
+  /** Ends the stream; the consumer's iteration finishes once drained. */
+  end(): void {
+    if (this.#ended) return;
+    this.#ended = true;
+    const waiter = this.#waiting;
+    if (waiter) {
+      this.#waiting = null;
+      waiter(null);
+    }
+  }
+
+  async *frames(): AsyncGenerator<Frame> {
+    for (;;) {
+      const buffered = this.#buffered.shift();
+      if (buffered) {
+        yield buffered;
+        continue;
+      }
+      if (this.#ended) return;
+      const next = await new Promise<Frame | null>((resolve) => {
+        this.#waiting = resolve;
+      });
+      if (next === null) return;
+      yield next;
+    }
+  }
+}

package/src/git-facts.ts

@@ -0,0 +1,32 @@
+import type { CassetteGit } from "./cassette.ts";
+
+/**
+ * Observes the branch and commit at a cwd without changing repository state.
+ *
+ * Returns undefined when Git cannot describe a checked-out work tree.
+ */
+export async function readGitFacts(cwd: string): Promise<CassetteGit | undefined> {
+  const inWorkTree = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inWorkTree !== "true") return undefined;
+  const [branch, head] = await Promise.all([
+    git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    git(cwd, ["rev-parse", "HEAD"]),
+  ]);
+  if (!branch || !head) return undefined;
+  return { branch, head };
+}
+
+async function git(cwd: string, args: readonly string[]): Promise<string | undefined> {
+  try {
+    const process = Bun.spawn({
+      cmd: ["git", "-C", cwd, ...args],
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const [code, output] = await Promise.all([process.exited, new Response(process.stdout).text()]);
+    const value = output.trim();
+    return code === 0 && value.length > 0 && !value.includes("\n") ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/idle-watch.ts

@@ -0,0 +1,154 @@
+import type { AskStalledOutcome } from "./errors.ts";
+import type { Frame } from "./transport.ts";
+
+/** Fixed time allowed for `agent_settled` to arrive after the idle abort. */
+export const IDLE_ABORT_SETTLE_MS = 5_000;
+
+export interface IdleWatchOptions {
+  /** Maximum silence, in milliseconds, before escalation starts. */
+  readonly idleMs: number;
+  readonly command: (frame: Frame) => Promise<boolean>;
+  /** Bounded wait for `agent_settled` after the abort; defaults to 5s. */
+  readonly abortSettleMs?: number;
+}
+
+/** Rejection carried by {@link IdleWatch.killed} when abort produced nothing. */
+export class IdleKillSignal extends Error {
+  readonly outcome: AskStalledOutcome;
+
+  constructor(outcome: AskStalledOutcome) {
+    super(`no frame for ${outcome.idleMs}ms and abort did not settle the Agent`);
+    this.name = "IdleKillSignal";
+    this.outcome = outcome;
+  }
+}
+
+/**
+ * Per-Ask silence watchdog, a sibling of `AskLimit` (ADR-0020).
+ *
+ * The timer starts at prompt send and resets on every frame. On expiry it
+ * sends `abort` and nothing else — a queued `steer` would be delivered as a new
+ * turn the instant abort ends the hung one, and `agent_settled` would never
+ * arrive.
+ */
+export class IdleWatch {
+  readonly #idleMs: number;
+  readonly #command: (frame: Frame) => Promise<boolean>;
+  readonly #abortSettleMs: number;
+  readonly #failure: Promise<never>;
+  readonly #kill: Promise<never>;
+  #rejectFailure: (reason: unknown) => void = () => {};
+  #rejectKill: (reason: unknown) => void = () => {};
+  #idleTimer: ReturnType<typeof setTimeout> | undefined;
+  #killTimer: ReturnType<typeof setTimeout> | undefined;
+  #tripped = false;
+  #done = false;
+  #result: AskStalledOutcome | null = null;
+
+  constructor(options: IdleWatchOptions) {
+    this.#idleMs = options.idleMs;
+    this.#command = options.command;
+    this.#abortSettleMs = options.abortSettleMs ?? IDLE_ABORT_SETTLE_MS;
+    this.#failure = new Promise<never>((_resolve, reject) => {
+      this.#rejectFailure = reject;
+    });
+    this.#kill = new Promise<never>((_resolve, reject) => {
+      this.#rejectKill = reject;
+    });
+    // Either race may settle before the Ask starts awaiting them.
+    void this.#failure.catch(() => {});
+    void this.#kill.catch(() => {});
+  }
+
+  /** Arms the idle timer immediately before the prompt command is sent. */
+  start(): void {
+    this.#arm();
+  }
+
+  /** Resets the silence timer; after escalation, watches for `agent_settled`. */
+  observe(frame: Frame): void {
+    if (this.#done) return;
+    if (this.#tripped) {
+      if (frame.type === "agent_settled") this.#finish(false);
+      return;
+    }
+    this.#arm();
+  }
+
+  /** Cancels the watch once the Ask settles. Idempotent. */
+  settled(): void {
+    if (this.#done) return;
+    if (this.#tripped) {
+      this.#finish(false);
+      return;
+    }
+    this.#done = true;
+    this.cleanup();
+  }
+
+  /** Cancels timers on every other Ask exit path. Idempotent. */
+  cleanup(): void {
+    clearTimeout(this.#idleTimer);
+    clearTimeout(this.#killTimer);
+    this.#idleTimer = undefined;
+    this.#killTimer = undefined;
+  }
+
+  /** True once the silence budget expired and escalation began. */
+  get tripped(): boolean {
+    return this.#tripped;
+  }
+
+  /** The stalled outcome, once escalation resolved either way. */
+  get result(): AskStalledOutcome | null {
+    return this.#result;
+  }
+
+  /** Rejects when the abort RPC is refused, mirroring `AskLimit.failed`. */
+  get failed(): Promise<never> {
+    return this.#failure;
+  }
+
+  /** Rejects with an {@link IdleKillSignal} only on the destructive path. */
+  get killed(): Promise<never> {
+    return this.#kill;
+  }
+
+  #arm(): void {
+    clearTimeout(this.#idleTimer);
+    this.#idleTimer = setTimeout(() => this.#trip(), this.#idleMs);
+  }
+
+  #trip(): void {
+    if (this.#done || this.#tripped) return;
+    this.#tripped = true;
+    clearTimeout(this.#idleTimer);
+    this.#idleTimer = undefined;
+    this.#killTimer = setTimeout(() => this.#finish(true), this.#abortSettleMs);
+    void this.#sendAbort();
+  }
+
+  #finish(destructive: boolean): void {
+    if (this.#done) return;
+    this.#done = true;
+    this.#result = { idleMs: this.#idleMs, destructive };
+    this.cleanup();
+    if (destructive) this.#rejectKill(new IdleKillSignal(this.#result));
+  }
+
+  async #sendAbort(): Promise<void> {
+    try {
+      if (!(await this.#command({ type: "abort" }))) {
+        this.#rejectFailure(new Error("idle abort command was rejected"));
+      }
+    } catch (error) {
+      this.#rejectFailure(
+        new Error(
+          error instanceof Error
+            ? `idle abort command failed: ${error.message}`
+            : "idle abort command failed",
+        ),
+      );
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+export type {
+  Cassette,
+  CassetteAgent,
+  CassetteArtifact,
+  CassetteAsk,
+  CassetteGit,
+  CassetteRun,
+  CassetteSink,
+  CassetteSpawn,
+} from "./cassette.ts";
+export { CASSETTE_VERSION } from "./cassette.ts";
+export { loadCassette } from "./cassette-loader.ts";
+export type { AgentConfig, AgentDefinition } from "./define-agent.ts";
+export { agentDefinitionConfig, defineAgent, isAgentDefinition } from "./define-agent.ts";
+export type { OrchestrationProgram, ProgramDefinition } from "./define-run.ts";
+export { defineRun, isOrchestrationProgram, programDefinition } from "./define-run.ts";
+export type {
+  AskInvalidOutputOutcome,
+  AskLimitKind,
+  AskLimitOutcome,
+  AskStalledOutcome,
+  YaagErrorCode,
+} from "./errors.ts";
+export { isYaagError, YaagError } from "./errors.ts";
+export type {
+  AgentActivity,
+  AskOutputChannel,
+  EventSink,
+  LifecycleEvent,
+  LifecycleEventBody,
+  NodeState,
+  NodeUsage,
+  StampedEventSink,
+} from "./events.ts";
+export type { DecodedNode, NodeDecoder } from "./node-decoder.ts";
+export { DEFAULT_NODE_DECODERS } from "./node-decoders.ts";
+export type { NodePath } from "./node-path.ts";
+export { agentAskPath, childPath, sanitizeNodeName } from "./node-path.ts";
+export type { NodeSnapshot } from "./node-tracker.ts";
+export { NodeTracker } from "./node-tracker.ts";
+export { prompt } from "./prompt.ts";
+export { promptGist } from "./prompt-gist.ts";
+export type { ReapPath, ReapTarget } from "./reap.ts";
+export { reap } from "./reap.ts";
+export { recordingTransport } from "./recording-transport.ts";
+export { replayTransport } from "./replay-transport.ts";
+export { resumeTransport } from "./resume-transport.ts";
+export type { RunOptions } from "./run.ts";
+export { executeRun } from "./run.ts";
+export type { RunContext } from "./run-context.ts";
+export type { DiscoveredSkill, SkillProbeFactory } from "./skill-probe.ts";
+export type {
+  AgentInfo,
+  AgentState,
+  AskingAgentInfo,
+  EndedRunSummary,
+  ExitedAgentInfo,
+  IdleAgentInfo,
+  NodeInfo,
+  RunningRunSummary,
+  RunOutcome,
+  RunState,
+  RunSummary,
+} from "./summary.ts";
+export { applyEvent, initialSummary } from "./summary.ts";
+export type {
+  AgentStats,
+  AgentTransport,
+  AskMarker,
+  AskMarkerContext,
+  AskPlayback,
+  Frame,
+  TokenBreakdown,
+  TransportFactory,
+  TransportStartup,
+  TransportStartupObserver,
+  WorktreeResolution,
+} from "./transport.ts";
+export type {
+  AskOptions,
+  Handle,
+  SpawnOptions,
+  SpawnOverrides,
+  StructuredAskOptions,
+  ThinkingLevel,
+} from "./types.ts";
+export {
+  AGENT_NODE_TABLE_MAX,
+  ASK_OUTPUT_FLUSH_INTERVAL_MS,
+  ASK_OUTPUT_MAX_BYTES,
+  ASK_OUTPUT_TRUNCATION_MARKER,
+  NODE_GIST_MAX_CHARS,
+  PROMPT_GIST_MAX_CHARS,
+  TOOL_ARGS_GIST_MAX_CHARS,
+} from "./wire-constants.ts";
+export { worktreeTransport } from "./worktree-transport.ts";