@wrongstack/core 0.284.1 → 0.286.0

package/dist/execution/brain-runtime.d.ts

@@ -0,0 +1,171 @@
+/**
+ * BrainRuntime — the live, rebuildable owner of `config.brain`.
+ *
+ * The Brain chain used to be assembled once at boot; every knob except the
+ * risk ceiling and escalation mode was frozen until restart. This module
+ * makes the whole `BrainConfig` surface live-editable AND persistable from
+ * any host surface (/brain subcommands, TUI Brain panel, WebUI BrainSection):
+ *
+ *   - `arbiter` is a STABLE delegating handle (`decide` reads a mutable
+ *     `current`), so hosts wrap it once in their EscalationRouting/Observable
+ *     layers and no consumer ever needs a rebind after a settings change.
+ *   - `apply(patch)` normalizes + validates the patch, commits it, rebuilds
+ *     the tier chain when a structural knob changed (pool, council, timeout,
+ *     ledger guard), and persists through an injected callback — core never
+ *     touches config files itself.
+ *   - `getSnapshot()` is the JSON-safe truth both UIs render: configured
+ *     values plus derived facts (resolved pool/council labels, EFFECTIVE
+ *     council enablement, session-model fallback).
+ *
+ * Persistence contract: `config.brain` is on the in-project deny list, so
+ * the injected `persist` MUST write the GLOBAL config. A persist failure
+ * never rolls back the live change; it is reported via the returned promise.
+ *
+ * @module brain-runtime
+ */
+import { type BrainArbiter, type BrainDecisionRequest, type BrainEscalationMode } from '../coordination/brain.js';
+import type { BrainConfig, BrainCouncilVoterConfig, BrainModelEntry } from '../types/config.js';
+import type { Provider } from '../types/provider.js';
+import { type BrainAutoRisk } from './autonomy-brain.js';
+export type BrainCouncilMinRisk = 'medium' | 'high' | 'critical';
+export type BrainPoolStrategy = 'fallback' | 'round-robin';
+/** JSON-safe view of the live Brain configuration + derived facts. */
+export interface BrainConfigSnapshot {
+    mode: BrainEscalationMode;
+    maxAutoRisk: BrainAutoRisk;
+    /** Configured pool entries (normalized). Empty = session model. */
+    models: BrainModelEntry[];
+    strategy: BrainPoolStrategy;
+    decisionTimeoutMs: number | undefined;
+    humanTimeoutMs: number | undefined;
+    council: {
+        /** EFFECTIVE enablement (default rule `voters >= 2` applied). */
+        enabled: boolean;
+        /** Raw configured value (undefined = default rule decides). */
+        configured: boolean | undefined;
+        minRisk: BrainCouncilMinRisk;
+        /** Explicitly configured voters; seats derived from the pool are visible via `councilLabels`. */
+        voters: BrainCouncilVoterConfig[];
+        quorum: number | undefined;
+        approval: number | undefined;
+        judge: BrainModelEntry | undefined;
+    };
+    ledger: {
+        enabled: boolean;
+        autoDenyAfterFailures: number | undefined;
+        path: string | undefined;
+    };
+    /** Resolved pool labels from the LAST assembly (may be fewer than `models` — unresolvable refs are skipped). */
+    poolLabels: string[];
+    /** Resolved council seat labels; empty = council effectively disabled. */
+    councilLabels: string[];
+    usingSessionModel: boolean;
+}
+/** Council sub-patch. Arrays REPLACE; `null` clears back to the default. */
+export interface BrainCouncilPatch {
+    enabled?: boolean | null | undefined;
+    minRisk?: BrainCouncilMinRisk | null | undefined;
+    voters?: Array<string | BrainCouncilVoterConfig> | null | undefined;
+    quorum?: number | null | undefined;
+    approval?: number | null | undefined;
+    judge?: string | BrainModelEntry | null | undefined;
+}
+/**
+ * Partial update for the live Brain config. Omitted fields are untouched,
+ * `null` clears a field back to its default, arrays replace wholesale.
+ */
+export interface BrainConfigPatch {
+    mode?: BrainEscalationMode | undefined;
+    maxAutoRisk?: BrainAutoRisk | undefined;
+    models?: Array<string | BrainModelEntry> | null | undefined;
+    strategy?: BrainPoolStrategy | null | undefined;
+    decisionTimeoutMs?: number | null | undefined;
+    humanTimeoutMs?: number | null | undefined;
+    council?: BrainCouncilPatch | null | undefined;
+    ledger?: {
+        enabled?: boolean | undefined;
+        autoDenyAfterFailures?: number | null | undefined;
+    } | null | undefined;
+}
+/** Host-owned ledger controller — the runtime never touches ledger files. */
+export interface BrainRuntimeLedgerHost {
+    getPath: () => string | undefined;
+    isEnabled: () => boolean;
+    /** Host starts/stops its BrainDecisionLedger instance. */
+    setEnabled: (enabled: boolean) => void;
+    failureStreakFor?: ((request: Pick<BrainDecisionRequest, 'source' | 'question' | 'id'>) => number) | undefined;
+    getDecisionDigest?: ((request: BrainDecisionRequest) => string | undefined) | undefined;
+}
+export interface BrainRuntimeOptions {
+    /** Boot-time `config.brain`. Invalid entries are dropped leniently here (apply() is strict). */
+    initialConfig: BrainConfig | undefined;
+    /** The session's provider id (`config.provider`). */
+    defaultProviderId: string;
+    /** Live session provider — read per decision so `/setmodel` switches apply. */
+    sessionProvider: () => Provider;
+    /** Live session model id — read per decision. */
+    sessionModel: () => string;
+    /** Resolve a NON-default provider id. May throw / return null → entry skipped. */
+    resolveProvider: (providerId: string, model: string) => Provider | null;
+    ledger?: BrainRuntimeLedgerHost | undefined;
+    /**
+     * Injected writer for the canonical `BrainConfig`. MUST target the global
+     * config (`config.brain` is denied in project scope). Absent = live-only.
+     */
+    persist?: ((config: BrainConfig) => Promise<void>) | undefined;
+    /** Fired after every successful apply, with the fresh snapshot. */
+    onApplied?: ((snapshot: BrainConfigSnapshot) => void) | undefined;
+}
+export interface BrainApplyResult {
+    snapshot: BrainConfigSnapshot;
+    /** Resolves `{ok: true}` immediately when persistence was skipped or absent. */
+    persisted: Promise<{
+        ok: boolean;
+        error?: string | undefined;
+    }>;
+}
+export interface BrainRuntime {
+    /** STABLE arbiter handle — the inner tier chain swaps on `apply`. */
+    arbiter: BrainArbiter;
+    getMode(): BrainEscalationMode;
+    getMaxAutoRisk(): BrainAutoRisk;
+    getHumanTimeoutMs(): number | undefined;
+    getSnapshot(): BrainConfigSnapshot;
+    /** Canonical shape written to `config.brain` (compact string refs where lossless). */
+    getConfig(): BrainConfig;
+    /** Live-apply synchronously; persistence (default on) is async best-effort. */
+    apply(patch: BrainConfigPatch, opts?: {
+        persist?: boolean | undefined;
+    }): BrainApplyResult;
+}
+export interface BrainDefaultsContext {
+    /** The session's fallback chain (`config.fallbackModels`) — seeds the default pool. */
+    fallbackModels?: readonly string[] | undefined;
+}
+/**
+ * Product defaults for hosts that want a minimum-human Brain out of the box
+ * (CLI/TUI wiring and the standalone WebUI server both apply this before
+ * `createBrainRuntime`). Only FILLS GAPS — every explicitly configured field
+ * wins, so existing `config.brain` blocks are untouched by updates.
+ *
+ *   - `models`  → the user's own `fallbackModels` chain (never hardcoded
+ *     model ids; every install has different providers). With ≥2 entries the
+ *     council auto-derives from the pool, so multi-model users get a council
+ *     by default.
+ *   - `mode`    → 'headless': decisions never block on a human; the terminal
+ *     policy (safe default / deny) is the escalation of last resort.
+ *   - `maxAutoRisk` → adaptive: 'all' when a council can convene (critical
+ *     questions get a multi-model panel), otherwise 'high' (critical
+ *     questions resolve via the conservative terminal policy instead of a
+ *     single unchecked model).
+ *   - `humanTimeoutMs` → 120s: if the user explicitly switches back to
+ *     'interactive', an unanswered prompt still auto-resolves instead of
+ *     hanging an unattended run forever. Set `humanTimeoutMs: 0` to restore
+ *     the legacy wait-indefinitely behavior.
+ *
+ * NOTE deliberately NOT persisted anywhere — resolved at boot, so existing
+ * users pick these up on update without any config migration/write.
+ */
+export declare function resolveBrainConfigDefaults(brain: BrainConfig | undefined, ctx?: BrainDefaultsContext): BrainConfig;
+export declare function createBrainRuntime(opts: BrainRuntimeOptions): BrainRuntime;
+//# sourceMappingURL=brain-runtime.d.ts.map

package/dist/execution/brain-runtime.d.ts.map

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

package/dist/execution/compaction-core.d.ts

@@ -0,0 +1,103 @@
+import type { Message } from '../types/messages.js';
+import { estimateMessageTokens } from '../utils/token-estimate.js';
+/**
+ * Token estimate for a message array (text + tool I/O). Re-exported from the
+ * canonical `token-estimate` helper so compactors and the context-pressure
+ * monitor share one number.
+ */
+export declare const estimateMessages: typeof estimateMessageTokens;
+/**
+ * Shared, pure compaction primitives.
+ *
+ * Before this module the three compactors (`HybridCompactor`,
+ * `IntelligentCompactor`, `SelectiveCompactor`) each carried their own copies
+ * of message-token estimation, tool-result elision, text detection and digest
+ * rendering — with subtle divergences (notably Selective lacked the
+ * tool_use/tool_result pair preservation, so it could elide the result of a
+ * tool call it was supposed to keep). These helpers are the single source of
+ * truth. They operate on plain `Message[]` and never touch `Context`/state, so
+ * each compactor keeps its own `ctx.state.replaceMessages(...)` plumbing.
+ */
+/** Does this message carry any non-empty text? */
+export declare function hasTextContent(m: Message): boolean;
+/**
+ * Index where the preserved (recent) window starts. Walks back counting
+ * user/assistant messages until `preserveK` are covered, then walks forward to
+ * keep any tool_use/tool_result protocol pair intact — so a tool_result whose
+ * tool_use is preserved is never elided.
+ *
+ * Instrumentation: emits `compaction.find_preserve_start.ended` with the
+ * repair-loop block count so we can track whether protocol-pair repair is
+ * scanning too much content.
+ */
+export declare function findPreserveStart(messages: readonly Message[], preserveK: number): number;
+export interface EliseResult {
+    /** New message array, or the same reference when nothing changed. */
+    messages: Message[];
+    /** Estimated tokens reclaimed. */
+    saved: number;
+    changed: boolean;
+}
+/**
+ * Elide oversized tool I/O that falls before the preserve window. Pure:
+ * returns a fresh array (or the same reference when unchanged). Replaces the
+ * duplicate copies that lived in all three compactors.
+ */
+export declare function eliseOldToolResults(messages: readonly Message[], opts: {
+    preserveK: number;
+    eliseThreshold: number;
+}): EliseResult;
+/**
+ * Lossless textual digest of a message range. Every text block is kept verbatim
+ * (across all roles, so prior `system` digests fold forward and nothing
+ * accumulates as loss). `tool_use` / `tool_result` blocks are counted and
+ * replaced with a marker rather than serialized — their payload is already
+ * persisted in the session log. Empty/tool-only messages are skipped.
+ */
+export declare function buildLosslessDigest(messages: readonly Message[]): string;
+/** Importance score for a message — drives retention vs. summarization. */
+export type ContentScore = 0 | 1 | 2 | 3 | 4 | 5;
+/**
+ * Extract the plain text from a message (ignoring tool blocks).
+ * Returns empty string if no text content exists.
+ */
+export declare function extractText(m: Message): string;
+/** Check if a message contains a tool_use block. */
+export declare function hasToolUse(m: Message): boolean;
+/** Check if a message contains a tool_result block over the given char threshold. */
+export declare function hasLargeToolResult(m: Message, threshold?: number): boolean;
+/**
+ * Score a message by content importance.
+ *
+ * CRITICAL (5): user corrections, explicit "no/wrong/stop", error messages,
+ *   architecture decisions, security findings.
+ * MEDIUM (3): normal exchanges, successful tool calls, file reads, edits.
+ * LOW (1): large tool results (>3K chars), grep/file-list outputs, boilerplate.
+ * NOISE (0): repeated identical failures (same tool, same error, 5th+ occurrence
+ *   within the range), pure tool I/O with no text.
+ */
+export declare function scoreMessage(m: Message, context?: {
+    failureCounts?: Map<string, number>;
+}): ContentScore;
+/**
+ * Build a content-aware digest of messages.
+ *
+ * Unlike `buildLosslessDigest` which preserves all text equally, this uses
+ * `scoreMessage` to apply tiered treatment:
+ * - Score 5 (critical): verbatim text
+ * - Score 3 (medium):   first sentence only
+ * - Score 1 (low):      one-line summary
+ * - Score 0 (noise):    collapsed to count marker
+ */
+export declare function buildSmartDigest(messages: readonly Message[]): string;
+/**
+ * Nearest safe cut boundary in [from, to]: the start of the exchange of the
+ * closest user-with-text message. Returns -1 when no such boundary exists.
+ */
+export declare function findSafeBoundary(messages: readonly Message[], from: number, to: number): number;
+/**
+ * Walk backwards from a user message to find where its logical exchange began
+ * (just after the last assistant message that made no tool calls).
+ */
+export declare function findExchangeStart(messages: readonly Message[], userIndex: number): number;
+//# sourceMappingURL=compaction-core.d.ts.map

package/dist/execution/compaction-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-core.d.ts","sourceRoot":"","sources":["../../src/execution/compaction-core.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EACL,qBAAqB,EAGtB,MAAM,4BAA4B,CAAC;AAkHpC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,8BAAwB,CAAC;AAEtD;;;;;;;;;;;GAWG;AAEH,kDAAkD;AAClD,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAGlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA8CzF;AAiCD,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAClD,WAAW,CAsIb;AAkED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAoBxE;AAID,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAMjD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAM9C;AAED,oDAAoD;AACpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAG9C;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAO,GAAG,OAAO,CAUxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,OAAO,EACV,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAChD,YAAY,CA6Dd;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAuDrE;AAiCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAS/F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAczF"}

package/dist/execution/compactor.d.ts

@@ -0,0 +1,56 @@
+import type { Context } from '../core/context.js';
+import type { CompactReport, Compactor } from '../types/compactor.js';
+export interface CompactorOptions {
+    preserveK?: number | undefined;
+    eliseThreshold?: number | undefined;
+    /**
+     * Enable content-aware digest mode. When true, `collapseAncientTurns` uses
+     * `buildSmartDigest` which scores messages by importance: critical content
+     * (errors, corrections, decisions) is kept verbatim; normal exchanges get
+     * first-sentence summaries; large tool outputs and repeated failures are
+     * aggressively compressed. Defaults to false (lossless digest).
+     */
+    smart?: boolean | undefined;
+    /**
+     * @deprecated Ignored. Token estimation is centralized in
+     * `compaction-core`/`token-estimate` so all compactors and the context-pressure
+     * monitor agree on one number. Kept only for backward-compatible call sites.
+     */
+    estimator?: (((text: string) => number)) | undefined;
+}
+/**
+ * Default tools config values shared across CLI and WebUI.
+ * Import this instead of hardcoding to avoid cross-surface inconsistencies.
+ * These mirror the values in BEHAVIOR_DEFAULTS (config-loader.ts).
+ *
+ * @deprecated Import from '../types/default-config.js' instead.
+ *             This re-export exists for backward compatibility.
+ */
+export { DEFAULT_TOOLS_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_AUTONOMY_CONFIG } from '../types/default-config.js';
+export declare class HybridCompactor implements Compactor {
+    private readonly preserveK;
+    private readonly eliseThreshold;
+    private readonly smart;
+    constructor(opts?: CompactorOptions);
+    compact(ctx: Context, opts?: {
+        aggressive?: boolean | undefined;
+    }): Promise<CompactReport>;
+    /**
+     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+     * This is the accurate figure for context-window pressure monitoring.
+     */
+    private estimateFullRequest;
+    /**
+     * Lossless rule-based collapse of ancient turns into a single digest message.
+     *
+     * Preserves ALL textual content of the collapsed range — user instructions,
+     * assistant decisions/conclusions, and any prior digests (chained forward so
+     * the digest stays lossless across repeated compactions). Only `tool_use` /
+     * `tool_result` protocol blocks are dropped and replaced with a count marker;
+     * their full payload already lives in the session log. No sub-LLM call.
+     *
+     * Returns the token savings and the digest text (for audit logging).
+     */
+    private collapseAncientTurns;
+}
+//# sourceMappingURL=compactor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compactor.d.ts","sourceRoot":"","sources":["../../src/execution/compactor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AActE,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;CACtD;AAED;;;;;;;GAOG;AACH,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAEnH,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;IAEhC,YAAY,IAAI,GAAE,gBAAqB,EAItC;IAEK,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,GAAE;QAAE,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAsDnG;IAED;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;CAiD7B"}

package/dist/execution/council-brain.d.ts

@@ -0,0 +1,79 @@
+/**
+ * CouncilBrainArbiter — a multi-LLM decision panel for high-stakes questions.
+ *
+ * Instead of trusting one model's single completion, the council convenes N
+ * independent voters (ideally different models/providers), each with a
+ * distinct decision persona:
+ *
+ *   - executor — biased toward forward progress; hates stalling.
+ *   - skeptic  — hunts for the reason the proposed action is wrong; may veto.
+ *   - auditor  — cost/waste/budget lens; hates throwing tokens at dead ends.
+ *
+ * Votes are cast INDEPENDENTLY (no voter sees another's rationale), then
+ * tallied with weights. Resolution ladder:
+ *
+ *   1. QUORUM  — fewer than `quorumFraction` of seats returned a valid vote
+ *      → the council abstains (`ask_human`), letting the escalation tier
+ *      (human prompt or headless terminal policy) resolve it.
+ *   2. VETO    — a veto seat explicitly refusing denies the request outright.
+ *   3. MAJORITY — the option with the highest total weight wins when it
+ *      exceeds `approvalFraction` of all cast weight.
+ *   4. JUDGE   — ties / weak pluralities go to a judge model that sees every
+ *      vote's rationale and issues the final structured decision. No judge
+ *      (or judge failure) → abstain (`ask_human`).
+ *
+ * Optionless (free-text) requests skip the tally: every voter writes an
+ * independent stance and the judge synthesizes the final answer; without a
+ * judge, the first valid stance wins.
+ *
+ * The council NEVER blocks on a human itself — its worst case is an
+ * `ask_human` abstention that the outer escalation tier resolves.
+ *
+ * @module council-brain
+ */
+import type { BrainArbiter, BrainDecision, BrainDecisionRequest } from '../coordination/brain.js';
+import { type BrainLlmTarget } from './autonomy-brain.js';
+/** One voting seat on the council. */
+export interface CouncilVoter extends BrainLlmTarget {
+    /**
+     * Decision lens. Built-ins: 'executor', 'skeptic', 'auditor'. Any other
+     * string is injected verbatim as the persona description.
+     */
+    persona?: string | undefined;
+    /** Vote weight in the tally. Default 1. */
+    weight?: number | undefined;
+    /** When true, this seat's explicit refusal denies the request outright. */
+    veto?: boolean | undefined;
+}
+export interface CouncilBrainOptions {
+    voters: CouncilVoter[];
+    /** Tie-breaker / synthesizer. Default: none (ties abstain to escalation). */
+    judge?: BrainLlmTarget | undefined;
+    /** Fraction of seats that must return a valid vote. Default 0.5. */
+    quorumFraction?: number | undefined;
+    /** Fraction of cast weight the winning option must EXCEED. Default 0.5. */
+    approvalFraction?: number | undefined;
+    /** Per-voter (and judge) completion timeout in ms. Default 15000. */
+    decisionTimeoutMs?: number | undefined;
+    /**
+     * Decision-history digest (typically `BrainDecisionLedger.digestFor`) —
+     * appended to every voter's user message so the panel sees how similar
+     * past decisions turned out.
+     */
+    getDecisionDigest?: ((request: BrainDecisionRequest) => string | undefined) | undefined;
+    /** Called with a human-readable summary after every council decision. */
+    onDecision?: ((summary: string, decision: BrainDecision, request: BrainDecisionRequest) => void) | undefined;
+}
+/**
+ * Synthetic ballot entry that lets any voter refuse every real option. Kept
+ * deliberately awkward so it can never collide with a caller option id; if
+ * it somehow does, the synthetic entry is skipped for that request.
+ */
+export declare const COUNCIL_REFUSE_OPTION_ID = "council_refuse";
+/**
+ * Create a council-of-LLMs Brain arbiter. See the module docs for the
+ * resolution ladder. Positioned by `createTieredBrainArbiter` above the
+ * single-LLM tier for requests at/above the council risk floor.
+ */
+export declare function createCouncilBrainArbiter(opts: CouncilBrainOptions): BrainArbiter;
+//# sourceMappingURL=council-brain.d.ts.map

package/dist/execution/council-brain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"council-brain.d.ts","sourceRoot":"","sources":["../../src/execution/council-brain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEb,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,KAAK,cAAc,EAMpB,MAAM,qBAAqB,CAAC;AAE7B,sCAAsC;AACtC,MAAM,WAAW,YAAa,SAAQ,cAAc;IAClD;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACnC,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,2EAA2E;IAC3E,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,oBAAoB,KAAK,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IACxF,yEAAyE;IACzE,UAAU,CAAC,EACP,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC,GACnF,SAAS,CAAC;CACf;AAED;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,mBAAmB,CAAC;AAiDzD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,mBAAmB,GAAG,YAAY,CA6OjF"}

package/dist/execution/design-color.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Design Studio color utilities.
+ *
+ * Design kit tokens are authored in OKLCH (CSS-native, the modern 2026 default).
+ * CSS targets keep them verbatim, but native stacks (React Native, Flutter,
+ * SwiftUI, Compose) need concrete sRGB — so `materialize` converts each token
+ * with `oklchToHex`. The verifier also normalizes colors to hex before
+ * comparing, so an `oklch()` token and the same color written as `#rrggbb`
+ * count as a match.
+ *
+ * Conversion is the standard Björn Ottosson OKLab→linear-sRGB pipeline; values
+ * out of the sRGB gamut are clamped (not gamut-mapped) — adequate for the
+ * near-in-gamut palettes our kits use.
+ */
+/** Parse an `oklch(L C H[ / a])` string into [L(0..1), C, H(deg), a(0..1)] or null. */
+export declare function parseOklch(value: string): [number, number, number, number] | null;
+/**
+ * Convert an OKLCH string to `#rrggbb` (or `#rrggbbaa` when alpha < 1).
+ * Returns null if `value` is not parseable OKLCH.
+ */
+export declare function oklchToHex(value: string): string | null;
+/**
+ * Normalize any color token to a lowercase `#rrggbb[aa]` hex when possible.
+ * Passes through existing hex (lowercased, expanded from #rgb), converts
+ * `oklch(...)`, and returns null for values we can't resolve (named colors,
+ * gradients, non-color tokens like font names).
+ */
+export declare function colorToHex(value: string): string | null;
+/** True when a token value looks like a color (OKLCH or hex), not a font/size. */
+export declare function isColorToken(value: string): boolean;
+//# sourceMappingURL=design-color.d.ts.map

package/dist/execution/design-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-color.d.ts","sourceRoot":"","sources":["../../src/execution/design-color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAiBjF;AAsCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBvD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBvD;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD"}

package/dist/execution/design-detect.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Design Studio detection + injection middleware.
+ *
+ * The system prompt is built ONCE per session (boot / project-switch), so a
+ * system-prompt contributor cannot react to "the model just started building a
+ * UI" mid-session. Instead, detection and injection ride the per-turn pipelines:
+ *
+ *   - userInput  middleware → detect UI intent in the user's message
+ *   - toolCall   middleware → detect a frontend file being written
+ *       (both set `ctx.meta.designStudio`)
+ *   - request    middleware → on every turn, read `ctx.meta.designStudio` and
+ *       append an ephemeral block to `req.system`: the kit menu (until a kit is
+ *       chosen) or a one-line adherence reminder (once chosen).
+ *
+ * Keeping the heavy kit body out of this path — the model loads it on demand via
+ * the `design` tool — is what keeps per-turn token cost low.
+ */
+import type { AgentPipelines, ToolCallPipelinePayload, UserInputPayload } from '../core/agent-types.js';
+import type { Context } from '../core/context.js';
+import type { Middleware } from '../kernel/pipeline.js';
+import type { DesignKitLoader, DesignStack, DesignStudioState } from '../types/design-kit.js';
+import type { Request } from '../types/provider.js';
+export declare function getDesignState(ctx: {
+    meta: Record<string, unknown>;
+}): DesignStudioState | undefined;
+/** Mark Design Studio active and merge in detected signals/stack. */
+export declare function activateDesign(ctx: {
+    meta: Record<string, unknown>;
+}, signals: string[], stack?: DesignStack): DesignStudioState;
+/** Record the kit the model/user committed to. */
+export declare function setActiveKit(ctx: {
+    meta: Record<string, unknown>;
+}, kitId: string, stack?: DesignStack, overrides?: Record<string, string> | undefined): void;
+/** Merge color/token overrides into the live state (used by `design set`). */
+export declare function setDesignOverrides(ctx: {
+    meta: Record<string, unknown>;
+}, overrides: Record<string, string>): void;
+/** Clear the active kit (e.g. `/design off`), leaving detection state intact. */
+export declare function clearActiveKit(ctx: {
+    meta: Record<string, unknown>;
+}): void;
+/**
+ * Inspect user text for UI/design intent. Returns the strongest stack hint and
+ * the matched signals, or `null` when nothing UI-ish was found.
+ */
+export declare function detectFrontendIntent(text: string): {
+    stack?: DesignStack;
+    signals: string[];
+} | null;
+/** Detect whether a written/edited file path is a frontend file. */
+export declare function detectFrontendFile(filePath: string): {
+    stack?: DesignStack;
+} | null;
+/** userInput middleware: detect UI intent from the user's message. */
+export declare function makeDesignDetectUserInputMiddleware(): Middleware<UserInputPayload>;
+/** toolCall middleware: detect frontend file writes/edits. */
+export declare function makeDesignDetectToolCallMiddleware(): Middleware<ToolCallPipelinePayload>;
+/**
+ * toolCall middleware: after a frontend file is written/edited AND a kit is
+ * pinned, scan the file for off-palette colors and append a non-blocking
+ * warning to the tool result. This makes adherence PASSIVE — the model is
+ * nudged toward kit tokens the moment it drifts, without anyone running
+ * `design verify` by hand. Best-effort: any failure leaves the result untouched.
+ */
+export declare function makeDesignVerifyToolCallMiddleware(): Middleware<ToolCallPipelinePayload>;
+/**
+ * request middleware: per-turn, inject the kit menu (until a kit is chosen) or a
+ * compact adherence reminder (once chosen). No-op when Design Studio is inactive.
+ *
+ * Closes over the live `Context` because the `request` pipeline payload is just
+ * the `Request` — it carries no ctx. `req.system` shares the array reference
+ * with `ctx.systemPrompt`, so we return a NEW array rather than mutating it.
+ */
+export declare function makeDesignStudioRequestMiddleware(deps: {
+    ctx: Context;
+    loader: DesignKitLoader;
+    enabled?: () => boolean;
+}): Middleware<Request>;
+/**
+ * Install the Design Studio per-turn middleware onto an agent's pipelines.
+ * Shared by every host (CLI/TUI + both WebUI servers) so auto-detection behaves
+ * identically everywhere. All three are PREPENDED:
+ *   - detection runs first so a short-circuiting middleware can't suppress it;
+ *   - the request injector must sit ahead of `ModelRuntimeSettings`, which does
+ *     not call `next` and would otherwise end the chain before us.
+ *
+ * The `design` tool and `/design` command are wired separately (builtin pack +
+ * slash registry); this only installs the activation behavior.
+ */
+export declare function installDesignStudioMiddleware(deps: {
+    pipelines: AgentPipelines;
+    ctx: Context;
+    /** When false, nothing is installed (tool + /design stay manual). */
+    enabled?: boolean | undefined;
+}): void;
+//# sourceMappingURL=design-detect.d.ts.map

package/dist/execution/design-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-detect.d.ts","sourceRoot":"","sources":["../../src/execution/design-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE9F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAOpD,wBAAgB,cAAc,CAAC,GAAG,EAAE;IAClC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GAAG,iBAAiB,GAAG,SAAS,CAGhC;AAWD,qEAAqE;AACrE,wBAAgB,cAAc,CAC5B,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EACtC,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,CAAC,EAAE,WAAW,GAClB,iBAAiB,CAMnB;AAED,kDAAkD;AAClD,wBAAgB,YAAY,CAC1B,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EACtC,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC7C,IAAI,CAMN;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAChC,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EACtC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,IAAI,CAGN;AAED,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,IAAI,CAG3E;AAgBD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,GACX;IAAE,KAAK,CAAC,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAyBnD;AAWD,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,CAMnF;AAID,sEAAsE;AACtE,wBAAgB,mCAAmC,IAAI,UAAU,CAAC,gBAAgB,CAAC,CAUlF;AAED,8DAA8D;AAC9D,wBAAgB,kCAAkC,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAexF;AAID;;;;;;GAMG;AACH,wBAAgB,kCAAkC,IAAI,UAAU,CAAC,uBAAuB,CAAC,CAgDxF;AAWD;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE;IACtD,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC;CACzB,GAAG,UAAU,CAAC,OAAO,CAAC,CAwDtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,SAAS,EAAE,cAAc,CAAC;IAC1B,GAAG,EAAE,OAAO,CAAC;IACb,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B,GAAG,IAAI,CAsBP"}

package/dist/execution/design-kit-loader.d.ts

@@ -0,0 +1,53 @@
+import { type DesignKitEntry, type DesignKitLoader, type DesignKitManifest, type DesignKitTokens, type DesignStack } from '../types/design-kit.js';
+export interface DesignKitLoaderOptions {
+    /** <project>/.wrongstack/design-kits */
+    inProjectDir: string;
+    /** ~/.wrongstack/design-kits */
+    globalDir: string;
+    /** Bundled kits shipped with @wrongstack/core (packages/core/design-kits). */
+    bundledDir?: string | undefined;
+}
+/**
+ * Discovery order (highest priority first; later layers are shadowed by name):
+ *   1. Project-committed:  <project>/.wrongstack/design-kits/
+ *   2. User-global:        ~/.wrongstack/design-kits/
+ *   3. Bundled with build: packages/core/design-kits/
+ *
+ * The `_foundations` directory is a reserved kit id holding the mandatory
+ * cross-cutting baseline; it is excluded from the selectable menu.
+ */
+export declare class DefaultDesignKitLoader implements DesignKitLoader {
+    private readonly dirs;
+    private cache?;
+    private readonly bodyCache;
+    private readonly tokenCache;
+    constructor(opts: DesignKitLoaderOptions);
+    list(): Promise<DesignKitManifest[]>;
+    /** Selectable kits only (excludes the reserved `_foundations` entry). */
+    private selectable;
+    listEntries(): Promise<DesignKitEntry[]>;
+    find(id: string): Promise<DesignKitManifest | undefined>;
+    menuText(): Promise<string>;
+    readBody(id: string, stack?: DesignStack): Promise<string>;
+    readTokens(id: string): Promise<DesignKitTokens | undefined>;
+    foundationsText(stack?: DesignStack): Promise<string>;
+    invalidateCache(): void;
+}
+/**
+ * Resolve the bundled `design-kits/` directory shipped alongside this module.
+ * The directory is a sibling of `src/` (dev) and `dist/` (built), so we probe a
+ * few candidate depths relative to the compiled module location and return the
+ * first that exists. Returns `undefined` if none is found (treated as "no
+ * bundled kits this run").
+ */
+export declare function resolveBundledDesignKitsDir(): string | undefined;
+/**
+ * Memoized per-project loader. Used by the `design` tool and the Design Studio
+ * middleware/slash-command so they share one cached instance without threading
+ * the loader through every boot path. The loader is a pure disk reader (no
+ * injected services), so a module-level memo is safe.
+ */
+export declare function getDesignKitLoader(projectRoot: string): DefaultDesignKitLoader;
+/** Test helper — clears the per-project loader memo. */
+export declare function _resetDesignKitLoaderMemo(): void;
+//# sourceMappingURL=design-kit-loader.d.ts.map

package/dist/execution/design-kit-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-kit-loader.d.ts","sourceRoot":"","sources":["../../src/execution/design-kit-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,WAAW,EAEjB,MAAM,wBAAwB,CAAC;AAwHhC,MAAM,WAAW,sBAAsB;IACrC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyD;IAC9E,OAAO,CAAC,KAAK,CAAC,CAAkC;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkD;IAE7E,YAAY,IAAI,EAAE,sBAAsB,EAMvC;IAEK,IAAI,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAwCzC;IAED,yEAAyE;YAC3D,UAAU;IAIlB,WAAW,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAS7C;IAEK,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAI7D;IAEK,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAUhC;IAEK,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAU/D;IAEK,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAiBjE;IAEK,eAAe,CAAC,KAAK,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAM1D;IAED,eAAe,IAAI,IAAI,CAItB;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,GAAG,SAAS,CAgBhE;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,sBAAsB,CAW9E;AAED,wDAAwD;AACxD,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}