@wrongstack/cli 0.313.1 → 0.316.2

package/dist/execution-chimera-cascade.d.ts

@@ -5,7 +5,7 @@ import type { ExecuteDeps } from './execute-deps.js';
 type Director = NonNullable<ExecuteDeps['fleet']['director']>;
 type Events = ExecuteDeps['core']['events'];
 type Session = ExecuteDeps['session']['session'];
-export type InstallChimeraCascadeHandlerOptions = {
+type InstallChimeraCascadeHandlerOptions = {
     events: Events;
     director: Director | null | undefined;
     session: Session;

package/dist/execution-chimera-review.d.ts

@@ -19,7 +19,7 @@ type Config = ExecuteDeps['core']['config'];
  * direct test.
  */
 export declare function normalizeFileKeyForCitation(raw: string, cwd: string): string;
-export type InstallChimeraReviewHandlerOptions = {
+type InstallChimeraReviewHandlerOptions = {
     events: Events;
     director: Director | null | undefined;
     session: Session;

package/dist/execution-cleanup.d.ts

@@ -2,7 +2,7 @@ import type { Director } from '@wrongstack/core/coordination';
 import type { ChimeraWorkRegistry } from './chimera-work-registry.js';
 import type { ExecuteDeps } from './execute-deps.js';
 import type { FleetStatusLine } from './fleet-statusline.js';
-export interface ExecutionCleanupInput {
+interface ExecutionCleanupInput {
     offStorageObservability: () => void;
     fleetStatusLine: FleetStatusLine | null;
     onCoordinatorStop?: (() => void) | undefined;
@@ -21,4 +21,5 @@ export interface ExecutionCleanupInput {
     reader: ExecuteDeps['ui']['reader'];
 }
 export declare function finalizeExecutionCleanup(input: ExecutionCleanupInput): Promise<void>;
+export {};
 //# sourceMappingURL=execution-cleanup.d.ts.map

package/dist/execution-kanban-dispatch.d.ts

@@ -1,10 +1,11 @@
 import type { WebUIDispatchContext } from './boot/dispatch-webui.js';
 import type { ExecuteDeps } from './execute-deps.js';
-export type CreateKanbanDispatchHandlerOptions = {
+type CreateKanbanDispatchHandlerOptions = {
     config: ExecuteDeps['core']['config'];
     events: ExecuteDeps['core']['events'];
     skillLoader: ExecuteDeps['ui']['skillLoader'];
     sddSubagentFactory: ExecuteDeps['provider']['sddSubagentFactory'];
 };
 export declare function createKanbanDispatchHandler({ config, events, skillLoader, sddSubagentFactory, }: CreateKanbanDispatchHandlerOptions): Pick<WebUIDispatchContext, 'onKanbanDispatch'>;
+export {};
 //# sourceMappingURL=execution-kanban-dispatch.d.ts.map

package/dist/execution-repl-fleet-callbacks.d.ts

@@ -1,11 +1,12 @@
 import type { Director } from '@wrongstack/core/coordination';
-export interface ReplFleetCallbacksOptions {
+interface ReplFleetCallbacksOptions {
     director: Director | null | undefined;
     getDirector: (() => Director | null | undefined) | undefined;
 }
-export interface ReplFleetCallbacks {
+interface ReplFleetCallbacks {
     onInterruptFleet: () => number;
     onAgentIterationComplete: (tokens: number) => void;
 }
 export declare function createReplFleetCallbacks({ director, getDirector, }: ReplFleetCallbacksOptions): ReplFleetCallbacks;
+export {};
 //# sourceMappingURL=execution-repl-fleet-callbacks.d.ts.map

package/dist/fleet/budget-source.d.ts

@@ -1,6 +1,6 @@
 import type { Config } from '@wrongstack/core/types';
 export type FleetBudgetSource = 'cli-flag' | 'env' | 'profile' | 'default';
-export interface ResolvedFleetBudget {
+interface ResolvedFleetBudget {
     maxConcurrent: number;
     maxConcurrentSource: FleetBudgetSource;
     maxSpawns: number;
@@ -15,4 +15,5 @@ export declare function resolveFleetBudgetSources(input: {
     /** Built-in maxSpawns when nothing else wins. */
     defaultMaxSpawns?: number | undefined;
 }): ResolvedFleetBudget;
+export {};
 //# sourceMappingURL=budget-source.d.ts.map

package/dist/fleet/host-context.d.ts

@@ -12,5 +12,12 @@ export interface SkillResolutionReport {
 export declare function resolveHostSubagentSkillResolution(deps: MultiAgentDeps, roster: Record<string, SubagentConfig>, subCfg: SubagentConfig, availableToolNames?: readonly string[]): Promise<SkillResolutionReport>;
 /** Backwards-compatible wrapper for callers that only need the prompt text. */
 export declare function resolveHostSubagentSkillContent(deps: MultiAgentDeps, roster: Record<string, SubagentConfig>, subCfg: SubagentConfig, availableToolNames?: readonly string[]): Promise<string>;
-export declare function retrieveHostSubagentMemory(deps: MultiAgentDeps, getLeaderMode: (() => string | undefined) | undefined, subCfg: SubagentConfig, taskContext?: Record<string, unknown>): Promise<string[]>;
+export declare function retrieveHostSubagentMemory(deps: MultiAgentDeps, getLeaderMode: (() => string | undefined) | undefined, subCfg: SubagentConfig, taskContext?: Record<string, unknown>, 
+/**
+ * Conversation this worker belongs to, for injection attribution. The host's
+ * own session is the boot tab once several tabs share the process, so
+ * without it every background tab's memory reads were recorded against a
+ * conversation that never made them.
+ */
+owningSessionId?: string): Promise<string[]>;
 //# sourceMappingURL=host-context.d.ts.map

package/dist/fleet/host-director-event-bridges.d.ts

@@ -13,24 +13,49 @@ export declare function installDirectorTaskCompletedHandler(input: {
 export declare function registerDirectorBudgetAndContextBridges(input: {
     director: Director;
     events: EventBus;
-    sessionId: string;
+    /**
+     * The session that OWNS the subagent an event is about — not the host's own.
+     * With four tabs on one host these differ: the host session names the tab it
+     * booted with, so a worker delegated from a background tab announced its
+     * budget and context pressure into the boot tab's panels and vanished from
+     * the tab that was actually waiting on it.
+     */
+    sessionFor: (subagentId: string) => string;
 }): Array<() => void>;
+/**
+ * `coordinator.stats` — fleet-wide on purpose.
+ *
+ * Unlike the lifecycle bridges beside it, this one is NOT split per
+ * conversation, and the stamp is the host's own session rather than any
+ * worker's owner. Everything it reports is a property of the fleet as a
+ * whole: the spawn and concurrency budget is one ceiling shared by every tab,
+ * and the status list is the coordinator's own roll-up. Splitting it would
+ * mean reporting a shared budget four times as if each tab had its own.
+ *
+ * The client stores it in `useCoordinatorMonitorStore`, which has no live UI
+ * consumer. If one is ever added it must filter `subagentStatuses` by owner
+ * (`coordinator.sessionOf`) rather than assume the frame describes the tab it
+ * arrived in.
+ */
 export declare function registerDirectorStatsBridge(input: {
     director: Director;
     events: EventBus;
+    /** Host session — the fleet's own address, not any worker's owner. */
     sessionId: string;
 }): () => void;
 export declare function registerDirectorSubagentLifecycleBridges(input: {
     director: Director;
     events: EventBus;
-    sessionId: string;
+    /** Owning session of the subagent — see `registerDirectorBudgetAndContextBridges`. */
+    sessionFor: (subagentId: string) => string;
     agentMonitor?: AgentMonitorService | undefined;
     onSubagentRemoved(subagentId: string): void;
 }): Array<() => void>;
 export declare function registerCoordinatorLifecycleHandlers(input: {
     coordinator: DefaultMultiAgentCoordinator;
     events: EventBus;
-    sessionId: string;
+    /** Owning session of the subagent — see `registerDirectorBudgetAndContextBridges`. */
+    sessionFor: (subagentId: string) => string;
     isShadowTask(taskId: string): boolean;
     onSubagentStopped(subagentId: string): void;
 }): () => void;

package/dist/fleet/host-event-bridge.d.ts

@@ -1,5 +1,5 @@
 import type { EventBus } from '@wrongstack/core/kernel';
-import type { SubagentConfig } from '@wrongstack/core/types';
+import type { SubagentConfig, TokenCounter } from '@wrongstack/core/types';
 /**
  * Bound tool inputs before they cross from a subagent EventBus into the host.
  * File bodies and patches can be multi-megabyte; the host only needs their
@@ -13,5 +13,10 @@ export declare function installSubagentEventBridge(opts: {
     projectRoot: string;
     effectiveCfg: SubagentConfig;
     subCfg: SubagentConfig;
+    /** The subagent's own counter, for the cumulative snapshot on each emit. */
+    tokenCounter?: Pick<TokenCounter, 'total'> | undefined;
+    /** Routed provider/model, used when an event omits its own. */
+    subagentProvider?: string | undefined;
+    subagentModel?: string | undefined;
 }): () => void;
 //# sourceMappingURL=host-event-bridge.d.ts.map

package/dist/fleet/host-explore-companion-registry.d.ts

@@ -0,0 +1,60 @@
+/**
+ * One ExploreCompanion per live conversation.
+ *
+ * `MultiAgentHost` is built once, for the session the process booted with, and
+ * the companion was built with it. That is exactly right for the CLI and the
+ * TUI, which have one conversation. The WebUI runs up to four on the same host:
+ * the companion filters every signal against its own `leaderSessionId`
+ * (fail-closed, so nothing ever leaked into the wrong tab) and therefore simply
+ * did nothing for tabs 2-4 — no probes, no findings, silently.
+ *
+ * A companion is cheap (two or three event listeners, plus one poll timer when
+ * the mailbox-ask signal is on) and its resident worker is spawned lazily on
+ * the first probe, so a tab that never triggers one pays nothing. What is not
+ * free is keeping companions for conversations that are gone: a closed tab
+ * would leave its poll timer running. Hence the two bounds below.
+ *
+ * Bounds, both mirroring conventions already in the codebase:
+ *   - `max` live companions (4 — the WebUI's tab-slot count), least-recently
+ *     active evicted first, the way `auto-submit-streak` bounds its per-session
+ *     map;
+ *   - companions with no run for `idleMs` are swept, the way BrainMonitor
+ *     prunes its idle `bySession` entries.
+ *
+ * Neither bound loses work: a swept session gets a fresh companion on its next
+ * run, and probe cooldowns are per-companion advisory state, not results.
+ *
+ * @module host-explore-companion-registry
+ */
+import type { ExploreCompanion } from '@wrongstack/core/coordination';
+interface ExploreCompanionRegistryInput {
+    /**
+     * Build a companion for one session. Returns null when the feature is off
+     * for this host, in which case the registry stays permanently empty and
+     * `ensure` is a no-op — no negative caching needed, the builder is cheap and
+     * its own `enabled === false` check is the authority.
+     */
+    create: (sessionId: string) => ExploreCompanion | null;
+    max?: number | undefined;
+    idleMs?: number | undefined;
+    now?: (() => number) | undefined;
+}
+export interface ExploreCompanionRegistry {
+    /**
+     * Make sure this session has a companion, and mark it active.
+     *
+     * Safe to call on every run start: an existing entry is only touched.
+     */
+    ensure: (sessionId: string) => void;
+    /** Live companion for a session, for tests and status surfaces. */
+    peek: (sessionId: string) => ExploreCompanion | undefined;
+    /** Session ids holding a live companion, most recently active last. */
+    ids: () => string[];
+    /** Stop and forget one session's companion. */
+    release: (sessionId: string) => void;
+    /** Stop and forget everything — host teardown. */
+    disposeAll: () => void;
+}
+export declare function createExploreCompanionRegistry(input: ExploreCompanionRegistryInput): ExploreCompanionRegistry;
+export {};
+//# sourceMappingURL=host-explore-companion-registry.d.ts.map

package/dist/fleet/host-explore-companion.d.ts

@@ -13,7 +13,10 @@
  * gone (removed/reaped/never spawned), the next probe spawns a fresh one.
  * Probes are `assignInternal`ed, never awaited — the leader is never
  * blocked, and internal tasks stay out of the leader-visible task surface
- * (same treatment as shadow passes).
+ * (same treatment as shadow passes). When the resident `submit_result`s,
+ * this host posts a same-session `session.note` so the leader folds the
+ * findings at its next iteration. Mailbox stays the durable cross-session
+ * channel; it is not the in-session talk path.
  *
  * @module host-explore-companion
  */
@@ -21,7 +24,7 @@ import { type Director, ExploreCompanion } from '@wrongstack/core/coordination';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { SubagentConfig } from '@wrongstack/core/types';
 /** Config block for the explore-companion host wiring (FleetConfig.exploreCompanion). */
-export interface HostExploreCompanionConfig {
+interface HostExploreCompanionConfig {
     /** Kill switch. Default true. */
     enabled?: boolean | undefined;
     /** Min gap between probes on the same subject (ms). Default 120_000. */
@@ -31,7 +34,7 @@ export interface HostExploreCompanionConfig {
     /** Mailbox poll interval for explicit asks (ms). Default 5_000. */
     pollIntervalMs?: number | undefined;
 }
-export interface HostExploreCompanionInput {
+interface HostExploreCompanionInput {
     director: Director;
     events: EventBus;
     sessionId: string;
@@ -40,4 +43,5 @@ export interface HostExploreCompanionInput {
     config?: HostExploreCompanionConfig | undefined;
 }
 export declare function createHostExploreCompanion(input: HostExploreCompanionInput): ExploreCompanion | null;
+export {};
 //# sourceMappingURL=host-explore-companion.d.ts.map

package/dist/fleet/host-provider.d.ts

@@ -2,7 +2,7 @@ import type { Config, Provider, ReasoningConfig, SubagentConfig } from '@wrongst
 import type { MultiAgentDeps } from './host-types.js';
 export declare function buildHostSubagentProvider(deps: MultiAgentDeps, config: Config, overrideId?: string | undefined, model?: string | undefined): Promise<Provider>;
 export declare function resolveHostSubagentReasoningConfig(deps: MultiAgentDeps, providerId: string, modelId: string): Promise<ReasoningConfig | undefined>;
-export interface HostSubagentModelSelection {
+interface HostSubagentModelSelection {
     effProvider: string;
     effModel: string;
     fallbackProfile: string | undefined;
@@ -19,4 +19,5 @@ export declare function resolveHostSubagentModelSelection(liveConfig: Config, ef
     fallbackProfile?: string | undefined;
     modelRuntime?: SubagentConfig['modelRuntime'] | undefined;
 } | undefined): HostSubagentModelSelection;
+export {};
 //# sourceMappingURL=host-provider.d.ts.map

package/dist/fleet/host-session-writer.d.ts

@@ -3,6 +3,14 @@ import type { SessionWriter } from '@wrongstack/core/types';
  * Session writer for a subagent that has no journal of its own: its events are
  * interleaved into the parent's JSONL.
  *
+ * Pass `agentId` so those interleaved events carry attribution. Without it the
+ * subagent's `tool_call_start`, `llm_response` and error records are byte-for-
+ * byte indistinguishable from the leader's in the one file that holds both,
+ * and every consumer that reads the leader transcript — resume timeline,
+ * `/diag`, the HQ ledger, cost roll-ups — silently credits the leader for
+ * work it did not do. It is optional only so existing callers that have not
+ * resolved a name yet keep compiling; every real spawn site should pass one.
+ *
  * Lifecycle and rewind *control* stay no-ops — `writeCheckpoint`,
  * `writeInFlightMarker`, `truncateToCheckpoint`, `clearSession` and `close`
  * belong to the parent, and a subagent driving them would corrupt the parent's
@@ -15,7 +23,7 @@ import type { SessionWriter } from '@wrongstack/core/types';
  * parent writer files them against its own `activePromptIndex`, which is
  * exactly the prompt a user rewinding this work would target.
  */
-export declare function createParentSubagentSessionWriter(parentSession: SessionWriter): SessionWriter;
+export declare function createParentSubagentSessionWriter(parentSession: SessionWriter, agentId?: string): SessionWriter;
 /**
  * Wrap a subagent's own `SessionWriter` so its file mutations are ALSO recorded
  * against the parent session.

package/dist/fleet/host-shadow-manager.d.ts

@@ -1,12 +1,46 @@
 /**
  * Host-level Shadow Agent lifecycle and observation management.
  *
+ * ## One shadow review per conversation
+ *
+ * The shadow agent is a reactive reviewer: the host counts the work it sees
+ * start and finish, and when a run or a subagent task ends badly it spawns a
+ * one-shot reviewer once everything it was watching has settled.
+ *
+ * All of that state used to be flat fields on this class, which is exactly
+ * right for the CLI and the TUI — one process, one conversation. The WebUI
+ * puts up to four conversations on the same process, and flat fields made
+ * them one conversation as far as the shadow agent was concerned:
+ *
+ *   - the depth counter mixed all four tabs, so a review triggered by tab 3
+ *     was held back for as long as ANY other tab was still running, and the
+ *     "problem" text it was eventually given was a semicolon-joined mix of
+ *     failures from tabs that had nothing to do with each other;
+ *   - the spawn carried no owning session, so the coordinator filed the
+ *     reviewer under the host's own (boot) session: tab 3's failure grew a
+ *     shadow agent in **tab 1's** roster, reporting to tab 1's leader, while
+ *     the tab that actually failed saw nothing;
+ *   - `shadowAgentId` was a single slot, so the second conversation to need a
+ *     review either reused the first one's agent or quietly overwrote the
+ *     pointer to it, leaving the first agent unstoppable.
+ *
+ * State is now keyed by the owning conversation. Every event this class
+ * listens to already carries `sessionId` (the subagent bridges stamp the
+ * spawning tab since the owning-session wave); an unstamped event — thin
+ * embedders, and every single-session host — falls back to the host's own
+ * session, which is why the CLI and the TUI behave exactly as before.
+ *
+ * The map is bounded the way the other per-session maps in the codebase are:
+ * at most `MAX_TRACKED_SESSIONS` entries, evicting the oldest one that holds
+ * nothing worth keeping (no live agent, no work in flight, no queued
+ * problem). Losing such an entry loses nothing — the next run rebuilds it.
+ *
  * @module fleet/host-shadow-manager
  */
 import type { SubagentConfig } from '@wrongstack/core/types';
 import type { Director } from '@wrongstack/core/coordination';
 import type { MultiAgentDeps, MultiAgentHostOptions } from './host-types.js';
-export interface HostShadowManagerContext {
+interface HostShadowManagerContext {
     deps: MultiAgentDeps;
     opts: MultiAgentHostOptions;
     getDirector: () => Director | undefined;
@@ -28,37 +62,65 @@ export interface HostShadowManagerContext {
 }
 export declare class HostShadowManager {
     private readonly ctx;
-    private shadowAgentId;
-    private shadowTaskId;
-    private readonly shadowTaskIds;
-    private readonly shadowOutstandingTaskIds;
-    private readonly shadowStopAfterTaskIds;
-    private shadowHeartbeatIntervalMs;
-    private shadowAutoStartSuppressions;
-    private shadowObservedWorkDepth;
-    private shadowPassInFlight;
-    private shadowQueuedProblem;
+    private readonly sessions;
+    /** Shadow task id → owning conversation. Also the `isShadowTask` index. */
+    private readonly taskSessions;
+    /** Live shadow agent id → owning conversation. */
+    private readonly agentSessions;
     private readonly shadowActivityOffHandles;
     constructor(ctx: HostShadowManagerContext);
+    /**
+     * The conversation an unstamped caller means.
+     *
+     * Single-session hosts never name one, and for them this is the only
+     * session there is.
+     */
+    private hostSessionId;
+    private resolve;
+    /** Existing state for a conversation, without creating one. */
+    private peek;
+    private stateFor;
+    private evictIfFull;
     getTaskIds(): ReadonlySet<string>;
     isShadowTask(taskId: string): boolean;
-    getAgentId(): string | null;
-    getTaskId(): string | null;
-    enterShadowSpawn(): void;
-    exitShadowSpawn(): void;
+    /** Conversation that owns a shadow task, if it is one. */
+    sessionForTask(taskId: string): string | undefined;
+    /** True when this subagent is some conversation's live shadow agent. */
+    isShadowAgent(subagentId: string): boolean;
+    getAgentId(sessionId?: string | undefined): string | null;
+    getTaskId(sessionId?: string | undefined): string | null;
+    enterShadowSpawn(sessionId?: string | undefined): void;
+    exitShadowSpawn(sessionId?: string | undefined): void;
     onShadowTaskCompleted(taskId: string, subagentId: string): void;
     armIfNeeded(): void;
-    recordShadowAgent(subagentId: string, taskId: string, intervalMs?: number): void;
+    recordShadowAgent(subagentId: string, taskId: string, intervalMs?: number | undefined, sessionId?: string | undefined): void;
+    /**
+     * Forget a shadow agent.
+     *
+     * With an id, only the conversation that owns that agent is touched — the
+     * flat version cleared the single slot whoever asked, so one tab's reaped
+     * reviewer used to wipe another tab's live one.
+     */
     clearShadowAgent(subagentId?: string): void;
-    markShadowTask(taskId: string): void;
-    addStopAfterTaskId(taskId: string): void;
+    private clearSessionShadowAgent;
+    markShadowTask(taskId: string, sessionId?: string | undefined): void;
+    addStopAfterTaskId(taskId: string, sessionId?: string | undefined): void;
     removeShadowTask(taskId: string): void;
     isActiveSubagent(subagentId: string): boolean;
     private noteShadowWorkStarted;
     private noteShadowWorkCompleted;
-    requestShadowPass(reason: string): void;
-    runShadowPass(reason: string): Promise<void>;
+    requestShadowPass(reason: string, sessionId?: string | undefined): void;
+    runShadowPass(reason: string, sessionId?: string | undefined): Promise<void>;
     private stopShadowAfterTask;
+    /**
+     * Drop everything one conversation was tracking — its tab closed.
+     *
+     * The live agent is cleared through the normal path so `onShadowAgentStopped`
+     * still fires; stopping the subagent itself belongs to the caller that owns
+     * the fleet teardown.
+     */
+    releaseSession(sessionId: string): void;
     dispose(): void;
 }
+export {};
 //# sourceMappingURL=host-shadow-manager.d.ts.map

package/dist/fleet/host-shadow-pass.d.ts

@@ -1,5 +1,5 @@
 import type { Config, SubagentConfig } from '@wrongstack/core/types';
-export interface HostShadowPassContext {
+interface HostShadowPassContext {
     getDirector: () => {
         isWorkComplete(): boolean;
     } | undefined;
@@ -9,6 +9,13 @@ export interface HostShadowPassContext {
     setQueuedProblem: (value: string | null) => void;
     setPassInFlight: (value: boolean) => void;
     getHeartbeatIntervalMs: () => number;
+    /**
+     * Conversation this review belongs to. Stamped onto the spawn so the
+     * coordinator files the reviewer under the tab whose work went wrong —
+     * without it every tab's shadow agent landed in the boot tab's roster and
+     * reported to the boot tab's leader.
+     */
+    sessionId?: string | undefined;
     spawnAndAssign: (subagentConfig: SubagentConfig, task: string, opts: {
         internalTask: true;
         stopShadowAfterTask: true;
@@ -18,4 +25,5 @@ export interface HostShadowPassContext {
 }
 export declare function runHostShadowPass(ctx: HostShadowPassContext, reason: string): Promise<void>;
 export declare function stopHostShadowAfterTask(stopSubagent: (subagentId: string) => Promise<void>, clearShadowAgent: (subagentId: string) => void, getObservedWorkDepth: () => number, getQueuedProblem: () => string | null, setQueuedProblem: (value: string | null) => void, requestShadowPass: (reason: string) => void, subagentId: string): Promise<void>;
+export {};
 //# sourceMappingURL=host-shadow-pass.d.ts.map

package/dist/fleet/host-spawn-types.d.ts

@@ -6,6 +6,15 @@ export interface HostSpawnOptions {
     name?: string | undefined;
     allowedCapabilities?: readonly string[] | undefined;
     shadowIntervalMs?: number | undefined;
+    /**
+     * Conversation on whose behalf this spawn happens.
+     *
+     * The coordinator captures it once and the worker keeps it for life, so
+     * every event, mail and roster row it produces lands in the tab that asked.
+     * Omitted means the host's own session — correct for the CLI and the TUI,
+     * and the boot tab (not the caller) once several tabs share the process.
+     */
+    originSessionId?: string | undefined;
     /**
      * Free-form task context propagated into the spawned `TaskSpec.context`.
      * Used by `/kanban task dispatch` (and the WebUI relay) to carry

package/dist/fleet/host-status.d.ts

@@ -53,7 +53,7 @@ export interface FleetHostUsage {
         durationMs: number;
     };
 }
-export interface FleetHostStatusInputs {
+interface FleetHostStatusInputs {
     coordinatorStatus?: {
         subagents: readonly {
             id: string;
@@ -76,4 +76,5 @@ export declare function formatFleetBudgetLines(budget: FleetBudgetView, colorize
     amber: (s: string) => string;
 }): string[];
 export declare function aggregateFleetUsage(completed: readonly TaskResult[]): FleetHostUsage;
+export {};
 //# sourceMappingURL=host-status.d.ts.map

package/dist/fleet/host-subagent-factory.d.ts

@@ -2,7 +2,7 @@ import { type AgentFactory, type DirectorSessionFactory } from '@wrongstack/core
 import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { Config, SubagentConfig, Tool } from '@wrongstack/core/types';
 import type { MultiAgentDeps, MultiAgentHostOptions } from './host-types.js';
-export interface HostSubagentFactoryContext {
+interface HostSubagentFactoryContext {
     deps: MultiAgentDeps;
     opts: MultiAgentHostOptions;
     roster: Record<string, SubagentConfig>;
@@ -13,4 +13,5 @@ export interface HostSubagentFactoryContext {
     subagentToolRegistry: (allow?: string[]) => ToolRegistry;
 }
 export declare function createHostSubagentFactory(config: Config, host: HostSubagentFactoryContext): AgentFactory;
+export {};
 //# sourceMappingURL=host-subagent-factory.d.ts.map

package/dist/fleet/host-subagent-session-audit.d.ts

@@ -0,0 +1,56 @@
+/**
+ * host-subagent-session-audit — the tool-lifecycle and session-lifecycle
+ * records a subagent's own JSONL was missing.
+ *
+ * A subagent gets a real `DefaultSessionStore` writer, the same engine the
+ * leader uses, so its transcript carries `session_start`, `user_input`,
+ * `llm_request`/`llm_response`, `tool_result` and the message journal. Two
+ * things never reached it, both for the same structural reason: the leader's
+ * copies are written by `cli/src/session-event-wiring.ts`, which subscribes to
+ * the HOST EventBus, while every subagent runs on a private `new EventBus()`
+ * (see host-subagent-factory). Nothing was subscribed on that side.
+ *
+ * The consequences were measurable — over a 3,156-transcript corpus, not one
+ * subagent JSONL contained a `tool_call_start`, `tool_call_end`, or
+ * `session_end`:
+ *
+ *  - `SessionSummaryTracker` counts tool calls from `tool_call_start`, so every
+ *    subagent summary reported `toolCallCount: 0` and an empty `toolBreakdown`
+ *    no matter how much work it did.
+ *  - With no `session_end`, `summarizeSessionEventSequence` never sees the
+ *    terminal marker, so a cleanly finished subagent is indistinguishable from
+ *    one killed mid-flight, and `SessionRecovery` treats both as stale.
+ *
+ * Audit gating mirrors the leader: `tool_call_start`/`tool_call_end` are
+ * STANDARD-level events, so a `minimal` auditLevel drops them here too, exactly
+ * as `SessionEventBridge` would. `session_end` is a core reconstruct event and
+ * is always written.
+ */
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { SessionEventBridge } from '@wrongstack/core/storage';
+import type { SessionWriter, TokenCounter } from '@wrongstack/core/types';
+interface SubagentSessionAudit {
+    /**
+     * Append `session_end` carrying this subagent's own cumulative usage, then
+     * drop the tool subscriptions. Call before `session.close()` — close()
+     * finalizes the summary sidecar, and a `session_end` appended after it would
+     * miss that snapshot.
+     *
+     * Idempotent: a second call is a no-op, so a dispose path that runs twice
+     * cannot write two terminal markers (`metaFromEvents` takes the LAST
+     * `session_end`, but recovery treats any trailing marker as a clean exit).
+     */
+    finalize(): Promise<void>;
+}
+export declare function installSubagentSessionAudit(opts: {
+    /** The subagent's private EventBus. */
+    events: EventBus;
+    /** The subagent's own JSONL writer. */
+    session: SessionWriter;
+    /** The subagent's own counter — never the leader's. */
+    tokenCounter: TokenCounter;
+    /** Shared audit-level gate, so subagents honor the same config as the leader. */
+    bridge: Pick<SessionEventBridge, 'allows'>;
+}): SubagentSessionAudit;
+export {};
+//# sourceMappingURL=host-subagent-session-audit.d.ts.map

package/dist/fleet/host-supervisor.d.ts

@@ -2,15 +2,25 @@ import { type Director, FleetSupervisor } from '@wrongstack/core/coordination';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { Config, SubagentConfig } from '@wrongstack/core/types';
 import type { MultiAgentHostOptions } from './host-types.js';
-export interface HostFleetSupervisorInput {
+interface HostFleetSupervisorInput {
     director: Director | undefined;
     brain: MultiAgentHostOptions['brain'];
     supervisorConfig: NonNullable<Config['fleet']>['supervisor'] | undefined;
     events: EventBus;
     sessionId: string;
+    /**
+     * The conversation a worker belongs to, from the coordinator's spawn-time
+     * stamp. The supervisor watches ONE fleet — that part is genuinely
+     * process-wide — but everything it SAYS is addressed: a steer is delivered
+     * through the session-note hub, which routes strictly by session, so a note
+     * posted under the host's own session never reached a worker spawned by any
+     * other tab, and the leader told about it was the wrong one.
+     */
+    sessionFor?: ((subagentId: string) => string) | undefined;
     mailboxProjectDir: string;
     roster: Record<string, SubagentConfig>;
     getLeaderMailboxId?: (() => string | undefined) | undefined;
 }
 export declare function createHostFleetSupervisor(input: HostFleetSupervisorInput): FleetSupervisor | null;
+export {};
 //# sourceMappingURL=host-supervisor.d.ts.map

package/dist/fleet/host-task-result-report.d.ts

@@ -1,6 +1,6 @@
 import { type TaskResultNotification } from '@wrongstack/core/coordination';
 import type { EventBus } from '@wrongstack/core/kernel';
-export type ReportTaskResultToLeaderOptions = {
+type ReportTaskResultToLeaderOptions = {
     notification: TaskResultNotification;
     sessionId: string;
     mailboxProjectDir: string;
@@ -8,4 +8,5 @@ export type ReportTaskResultToLeaderOptions = {
     getLeaderMailboxId?: (() => string | undefined) | undefined;
 };
 export declare function reportTaskResultToLeader({ notification: n, sessionId, mailboxProjectDir, events, getLeaderMailboxId, }: ReportTaskResultToLeaderOptions): Promise<void>;
+export {};
 //# sourceMappingURL=host-task-result-report.d.ts.map