@wrongstack/core 0.9.19 → 0.10.0

package/dist/{events-CiG9qUM_.d.ts → events-Bw1K5E6K.d.ts}

@@ -1,4 +1,4 @@
-import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-BRNbHmRM.js';
+import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-7u93AcGD.js';
 
 /**
  * EventBus — observe-only typed event bus.
@@ -160,6 +160,20 @@ interface EventMap {
          * for tools without a meaningful line count. */
         outputLines?: number;
     };
+    /**
+     * Fired on every `iteration.completed`. UIs subscribe to render a live
+     * context-window fill bar per agent (e.g. "67% ████████░░"). The
+     * `load` fraction matches the threshold levels: 0–0.6 green, 0.6–0.75
+     * yellow, 0.75+ red.
+     */
+    'ctx.pct': {
+        /** Fraction of maxContext currently in use (0–1+. Can exceed 1 when over budget). */
+        load: number;
+        /** Estimated total tokens (system + tools + messages). */
+        tokens: number;
+        /** Provider's max context window. */
+        maxContext: number;
+    };
     'token.threshold': {
         used: number;
         limit: number;
@@ -365,6 +379,18 @@ interface EventMap {
         summary: string;
         ok: boolean;
     };
+    /**
+     * Fired by MultiAgentHost when a subagent's context window load changes.
+     * The leader agent's ctx.pct is emitted directly on the host EventBus;
+     * subagent ctx.pct events are forwarded here with subagentId attribution.
+     * TUI uses this to render live context fill bars per agent.
+     */
+    'subagent.ctx_pct': {
+        subagentId: string;
+        load: number;
+        tokens: number;
+        maxContext: number;
+    };
     'mcp.server.connected': {
         name: string;
         toolCount: number;
@@ -387,6 +413,21 @@ interface EventMap {
         ts: string;
         fileCount: number;
     };
+    /**
+     * Fired by SessionWriter.writeInFlightMarker() — the agent loop has
+     * started a long-running operation. Pairs with `in_flight.ended`
+     * on clean shutdown. A marker with no end indicates a crash.
+     * (Idea #1 from IDEAS.md — Stateful Session Recovery.)
+     */
+    'in_flight.started': {
+        context: string;
+        ts: string;
+    };
+    /** Fired by SessionWriter.clearInFlightMarker() — operation completed cleanly. */
+    'in_flight.ended': {
+        reason: 'clean' | 'aborted' | 'recovered';
+        ts: string;
+    };
     /**
      * Fired after a session rewind completes: files are reverted and the session
      * history is truncated. The TUI listens to this to update its checkpoint
@@ -571,6 +612,13 @@ declare class ScopedEventBus extends EventBus {
      * Uses EventBus's public API directly to avoid triggering our own `on()`
      * override (which would consume a key slot for the wrapper, then orphan
      * our registration entry under a different key).
+     *
+     * When the wrapper fires, it cleans up BOTH the underlying EventBus
+     * listener AND the tracking entry — so `scopedListenerCount` returns to
+     * its pre-`once()` value without requiring the caller to invoke the
+     * returned unsubscribe. The returned `unsub` is still safe to call
+     * after auto-removal (its delete is a no-op and its off() finds
+     * nothing to remove).
      */
     once<E extends EventName>(event: E, fn: Listener<E>): () => void;
     /**

package/dist/execution/index.d.ts

@@ -1,23 +1,23 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-Boo3dekH.js';
-import { m as Provider, d as Context } from '../context-BRNbHmRM.js';
-import { a as Compactor, C as CompactReport } from '../compactor-DVTKL7XD.js';
-import { M as MessageSelector } from '../selector-pox8abg0.js';
-import { E as EventBus } from '../events-CiG9qUM_.js';
-import { b as MiddlewareHandler } from '../system-prompt-Bs-Wliab.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-CWva0qoL.js';
-import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-aizK8olO.js';
-import { D as DoneCondition } from '../multi-agent-3ZnTB1aT.js';
-import { J as JournalEntry } from '../goal-store-C7jcumEh.js';
-import { A as AgentFactory } from '../agent-subagent-runner-C4qt9e5Y.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-bRaI_aD1.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-D7RxLtg4.js';
+import { m as Provider, d as Context } from '../context-7u93AcGD.js';
+import { a as Compactor, C as CompactReport } from '../compactor-D1RHFRmF.js';
+import { M as MessageSelector } from '../selector-DmXxpFyM.js';
+import { E as EventBus } from '../events-Bw1K5E6K.js';
+import { b as MiddlewareHandler } from '../system-prompt-CM6zOhd2.js';
+import { a as SessionEventBridge, J as JournalEntry } from '../goal-store-BeRsj7YX.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-CJXBka2r.js';
+import { c as Agent, R as RunResult, w as SystemPromptContributor } from '../index-DgQWnZxP.js';
+import { D as DoneCondition } from '../multi-agent-C1O8EFzb.js';
+import { A as AgentFactory } from '../agent-subagent-runner-KwufTWwn.js';
+import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-DoVSBFNx.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
-import { a as WstackPaths } from '../wstack-paths-BCgmTNlG.js';
-import '../retry-policy-BYkq0ugs.js';
+import { a as WstackPaths } from '../wstack-paths-eMXnY1_X.js';
+import '../retry-policy-KF18W4dg.js';
 import '../models-registry-BcYJDKLm.js';
 import '../logger-DDd5C--Z.js';
 import '../observability-BhnVLBLS.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-bPuzAy4x.js';
+import '../permission-B6sldrSp.js';
 import 'node:events';
 
 interface SkillLoaderOptions {
@@ -92,6 +92,11 @@ declare class IntelligentCompactor implements Compactor {
     compact(ctx: Context, opts?: {
         aggressive?: boolean;
     }): Promise<CompactReport>;
+    /**
+     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+     * This is the accurate figure for context-window pressure monitoring.
+     */
+    private estimateFullRequest;
     private summarizeAncientTurns;
     private findSafeBoundary;
     private findExchangeStart;
@@ -154,6 +159,11 @@ declare class SelectiveCompactor implements Compactor {
     compact(ctx: Context, opts?: {
         aggressive?: boolean;
     }): Promise<CompactReport>;
+    /**
+     * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+     * This is the accurate figure for context-window pressure monitoring.
+     */
+    private estimateFullRequest;
     private repairProtocolAdjacency;
     /**
      * Run the LLM selector to decide what to keep vs collapse.
@@ -185,16 +195,23 @@ interface AutoCompactionOptions {
     events?: EventBus;
     failureMode?: CompactionFailureMode;
     policyProvider?: (ctx: Context) => Pick<ContextWindowPolicy, 'thresholds' | 'aggressiveOn'> | null | undefined;
+    /** Optional bridge for writing compaction events into the persistent session log. */
+    sessionBridge?: SessionEventBridge;
 }
 /**
  * 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.
  */
 declare class AutoCompactionMiddleware {
     readonly name = "AutoCompaction";
     private readonly compactor;
-    private readonly estimator;
+    /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+    private readonly _estimator?;
     private readonly warnThreshold;
     private readonly softThreshold;
     private readonly hardThreshold;
@@ -204,19 +221,7 @@ declare class AutoCompactionMiddleware {
     private readonly events?;
     private readonly failureMode;
     private readonly policyProvider?;
-    /**
-     * Calibration factor applied to the estimator output. The estimator is now
-     * expected to already include messages + system prompt + tool definitions
-     * (see `estimateRequestTokens.total`), so no overhead boost is needed. Kept
-     * as a constant so a future calibration against real provider tokenization
-     * (BPE vs the chars/3.5 rough estimator) can dial this without touching the
-     * threshold-check math.
-     *
-     * Historical note: was 1.3 when the estimator only counted messages — that
-     * double-counted system+tools once the estimator was upgraded, firing
-     * compaction ~30% earlier than intended (e.g. real 56% load showed as 73%).
-     */
-    private static readonly OVERHEAD_FACTOR;
+    private readonly sessionBridge?;
     /**
      * Once a compaction attempt reduces nothing (preserveK protects everything,
      * no oversized tool_results remain to elide), retrying on every iteration
@@ -229,8 +234,11 @@ declare class AutoCompactionMiddleware {
     private lastNoopAttempt;
     /**
      * @param compactor        Compactor to use for compaction.
-     * @param maxContext       Provider's max context window in tokens.
-     * @param estimator        Token estimation function.
+     * @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
@@ -238,7 +246,7 @@ declare class AutoCompactionMiddleware {
      *                         provider context overflow. Warn/soft failures
      *                         still emit compaction.failed and continue.
      */
-    constructor(compactor: Compactor, maxContext: number, estimator: (ctx: Context) => number, thresholds: {
+    constructor(compactor: Compactor, maxContext: number, _estimator: (ctx: Context) => number, thresholds: {
         warn: number;
         soft: number;
         hard: number;
@@ -563,6 +571,12 @@ interface ParallelEternalOptions {
     agent: Agent;
     /** Project root (used for goal.json path). */
     projectRoot: string;
+    /**
+     * Override the resolved goal.json path. Defaults to
+     * `goalFilePath(projectRoot)` (a hashed location under the home dir).
+     * Primarily for tests that want an isolated goal file under a temp dir.
+     */
+    goalPath?: string;
     /**
      * Number of parallel subagent slots per tick.
      * Default: 4. Range 1–16; values >8 are for high-throughput machines.