@wrongstack/core 0.313.1 → 0.316.2

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

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

package/dist/kernel/index.js

@@ -1,16 +1,16 @@
 import {
   Container
-} from "../chunk-O74MJHXU.js";
+} from "../chunk-KZMSZV32.js";
 import {
   EventBus,
   ScopedEventBus
-} from "../chunk-4LJJYBAU.js";
+} from "../chunk-FHZVFYSL.js";
 import {
   Pipeline,
   RunController,
   TOKENS
-} from "../chunk-Y2GE5TSI.js";
-import "../chunk-WOEZV3Q4.js";
+} from "../chunk-NS52ISWS.js";
+import "../chunk-25LSLC3G.js";
 import "../chunk-TBRL2RCC.js";
 export {
   Container,

package/dist/mailbox-attach.d.ts

@@ -16,8 +16,8 @@
  * @module mailbox-attach
  */
 import type { MailboxMessage } from './coordination/mailbox-types.js';
-import type { FleetConfig } from './types/config.js';
 import type { AgentInternals } from './core/agent-internals.js';
+import type { FleetConfig } from './types/config.js';
 export declare function attachMailboxChecker(a: AgentInternals, source?: 'cli' | 'webui'): () => Promise<MailboxMessage[]>;
 /**
  * Fleet-pulse provider: returns a fresh "[FLEET PULSE]" digest block when

package/dist/models/index.js

@@ -1,32 +1,32 @@
 import {
   LLMSelector
-} from "../chunk-2FQL4PDC.js";
+} from "../chunk-I7DALG7J.js";
 import {
   noOpLogger
 } from "../chunk-WBPVKEEE.js";
-import {
-  DEFAULT_MODES
-} from "../chunk-2FK4WTFF.js";
 import {
   mergeModelsPayload
 } from "../chunk-EODDVJBM.js";
 import {
   FORBIDDEN_PROTO_KEYS
-} from "../chunk-DEIQMBD2.js";
+} from "../chunk-B7F4WVP4.js";
 import "../chunk-5S437PRC.js";
 import "../chunk-4VWO3ZXL.js";
-import "../chunk-FSWCWSTS.js";
+import "../chunk-HMLIGAU7.js";
 import {
   atomicWrite
-} from "../chunk-7ZHZE5EO.js";
+} from "../chunk-OSGLYW5J.js";
+import {
+  DEFAULT_MODES
+} from "../chunk-2FK4WTFF.js";
+import "../chunk-PFZO3C6H.js";
 import "../chunk-O37BQ65S.js";
 import {
   FetchError
-} from "../chunk-WOEZV3Q4.js";
+} from "../chunk-25LSLC3G.js";
 import {
   toErrorMessage
 } from "../chunk-TBRL2RCC.js";
-import "../chunk-PFZO3C6H.js";
 
 // src/models/models-registry.ts
 import * as fs from "node:fs/promises";
@@ -749,6 +749,7 @@ function alibabaTokenPlanModelMeta(id) {
 
 // src/models/models-dev-schema.ts
 import { z } from "zod";
+if ("document" in globalThis) z.config({ jitless: true });
 var MODELS_DEV_MODALITY_VALUES = ["text", "image", "audio", "video", "pdf"];
 var REASONING_EFFORT_LITERALS = [
   "none",

package/dist/observability/event-bridge.d.ts

@@ -1,10 +1,30 @@
 import type { EventBus } from '../kernel/events.js';
 import type { MetricsSink } from '../types/observability.js';
+/** Per-tool usage record maintained by the event-bridge for the auto-thinning
+ *  pipeline's in-process fallback. The Chronicle rollup is the cross-session
+ *  source of truth; this Map only fills the gap when Chronicle is unavailable
+ *  (no node:sqlite at runtime) or hasn't refreshed yet. */
+export interface ToolUsageRecord {
+    invocations: number;
+    failures: number;
+    durationMsTotal: number;
+    lastInvokedAt: number;
+    firstInvokedAt: number;
+}
+export type ToolUsageSnapshot = ReadonlyMap<string, ToolUsageRecord>;
+/** The wireMetricsToEvents return value: the metrics sink plus the in-process
+ *  tool-usage Map (read-only snapshot, updated in place by the listener), plus
+ *  a `dispose()` that detaches every listener. */
+export interface WiredMetricsHandle {
+    sink: MetricsSink;
+    getToolUsage(): ToolUsageSnapshot;
+    dispose(): void;
+}
 /**
- * Subscribes a MetricsSink to the EventBus. Returns an unsubscribe function
- * that detaches all listeners. This is the single integration point between
- * the agent's event stream and the observability layer — no metric calls
- * leak into core call sites.
+ * Subscribes a MetricsSink to the EventBus. Returns a handle with the sink
+ * and a `getToolUsage()` accessor for the in-process per-tool usage Map.
+ * This is the single integration point between the agent's event stream
+ * and the observability layer — no metric calls leak into core call sites.
  */
-export declare function wireMetricsToEvents(events: EventBus, sink: MetricsSink): () => void;
+export declare function wireMetricsToEvents(events: EventBus, sink: MetricsSink): WiredMetricsHandle;
 //# sourceMappingURL=event-bridge.d.ts.map

package/dist/observability/index.d.ts

@@ -1,12 +1,13 @@
-export { InMemoryMetricsSink, type InMemoryMetricsSinkOptions, NoopMetricsSink, } from './metrics.js';
+export { type ToolUsageRecord, type ToolUsageSnapshot, type WiredMetricsHandle, wireMetricsToEvents, } from './event-bridge.js';
 export { DefaultHealthRegistry } from './health.js';
-export { NoopTracer } from './tracer.js';
+export { InMemoryMetricsSink, type InMemoryMetricsSinkOptions, NoopMetricsSink, } from './metrics.js';
+export { type NetworkTelemetryContext, runWithNetworkTelemetry, startNetworkTelemetryMonitor, } from './network-telemetry.js';
 export { OTelTracer } from './otel-tracer.js';
-export { wireMetricsToEvents } from './event-bridge.js';
-export { emitProcessCompleted, emitProcessOutput, emitProcessStarted, runWithProcessTelemetry, type ProcessTelemetryContext, } from './process-telemetry.js';
+export { buildOtlpMetricsRequest, type OtlpMetricsExporterHandle, type OtlpMetricsExporterOptions, startOtlpMetricsExporter, } from './otlp-metrics.js';
+export { buildOtlpTracesRequest, type OtlpTraceExporterHandle, type OtlpTraceExporterOptions, startOtlpTraceExporter, } from './otlp-traces.js';
+export { emitProcessCompleted, emitProcessOutput, emitProcessStarted, type ProcessTelemetryContext, runWithProcessTelemetry, } from './process-telemetry.js';
+export { type MetricsServerHandle, type MetricsServerOptions, type MetricsTlsOptions, PROMETHEUS_CONTENT_TYPE, renderPrometheus, startMetricsServer, } from './prometheus.js';
 export { redactCommand, redactCommandArgs } from './redact-command.js';
-export { runWithNetworkTelemetry, startNetworkTelemetryMonitor, type NetworkTelemetryContext } from './network-telemetry.js';
-export { renderPrometheus, startMetricsServer, PROMETHEUS_CONTENT_TYPE, type MetricsServerOptions, type MetricsServerHandle, type MetricsTlsOptions, } from './prometheus.js';
-export { buildOtlpMetricsRequest, startOtlpMetricsExporter, type OtlpMetricsExporterOptions, type OtlpMetricsExporterHandle, } from './otlp-metrics.js';
-export { buildOtlpTracesRequest, startOtlpTraceExporter, type OtlpTraceExporterOptions, type OtlpTraceExporterHandle, } from './otlp-traces.js';
+export { type CreateToolUsageSourceDeps, createToolUsageSource, filterUnderused, type ToolUsageSource, type UnderusedQueryOptions, type UnderusedToolCandidate, } from './tool-usage-source.js';
+export { NoopTracer } from './tracer.js';
 //# sourceMappingURL=index.d.ts.map