@wrongstack/core 0.313.0 → 0.316.1

package/dist/coordination/agents/phase3-wave1-platform.d.ts

@@ -1,5 +1,3 @@
-import { type AgentDefinition, type RoleDispatcherSignal } from './types.js';
+import { type AgentDefinition } from './types.js';
 export declare const WAVE1_AGENTS: AgentDefinition[];
-export declare const WAVE1_ROLE_METAS: Record<string, RoleDispatcherSignal>;
-export declare const WAVE1_ROLES: Set<string>;
 //# sourceMappingURL=phase3-wave1-platform.d.ts.map

package/dist/coordination/agents/phase3-wave2-meta.d.ts

@@ -1,5 +1,3 @@
-import { type AgentDefinition, type RoleDispatcherSignal } from './types.js';
+import { type AgentDefinition } from './types.js';
 export declare const WAVE2_AGENTS: AgentDefinition[];
-export declare const WAVE2_ROLE_METAS: Record<string, RoleDispatcherSignal>;
-export declare const WAVE2_ROLES: Set<string>;
 //# sourceMappingURL=phase3-wave2-meta.d.ts.map

package/dist/coordination/agents/phase8-wave3-products.d.ts

@@ -1,5 +1,3 @@
-import { type AgentDefinition, type RoleDispatcherSignal } from './types.js';
+import { type AgentDefinition } from './types.js';
 export declare const WAVE3_AGENTS: AgentDefinition[];
-export declare const WAVE3_ROLE_METAS: Record<string, RoleDispatcherSignal>;
-export declare const WAVE3_ROLES: Set<string>;
 //# sourceMappingURL=phase8-wave3-products.d.ts.map

package/dist/coordination/agents/phase9-wave4-platform-meta.d.ts

@@ -1,5 +1,3 @@
-import { type AgentDefinition, type RoleDispatcherSignal } from './types.js';
+import { type AgentDefinition } from './types.js';
 export declare const WAVE4_AGENTS: AgentDefinition[];
-export declare const WAVE4_ROLE_METAS: Record<string, RoleDispatcherSignal>;
-export declare const WAVE4_ROLES: Set<string>;
 //# sourceMappingURL=phase9-wave4-platform-meta.d.ts.map

package/dist/coordination/agents/project-agent-identity.d.ts

@@ -20,26 +20,26 @@
 import { existsSync } from 'node:fs';
 import { CAPTURE_COOLDOWN_MS, CAPTURE_MAX_PER_SESSION } from './project-agent-capture-window.js';
 import type { RoleKnowledgeManifest } from './project-agent-identity-types.js';
-export { type AutoOptimizeDecision, type AutoOptimizeEvent, type AutoOptimizePolicy, type AutoOptimizePolicyOverrides, DEFAULT_AUTO_OPTIMIZE_POLICY, evaluateAutoOptimize, LearningOptimizationScheduler, type LearningOptimizationSchedulerOptions, resolveAutoOptimizePolicy, } from './project-agent-auto-optimize.js';
-export { CAPTURE_SESSION_WINDOW_MS, resetCaptureWindow, resetCaptureWindows, } from './project-agent-capture-window.js';
+export { DEFAULT_AUTO_OPTIMIZE_POLICY, evaluateAutoOptimize, LearningOptimizationScheduler, resolveAutoOptimizePolicy } from './project-agent-auto-optimize.js';
+export { CAPTURE_SESSION_WINDOW_MS, resetCaptureWindow, resetCaptureWindows } from './project-agent-capture-window.js';
 export { loadProjectAgentConfig } from './project-agent-config-io.js';
 export { validateProjectAgentConfig } from './project-agent-config-validation.js';
-export { buildConsolidationInstruction, type ConsolidationMetadata, clearProjectAgentConsolidated, consolidatedDocumentPath, isConsolidated, loadConsolidationMetadata, loadProjectAgentConsolidated, readRawLearnedEntries, type SaveConsolidationOptions, saveProjectAgentConsolidated, } from './project-agent-consolidation.js';
-export { DIRECTIVE_QUARANTINE_MAX_UTILITY, DIRECTIVE_QUARANTINE_MIN_APPLIED, type DirectiveOutcomeResult, directiveWasApplied, recordDirectiveOutcomes, } from './project-agent-directive-outcome.js';
+export { buildConsolidationInstruction, clearProjectAgentConsolidated, consolidatedDocumentPath, isConsolidated, loadConsolidationMetadata, loadProjectAgentConsolidated, readRawLearnedEntries, saveProjectAgentConsolidated } from './project-agent-consolidation.js';
+export { DIRECTIVE_QUARANTINE_MAX_UTILITY, DIRECTIVE_QUARANTINE_MIN_APPLIED, directiveWasApplied, recordDirectiveOutcomes } from './project-agent-directive-outcome.js';
 export type { CreateProjectAgentInput, LearnedCaptureResult, ProjectAgentConfig, ProjectAgentProfile, RoleKnowledgeManifest, } from './project-agent-identity-types.js';
 export { splitLearnedEntries, tokenOverlap } from './project-agent-learning-entries.js';
-export { classifyLearnedEntry, LEARNED_ENTRY_MAX_CHARS, LEARNED_HARD_LIMIT, LEARNED_SOFT_LIMIT, type LearnedEntryCategory, normalizeLearnedEntry, } from './project-agent-learning-normalize.js';
-export { loadProjectAgentLearningPolicy, type ProjectAgentLearningPolicy, recordProjectAgentOptimizePass, updateProjectAgentLearningPolicy, } from './project-agent-learning-policy.js';
-export { DIRECTIVE_PROVEN_MIN_APPLIED, DIRECTIVE_PROVEN_MIN_UTILITY, decomposeLearnedEntry, directiveTrials, directiveUtility, enforceLearnedBudget, isProvenDirective, mergeStructuredEntries, parseLearnedEntryStamp, parseStructuredLearnedEntriesFromContent, renderLearnedInstructions, type StructuredLearnedEntry, } from './project-agent-learning-structured.js';
-export { type LearningOptimizerLlm, type OptimizeLearningOptions, type OptimizeLearningResult, optimizeProjectAgentLearning, unwrapWholeDocumentFence, } from './project-agent-optimizer.js';
+export { classifyLearnedEntry, LEARNED_ENTRY_MAX_CHARS, LEARNED_HARD_LIMIT, LEARNED_SOFT_LIMIT, normalizeLearnedEntry } from './project-agent-learning-normalize.js';
+export { loadProjectAgentLearningPolicy, recordProjectAgentOptimizePass, updateProjectAgentLearningPolicy } from './project-agent-learning-policy.js';
+export { DIRECTIVE_PROVEN_MIN_APPLIED, DIRECTIVE_PROVEN_MIN_UTILITY, decomposeLearnedEntry, directiveTrials, directiveUtility, enforceLearnedBudget, isProvenDirective, mergeStructuredEntries, parseLearnedEntryStamp, parseStructuredLearnedEntriesFromContent, renderLearnedInstructions } from './project-agent-learning-structured.js';
+export { optimizeProjectAgentLearning, unwrapWholeDocumentFence } from './project-agent-optimizer.js';
 export { assertProjectAgentRole } from './project-agent-paths.js';
-export { type QuarantinedDirective, quarantinePath, readQuarantinedDirectives, retiredDirectivesToWarnAbout, scrubRetiredLines, } from './project-agent-quarantine.js';
-export { buildSkillDistillInstruction, clearProjectSkillAugmentation, DEFAULT_EAGER_SKILL_LIMIT, listProjectSkillAugmentations, loadProjectSkillAugmentation, loadSkillAffinity, rankRoleSkills, recordSkillLoad, recordSkillOutcome, renderSkillAugmentation, resolveRoleSkillCandidates, routeDirectiveToSkill, SKILL_AUGMENTATION_MAX_BYTES, SKILL_EVIDENCE_HALF_LIFE_DAYS, type SkillAffinity, type SkillAffinityEntry, saveProjectSkillAugmentation, scoreSkillAffinity, setSkillPinned, } from './project-agent-skill-layer.js';
+export { quarantinePath, readQuarantinedDirectives, retiredDirectivesToWarnAbout, scrubRetiredLines } from './project-agent-quarantine.js';
+export { buildSkillDistillInstruction, clearProjectSkillAugmentation, DEFAULT_EAGER_SKILL_LIMIT, listProjectSkillAugmentations, loadProjectSkillAugmentation, loadSkillAffinity, rankRoleSkills, recordSkillLoad, recordSkillOutcome, renderSkillAugmentation, resolveRoleSkillCandidates, routeDirectiveToSkill, SKILL_AUGMENTATION_MAX_BYTES, SKILL_EVIDENCE_HALF_LIFE_DAYS, saveProjectSkillAugmentation, scoreSkillAffinity, setSkillPinned } from './project-agent-skill-layer.js';
 export { CAPTURE_COOLDOWN_MS, CAPTURE_MAX_PER_SESSION };
 export { listProjectAgentRoles, refreshProjectAgentIdentity, resetProjectAgentIdentity, updateProjectAgentConfig, updateProjectAgentIdentity, updateProjectAgentKnowledge, updateProjectAgentLearned, } from './project-agent-files.js';
 export { createProjectAgent, loadProjectAgentProfile, slugifyProjectAgentRole, } from './project-agent-profile.js';
 export { applyProjectAgentConfig, createProjectAgentRoster, } from './project-agent-roster.js';
-export { canCaptureNewLearned, captureLearnedFromAgentOutput, captureLearnedFromAgentOutputDetailed, detectLearnedConflicts, getProjectAgentLearnStats, hintLearnedNeedsSummarization, listProjectAgentLearnedEntries, loadProjectAgentLearned, parseStructuredLearnedEntries, type ProjectAgentLearnStats, } from './project-agent-capture.js';
+export { canCaptureNewLearned, captureLearnedFromAgentOutput, captureLearnedFromAgentOutputDetailed, detectLearnedConflicts, getProjectAgentLearnStats, hintLearnedNeedsSummarization, listProjectAgentLearnedEntries, loadProjectAgentLearned, parseStructuredLearnedEntries } from './project-agent-capture.js';
 /**
  * Load the project-level identity appendix for a given role.
  * Appended to the subagent prompt after the base role prompt and policy.

package/dist/coordination/agents/types.d.ts

@@ -41,6 +41,12 @@ export interface AgentCapability {
      * Optional `RoleDispatcherSignal` attached to the role. Wave-1/2/3/4 roles
      * carry this to make the "why this role wins" rationale auditable; legacy
      * roles omit it and the dispatcher falls back to `summary` + `keywords`.
+     *
+     * Set it on the definition itself — `ROLE_DISPATCH_RATIONALE` in
+     * `agents/index.ts` is derived from the catalog, and the LLM classifier
+     * reads `differentiatesFrom` from here. For a long stretch the wave files
+     * declared these blocks but only spread `.signals` into `keywords`, so the
+     * rationale and contrast text were authored and then dropped on the floor.
      */
     rationale?: RoleDispatcherSignal | undefined;
 }
@@ -57,8 +63,13 @@ export interface RoleDispatcherSignal {
     signals: readonly string[];
     /**
      * One-line description of how this role differs from its closest sibling
-     * ("X finds defects; Y designs threats before code exists"). Used by tests
-     * to assert distinct boundaries and by docs to explain routing.
+     * ("X finds defects; Y designs threats before code exists").
+     *
+     * Handed to the LLM dispatch classifier as a `vs. siblings:` line beside the
+     * candidate's summary (see `makeLLMClassifier`), which is the moment it
+     * matters: the classifier only runs when the heuristic could not separate
+     * roles that share vocabulary. Also asserted by
+     * `tests/coordination/role-dispatch-rationale.test.ts`.
      */
     differentiatesFrom: string;
 }

package/dist/coordination/brain-monitor.d.ts

@@ -41,6 +41,16 @@ export type { BrainInterventionKind };
 export interface BrainInterventionInput {
     subject: string;
     body: string;
+    /**
+     * The session whose distress triggered this intervention.
+     *
+     * The steer has to reach THAT leader. A host that resolves the target from
+     * its own "current session" instead delivers the correction to whichever
+     * session is in front — with several sessions live under one host, the tab
+     * that is struggling gets nothing and an unrelated one is told to change
+     * approach. Undefined only when the signal itself carried no session.
+     */
+    sessionId?: string | undefined;
 }
 /**
  * How a detected distress signal is resolved.
@@ -132,14 +142,8 @@ export type BrainMonitorTunables = Partial<Pick<BrainMonitorOptions, 'enabled' |
 export declare const DEFAULT_FILE_EDIT_TOOLS: readonly string[];
 export declare class BrainMonitor {
     private readonly opts;
-    private readonly failStreaks;
-    private errorTimestamps;
-    private readonly editTimestamps;
-    private readonly lastEngagedAt;
+    private readonly bySession;
     private readonly unsubscribers;
-    private engaging;
-    private activeRuns;
-    private lastProgressAt;
     private stallTimer;
     private toolFailureStreak;
     private errorStormCount;
@@ -164,6 +168,25 @@ export declare class BrainMonitor {
     private hostStarted;
     /** Resolve the leader's own session id for event filtering. */
     private resolveLeaderSessionId;
+    /**
+     * The signal state for one session, created on first sight.
+     *
+     * A host that pins `leaderSessionId` (the CLI, one session per process) only
+     * ever reaches one bucket. A host that does not (the WebUI, four tabs on one
+     * runtime) gets one bucket per tab, which is the point.
+     */
+    private stateFor;
+    /**
+     * Drop buckets for sessions that have been quiet longer than any signal
+     * window. Without this a long-lived host accumulates one bucket per session
+     * it has ever seen — cheap individually, unbounded in aggregate.
+     *
+     * Cooldowns are the one thing worth losing sleep over here: pruning a bucket
+     * resets its rate limit. That is acceptable only because the prune horizon is
+     * strictly longer than the cooldown, so a pruned session could have engaged
+     * again anyway.
+     */
+    private pruneIdleSessions;
     constructor(opts: BrainMonitorOptions);
     /** Resolve the live-tunable subset onto the instance. Shared by the constructor and `reconfigure`. */
     private applyTunables;

package/dist/coordination/collab-debug.d.ts

@@ -40,7 +40,7 @@ export declare const DEFAULT_MAX_TARGET_FILES = 30;
  * These flow through the FleetBus so the host can display them in the UI.
  */
 export { DirectorAlertLevel } from './collab-debug-types.js';
-export type { BugFinding, CollabBudgetConfig, BugFoundPayload, CollabBudgetOverrides, CollabBudgetWarningPayload, CollabDebugReport, CollabSessionOptions, CriticConcern, CriticEvaluation, CriticEvaluationPayload, DirectorAlert, DirectorCancelCollabPayload, RefactorPlan, RefactorPlanPayload, RefactorPhase, SharedFileEntry, SharedFileSnapshot, } from './collab-debug-types.js';
+export type { BugFinding, CollabBudgetConfig, CollabBudgetOverrides, CollabBudgetWarningPayload, CollabDebugReport, CollabSessionOptions, CriticConcern, CriticEvaluation, DirectorAlert, DirectorCancelCollabPayload, RefactorPlan, RefactorPhase, SharedFileEntry, SharedFileSnapshot } from './collab-debug-types.js';
 import type { CollabDebugReport, CollabSessionOptions, DirectorAlert, SharedFileSnapshot } from './collab-debug-types.js';
 export declare class CollabSession extends EventEmitter {
     readonly sessionId: string;

package/dist/coordination/collab-pause.d.ts

@@ -1,5 +1,5 @@
 import type { CollaborationBus, InjectedToolResult } from './collab-bus.js';
-import type { ToolCallPipelinePayload } from '../core/agent.js';
+import type { ToolCallPipelinePayload } from '../core/agent-types.js';
 import type { Middleware } from '../kernel/pipeline.js';
 /**
  * collabPauseMiddleware — gates the agent's `toolCall` pipeline on

package/dist/coordination/delegate-tool.d.ts

@@ -62,11 +62,13 @@ export interface CreateDelegateToolOptions {
     subagentTimeoutBufferMs?: number | undefined;
     /**
      * Host EventBus. When supplied, `delegate` emits `delegate.started`
-     * (before it blocks on the subagent) and `delegate.completed` (once the
-     * subagent settles) so UIs / the Telegram bridge can render readable
-     * start/finish lines instead of inferring them from the truncated
-     * `tool.executed` JSON preview. Optional — emits are best-effort and a
-     * missing bus never affects delegation behaviour.
+     * (before it blocks on the subagent) and, once the subagent settles, both
+     * `delegate.completed` and `subagent.done` — see `emitDelegateCompleted`
+     * below for why the outcome goes out on two names. UIs / the Telegram
+     * bridge render readable start/finish lines from these instead of
+     * inferring them from the truncated `tool.executed` JSON preview.
+     * Optional — emits are best-effort and a missing bus never affects
+     * delegation behaviour.
      */
     events?: EventBus | undefined;
 }

package/dist/coordination/director-kanban-queue-helpers.d.ts

@@ -14,6 +14,7 @@ export interface KanbanQueueInput {
     role?: string | undefined;
     provider?: string | undefined;
     model?: string | undefined;
+    tier?: string | undefined;
     fallbackModels?: string[] | undefined;
     tools?: string[] | undefined;
     allowedCapabilities?: string[] | undefined;

package/dist/coordination/director-options.d.ts

@@ -1,3 +1,4 @@
+import type { Config } from '../types/config.js';
 import type { Logger } from '../types/logger.js';
 import type { MultiAgentConfig, SubagentConfig, SubagentRunner, TaskResult, TaskSpec } from '../types/multi-agent.js';
 import type { SessionWriter } from '../types/session.js';
@@ -93,6 +94,12 @@ export interface DirectorOptions {
     maxLeaderContextLoad?: number | undefined;
     /** Provider's max context window in tokens. */
     maxContext?: number | (() => number | undefined) | undefined;
+    /**
+     * Live app config source for the deterministic model-tier layer. A getter is
+     * preferred so tier edits (WebUI / TUI / `/tier`) take effect on the next
+     * spawn without a restart, exactly like `modelMatrix`.
+     */
+    appConfig?: Config | (() => Config | undefined) | undefined;
     /** Per-task model matrix. */
     modelMatrix?: ModelMatrixSource | undefined;
     /** Optional git-worktree manager for Director fleet isolation. */

package/dist/coordination/director-spawn-model.d.ts

@@ -1,9 +1,26 @@
+import type { Config } from '../types/config.js';
 import type { Logger } from '../types/logger.js';
 import type { SubagentConfig } from '../types/multi-agent.js';
 import type { ModelMatrixSource } from './model-matrix.js';
+import type { ResolvedTierTarget } from './model-tier.js';
 import type { ProviderModelStatusTracker } from './provider-status-tracker.js';
 export interface ResolveDirectorSpawnModelOptions {
     modelMatrix?: ModelMatrixSource | undefined;
+    /**
+     * Live config, used to resolve the deterministic model-tier layer. Optional:
+     * when omitted (or when `modelTiers.enabled` is not true) the tier step is
+     * skipped entirely and resolution behaves exactly as it did before tiers
+     * existed.
+     */
+    config?: Config | undefined;
+    /**
+     * Tier named explicitly by the caller — the `tier` argument on `delegate` /
+     * `spawn_subagent`, or a Kanban task's persisted route. Outranks the routing
+     * table but still loses to an explicit provider/model.
+     */
+    tier?: string | undefined;
+    /** Observability hook: fired when a tier actually contributed a decision. */
+    onTierResolved?: ((resolved: ResolvedTierTarget) => void) | undefined;
     sessionProvider?: string | undefined;
     sessionModel?: string | undefined;
     statusTracker?: ProviderModelStatusTracker | undefined;

package/dist/coordination/director-tools.d.ts

@@ -3,9 +3,9 @@ import type { Tool } from '../types/tool.js';
 import type * as Host from './director-host-contracts.js';
 export { makeAskResultTool, makeAskTool, makeAssignTool, makeAwaitTasksTool, makeFleetTool, makeRollUpTool, makeTerminateAllTool, makeTerminateTool, } from './director-basic-tools.js';
 export { makeCollabDebugTool, makeFleetEmitTool, makeWorkCompleteTool, } from './director-collab-tools.js';
-export { makeQualityGateTool } from './director-quality-gate-tool.js';
 export { makeMutationTestTool } from './director-mutation-test-tool.js';
-export { applyMutation, type MutationKind, type MutationPlanItem, parseMutationReport, planMutations, } from './mutation-engine.js';
+export { makeQualityGateTool } from './director-quality-gate-tool.js';
+export { applyMutation, parseMutationReport, planMutations } from './mutation-engine.js';
 export declare function makeSpawnTool(director: Host.DirectorAdmissionPort, roster?: Record<string, SubagentConfig>): Tool;
 export declare function makeKanbanQueueTool(director: Host.DirectorLeaseRecoveryPort, roster?: Record<string, SubagentConfig>): Tool;
 //# sourceMappingURL=director-tools.d.ts.map

package/dist/coordination/director.d.ts

@@ -86,6 +86,7 @@ export declare class Director implements DirectorFleetHost, ICoordinator {
     leaderContextPressure: number;
     readonly maxLeaderContextLoad: number;
     private readonly maxContext;
+    private readonly appConfig?;
     readonly modelMatrix?: ModelMatrixSource | undefined;
     workCompleteFlag: boolean;
     private readonly btwNotes;
@@ -142,6 +143,17 @@ export declare class Director implements DirectorFleetHost, ICoordinator {
     retargetPendingTask(taskId: string, subagentId: string | undefined): boolean;
     terminate(subagentId: string): Promise<void>;
     terminateAll(): Promise<void>;
+    /**
+     * Terminate every subagent spawned by ONE session.
+     *
+     * What a tab's Stop button needs. `terminateAll()` is the wrong tool once
+     * several sessions share a director: it would kill three other tabs' fleets
+     * along with this one's. Aborting the leader's run only unwinds workers the
+     * leader is BLOCKED on (the delegate tool terminates those itself); anything
+     * started with `spawn_subagent` + `assign_task` keeps running because nobody
+     * asked it to stop. This is that ask, scoped to the session that owns them.
+     */
+    terminateSession(sessionId: string): Promise<void>;
     remove(subagentId: string): Promise<void>;
     private clearSubagentIdleRetirement;
     private armSubagentIdleRetirement;

package/dist/coordination/dispatcher.d.ts

@@ -43,11 +43,19 @@ export interface DispatchResult {
  * Provider-agnostic classifier seam. Given the task and the candidate agents
  * (role + summary), return the chosen role (and optional reason), or null to
  * decline. Wire via `makeLLMClassifier`.
+ *
+ * `differentiatesFrom` is present for roles that declare a
+ * `capability.rationale`. The classifier only ever runs on an ambiguous task —
+ * that is exactly when two siblings share vocabulary and a summary alone
+ * cannot separate them — so the contrast line is the most useful thing to hand
+ * it. Optional: legacy roles omit the rationale and the classifier falls back
+ * to `summary` for those.
  */
 export type DispatchClassifier = (task: string, candidates: {
     role: string;
     name: string;
     summary: string;
+    differentiatesFrom?: string | undefined;
 }[]) => Promise<{
     role: string;
     reason?: string | undefined;

package/dist/coordination/fleet-bus.d.ts

@@ -58,6 +58,17 @@ export declare class FleetBus {
  * lean on summaries for the next task").
  */
 export interface FleetUsage {
+    /**
+     * Cumulative spend for the WHOLE run, retired subagents included.
+     *
+     * This used to be decremented when a subagent was retired, which made the
+     * figure mean "currently-live subagents" while every reader — the director's
+     * budget reasoning, `fleet.json`, `director-state.json` — treated it as the
+     * run total. A long orchestration that retires workers as it goes therefore
+     * under-reported its own spend, and the number could only ever fall.
+     * Retirement now moves a subagent's contribution into {@link retired}
+     * instead of erasing it.
+     */
     total: {
         input: number;
         output: number;
@@ -65,7 +76,22 @@ export interface FleetUsage {
         cacheWrite: number;
         cost: number;
     };
+    /** Live subagents only — retirement drops the entry to bound memory. */
     perSubagent: Record<string, SubagentUsageSnapshot>;
+    /**
+     * The share of {@link total} contributed by subagents no longer in
+     * `perSubagent`. `total` minus `retired` is the live-only figure the old
+     * decrementing behavior produced, so any consumer that genuinely wants
+     * "currently live" can still compute it.
+     */
+    retired: {
+        subagents: number;
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        cost: number;
+    };
 }
 export interface SubagentUsageSnapshot {
     subagentId: string;
@@ -93,6 +119,7 @@ export declare class FleetUsageAggregator {
     private readonly metaLookup?;
     private readonly perSubagent;
     private readonly total;
+    private readonly retired;
     private readonly unsub;
     constructor(bus: FleetBus, priceLookup?: ((subagentId: string, provider?: string | undefined, model?: string | undefined) => {
         input?: number | undefined;
@@ -104,10 +131,14 @@ export declare class FleetUsageAggregator {
         model?: string | undefined;
     } | undefined) | undefined);
     /**
-     * Remove a terminated subagent's data from the aggregator and subtract its
-     * contribution from the running totals. Call this when a subagent is removed
-     * from the fleet so the aggregator doesn't accumulate unbounded data for
-     * entities that will never emit events again.
+     * Drop a terminated subagent's per-agent entry, folding its spend into
+     * {@link FleetUsage.retired} so the run total stays whole.
+     *
+     * The per-agent map is what needed bounding — one entry per spawn, for
+     * entities that will never emit again. Deducting from `total` as well (the
+     * original behavior) also un-spent real tokens: a run that retires each
+     * worker on completion reported a total that shrank as it made progress, and
+     * the director budgets against that number.
      */
     removeSubagent(subagentId: string): void;
     /** Disposes all fleet-bus subscriptions. Call when the aggregator is no longer needed. */

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

@@ -60,8 +60,16 @@ export interface FleetSupervisorActions {
     }>;
     /** High-priority steer mail to one agent. */
     steerAgent(subagentId: string, subject: string, body: string): Promise<void>;
-    /** Status/steer mail to the session leader. */
-    notifyLeader(subject: string, body: string): Promise<void>;
+    /**
+     * Status note to the session leader.
+     *
+     * `subagentId` names the worker the note is ABOUT, when there is one. The
+     * host resolves the conversation from it: with several tabs sharing this
+     * fleet, "the session leader" is not one address, and a note about tab 3's
+     * worker sent to the boot tab's leader reaches nobody who can act on it.
+     * Omitted for fleet-wide observations, which fall back to the host session.
+     */
+    notifyLeader(subject: string, body: string, subagentId?: string): Promise<void>;
     /** Abort a subagent (only used when config.allowTerminate). */
     terminate(subagentId: string): Promise<void>;
 }

package/dist/coordination/fleet.d.ts

@@ -1,8 +1,3 @@
-/**
- * Pre-built subagent role configurations for the WrongStack fleet.
- * These can be passed to `MultiAgentHost.spawn()` or used as templates
- * for the director's roster.
- */
 import type { SubagentConfig } from '../types/multi-agent.js';
 /**
  * Audit Log Agent — analyzes session logs, event streams, and traces.
@@ -24,12 +19,26 @@ export declare const REFACTOR_PLANNER_AGENT: SubagentConfig;
  * Use for: CI checks, pre-release audits, dependency vulnerability scanning.
  */
 export declare const SECURITY_SCANNER_AGENT: SubagentConfig;
+/**
+ * Read-only discovery surface for the Explore Companion.
+ *
+ * Index tools first (the point of the role: save the leader those calls).
+ * `codebase-impact-analysis` is read-only blast radius — the leader is about
+ * to edit; the companion should say who breaks. File tools are fallbacks
+ * when the index is cold or the probe needs a cited `file:line`.
+ *
+ * Deliberately omitted from `TOOLS.read`:
+ *   - `search` — web search, not codebase search
+ *   - `mailbox` — cross-session mail; same-session talk is `session_note`
+ *     (injected by the host, like `submit_result`)
+ */
+export declare const EXPLORE_COMPANION_TOOLS: readonly string[];
 /**
  * Explore Companion — state-triggered background codebase explorer.
  * Runs behind a leader agent: triggered by the in-progress state of the
  * work (unread-file edits, zero-hit searches, todo flips, explicit asks),
- * scans the codebase read-only, and feeds findings back via mailbox
- * `result`/`btw` + `submit_result`. See
+ * scans the codebase read-only, and feeds findings back via `submit_result`
+ * (the host mails a compact copy to the leader). See
  * docs/architecture/explore-companion-subagent.md.
  *
  * Operational role — deliberately NOT in ALL_AGENT_DEFINITIONS (like

package/dist/coordination/index.d.ts

@@ -28,6 +28,8 @@ export type { ICoordinator } from './icoordinator.js';
 export type { IFleetManager } from './ifleet-manager.js';
 export { LargeAnswerStore } from './large-answer-store.js';
 export { type MailToolsOptions, makeMailInboxTool, makeMailSendTool } from './mail-tools.js';
+export { postSessionNote, SessionNoteHub, sessionNoteHub, type SessionNoteInbox, type SessionNotePost, type SessionNotePostResult, } from './session-note-hub.js';
+export { makeSessionNoteTool } from './session-note-tool.js';
 export type { MailboxActionInput, MailboxActionResult, MailboxMessageAction, } from './mailbox-actions.js';
 export { actionToAckInput } from './mailbox-actions.js';
 export { parseMailboxAckInput, parseMailboxQueryInput, parseMailboxSendInput, } from './mailbox-codecs.js';
@@ -46,6 +48,8 @@ export { applyMailboxSendPolicy, type MailboxResolver, type MailboxToolOptions,
 export type { AgentHeartbeatInput, AgentRegistrationInput, ClientHeartbeatInput, ClientRegistrationInput, ClientSource, ClientStatus, Mailbox, MailboxAckBatchInput, MailboxAckInput, MailboxAgentStatus, MailboxAudience, MailboxMessage, MailboxMessageProjection, MailboxMessageType, MailboxQuery, MailboxRecipientState, MailboxSendInput, MailboxTaskContext, PurgeOptions, PurgeResult, ReadReceipts, RegisteredAgent, } from './mailbox-types.js';
 export { isMailboxLeader, isMailboxMessageVisibleTo, MAILBOX_TYPE_PROPERTIES, mailboxIdentityBase, normalizeRecipient, SESSION_RECIPIENT_PREFIX, sessionRecipient, } from './mailbox-types.js';
 export { isValidMatrixKey, MATRIX_PHASE_KEYS, type MatrixKeyKind, type ModelMatrixResolution, type ModelMatrixResolutionSource, type ModelReference, matrixKeyKind, phaseForRole, type ResolvedModelTarget, type ResolvedSubagentModelTarget, resolveImplementationModelTarget, resolveModelMatrix, resolveModelMatrixResolution, resolveModelTargetFromEntry, resolveSubagentModelTarget, roleNeedsIndependentReviewModel, sameModelReference, } from './model-matrix.js';
+export { activeTierConfig, applyTierToSubagentConfig, classifyTier, DEFAULT_TIER_ID, isConfiguredTier, listTierIds, type ModelTierBudget, type ModelTierDecision, type ModelTierSource, type ResolvedTierTarget, resolveTier, tierBudget, tierLevel, tierModelTarget, } from './model-tier.js';
+export { evaluateLeaderTierSwitch, evaluateSwitchEconomics, type LeaderTierRefusalCode, type LeaderTierSwitchRequest, type LeaderTierVerdict, leaderTierPolicy, type ResolvedLeaderTierPolicy, type TierModelEconomics, tierRank, } from './model-tier-leader.js';
 export { DefaultMultiAgentCoordinator, type MultiAgentCoordinatorOptions, } from './multi-agent-coordinator.js';
 export { NULL_FLEET_BUS } from './null-fleet-bus.js';
 export { detectEcosystem, getFullPackageLog, getManifestPackages, getPackageAuthor, getPackagesByAgent, type PackageAuthorEntry, type PackageAuthorLog, type PackageAuthorTrackerOptions, recordPackageAction, updatePackageOutdatedStatus, } from './package-author-tracker.js';