@wrongstack/core 0.313.0 → 0.316.1

package/dist/infrastructure/token-counter.d.ts

@@ -22,6 +22,13 @@ export declare class DefaultTokenCounter implements TokenCounter {
     private readonly providerId?;
     private readonly events?;
     private sessionId?;
+    /**
+     * Agent this counter belongs to, stamped onto every `token.accounted`.
+     * Undefined for the leader. Subagent counters are constructed with the HOST
+     * session id (so live cost UIs stay on one row), which makes this the only
+     * thing separating a subagent's tokens from the leader's downstream.
+     */
+    private readonly agentId?;
     private priceCache;
     /** Most recently accounted request's tokens. Used for per-request context pressure. */
     private lastInput;
@@ -32,6 +39,7 @@ export declare class DefaultTokenCounter implements TokenCounter {
         providerId?: string | (() => string | undefined) | undefined;
         events?: EventBus | undefined;
         sessionId?: string | (() => string | undefined) | undefined;
+        agentId?: string | (() => string | undefined) | undefined;
     });
     setSessionId(sessionId: string | (() => string | undefined) | undefined): void;
     account(usage: Usage, model?: string, providerId?: string | undefined): void;
@@ -56,6 +64,7 @@ export declare class DefaultTokenCounter implements TokenCounter {
     private emitAccounted;
     private currentSessionId;
     private currentProviderId;
+    private currentAgentId;
     reset(): void;
     private recordProviderCache;
     private applyPrice;

package/dist/kernel/events/agent-events.d.ts

@@ -1,4 +1,5 @@
 import type { Context } from '../../core/context.js';
+import type { Usage } from '../../types/provider.js';
 export interface AgentEventMap {
     /**
      * Fired around a single Agent.run() call. Status trackers use these to
@@ -344,9 +345,15 @@ export interface AgentEventMap {
         reason?: string | undefined;
     };
     /**
-     * Fired by the delegate tool when a subagent finishes. The agent's run
-     * loop listens for this to collect `delegateSummaries` for the RunResult,
-     * so the CLI/TUI can render flashy completion banners.
+     * Fired by the delegate tool when a subagent finishes — raised from
+     * `emitDelegateCompleted` in `coordination/delegate-tool.ts`, alongside the
+     * richer `delegate.completed`. That helper is the ONLY emitter; keep any new
+     * completion branch routed through it rather than emitting
+     * `delegate.completed` directly, or these subscribers go silent again:
+     *   - `core/agent-loop.ts` collects `delegateSummaries` for the RunResult
+     *     (the CLI renderer's completion banner reads that array),
+     *   - the bundled `agent-handoff` plugin posts its mailbox handoff note,
+     *   - `webui-server` collab mirror forwards it to connected observers.
      */
     'subagent.done': {
         sessionId?: string | undefined;
@@ -370,5 +377,72 @@ export interface AgentEventMap {
         tokens: number;
         maxContext: number;
     };
+    /**
+     * A subagent's token spend, re-emitted onto the host EventBus with agent
+     * attribution attached.
+     *
+     * Deliberately NOT a replay of `token.accounted` under its own name. Every
+     * subagent runs on a private EventBus, so its `token.accounted` never
+     * reaches the host — but the host's subscribers for that event (statusline,
+     * `hq/cost-bridge`, `provider-cache-ledger`) all read it as LEADER spend.
+     * Re-emitting verbatim would fix subagent attribution by corrupting the
+     * leader's. Chronicle's domain adapter consumes this name through the
+     * `subagent.` prefix, mapping `subagentId` to `scope.agentId` and
+     * `provider`/`model` to `runtime`.
+     */
+    'subagent.token_accounted': {
+        /** Parent/host session id — a subagent's spend rolls up to it. */
+        sessionId?: string | undefined;
+        subagentId: string;
+        agentName?: string | undefined;
+        /** Routed provider, falling back to the spawn-time selection. */
+        provider?: string | undefined;
+        /** Routed model, falling back to the spawn-time selection. */
+        model?: string | undefined;
+        /** This subagent's cumulative usage — never the leader's. */
+        usage: Usage;
+        /** Usage contributed by this one accounting call (not cumulative). */
+        deltaUsage?: Usage | undefined;
+        cost: {
+            input: number;
+            output: number;
+            total: number;
+        };
+    };
+    /**
+     * A subagent's provider attempt, re-emitted onto the host EventBus with
+     * agent attribution. Same rationale as {@link subagent.token_accounted}: the
+     * host's `provider.attempt.*` subscribers (fallback management, the shared
+     * `ProviderModelStatusTracker`, the leader's status surfaces) treat those
+     * events as leader activity, so subagent attempts get their own name. The
+     * three lifecycle phases collapse into one event keyed by `outcome` because
+     * every consumer of the subagent variant wants them on one timeline.
+     */
+    'subagent.provider_attempt': {
+        /** Parent/host session id. */
+        sessionId?: string | undefined;
+        subagentId: string;
+        agentName?: string | undefined;
+        outcome: 'started' | 'completed' | 'failed';
+        provider?: string | undefined;
+        model?: string | undefined;
+        /** 0-based retry index within one logical request. */
+        attempt?: number | undefined;
+        durationMs?: number | undefined;
+        stopReason?: string | undefined;
+        /** Full Usage, cache buckets included — the point of bridging this at all. */
+        usage?: Usage | undefined;
+        /** Failure description; present on `outcome: 'failed'`. */
+        description?: string | undefined;
+        /** HTTP status; present on `outcome: 'failed'`. */
+        status?: number | undefined;
+        /** Retry classification; present on `outcome: 'failed'`. */
+        failureKind?: string | undefined;
+        retryable?: boolean | undefined;
+        traceId?: string | undefined;
+        logicalRequestId?: string | undefined;
+        promptManifestId?: string | undefined;
+        attemptId?: string | undefined;
+    };
 }
 //# sourceMappingURL=agent-events.d.ts.map

package/dist/kernel/events/brain-events.d.ts

@@ -198,6 +198,18 @@ export interface BrainEventMap {
      */
     'token.accounted': {
         sessionId?: string | undefined;
+        /**
+         * Agent that burned these tokens. Absent means the leader.
+         *
+         * Every subagent runs on its own `DefaultTokenCounter` but reports the
+         * LEADER's session id (its counter is constructed with the host session so
+         * live cost UIs stay on one row). Without this field, a subagent's usage is
+         * indistinguishable from the leader's in every downstream consumer —
+         * Chronicle's domain adapter keys `scope.agentId` off it, and 2,402
+         * measured `token.accounted` rows landed with a null agent because nothing
+         * ever set it.
+         */
+        agentId?: string | undefined;
         usage: Usage;
         /** Usage contributed by this one accounting call (not cumulative). */
         deltaUsage?: Usage | undefined;

package/dist/kernel/events/provider-events.d.ts

@@ -1,7 +1,7 @@
 import type { ChroniclePromptManifest } from '../../chronicle/prompt-manifest.js';
 import type { ContentBlock } from '../../types/blocks.js';
 import type { AgentContext } from '../../types/context.js';
-import type { ProviderErrorBody, Usage } from '../../types/provider.js';
+import type { ProviderErrorBody, ProviderErrorKind, Usage } from '../../types/provider.js';
 export interface ProviderEventMap {
     /** Fired before every physical provider/model attempt, including attempt zero. */
     'provider.attempt.started': {
@@ -223,6 +223,12 @@ export interface ProviderEventMap {
         reason: string;
         timestamp: number;
         stateExpiresAt?: number | undefined;
+        /** Last-error context for durable audit logs; absent on clean transitions. */
+        lastErrorKind?: ProviderErrorKind | undefined;
+        lastErrorStatus?: number | null | undefined;
+        lastErrorMessage?: string | null | undefined;
+        lastSessionId?: string | null | undefined;
+        lastAgentId?: string | null | undefined;
     };
     /**
      * Fired by the UI when the user manually picks a model from the
@@ -258,5 +264,20 @@ export interface ProviderEventMap {
         sessionId?: string | undefined;
         timestamp: number;
     };
+    /**
+     * Fired when the active provider/model is switched (e.g. via /model, UI switcher, or API).
+     */
+    'provider.model_switched': {
+        sessionId?: string | undefined;
+        from?: {
+            providerId: string;
+            model: string;
+        } | undefined;
+        to: {
+            providerId: string;
+            model: string;
+        };
+        timestamp: number;
+    };
 }
 //# sourceMappingURL=provider-events.d.ts.map

package/dist/kernel/events/session-events.d.ts

@@ -33,6 +33,20 @@ export interface SessionEventMap {
         sessionId?: string | undefined;
         agents: readonly TrackedAgentSnapshot[];
     };
+    /**
+     * Same-session, in-process note from one agent to another (or the leader).
+     * Ephemeral: folded into the recipient's next iteration. Not mailbox —
+     * mailbox is the durable cross-session channel.
+     */
+    'session.note': {
+        sessionId: string;
+        from: string;
+        to: string;
+        kind: 'note' | 'result' | 'ask' | 'steer';
+        body: string;
+        subject?: string | undefined;
+        ts: number;
+    };
     'iteration.started': {
         sessionId?: string | undefined;
         ctx: AgentContext;

package/dist/kernel/events/tool-events.d.ts

@@ -270,5 +270,18 @@ export interface ToolEventMap {
         name: string;
         reason: string;
     };
+    /**
+     * Fired by `ToolRegistry.thinUnderused()` after auto-thinning disables
+     * one or more tools. The names are the tools that actually flipped
+     * (registered + not already disabled). `reason` is the human-readable
+     * caller label (e.g. `'boot-time auto-thin'`, `'manual apply'`); the
+     * audit-trail reason `'auto-thinned'` is also written to
+     * `disabledToolMeta` so the decision survives restarts.
+     */
+    'tool.thinned': {
+        names: string[];
+        reason: string;
+        at: number;
+    };
 }
 //# sourceMappingURL=tool-events.d.ts.map