@wrongstack/core 0.284.1 → 0.285.0

package/dist/execution/auto-compaction-middleware.d.ts

@@ -0,0 +1,123 @@
+import type { Context } from '../core/context.js';
+import type { EventBus } from '../kernel/events.js';
+import type { MiddlewareHandler } from '../kernel/pipeline.js';
+import type { SessionEventBridge } from '../storage/session-event-bridge.js';
+import type { Compactor } from '../types/compactor.js';
+import type { ContextWindowAggressiveOn, ContextWindowPolicy } from '../types/context-window.js';
+export interface ContextWindowBudgetSnapshot {
+    maxContext: number;
+    inputTokens: number;
+    availableInputTokens: number;
+    remainingInputTokens: number;
+    reservedOutputTokens: number;
+    reservedSafetyTokens: number;
+    load: number;
+    overflowTokens: number;
+}
+export type CompactionFailureMode = 'throw' | 'throw_on_hard' | 'continue';
+export interface AutoCompactionOptions {
+    aggressiveOn?: ContextWindowAggressiveOn | undefined;
+    events?: EventBus | undefined;
+    failureMode?: CompactionFailureMode | undefined;
+    policyProvider?: (ctx: Context) => Pick<ContextWindowPolicy, 'thresholds' | 'aggressiveOn'> | null | undefined;
+    /** Optional bridge for writing compaction events into the persistent session log. */
+    sessionBridge?: SessionEventBridge | undefined;
+}
+/**
+ * Pipeline middleware that monitors context token load and automatically
+ * triggers compaction when the warn/soft/hard thresholds are crossed.
+ * Runs before the next agent iteration.
+ *
+ * Uses `estimateRequestTokens` for accurate full-request token counting:
+ * messages + systemPrompt + toolDefs. This replaces the previous pattern
+ * of applying an OVERHEAD_FACTOR to a messages-only estimate.
+ */
+export declare class AutoCompactionMiddleware {
+    readonly name = "AutoCompaction";
+    private readonly compactor;
+    /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+    private readonly _estimator?;
+    private readonly warnThreshold;
+    private readonly softThreshold;
+    private readonly hardThreshold;
+    /** Writable so model-switch can update the denominator without re-registering the middleware. */
+    private _maxContext;
+    /**
+     * Runtime on/off gate. The middleware is always installed in the pipeline so
+     * auto-compaction can be toggled live from the TUI `/settings` picker; when
+     * disabled the handler is a pass-through. Defaults to enabled.
+     */
+    private _enabled;
+    private readonly aggressiveOn;
+    private readonly events?;
+    private readonly failureMode;
+    private readonly policyProvider?;
+    private readonly sessionBridge?;
+    /**
+     * Once a compaction attempt reduces nothing (preserveK protects everything,
+     * no oversized tool_results remain to elide), retrying on every iteration
+     * just spams `compaction.fired` events without making progress. We remember
+     * the no-op and skip until either the pressure level escalates or context
+     * has grown by at least this many tokens since the failed attempt.
+     */
+    private static readonly NOOP_RETRY_DELTA_TOKENS;
+    /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+    private lastNoopAttempt;
+    /**
+     * Cached token estimate from the last handler() invocation. When the
+     * message count and tool count haven't changed since the last estimate
+     * (autonomous idle loops), we skip the expensive O(n) token estimation
+     * and reuse this value. Reset to -1 when the context changes.
+     */
+    private _cachedTokens;
+    private _cachedMsgCount;
+    private _cachedToolCount;
+    /**
+     * @param compactor        Compactor to use for compaction.
+     * @param maxContext Provider's max context window in tokens.
+     * @param _estimator       Deprecated parameter kept for backward compatibility.
+     *                         The middleware now uses `estimateRequestTokens` internally
+     *                         for accurate full-request token counting (messages +
+     *                         systemPrompt + toolDefs).
+     * @param thresholds       Threshold fractions (0-1) of maxContext.
+     * @param opts             Optional behavior. By default, failures at the
+     *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
+     *                         the agent does not continue into a likely
+     *                         provider context overflow. Warn/soft failures
+     *                         still emit compaction.failed and continue.
+     */
+    constructor(compactor: Compactor, maxContext: number, _estimator: (ctx: Context) => number, thresholds: {
+        warn: number;
+        soft: number;
+        hard: number;
+    }, optsOrAggressiveOn?: AutoCompactionOptions | ContextWindowAggressiveOn, events?: EventBus | undefined);
+    /** Allow callers (e.g. model-switch in WebUI) to update the context window
+     *  denominator when the active model changes. */
+    setMaxContext(maxContext: number): void;
+    /** Whether auto-compaction is currently active. */
+    get enabled(): boolean;
+    /** Toggle auto-compaction on a live session (TUI `/settings`). When disabled
+     *  the middleware passes every iteration straight through without estimating
+     *  tokens or compacting. */
+    setEnabled(enabled: boolean): void;
+    handler(): MiddlewareHandler<Context>;
+    /**
+     * H1: try to read a pre-computed token total from `ctx.lastRequestTokens`
+     * (set by the agent loop's pre-flight or its restash in emitContextPct).
+     * Returns the uncalibrated total when the stash is valid for the current
+     * context shape (positive number, and the message count it was computed
+     * at matches the current one — otherwise tool results have been appended
+     * since and the value is stale). Returns null when missing or stale so
+     * the caller falls back to a fresh walk.
+     */
+    private tryStashedTokens;
+    /**
+     * Returns true when the previous compaction at the same or higher pressure
+     * level reduced nothing and context has not grown materially since. Prevents
+     * a stuck preserveK window from spamming compaction events every iteration.
+     */
+    private shouldSkipNoopRetry;
+    private recordAttempt;
+    private compact;
+}
+//# sourceMappingURL=auto-compaction-middleware.d.ts.map

package/dist/execution/auto-compaction-middleware.d.ts.map

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

package/dist/execution/autonomous-runner.d.ts

@@ -0,0 +1,55 @@
+import type { Agent, RunResult } from '../core/agent.js';
+import type { Context } from '../core/context.js';
+import type { DoneCondition } from '../types/multi-agent.js';
+type AutonomousResult = RunResult & {
+    toolCalls: number;
+    reason?: string | undefined;
+};
+export interface DoneCheckResult {
+    done: boolean;
+    reason?: string | undefined;
+    iterations: number;
+    toolCalls: number;
+}
+export declare class DoneConditionChecker {
+    private readonly condition;
+    private readonly compiledRegex;
+    constructor(condition: DoneCondition);
+    check(state: {
+        iterations: number;
+        toolCalls: number;
+        lastOutput?: string | undefined;
+    }): DoneCheckResult;
+}
+export interface AutonomousRunnerOptions {
+    agent: Agent;
+    context: Context;
+    doneCondition: DoneCondition;
+    iterationTimeoutMs?: number | undefined;
+    onIteration?: (state: {
+        iteration: number | undefined;
+        toolCalls: number;
+    }) => void;
+    onDone?: (((result: AutonomousResult) => void)) | undefined;
+    /**
+     * When true and `doneCondition.type === 'directive'`, the runner
+     * runs the agent with `autonomousContinue: true` so the agent loop
+     * handles its own [continue]/[done] markers internally (no outer
+     * re-invocation needed). The runner still provides iteration/timeouts.
+     */
+    enableAutonomousContinue?: boolean | undefined;
+}
+export declare class AutonomousRunner {
+    private readonly opts;
+    private iterations;
+    private toolCalls;
+    private lastOutput?;
+    private stopped;
+    private readonly doneChecker;
+    constructor(opts: AutonomousRunnerOptions);
+    run(): Promise<AutonomousResult>;
+    private runLoop;
+    stop(): void;
+}
+export {};
+//# sourceMappingURL=autonomous-runner.d.ts.map

package/dist/execution/autonomous-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomous-runner.d.ts","sourceRoot":"","sources":["../../src/execution/autonomous-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAI7D,KAAK,gBAAgB,GAAG,SAAS,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEvF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,oBAAoB;IAGnB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAE9C,YAA6B,SAAS,EAAE,aAAa,EAiBpD;IAED,KAAK,CAAC,KAAK,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,eAAe,CA0DxG;CACF;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,aAAa,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACpF,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;IAC5D;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChD;AAED,qBAAa,gBAAgB;IAOf,OAAO,CAAC,QAAQ,CAAC,IAAI;IANjC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAC,CAAqB;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IAEnD,YAA6B,IAAI,EAAE,uBAAuB,EAEzD;IAEK,GAAG,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAgCrC;YAEa,OAAO;IA6GrB,IAAI,IAAI,IAAI,CAEX;CACF"}

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

@@ -0,0 +1,90 @@
+/**
+ * AutonomyBrain — a self-driving decision layer for autonomous workflows.
+ *
+ * Unlike the standard BrainArbiter which asks the human when uncertain,
+ * AutonomyBrain makes decisions autonomously within configured risk
+ * boundaries, keeping the system running unattended. It uses the session
+ * LLM to evaluate situations and produce decisions.
+ *
+ * ## Identity
+ * The AutonomyBrain is NOT the main agent. It is a dedicated decision
+ * engine with a single purpose: evaluate blocked/stuck situations in
+ * autonomous workflows and decide whether to continue, pivot, or stop.
+ *
+ * ## Decision Flow
+ * 1. RISK GATE — if request risk > maxAutoRisk, auto-deny
+ * 2. HEURISTIC — fast pattern-match for common situations (deadlock, retry-exhausted)
+ * 3. LLM EVALUATION — complex decisions (goal completion, conflict resolution)
+ *
+ * ## Decision Logging
+ * Every decision is emitted via `onDecision` callback with a human-readable
+ * summary suitable for chat history and journal entries.
+ *
+ * Usage:
+ *   const brain = createAutonomyBrain({
+ *     provider, model, maxAutoRisk: 'high',
+ *     onDecision: (summary) => journal.push(summary),
+ *   });
+ */
+import type { Provider } from '../types/provider.js';
+import type { BrainArbiter, BrainDecision, BrainDecisionRequest } from '../coordination/brain.js';
+export interface AutonomyBrainOptions {
+    /** LLM provider for decision-making. */
+    provider: Provider;
+    /** Model to use for decisions (should be fast + cheap). */
+    model: string;
+    /** Maximum risk level the brain will auto-decide. Default: 'high'.
+     *  'low'    — only auto-decide low-risk questions
+     *  'medium' — auto-decide low/medium
+     *  'high'   — auto-decide low/medium/high
+     *  'all'    — auto-decide everything (including critical)
+     */
+    maxAutoRisk?: 'low' | 'medium' | 'high' | 'all' | undefined;
+    /** Timeout for each decision call (ms). Default: 15_000. */
+    decisionTimeoutMs?: number | undefined;
+    /**
+     * Called after every decision with a human-readable summary.
+     * Use this to log decisions into chat history, journal, or status line.
+     * Example: "🧠 Brain: skipped deadlocked tasks → continuing with phase 3/5"
+     */
+    onDecision?: ((summary: string, decision: BrainDecision, request: BrainDecisionRequest) => void) | undefined;
+}
+/** Runtime-adjustable autonomy ceiling for the tiered brain. */
+export type BrainAutoRisk = 'off' | 'low' | 'medium' | 'high' | 'all';
+export interface TieredBrainArbiterOptions {
+    /** Fast deterministic policy layer (DefaultBrainArbiter). Consulted first. */
+    policy: BrainArbiter;
+    /** LLM-backed autonomous layer (createAutonomyBrain). Consulted when the
+     *  policy layer would escalate to the human and the request's risk is
+     *  within the live ceiling. */
+    autonomous?: BrainArbiter | undefined;
+    /**
+     * Live autonomy ceiling — read on EVERY decision so `/brain risk <level>`
+     * changes take effect immediately. 'off' disables the autonomous layer
+     * entirely (everything the policy can't answer goes to the human).
+     */
+    getMaxAutoRisk?: (() => BrainAutoRisk) | undefined;
+}
+/**
+ * The standard Brain positioning: policy first, LLM second, human last.
+ *
+ *   1. POLICY  — deterministic DefaultBrainArbiter (low-risk fast path,
+ *      fallback semantics). Answers and denies pass through untouched.
+ *   2. LLM     — when the policy says `ask_human` and the request's risk is
+ *      within the live ceiling, the autonomous brain gets a chance to
+ *      answer. Only a real `answer` short-circuits; LLM denials/failures
+ *      fall through.
+ *   3. HUMAN   — anything left escalates (callers wrap this in
+ *      HumanEscalatingBrainArbiter so `ask_human` becomes a real prompt).
+ */
+export declare function createTieredBrainArbiter(opts: TieredBrainArbiterOptions): BrainArbiter;
+/**
+ * Create a self-driving brain that makes autonomous decisions.
+ * Never asks the human — within its risk boundary it answers, above it denies.
+ */
+export declare function createAutonomyBrain(opts: AutonomyBrainOptions): BrainArbiter;
+/**
+ * Format a decision as a human-readable one-liner for chat history.
+ */
+export declare function formatDecisionSummary(decision: BrainDecision, request: BrainDecisionRequest): string;
+//# sourceMappingURL=autonomy-brain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-brain.d.ts","sourceRoot":"","sources":["../../src/execution/autonomy-brain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAIlG,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,QAAQ,EAAE,QAAQ,CAAC;IACnB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAC5D,4DAA4D;IAC5D,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC9G;AASD,gEAAgE;AAChE,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAEtE,MAAM,WAAW,yBAAyB;IACxC,8EAA8E;IAC9E,MAAM,EAAE,YAAY,CAAC;IACrB;;mCAE+B;IAC/B,UAAU,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACtC;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,aAAa,CAAC,GAAG,SAAS,CAAC;CACpD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,yBAAyB,GAAG,YAAY,CAmBtF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,oBAAoB,GAAG,YAAY,CAkC5E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAmBR"}

package/dist/execution/autonomy-prompt-contributor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * System-prompt contributor that surfaces eternal-autonomy state to the
+ * model on every turn.
+ *
+ * Why this exists: when the engine drives a long-running loop, the
+ * per-iteration directive carries the rules. But the directive is a USER
+ * message — it scrolls out of working memory after a few compactions and
+ * the model forgets it's in autonomy mode (forgets `[GOAL_COMPLETE]`,
+ * forgets the todo-state protocol, forgets the no-confirmation rule).
+ * Injecting the same anchor as a CACHED system-prompt block solves that
+ * — the rules sit next to the identity layer and survive compactions.
+ *
+ * Block is tagged `ephemeral` so its content (journal tail, iteration
+ * counter) changes each turn without invalidating the upstream prefix
+ * cache.
+ */
+import type { SystemPromptContributor } from '../types/system-prompt-contributor.js';
+export interface AutonomyPromptContributorOptions {
+    /** Absolute path to the project's `goal.json`. */
+    goalPath: string;
+    /**
+     * Gating function. The contributor consults this on every build and
+     * returns an empty array when `false` — without this, the block would
+     * leak into interactive runs that happen to have a goal on disk and
+     * teach the model loop-control markers it shouldn't emit.
+     *
+     * Typical wiring: enable while `eternal` or `eternal-parallel` autonomy is active.
+     */
+    enabled: () => boolean;
+    /** Number of journal entries to include in the recent-tail block. Default 5. */
+    journalTailSize?: number | undefined;
+}
+/**
+ * Build a contributor that renders the autonomy-state system block.
+ * Returns `[]` when disabled, no goal exists, or the goal has been
+ * completed/abandoned — all silent fast-paths.
+ */
+export declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOptions): SystemPromptContributor;
+//# sourceMappingURL=autonomy-prompt-contributor.d.ts.map

package/dist/execution/autonomy-prompt-contributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-prompt-contributor.d.ts","sourceRoot":"","sources":["../../src/execution/autonomy-prompt-contributor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAOrF,MAAM,WAAW,gCAAgC;IAC/C,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,gCAAgC,GACrC,uBAAuB,CA+CzB"}

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/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"}