indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/conductor/bash-guard.d.ts

@@ -1,106 +0,0 @@
-/**
- * Bash command parser/classifier + catastrophic-command blocklist.
- *
- * The permission engine ({@link "./permissions"}) matches a tool call against
- * induscode-style `Bash(...)` allow/ask/deny rules. For most tools the call is a
- * single atomic action, so a rule's argument specifier matches against one
- * subject string. The shell tool is different: `a && b; c | d` is FOUR commands
- * in one call, and a coarse "match the whole command string" check is trivially
- * bypassed — a benign-looking prefix can smuggle a destructive tail past an
- * allow rule (`npm test && rm -rf /`), or hide a blocked binary behind a wrapper
- * (`env X=1 rm -rf /`, `sudo rm -rf /`) or quoting.
- *
- * This module makes bash matching real. It is split in two concerns:
- *
- *   1. **A parser/classifier** — {@link parseBashCommand} splits a shell command
- *      string into its constituent *simple* commands across the control
- *      operators (`;`, `&&`, `||`, `|`, newlines) and `( … )` subshells /
- *      `$( … )` / `` ` … ` `` command substitutions, strips benign leading
- *      wrappers (`env VAR=x`, `nice`, `nohup`, `timeout N`, `xargs`, `command`,
- *      `builtin`, and `sudo`/`doas` — the last recorded as an *elevation* flag),
- *      and returns each base command + its raw argument string. Quoting is
- *      handled well enough that `"rm -rf /"` cannot hide behind quotes or a
- *      wrapper. The split is quote-aware so an operator *inside* a quoted string
- *      (`echo "a && b"`) is NOT treated as a command boundary.
- *
- *   2. **A catastrophic blocklist** — {@link isCatastrophicCommand} matches a
- *      single parsed sub-command against a conservative set of always-deny
- *      patterns (root-targeting `rm -rf`, fork bombs, `curl … | sh` of remote
- *      scripts, `dd of=/dev/…`, `mkfs`, `chmod -R 777 /`, redirect-to-raw-disk).
- *      It is deliberately narrow so normal dev commands (`rm -rf node_modules`,
- *      `rm -rf ./dist`, `curl … -o file`) are NOT blocked. This is
- *      defense-in-depth, NOT a hard security boundary — the OS sandbox and the
- *      permission gate are the real boundary.
- *
- * Everything here is pure, synchronous, and side-effect free so the classifier
- * and the blocklist are exhaustively unit-testable, and the permission engine
- * can fold them into its decision without any I/O.
- */
-/**
- * One simple command extracted from a (possibly compound) shell string.
- *
- * `rm -rf /tmp` parses to `{ name: "rm", args: ["-rf", "/tmp"], elevated: false,
- * raw: "rm -rf /tmp" }`. The `name` is the base binary AFTER benign wrappers are
- * stripped; `args` are its tokens (quotes removed); `raw` is the original
- * sub-command slice (wrappers included) so a caller can echo exactly what the
- * model asked for; `elevated` is true when a `sudo`/`doas` wrapper was stripped.
- */
-export interface ParsedCommand {
-    /** The base binary, lower-cased for stable comparison (e.g. `"rm"`). */
-    readonly name: string;
-    /** The argument tokens after the binary, with surrounding quotes removed. */
-    readonly args: readonly string[];
-    /** Whether a `sudo`/`doas` elevation wrapper preceded this command. */
-    readonly elevated: boolean;
-    /** The original sub-command slice (wrappers included), trimmed. */
-    readonly raw: string;
-}
-/**
- * Parse a (possibly compound) shell command string into the flat list of every
- * simple command it runs — across operators, subshells, and command
- * substitutions, with benign wrappers stripped.
- *
- * The result is order-preserving and exhaustive enough that the permission
- * engine can evaluate a `Bash(...)` rule (and the catastrophic blocklist)
- * against EACH sub-command independently: a deny on any sub-command denies the
- * whole call, and an allow must cover every sub-command to auto-allow.
- *
- * @returns one {@link ParsedCommand} per simple command; an empty array for an
- * empty/whitespace command string.
- */
-export declare function parseBashCommand(command: string): ParsedCommand[];
-/**
- * Classify a SINGLE parsed sub-command against the catastrophic blocklist.
- *
- * @returns the byte-stable deny reason when the command is catastrophic, else
- * `undefined`. Use {@link evaluateCatastrophic} for a whole compound call (it
- * also runs the cross-sub-command `curl | sh` correlation).
- */
-export declare function catastrophicReason(cmd: ParsedCommand): string | undefined;
-/** Convenience boolean form of {@link catastrophicReason}. */
-export declare function isCatastrophicCommand(cmd: ParsedCommand): boolean;
-/**
- * Evaluate the catastrophic blocklist over a WHOLE bash command string.
- *
- * Parses the (possibly compound) command, runs the per-sub-command blocklist on
- * each leaf, AND runs the cross-sub-command `curl | sh` correlation. Returns a
- * byte-stable deny message when ANY check fires, else `undefined`.
- *
- * This is what the permission engine calls for the bash tool: a catastrophic
- * command is denied REGARDLESS of allow/ask/deny rules or mode (it is not even
- * `bypass`-able, mirroring the original always-block guard).
- */
-export declare function evaluateCatastrophic(command: string): string | undefined;
-/**
- * Render the rule-matching SUBJECT for each sub-command of a bash call: the base
- * command joined with its argument tokens (wrappers stripped). The permission
- * engine matches an induscode `Bash(...)` specifier against EACH of these — an
- * allow rule must cover them all to auto-allow, a deny on any one denies the
- * whole call.
- *
- * For `npm test && rm important.txt` this yields `["npm test", "rm
- * important.txt"]`, so `Bash(npm test)` allows the first but not the second.
- * Returns the original command (single element) when nothing parses, so a tool
- * call always has at least one subject to match against.
- */
-export declare function bashSubcommandSubjects(command: string): string[];

package/dist/types/conductor/bash-guard.test.d.ts

@@ -1,17 +0,0 @@
-/**
- * Bash command parser/classifier + catastrophic blocklist — unit tests.
- *
- * Pins the parser ({@link parseBashCommand}) across the four concerns that make
- * coarse whole-string matching trivially bypassable:
- *   - **compound** splitting on `;`, `&&`, `||`, `|`, `&`, newlines,
- *   - benign **wrapper** stripping (`env VAR=x`, `nohup`, `timeout N`, `nice -n
- *     N`, `xargs`, `command`, and `sudo`/`doas` as elevation),
- *   - **subshell / command-substitution** descent (`( … )`, `$( … )`, `` ` … ` ``),
- *   - **quote-aware** tokenization so an operator inside a quote is not a
- *     boundary and a quoted/escaped binary cannot hide from the classifier,
- * plus the documented bypass cases. Then the catastrophic blocklist
- * ({@link evaluateCatastrophic}) — `rm -rf /` and root-ish targets, fork bombs,
- * `curl | sh`, raw-disk writes, `mkfs`, `chmod -R 777 /` — alongside the
- * negative cases proving normal dev commands are NOT blocked. No I/O.
- */
-export {};

package/dist/types/conductor/catalog/catalog.d.ts

@@ -1,87 +0,0 @@
-/**
- * Model catalog — `ModelCatalog`.
- *
- * A transform pipeline over the framework model list. The framework publishes
- * its catalog per provider via `getModels(provider)` from `indusagi/ai`; each
- * entry is a rich {@link Model} record. This module **re-derives** that data
- * into the conductor's own normalized shape — a {@link CatalogCard} — through a
- * validate → normalize → key pipeline, then exposes a small lookup surface
- * (`all`, `byProvider`, `get`) keyed by a canonical `"provider/modelId"` id.
- *
- * This replaces pi's `model-registry` / `ModelRegistry`. It is intentionally
- * *not* a re-export of the framework registry: the field order and shape are
- * the conductor's, the data is run back through a zod gate, and the public
- * methods read differently. The full framework {@link Model} is retained on each
- * card so the conductor can hand a complete model object to the agent without a
- * second registry round-trip.
- */
-import { type KnownProvider, type Model } from "indusagi/ai";
-import type { ModelCardRef } from "../contract";
-/**
- * One normalized entry in the catalog.
- *
- * Extends the lightweight {@link ModelCardRef} identity projection with the
- * extra capability facets the matcher filters on, plus the original framework
- * {@link Model}. `ref` is the slice a UI lists/labels with; `model` is the full
- * record the conductor binds to the agent.
- */
-export interface CatalogCard {
-    /** Canonical `"provider/modelId"` identifier — the catalog key. */
-    readonly id: string;
-    /** Owning provider slug. */
-    readonly provider: KnownProvider | string;
-    /** Provider-scoped model id (e.g. `"claude-sonnet-4"`). */
-    readonly modelId: string;
-    /** Human-readable display name. */
-    readonly name: string;
-    /** Whether the model exposes a reasoning/thinking budget. */
-    readonly reasoning: boolean;
-    /** Whether the model accepts image input. */
-    readonly acceptsImages: boolean;
-    /** Context window size in tokens (0 when the framework omits it). */
-    readonly contextTokens: number;
-    /** The framework model record, retained verbatim for binding. */
-    readonly model: Model<Model<string>["api"]>;
-}
-/** Project a {@link CatalogCard} down to its public {@link ModelCardRef} slice. */
-export declare function toCardRef(card: CatalogCard): ModelCardRef;
-/** Compose the canonical catalog key from a provider + model id. */
-export declare function canonicalId(provider: string, modelId: string): string;
-/** Injection seam for tests: how the catalog sources its raw data. */
-export interface CatalogSource {
-    /** Enumerate the providers to scan. */
-    readonly providers: () => readonly (KnownProvider | string)[];
-    /** Pull the raw model list for one provider. */
-    readonly models: (provider: string) => readonly Model<string>[];
-}
-/**
- * A normalized, validated view of the framework model list.
- *
- * Construct once (the build pipeline runs eagerly in the constructor) and query
- * many times. The instance is immutable after construction; call
- * {@link ModelCatalog.refreshed} to rebuild against the current framework state.
- */
-export declare class ModelCatalog {
-    #private;
-    /**
-     * @param source raw-data seam; defaults to the live `indusagi/ai` registry.
-     */
-    constructor(source?: CatalogSource);
-    /** Total number of cards in the catalog. */
-    get size(): number;
-    /** Every card, in insertion order (provider scan order). */
-    all(): readonly CatalogCard[];
-    /** Cards owned by one provider (empty array if the provider has none). */
-    byProvider(provider: KnownProvider | string): readonly CatalogCard[];
-    /** The providers that contributed at least one card, in scan order. */
-    providers(): readonly string[];
-    /**
-     * Look up one card by its canonical `"provider/modelId"` id. Also accepts a
-     * bare provider-scoped model id when it is unambiguous across providers.
-     */
-    get(id: string): CatalogCard | undefined;
-    /** True when the canonical id resolves to a card. */
-    has(id: string): boolean;
-    /** Rebuild against the current framework state, returning a fresh catalog. */
-    refreshed(source?: CatalogSource): ModelCatalog;
-}

package/dist/types/conductor/catalog/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * Model catalog subsystem — public barrel.
- *
- * Bundles the {@link ModelCatalog} (a normalized, validated transform over the
- * framework model list) and the {@link ModelMatcher} (a scored-candidate query
- * resolver). Consumers import both — plus the {@link CatalogCard} shape and the
- * `canonicalId` / `toCardRef` helpers — from `src/conductor/catalog` rather than
- * reaching into the individual modules.
- *
- * This pairing replaces pi's `model-registry` + `model-resolver`; the catalog
- * key, card shape, and resolution algorithm are all the conductor's own.
- */
-export { ModelCatalog, canonicalId, toCardRef, type CatalogCard, type CatalogSource, } from "./catalog";
-export { ModelMatcher, type ResolveInput, } from "./matcher";

package/dist/types/conductor/catalog/matcher.d.ts

@@ -1,47 +0,0 @@
-/**
- * Model matcher — `ModelMatcher`.
- *
- * A scored-candidate resolver over a {@link ModelCatalog}. Given a free-form
- * query (a string, or a structured {@link MatchQuery}), it produces the single
- * best-matching {@link ModelCardRef}, or `undefined` when nothing clears the bar.
- *
- * It is an independent implementation: resolution is a *prioritized scoring
- * pipeline*, not a chain of single-purpose match helpers with recursive
- * colon-splitting. Each candidate card is scored against the query by a set of
- * independent strategy probes (exact-canonical, exact-id, provider-prefix,
- * alias-substring, glob), the capability filters gate the field, and the highest
- * scorer (with deterministic tie-breaks) wins. Every helper name here is fresh.
- */
-import type { MatchQuery, ModelCardRef } from "../contract";
-import { type CatalogCard, type ModelCatalog } from "./catalog";
-/** Either a raw selector string or the structured {@link MatchQuery}. */
-export type ResolveInput = string | MatchQuery;
-/**
- * Resolves model queries against a {@link ModelCatalog} by scored candidates.
- *
- * Construct once with a catalog, then call {@link ModelMatcher.resolve} per
- * query. The matcher holds no mutable state; it is safe to share.
- */
-export declare class ModelMatcher {
-    #private;
-    constructor(catalog: ModelCatalog);
-    /**
-     * Resolve a query to the single best {@link ModelCardRef}, or `undefined`.
-     *
-     * Pipeline:
-     *   1. lift the input to a {@link MatchQuery};
-     *   2. honor an explicit `provider`+`modelId` *pin* (highest tier) up front;
-     *   3. gate every card through {@link clearsConstraints};
-     *   4. with no pattern, return the leading surviving candidate (default pick);
-     *   5. otherwise score each survivor via {@link probePattern} + {@link tieBonus}
-     *      and return the top scorer (deterministic tie-break by tier, bonus, id).
-     */
-    resolve(input: ResolveInput): ModelCardRef | undefined;
-    /** As {@link resolve}, but returns the full {@link CatalogCard}. */
-    resolveCard(input: ResolveInput): CatalogCard | undefined;
-    /**
-     * Resolve, returning *all* surviving candidates ranked best-first (the field
-     * a "did you mean" picker would show). Useful for ambiguous selectors.
-     */
-    resolveAll(input: ResolveInput): readonly ModelCardRef[];
-}

package/dist/types/conductor/conductor.d.ts

@@ -1,213 +0,0 @@
-/**
- * SessionConductor — the product-level orchestrator over the framework `Agent`.
- *
- * The framework `Agent` (from `indusagi/agent`) is a raw LLM conversation loop:
- * it streams a fine-grained {@link AgentEvent} surface and owns a flat message
- * list. The {@link SessionConductor} wraps one such agent and turns it into a
- * *coding-agent session*: it drives turns, projects the loop's events down to the
- * stable {@link SessionSignal} stream (via {@link translateAgentEvent} + the
- * {@link SignalHub}), persists every produced message into a branchable
- * {@link TranscriptStore}, retries transient model faults, condenses the
- * transcript when it nears the window, and resolves an immutable
- * {@link ConductorState} per turn.
- *
- * This replaces pi's `AgentSession`, but with a deliberately different internal
- * model (the clean-room divergence):
- *   - **Immutable state reducer.** The conductor never mutates a state object in
- *     place. Each transition runs through {@link reduceState}, which returns a
- *     fresh {@link ConductorState}; `snapshot()` hands out that value.
- *   - **Ordered in-flight tool list.** Live tool calls are tracked as an ordered
- *     array (start appends, end removes), not pi's `Set<string>` of pending ids.
- *   - **Typed discriminated faults.** Failures surface as a {@link ConductorFault}
- *     on a `{ kind: "fault" }` signal — never as a fabricated assistant message
- *     and never as a string sentinel.
- *   - **Pluggable condense seam.** Auto-compaction emits a `{ kind: "compacted" }`
- *     signal and calls an injectable {@link CondenseFn}; the real window-budget
- *     engine lands in Phase 3, so the default here is a no-op.
- *
- * Everything heavy is injectable so tests run with no network and no disk: pass a
- * scripted fake {@link AgentLike} (same submit/subscribe/event surface), an
- * in-memory {@link TranscriptStore}, a {@link SignalHub}, and a {@link ModelMatcher}
- * over a stubbed {@link ModelCatalog}.
- */
-import type { AgentEvent, AgentMessage, AgentTool, ThinkingLevel } from "indusagi/agent";
-import { type Model, type Usage } from "indusagi/ai";
-import { type ConductorFault, type ConductorPhase, type ConductorState, type SessionConductor, type SessionConductorOptions, type SessionHead } from "./contract";
-import { ModelMatcher } from "./catalog";
-import { SignalHub } from "./signal-hub";
-import { TranscriptStore } from "./transcript-store";
-import { DiagnosticsEngine, type DiagnosticsConfig } from "./diagnostics";
-/**
- * The slice of the framework `Agent` the conductor drives.
- *
- * The real `Agent` from `indusagi/agent` satisfies this structurally; tests pass
- * a scripted fake exposing the same submit/subscribe/event surface with no
- * network. Keeping the dependency to an interface (not the concrete class) is what
- * makes the conductor unit-testable.
- */
-export interface AgentLike {
-    /** Subscribe to the raw framework event stream; returns an unsubscribe thunk. */
-    subscribe(fn: (event: AgentEvent) => void): () => void;
-    /** Run one prompt turn to settlement. */
-    prompt(input: string): Promise<void>;
-    /** Cancel the in-flight turn, if any. */
-    abort(): void;
-    /** The agent's current state (message list, bound model, streaming flag). */
-    readonly state: {
-        readonly messages: AgentMessage[];
-        readonly model: Model<Model<string>["api"]>;
-        readonly isStreaming: boolean;
-    };
-    /** Replace the agent's message list (used on resume). */
-    replaceMessages(messages: AgentMessage[]): void;
-    /** Bind a different model for subsequent turns. */
-    setModel(model: Model<Model<string>["api"]>): void;
-    /** Seed/replace the system prompt. */
-    setSystemPrompt(prompt: string): void;
-    /** Set the tools available to the loop. */
-    setTools(tools: AgentTool[]): void;
-    /**
-     * Apply a reasoning effort to the loop, when the underlying agent supports it.
-     * Optional: a scripted fake may omit it, in which case the conductor stores the
-     * level and applies it on the next model bind.
-     */
-    setThinkingLevel?(level: ThinkingLevel): void;
-}
-/**
- * Options handed to a {@link CondenseFn} on each invocation.
- *
- * Every field is optional so a scripted/no-op hook can ignore the bag entirely:
- *   - `force`         — a manual `/compact` (fold to the last user turn) vs the
- *                       budget-gated auto path.
- *   - `model`         — the model bound to the live session, forwarded so the
- *                       summarizer can write a *real* digest instead of the
- *                       no-model local stub. Omitted when no model is bound.
- *   - `contextTokens` — the conductor's latest provider-reported context
- *                       occupancy, an optional anchor for the slice planner.
- */
-export interface CondenseOpts {
-    readonly force?: boolean;
-    readonly model?: Model<any>;
-    readonly contextTokens?: number;
-    /**
-     * Cancellation for a manual `/compact`. A hook MAY honor it mid-summarization;
-     * the conductor always checks it after the hook returns and discards the
-     * result when aborted, so even a hook that ignores the signal cancels cleanly.
-     */
-    readonly signal?: AbortSignal;
-    /**
-     * The bound model's credential, resolved through the session's per-call key
-     * resolver. Forwarded so the summarizer authenticates exactly like a turn —
-     * server-tier sessions have no env-var fallback for this.
-     */
-    readonly apiKey?: string;
-}
-/**
- * The pluggable condense hook. Given the active branch's messages (and an options
- * bag), it returns the (smaller) message list to replace it with. The live
- * window-budget engine is wired in `boot/runners/session.ts`; the
- * {@link noopCondense} default is an identity transform that ignores the opts.
- */
-export type CondenseFn = (messages: AgentMessage[], opts?: CondenseOpts) => AgentMessage[] | Promise<AgentMessage[]>;
-/** The default condense hook: returns the input unchanged (no-op), ignoring opts. */
-export declare const noopCondense: CondenseFn;
-/** Tuning for the transient-fault auto-retry. */
-export interface RetryPolicy {
-    /** Maximum retry attempts after the first try (default 2). */
-    readonly maxAttempts: number;
-    /** Base backoff in ms; doubled per attempt (default 250). */
-    readonly baseDelayMs: number;
-}
-/**
- * Injectable collaborators. Every field is optional; the factory supplies a live
- * default (a real `Agent`, an in-memory `TranscriptStore`, a fresh `SignalHub`, a
- * matcher over the live catalog). Tests override exactly what they need.
- */
-export interface ConductorDeps {
-    /** The framework agent (or a scripted fake). */
-    readonly agent?: AgentLike;
-    /** Where the transcript persists. */
-    readonly store?: TranscriptStore;
-    /** The product-signal fan-out. */
-    readonly hub?: SignalHub;
-    /** Resolves model ids/patterns to catalog cards. */
-    readonly matcher?: ModelMatcher;
-    /** The condense hook used by the auto-compaction seam. */
-    readonly condense?: CondenseFn;
-    /** Auto-retry tuning. */
-    readonly retry?: RetryPolicy;
-    /**
-     * Legacy branch-length condense threshold. The auto path is now token-gated
-     * ({@link isOverBudget}), so this field is accepted but no longer governs when
-     * auto-compaction fires; kept for back-compat with callers that pass it.
-     */
-    readonly compactAt?: number;
-    /** Sleep primitive (injected so tests don't actually wait). */
-    readonly sleep?: (ms: number) => Promise<void>;
-    /**
-     * Post-edit live-diagnostics control. Pass a ready {@link DiagnosticsEngine} to
-     * inject one directly (tests), a {@link DiagnosticsConfig} to tune the default
-     * engine, or omit it to get the default: ON when `workspace` has a
-     * `tsconfig.json` (eslint runner added when an eslint config is present),
-     * otherwise inert. Set `{ enabled: false }` to opt out entirely.
-     */
-    readonly diagnostics?: DiagnosticsEngine | DiagnosticsConfig;
-}
-/** The transitions the reducer understands — fresh vocabulary, all typed. */
-type StateAction = {
-    readonly type: "phase";
-    readonly phase: ConductorPhase;
-} | {
-    readonly type: "head";
-    readonly head: SessionHead;
-} | {
-    readonly type: "usage";
-    readonly usage: Usage;
-    readonly contextTokens: number;
-} | {
-    readonly type: "model";
-    readonly modelId: string;
-} | {
-    readonly type: "fault";
-    readonly fault: ConductorFault;
-} | {
-    readonly type: "settled";
-};
-/**
- * Pure transition over {@link ConductorState}. Always returns a brand-new object;
- * the previous state is never mutated. `settled` clears a stale fault and returns
- * to `idle`; `fault` records the fault and flips to `faulted`.
- */
-export declare function reduceState(prev: ConductorState, action: StateAction): ConductorState;
-/**
- * Construct a {@link SessionConductor}.
- *
- * Resolves (or accepts) every collaborator, then returns the orchestrator:
- *   - **Agent** — `deps.agent` if supplied (the scripted-fake seam tests use),
- *     else a live framework `Agent` bound to the model `options.modelId` resolves
- *     to via the {@link ModelMatcher} over the {@link ModelCatalog}.
- *   - **Store** — `deps.store` if supplied, else a fresh in-memory
- *     {@link TranscriptStore} for a new session id.
- *   - **Hub / matcher / condense / retry** — defaulted from `deps` or fresh.
- *
- * The conductor's public verbs (`submit`, `subscribe`, `abort`, `snapshot`,
- * `resume`, `cycleModel`) all read against this assembly.
- *
- * @param options session configuration (`modelId` required; system/tools/thinking/
- *                workspace/autoCompact optional)
- * @param deps    injectable collaborators; all optional, live defaults supplied
- */
-export declare function createSessionConductor(options: SessionConductorOptions, deps?: ConductorDeps): SessionConductor;
-/**
- * Return the framework model unchanged, or — when a gateway base URL is set
- * ("server mode") — a CLONE with its `baseUrl` swapped to the gateway so the
- * request flows through the quota-enforcing indus-server. Never mutates the
- * shared catalog card (always spreads into a fresh object). When
- * `gatewayBaseUrl` is `undefined` the model is returned by reference, keeping
- * the local-key path byte-for-byte unchanged.
- */
-export declare function withGatewayBaseUrl<M extends {
-    baseUrl: string;
-    provider: string;
-}>(model: M, gatewayBaseUrls: Record<string, string> | undefined): M;
-export {};

package/dist/types/conductor/conductor.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Phase 2 conductor — core behavioral tests.
- *
- * Covers the pure, framework-independent surface of the conductor: the
- * framework-event -> product-signal projector, the immutable state reducer, the
- * typed fault constructor, the signal fan-out hub, and the re-derived skill-block
- * parser. (The full submit() turn loop is exercised against the framework Agent
- * by higher-level integration; these unit tests need no network and no disk.)
- */
-export {};