@wrongstack/core 0.284.1 → 0.285.0

package/dist/core/fallback-model.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Cross-provider fallback model extension.
+ *
+ * Lives in core so EVERY agent surface can reuse it: the CLI leader, the CLI
+ * director/host subagent factory, and the runtime light subagent factory (used
+ * by standalone SDD runs). It wraps the provider runner and, when the active
+ * model 429s / overloads / stream-hangs, rotates through a fallback chain. The
+ * chain is recomputed from live config every turn, so changes take effect
+ * without a restart; an empty chain makes the wrapper a no-op.
+ *
+ * Moved here from `@wrongstack/cli` (it only ever depended on core types) so the
+ * runtime light factory can wire fallbacks for SDD worker subagents.
+ */
+import type { AgentExtension } from '../extension/extension-points.js';
+import type { EventBus } from '../kernel/events.js';
+import type { Config } from '../types/config.js';
+import type { Logger } from '../types/logger.js';
+import { type Provider } from '../types/provider.js';
+export interface FallbackModelDeps {
+    /** Returns the live config (re-read each turn so `/model` switches are honored). */
+    getConfig: () => Config;
+    /**
+     * Builds a credential-resolved Provider for a provider id (alias-resolved),
+     * WITHOUT persisting anything to config/configStore. Supplied by the boot
+     * path, which shares this with the `/model` switch logic. May be async — the
+     * subagent host resolves a provider's real context window asynchronously.
+     */
+    buildProvider: (providerId: string, modelId?: string | undefined) => Provider | Promise<Provider>;
+    /**
+     * Called after the active model changes (a fallback hop or the primary
+     * restore) so the host can refresh the auto-compaction / context-window
+     * denominator — important when a fallback crosses to a smaller-window model.
+     */
+    onModelSwitch?: (providerId: string, modelId: string) => void | Promise<void>;
+    events: EventBus;
+    /** Optional — warnings about un-buildable fallback providers. */
+    logger?: Logger | undefined;
+    /**
+     * Base cooldown after the configured primary fails with a fallback-worthy
+     * error. While active, `beforeRun` leaves the context on the working fallback
+     * instead of retrying the primary at the start of every turn. Default: 60s.
+     * Set 0 to preserve the legacy "probe primary every turn" behavior.
+     */
+    primaryCooldownMs?: number | undefined;
+    /**
+     * Maximum exponential cooldown for repeated failed primary probes. Default:
+     * 10 minutes. Ignored when `primaryCooldownMs` is 0.
+     */
+    primaryCooldownMaxMs?: number | undefined;
+    /** Test hook for deterministic cooldown assertions. */
+    now?: (() => number) | undefined;
+}
+interface ModelRef {
+    provider?: string | undefined;
+    model: string;
+}
+/** Parse a fallback entry: `model`, `provider/model`, or `provider model`. */
+export declare function parseModelRef(ref: string): ModelRef;
+export declare function formatModelRef(ref: ModelRef, defaultProvider?: string | undefined): string;
+export declare function normalizeModelRef(ref: string, defaultProvider?: string | undefined): string;
+export declare function fallbackProfileChain(config: Config, profileName: string | undefined): string[];
+/**
+ * Derive a fallback chain from the configured providers when the user has not
+ * set an explicit `fallbackModels` list. Picks declared models from every
+ * keyed provider — same-provider alternatives first (same key, cheapest
+ * failover), then cross-provider — excluding the active leader model. Returns
+ * `[]` when nothing usable is configured (e.g. providers with no `models`
+ * list), in which case the extension is a no-op.
+ */
+export declare function smartDefaultFallbackChain(config: Config): string[];
+/**
+ * The effective fallback chain for a turn: the explicit `fallbackModels` list
+ * when non-empty, otherwise the smart default (unless `fallbackAuto` is off).
+ */
+export declare function effectiveFallbackChain(config: Config): string[];
+/**
+ * Build the cross-provider fallback extension. Always returns an extension —
+ * the effective chain (`effectiveFallbackChain`) is recomputed every turn from
+ * the live config, so a chain that is empty at boot but populated later (via
+ * `/fallback add` or the smart default kicking in once a key is added) takes
+ * effect WITHOUT a restart. An empty chain makes the wrapper a no-op (it just
+ * rethrows the original error).
+ *
+ * Mechanism (see plan): wraps the provider runner. The inner runner already
+ * applies the per-model retry policy (backoff, up to 5 tries for 429), so the
+ * fallback only engages AFTER the active model's own retries are exhausted.
+ * Because the wrapper resolves within a single provider call, it does not
+ * consume the agent loop's `recoveryRetries` budget — chains longer than two
+ * entries work. `beforeRun` keeps the last working fallback while the primary
+ * is cooling down, then restores the configured primary for a half-open probe.
+ */
+export declare function createFallbackModelExtension(deps: FallbackModelDeps): AgentExtension;
+export {};
+//# sourceMappingURL=fallback-model.d.ts.map

package/dist/core/fallback-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-model.d.ts","sourceRoot":"","sources":["../../src/core/fallback-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,oBAAoB,CAAC;AAMjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,KAAK,QAAQ,EAAyC,MAAM,sBAAsB,CAAC;AAE5F,MAAM,WAAW,iBAAiB;IAChC,oFAAoF;IACpF,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB;;;;;OAKG;IACH,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClG;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,EAAE,QAAQ,CAAC;IACjB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,uDAAuD;IACvD,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAClC;AAED,UAAU,QAAQ;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAgBnD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAG1F;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAG3F;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAI9F;AAgDD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqClE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAa/D;AAiDD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,iBAAiB,GAAG,cAAc,CAuIpF"}

package/dist/core/fleet-pulse.d.ts

@@ -0,0 +1,42 @@
+/**
+ * fleet-pulse — pure formatter for the periodic peer-status digest.
+ *
+ * Every agent on a project (leader and fleet subagents alike) periodically
+ * gets a compact "[FLEET PULSE]" block folded into its conversation so it
+ * knows what its peers are doing — who is running what task, who went
+ * idle, who finished. This is the push half of peer awareness (the pull
+ * half is the `fleet_status` tool).
+ *
+ * This module is data-in/text-out only: it never touches the mailbox or
+ * the filesystem, so core/ stays free of runtime coordination/ imports
+ * (architecture Rule 3 — same posture as mailbox-loop.ts). The composition
+ * glue that feeds it live `MailboxAgentStatus[]` lives in
+ * ../mailbox-attach.ts (`attachFleetPulse`).
+ *
+ * @module fleet-pulse
+ */
+import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
+export interface FleetPulseOptions {
+    /** This agent's own mailbox id — excluded from the digest. */
+    selfId: string;
+    /** Max peers listed (rest summarized as "+N more"). Default 15. */
+    maxAgents?: number | undefined;
+    /** Hard cap on total digest characters. Default 900. */
+    maxChars?: number | undefined;
+}
+/**
+ * Stable signature over the fields that matter to a reader — used by the
+ * caller to skip re-injection when nothing meaningful changed since the
+ * last pulse. Deliberately excludes counters (iterations/toolCalls) and
+ * timestamps: those tick constantly and would defeat the dedup.
+ */
+export declare function fleetPulseSignature(statuses: MailboxAgentStatus[]): string;
+/**
+ * Build the digest block, or `null` when there is nothing worth saying
+ * (no online peers besides self). The caller owns cadence and dedup.
+ */
+export declare function buildFleetPulseBlock(statuses: MailboxAgentStatus[], opts: FleetPulseOptions): {
+    type: 'text';
+    text: string;
+} | null;
+//# sourceMappingURL=fleet-pulse.d.ts.map

package/dist/core/fleet-pulse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet-pulse.d.ts","sourceRoot":"","sources":["../../src/core/fleet-pulse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAK1E;AAiBD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,IAAI,EAAE,iBAAiB,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgCvC"}

package/dist/core/input-builder.d.ts

@@ -0,0 +1,95 @@
+import type { AddAttachmentInput, AttachmentRef, AttachmentStore } from '../types/attachment.js';
+import type { ContentBlock } from '../types/blocks.js';
+export interface InputBuilderOptions {
+    store: AttachmentStore;
+    /**
+     * Pastes ≥ this many lines collapse to a `[pasted #N]` placeholder.
+     * Default: 8 lines.
+     */
+    pasteLineThreshold?: number | undefined;
+    /**
+     * Pastes ≥ this many characters collapse to a placeholder regardless of
+     * line count. Default: 2000 chars.
+     */
+    pasteCharThreshold?: number | undefined;
+}
+export interface InputBuilderEvent {
+    /** Current display string (with placeholders, before submit). */
+    display: string;
+    refs: AttachmentRef[];
+}
+/**
+ * UI-agnostic accumulator for user input. The frontend (CLI/TUI) feeds in:
+ *   - typed text via `appendText()`
+ *   - large pastes via `appendPaste()` → returns placeholder string
+ *   - image paste via `appendImage()` → returns placeholder string
+ *   - file refs (`@path`) via `appendFile()` → returns placeholder string
+ *
+ * On `submit()` the builder runs the display string through AttachmentStore.expand()
+ * and returns the final ContentBlock[] ready for `agent.run()`.
+ *
+ * The builder does not know what a "line" or "key" is — that is the
+ * frontend's job. It only operates on strings and byte payloads.
+ */
+export declare class InputBuilder {
+    private readonly store;
+    private readonly pasteLineThreshold;
+    private readonly pasteCharThreshold;
+    private display;
+    private readonly refs;
+    constructor(opts: InputBuilderOptions);
+    get text(): string;
+    get attachments(): AttachmentRef[];
+    get isEmpty(): boolean;
+    appendText(text: string): void;
+    /**
+     * Decide whether a chunk of pasted text is "big" enough to collapse.
+     * If yes, store it and append a placeholder. If no, inline it.
+     * Returns the placeholder string actually appended (or `null` if inlined).
+     */
+    appendPaste(text: string): Promise<string | null>;
+    /**
+     * Always collapses to `[image #N]` — images are never inlined.
+     * `dataBase64` is the raw base64 payload (no data: prefix).
+     */
+    appendImage(dataBase64: string, mediaType: string): Promise<string>;
+    appendFile(input: AddAttachmentInput): Promise<string>;
+    /**
+     * Register-only variant of `appendPaste`. Always stores the paste and
+     * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
+     * `display` — the caller (TUI) owns its own editable buffer as the single
+     * source of truth, inserts the token there, and expands the buffer at
+     * submit. The collapse decision is the caller's (it gates this call); use
+     * `wouldCollapse()` for that.
+     */
+    registerPaste(text: string): Promise<string>;
+    /**
+     * Register-only variant of `appendImage` — see `registerPaste`. Returns a
+     * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
+     */
+    registerImage(dataBase64: string, mediaType: string): Promise<string>;
+    /**
+     * Register-only variant of `appendFile` — see `registerPaste`. Returns a
+     * path-keyed `[file:<path>]` token (resolved by path at expand time); does
+     * not touch `display`. The path is read from `meta.filename` (falling back
+     * to `meta.label`).
+     */
+    registerFile(input: AddAttachmentInput): Promise<string>;
+    /**
+     * Whether `appendPaste(text)` would collapse the text to a placeholder
+     * (rather than inlining it). Lets a frontend decide where to route a paste
+     * — e.g. collapsed pastes become a pill, while inlined ones can be shown
+     * in the editable input row — without calling `appendPaste` first (which
+     * mutates the display buffer).
+     */
+    wouldCollapse(text: string): boolean;
+    /** Reset display and ref list. Does NOT clear the store itself. */
+    reset(): void;
+    /**
+     * Resolve the current display string into ContentBlock[]. Empty
+     * input returns an empty array — caller decides what to do.
+     */
+    submit(): Promise<ContentBlock[]>;
+    private shouldCollapse;
+}
+//# sourceMappingURL=input-builder.d.ts.map

package/dist/core/input-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-builder.d.ts","sourceRoot":"","sources":["../../src/core/input-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,eAAe,CAAC;IACvB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED,MAAM,WAAW,iBAAiB;IAChC,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,aAAa,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAE5C,YAAY,IAAI,EAAE,mBAAmB,EAIpC;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,aAAa,EAAE,CAEjC;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED;;;;OAIG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CActD;IAED;;;OAGG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAUxE;IAEK,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM3D;IAED;;;;;;;OAOG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWjD;IAED;;;OAGG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAS1E;IAED;;;;;OAKG;IACG,YAAY,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAK7D;IAED;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnC;IAED,mEAAmE;IACnE,KAAK,IAAI,IAAI,CAGZ;IAED;;;OAGG;IACG,MAAM,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAItC;IAED,OAAO,CAAC,cAAc;CAcvB"}

package/dist/core/instruction-bundle.d.ts

@@ -0,0 +1,22 @@
+export interface SystemInstructionBundle {
+    identity?: string | undefined;
+    leaderAfterTask?: string | undefined;
+}
+export interface InstructionBundle {
+    version?: number | undefined;
+    system?: SystemInstructionBundle | undefined;
+    sections?: Record<string, string> | undefined;
+}
+export interface InstructionBundlePaths {
+    /** Bundled instruction directory. Defaults to `<@wrongstack/core>/instructions`. */
+    bundledDir?: string | undefined;
+    /** User-global override directory, e.g. `~/.wrongstack/instructions`. */
+    globalDir?: string | undefined;
+    /** Project override directory, e.g. `<project>/.wrongstack/instructions`. */
+    projectDir?: string | undefined;
+    /** Extra override JSON files applied after projectDir, in order. */
+    files?: readonly string[] | undefined;
+}
+export declare function loadInstructionBundle(paths: InstructionBundlePaths | undefined): Promise<InstructionBundle>;
+export declare function mergeInstructionBundle(base: InstructionBundle, override: InstructionBundle): InstructionBundle;
+//# sourceMappingURL=instruction-bundle.d.ts.map

package/dist/core/instruction-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-bundle.d.ts","sourceRoot":"","sources":["../../src/core/instruction-bundle.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,MAAM,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CAC/C;AAED,MAAM,WAAW,sBAAsB;IACrC,oFAAoF;IACpF,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,oEAAoE;IACpE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACvC;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,sBAAsB,GAAG,SAAS,GACxC,OAAO,CAAC,iBAAiB,CAAC,CAe5B;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,EAAE,iBAAiB,GAC1B,iBAAiB,CAanB"}

package/dist/core/iteration-limit.d.ts

@@ -0,0 +1,35 @@
+import type { EventBus } from '../kernel/events.js';
+export interface RequestLimitExtensionOptions {
+    events: EventBus;
+    sessionId?: string | undefined;
+    currentIterations: number;
+    currentLimit: number;
+    /** When true (default), auto-grant 100 extra after giving listeners a tick to deny. */
+    autoExtend: boolean;
+    /** Timeout in ms before falling back to "0 extra" if no listener responds. */
+    timeoutMs?: number | undefined;
+}
+/**
+ * Emit `iteration.limit_reached` and wait for a listener to grant or
+ * deny. Resolves with the number of extra iterations to grant (0 = stop).
+ * When `autoExtend` is true the listener gets a `setImmediate` window to
+ * react; otherwise the resolution stays open until the timer fires.
+ *
+ * Listener contract — **important for `autoExtend: true` callers**:
+ *
+ *   - `grant(extra)` and `deny()` must be invoked **synchronously** from
+ *     the event listener (or earlier than the next `setImmediate` tick).
+ *     The auto-grant path resolves to 100 inside `setImmediate`, so any
+ *     async work between receiving the event and calling grant/deny will
+ *     lose the race and the auto-grant wins.
+ *
+ *   - If you need to make an async decision (await a confirm dialog,
+ *     query a remote policy), pass `autoExtend: false`. The promise will
+ *     stay pending until the listener calls grant/deny or `timeoutMs`
+ *     fires (default 30s).
+ *
+ *   - Multiple listeners are allowed but the first to call grant/deny
+ *     wins; subsequent calls are no-ops.
+ */
+export declare function requestLimitExtension(opts: RequestLimitExtensionOptions): Promise<number>;
+//# sourceMappingURL=iteration-limit.d.ts.map

package/dist/core/iteration-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-limit.d.ts","sourceRoot":"","sources":["../../src/core/iteration-limit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,QAAQ,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,UAAU,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,GAAG,OAAO,CAAC,MAAM,CAAC,CA+CzF"}

package/dist/core/mailbox-loop.d.ts

@@ -0,0 +1,63 @@
+/**
+ * mailbox-loop — Agent-loop integration for mailbox checking.
+ *
+ * Integrates the inter-agent mailbox into the agent's iteration cycle.
+ * Before each LLM call, checks for unread messages from subagents and other
+ * agents. ALL message types are injected inline so the leader sees and acts
+ * on them even when mid-task — subagent results, asks, assigns, and
+ * steer/btw are all folded into the conversation with a call to action.
+ *
+ * Uses the project-level GlobalMailbox for cross-session communication.
+ *
+ * @module mailbox-loop
+ */
+import type { Mailbox, MailboxMessage } from '../coordination/mailbox-types.js';
+export interface MailboxLoopOptions {
+    mailbox: Mailbox;
+    /**
+     * The agent's globally unique mailbox identity (e.g. `leader@a1b2c3d4`,
+     * session-bound). Read receipts are recorded under this id, so two
+     * sessions whose leaders share a base name never consume each other's
+     * receipts. Pass a GETTER when the identity can change at runtime (an
+     * in-process session swap moves the leader onto a new session tag).
+     */
+    agentId: string | (() => string);
+    /**
+     * Additional addresses this agent also answers to — typically the bare
+     * base id (`leader`). Lets other agents (and humans) address "leader"
+     * without knowing the session tag; every live leader session receives it.
+     */
+    aliases?: string[] | undefined;
+    /** Optional delivery predicate applied before dedup/read receipts. */
+    include?: ((message: MailboxMessage) => boolean) | undefined;
+    /** Mark returned messages as read. Defaults to true for normal delivery. */
+    ack?: boolean | undefined;
+}
+export declare function createMailboxChecker(opts: MailboxLoopOptions): () => Promise<MailboxMessage[]>;
+export declare function buildMailboxBtwAwarenessBlock(messages: MailboxMessage[]): {
+    type: 'text';
+    text: string;
+};
+export declare function buildMailboxBlock(messages: MailboxMessage[]): {
+    type: 'text';
+    text: string;
+};
+/** Result of an inject pass — signals an out-of-band control request. */
+export interface MailboxInjectResult {
+    /** A fresh `control:interrupt` message asked this agent to stop. */
+    interrupt: boolean;
+    /** Operator-supplied reason for the interrupt, if any. */
+    interruptReason?: string | undefined;
+}
+export declare function injectPendingMailboxMessages(checkMailbox: () => Promise<MailboxMessage[]>, foldFn: (block: {
+    type: 'text';
+    text: string;
+}) => void, a: {
+    events: {
+        emit: (type: string, payload: unknown) => void;
+    };
+    logger: {
+        debug?: (...args: unknown[]) => void;
+    };
+}): Promise<MailboxInjectResult>;
+//# sourceMappingURL=mailbox-loop.d.ts.map

package/dist/core/mailbox-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailbox-loop.d.ts","sourceRoot":"","sources":["../../src/core/mailbox-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGhF,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IACjC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC/B,sEAAsE;IACtE,OAAO,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IAC7D,4EAA4E;IAC5E,GAAG,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3B;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,kBAAkB,GACvB,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,CAsEjC;AAgBD,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAuBxG;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAwE5F;AAOD,yEAAyE;AACzE,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAC;IACnB,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,wBAAsB,4BAA4B,CAChD,YAAY,EAAE,MAAM,OAAO,CAAC,cAAc,EAAE,CAAC,EAC7C,MAAM,EAAE,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,EACvD,CAAC,EAAE;IAAE,MAAM,EAAE;QAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;KAAE,CAAC;IAAC,MAAM,EAAE;QAAE,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAA;KAAE,CAAA;CAAE,GAClH,OAAO,CAAC,mBAAmB,CAAC,CAyC9B"}

package/dist/core/modes/brief.d.ts

@@ -0,0 +1,2 @@
+export declare const PROMPT: string;
+//# sourceMappingURL=brief.d.ts.map

package/dist/core/modes/brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brief.d.ts","sourceRoot":"","sources":["../../../src/core/modes/brief.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,QAA6B,CAAC"}

package/dist/core/modes/default.d.ts

@@ -0,0 +1,8 @@
+export declare const PROMPT: string;
+/**
+ * Leader-only after-task affordances. The full text lives in
+ * `packages/core/instructions/leader-after-task.md` so prompt wording can be
+ * overridden without editing TypeScript.
+ */
+export declare const LEADER_AFTER_TASK_PROMPT: string;
+//# sourceMappingURL=default.d.ts.map

package/dist/core/modes/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../src/core/modes/default.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM,QAA0C,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAAqD,CAAC"}

package/dist/core/modes/teach.d.ts

@@ -0,0 +1,2 @@
+export declare const PROMPT: string;
+//# sourceMappingURL=teach.d.ts.map

package/dist/core/modes/teach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teach.d.ts","sourceRoot":"","sources":["../../../src/core/modes/teach.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,QAA6B,CAAC"}

package/dist/core/provider-runner.d.ts

@@ -0,0 +1,24 @@
+import type { EventBus } from '../kernel/events.js';
+import type { Logger } from '../types/logger.js';
+import type { Tracer } from '../types/observability.js';
+import type { Provider, Request, Response } from '../types/provider.js';
+import type { RetryPolicy } from '../types/retry-policy.js';
+import type { Context } from './context.js';
+export interface RunProviderOptions {
+    provider: Provider;
+    request: Request;
+    signal: AbortSignal;
+    ctx: Context;
+    events: EventBus;
+    retry: RetryPolicy;
+    logger: Logger;
+    tracer?: Tracer | undefined;
+}
+/**
+ * Call a provider with the retry policy applied. Emits `provider.retry`
+ * before each retry and `provider.error` once when the retries are
+ * exhausted. Streaming providers route through the streaming-response
+ * builder so deltas reach the renderer.
+ */
+export declare function runProviderWithRetry(opts: RunProviderOptions): Promise<Response>;
+//# sourceMappingURL=provider-runner.d.ts.map

package/dist/core/provider-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-runner.d.ts","sourceRoot":"","sources":["../../src/core/provider-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGxE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAc5C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsHtF"}

package/dist/core/queued-messages.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Queue awareness — let the running agent *see* messages the user typed
+ * while it was busy, without delivering them early.
+ *
+ * The TUI queues plain messages typed mid-run and replays them as real user
+ * turns after the run finishes (the queue drainer in app.tsx). That keeps
+ * turn-taking clean, but the model is blind to the backlog: a queued message
+ * may invalidate the current approach, add a constraint, or just be a
+ * "by the way" note the user expected the agent to notice.
+ *
+ * Unlike `/btw` (a consume-once note channel, {@link ./btw.ts}), this is a
+ * SNAPSHOT channel: the host mirrors the queue's current contents onto the
+ * live `Context` on every queue mutation (enqueue, /queue delete, /queue
+ * clear, dequeue-for-delivery). At each iteration boundary the agent loop
+ * asks "did the snapshot change since the model last saw it?" and, if so,
+ * injects an informational block listing the pending messages. The queue
+ * itself is untouched — every queued message still arrives later as its own
+ * user turn.
+ *
+ * Deliberate quietness: when the queue transitions to empty (cleared by the
+ * user, drained between runs, or dropped by steering/abort) the snapshot is
+ * marked seen WITHOUT injecting a "queue is now empty" block. The empty
+ * transition usually happens at run boundaries where such a notice is stale
+ * noise; the cost is that a mid-run `/queue clear` isn't announced, which is
+ * safe because the block's framing already tells the model the queue may
+ * change and the authoritative messages arrive as future turns.
+ */
+import type { Context } from './context.js';
+/**
+ * Mirror the host's pending-message queue onto the context. Call on every
+ * queue mutation with the FULL current queue (head first) — not a delta.
+ * Blank entries are dropped; the head-most {@link MAX_ITEMS} are kept since
+ * the head is what arrives first.
+ */
+export declare function setQueuedMessagesSnapshot(ctx: Context, texts: string[]): void;
+/** Current snapshot (previews), without affecting seen-state. */
+export declare function peekQueuedMessages(ctx: Context): string[];
+/**
+ * Called by the agent loop at each iteration boundary. Returns the queued
+ * messages to surface when the snapshot changed since the model last saw it,
+ * or `null` when there is nothing new to say. Marks the snapshot seen either
+ * way, so the same state is never injected twice. An empty snapshot is
+ * acknowledged silently (see module comment).
+ */
+export declare function consumeQueuedMessagesUpdate(ctx: Context): string[] | null;
+/**
+ * Format the awareness block. Framing goals: (1) the model must NOT treat
+ * the listed messages as instructions to execute now — they each arrive as
+ * their own turn later; (2) it SHOULD let them influence in-flight decisions
+ * (a queued message may invalidate the current approach or be a /btw-style
+ * note); (3) the list is a full replacement of any earlier notice, so a
+ * shrunken list implicitly communicates deletions.
+ */
+export declare function buildQueuedMessagesBlock(items: string[]): string;
+//# sourceMappingURL=queued-messages.d.ts.map

package/dist/core/queued-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queued-messages.d.ts","sourceRoot":"","sources":["../../src/core/queued-messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAmC5C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAS7E;AAED,iEAAiE;AACjE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,IAAI,CAUzE;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAchE"}

package/dist/core/run-env.d.ts

@@ -0,0 +1,49 @@
+import type { TextBlock } from '../types/blocks.js';
+import type { Provider } from '../types/provider.js';
+import type { SessionWriter } from '../types/session.js';
+import type { TokenCounter } from '../types/token-counter.js';
+import type { Tool } from '../types/tool.js';
+import type { Context } from './context.js';
+/**
+ * Immutable run environment — the set-once dependencies for an agent run.
+ *
+ * `Context` today doubles as both a DI bag (provider, session, tokenCounter,
+ * cwd, …) and a mutable state container (messages, todos, meta). That makes
+ * it hard to test (every test reconstructs the full bag) and easy to abuse
+ * (any tool can swap the provider mid-run).
+ *
+ * `RunEnv` is the immutable half: a read-only projection that subsystems
+ * can hold instead of the whole `Context`. It's a view, not a copy — pulling
+ * a `RunEnv` from a `Context` is O(1) and reflects the same underlying
+ * references. The opposite direction (set things on Context) still works,
+ * and `extractRunEnv` rebuilds the view if you need a snapshot.
+ *
+ * Migration path: new APIs accept `RunEnv` instead of `Context` when they
+ * only need read access. Existing APIs continue to accept `Context` until
+ * a full split is scheduled.
+ */
+export interface RunEnv {
+    readonly provider: Provider;
+    readonly session: SessionWriter;
+    readonly signal: AbortSignal;
+    readonly tokenCounter: TokenCounter;
+    readonly cwd: string;
+    readonly projectRoot: string;
+    /** Mutable working directory — starts as `cwd`. */
+    readonly workingDir: string;
+    readonly model: string;
+    readonly systemPrompt: readonly TextBlock[];
+    readonly tools: readonly Tool[];
+    readonly agentId: string;
+    readonly agentName: string;
+}
+/**
+ * Build a `RunEnv` view from a Context. The returned object is a shallow
+ * frozen view — mutations to `Context` are visible (it's the same
+ * references), but the view itself can't be mutated.
+ *
+ * Use this in subsystems that want to declare "I only need read access to
+ * the env" without rewriting their signature to accept the full Context.
+ */
+export declare function extractRunEnv(ctx: Context): RunEnv;
+//# sourceMappingURL=run-env.d.ts.map

package/dist/core/run-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-env.d.ts","sourceRoot":"","sources":["../../src/core/run-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,SAAS,SAAS,EAAE,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAelD"}

package/dist/core/streaming-response-builder.d.ts

@@ -0,0 +1,78 @@
+import type { EventBus } from '../kernel/events.js';
+import type { Logger } from '../types/logger.js';
+import type { Provider, Request, Response } from '../types/provider.js';
+import type { Context } from './context.js';
+interface ThinkingEntry {
+    textBuf: string;
+    signature?: string | undefined;
+    providerMeta?: Record<string, unknown>;
+}
+interface StreamingState {
+    model: string;
+    stopReason: Response['stopReason'];
+    usage: Response['usage'];
+    textBuffers: string[];
+    currentTextIndex: number;
+    tools: Map<string, {
+        name: string;
+        partial: string;
+        input?: unknown | undefined;
+        providerMeta?: Record<string, unknown>;
+    }>;
+    thinking: ThinkingEntry[];
+    currentThinkingIndex: number;
+    blockOrder: Array<{
+        kind: 'text';
+        idx: number;
+    } | {
+        kind: 'tool';
+        id: string;
+    } | {
+        kind: 'thinking';
+        idx: number;
+    }>;
+}
+export declare function buildResponse(state: StreamingState): Response;
+export declare function createStreamingState(model: string): StreamingState;
+export declare function handleMessageStart(state: StreamingState, model: string): void;
+export declare function handleContentBlockStart(state: StreamingState, ev: {
+    kind?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    providerMeta?: Record<string, unknown>;
+}): void;
+export declare function handleContentBlockStop(state: StreamingState, ev: {
+    index?: number | undefined;
+}): void;
+export declare function handleTextDelta(state: StreamingState, text: string): void;
+export declare function handleToolUseStart(state: StreamingState, ev: {
+    id: string;
+    name: string;
+}): void;
+export declare function handleToolUseInputDelta(state: StreamingState, ev: {
+    id: string;
+    partial: string;
+}): void;
+export declare function safeJsonOrRaw(s: string): unknown;
+export declare function handleToolUseStop(state: StreamingState, ev: {
+    id: string;
+    input?: unknown | undefined;
+    providerMeta?: Record<string, unknown>;
+}): void;
+/**
+ * Open a fresh thinking block. Providers that don't pre-announce blocks
+ * (e.g. OpenAI/DeepSeek) can call this lazily on the first reasoning delta.
+ */
+export declare function handleThinkingStart(state: StreamingState, ev: {
+    providerMeta?: Record<string, unknown>;
+}): void;
+export declare function handleThinkingDelta(state: StreamingState, text: string): void;
+export declare function handleThinkingSignature(state: StreamingState, signature: string): void;
+export declare function handleThinkingStop(state: StreamingState): void;
+export declare function handleMessageStop(state: StreamingState, ev: {
+    stopReason?: Response['stopReason'] | undefined;
+    usage?: Response['usage'] | undefined;
+}): void;
+export declare function streamProviderToResponse(provider: Provider, req: Request, signal: AbortSignal, ctx: Context, events: EventBus, logger: Logger): Promise<Response>;
+export {};
+//# sourceMappingURL=streaming-response-builder.d.ts.map

package/dist/core/streaming-response-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-response-builder.d.ts","sourceRoot":"","sources":["../../src/core/streaming-response-builder.ts"],"names":[],"mappings":"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"}