@wrongstack/cli 0.313.0 → 0.316.1

package/dist/{acp-LQMSMV32.js → acp-CEQINXWB.js}

@@ -3,7 +3,7 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-CNQZ4HG4.js";
+} from "./chunk-37SPPLUD.js";
 import "./chunk-QYIIOMLE.js";
 import "./chunk-BXFYBQKR.js";
 import "./chunk-7OCVIDC7.js";
@@ -913,4 +913,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-LQMSMV32.js.map
+//# sourceMappingURL=acp-CEQINXWB.js.map

package/dist/acp-registry-cache.d.ts

@@ -17,8 +17,6 @@ export interface LoadedAcpRegistry {
     /** Full descriptors, for listing. */
     agents: ACPAgentDescriptor[];
 }
-/** Where the synced registry snapshot lives. */
-export declare function acpRegistryCachePath(paths: WstackPaths): string;
 /** Read the cached registry, or `null` if it's missing or unreadable. */
 export declare function loadCachedAcpRegistry(paths: WstackPaths): Promise<LoadedAcpRegistry | null>;
 /** Fetch the live registry and persist it. Throws on network/parse failure. */

package/dist/acp-server-agent.d.ts

@@ -25,7 +25,7 @@ import type { SubcommandDeps } from './subcommands/contracts.js';
 export declare class AcpServerConfigError extends Error {
     constructor(message: string);
 }
-export interface AcpAgentFactoryOptions {
+interface AcpAgentFactoryOptions {
     /** Caller-supplied logger; a minimal stderr logger is created when omitted. */
     logger?: Logger | undefined;
 }
@@ -64,4 +64,5 @@ export declare class ACPClientPermissionPolicy implements PermissionPolicy {
  * Throws `AcpServerConfigError` up front if no provider is configured.
  */
 export declare function buildAcpServerAgentFactory(deps: SubcommandDeps, options?: AcpAgentFactoryOptions): (sessionId: string, cwd: string, api?: RunTurnApi) => Promise<Agent>;
+export {};
 //# sourceMappingURL=acp-server-agent.d.ts.map

package/dist/arg-parser.d.ts

@@ -19,7 +19,7 @@ export interface AuthFlags {
 }
 /** Parse `wstack auth <provider> [--label ...] [--family ...] [...]` flags. */
 export declare function parseAuthFlags(args: string[]): AuthFlags;
-export interface SpawnFlags {
+interface SpawnFlags {
     description: string;
     opts: {
         provider?: string | undefined;
@@ -38,4 +38,5 @@ export interface SpawnFlags {
  * Anything after the last flag is the task description.
  */
 export declare function parseSpawnFlags(input: string): SpawnFlags;
+export {};
 //# sourceMappingURL=arg-parser.d.ts.map

package/dist/{auth-VQMSZGKE.js → auth-GZ5A5OF5.js}

@@ -13,7 +13,7 @@ import {
   runOAuthLoginKind,
   runOAuthLoginMenu,
   validateFamily
-} from "./chunk-USYOJIV2.js";
+} from "./chunk-32MTOI2I.js";
 import {
   restoreFlags
 } from "./chunk-CSAPOCBP.js";
@@ -23,7 +23,7 @@ import {
 } from "./chunk-2VMJ3E5Z.js";
 import {
   parseAuthFlags
-} from "./chunk-PKHGLWUJ.js";
+} from "./chunk-T642Q732.js";
 import "./chunk-B4JLSXZB.js";
 import "./chunk-VUVOMXWP.js";
 import {
@@ -596,4 +596,4 @@ async function runAuthRemove(deps, providerId) {
 export {
   authCmd
 };
-//# sourceMappingURL=auth-VQMSZGKE.js.map
+//# sourceMappingURL=auth-GZ5A5OF5.js.map

package/dist/auth-menu/local.d.ts

@@ -28,10 +28,11 @@ import type { SecretScrubber } from '@wrongstack/core/types';
 import type { ProbeOptions, ProbeResult } from '@wrongstack/runtime/probe';
 import { probeLocalLlm } from '@wrongstack/runtime/probe';
 import { type AuthAuditLogger } from './auth-menu-audit.js';
-import { LOCAL_LLM_PRESETS, type LocalLlmPresetEntry } from './local-presets.js';
+import { LOCAL_LLM_PRESETS } from './local-presets.js';
+export type { LocalLlmPresetEntry } from './local-presets.js';
 import { suggestLabel } from './shared.js';
 import type { AuthMenuDeps } from './types.js';
-export { LOCAL_LLM_PRESETS, type LocalLlmPresetEntry, type ProbeOptions, type ProbeResult, probeLocalLlm, };
+export { LOCAL_LLM_PRESETS, type ProbeOptions, type ProbeResult, probeLocalLlm };
 export interface RunAuthLocalOptions {
     /**
      * Direct pick: skip the interactive menu and configure this preset.

package/dist/boot/boot-auto-thin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Boot-time entry point for the auto-thinning pipeline.
+ *
+ * Called once after `registerBuiltinTools` and after the Chronicle
+ * metrics store is opened. If `tools.autoThin.enabled` is true AND
+ * `tools.autoThin.applyOnBoot` is true, the pipeline queries the
+ * configured source (Chronicle primary, in-process bridge fallback),
+ * filters with the policy, and calls `registry.thinUnderused()`.
+ *
+ * The decision is persisted back to `disabledTools` and
+ * `disabledToolMeta` via `configStore.update` so the next boot picks up
+ * the same set without re-running the policy.
+ */
+import type { ChronicleMetricsStore } from '@wrongstack/core/chronicle';
+import type { EventBus } from '@wrongstack/core/kernel';
+import { type ToolUsageSnapshot, type UnderusedToolCandidate } from '@wrongstack/core/observability';
+import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { AutoThinConfig, ConfigStore } from '@wrongstack/core/types';
+interface BootAutoThinDeps {
+    toolRegistry: ToolRegistry;
+    events: EventBus;
+    configStore: ConfigStore;
+    config: AutoThinConfig;
+    chronicle?: ChronicleMetricsStore | undefined;
+    /** In-process bridge snapshot — fallback when Chronicle is unavailable. */
+    bridge?: ToolUsageSnapshot | undefined;
+    /** Wall-clock anchor for tests; defaults to `Date.now()`. */
+    now?: () => number;
+    /**
+     * When true, log the dry-run outcome but do not mutate the registry
+     * or persist anything. Used by `/tool autothin candidates` and by
+     * the WebUI's "Run now" preview.
+     */
+    dryRun?: boolean;
+}
+interface BootAutoThinResult {
+    candidates: UnderusedToolCandidate[];
+    applied: string[];
+    skipped: string[];
+    source: 'chronicle' | 'in-process' | 'none';
+}
+export declare function runBootAutoThin(deps: BootAutoThinDeps): Promise<BootAutoThinResult>;
+export {};
+//# sourceMappingURL=boot-auto-thin.d.ts.map

package/dist/boot/brain-decision-log.d.ts

@@ -12,7 +12,7 @@
  * The host wires this up once at boot and retains a reference to `brainLog`
  * (and indirectly `pushBrainLog`) for the duration of the session.
  */
-export type BrainDecisionKind = 'answered' | 'ask_human' | 'denied' | 'intervention' | 'council_warn';
+type BrainDecisionKind = 'answered' | 'ask_human' | 'denied' | 'intervention' | 'council_warn';
 export interface BrainDecisionEntry {
     at: number;
     kind: BrainDecisionKind;
@@ -37,4 +37,5 @@ export declare function subscribeBrainDecisionLog(events: any): {
     pushBrainLog: (entry: BrainDecisionEntry) => void;
     dispose: () => void;
 };
+export {};
 //# sourceMappingURL=brain-decision-log.d.ts.map

package/dist/boot/config-backup-recovery.d.ts

@@ -1,6 +1,6 @@
 import type { ReadlineInputReader } from '../input-reader.js';
 import type { TerminalRenderer } from '../renderer.js';
-export interface ProviderConfigBackup {
+interface ProviderConfigBackup {
     filePath: string;
     fileName: string;
     raw: string;
@@ -19,11 +19,6 @@ export declare function defaultProfileProvidersAreEmpty(profilePath: string): Pr
  * `profiles-default-config-2026-07-19T12-34-56-789.json`.
  */
 export declare function findLatestProviderBackup(globalRoot: string): Promise<ProviderConfigBackup | undefined>;
-export declare function restoreDefaultProfileBackup(opts: {
-    backup: ProviderConfigBackup;
-    globalRoot: string;
-    profilePath: string;
-}): Promise<void>;
 /** Prompt once during an ordinary interactive boot. Enter accepts recovery. */
 export declare function maybeRestoreDefaultProfileFromBackup(opts: {
     globalRoot: string;
@@ -31,4 +26,5 @@ export declare function maybeRestoreDefaultProfileFromBackup(opts: {
     renderer: TerminalRenderer;
     reader: ReadlineInputReader;
 }): Promise<boolean>;
+export {};
 //# sourceMappingURL=config-backup-recovery.d.ts.map

package/dist/boot/dispatch-singleshot.d.ts

@@ -14,7 +14,7 @@
 import type { Agent } from '@wrongstack/core/agent';
 import type { TokenCounter } from '@wrongstack/core/types';
 import type { TerminalRenderer } from '../renderer.js';
-export interface SingleShotDispatchContext {
+interface SingleShotDispatchContext {
     /** The agent to run. */
     agent: Agent;
     /** Joined positional args forming the query string. */
@@ -33,4 +33,5 @@ export interface SingleShotDispatchContext {
  * aborted.
  */
 export declare function runSingleShotDispatch(ctx: SingleShotDispatchContext): Promise<number>;
+export {};
 //# sourceMappingURL=dispatch-singleshot.d.ts.map

package/dist/boot/dispatch-webui.d.ts

@@ -67,7 +67,7 @@ export interface WebUIDispatchContext {
     /** Read-only worker transcript snapshot used for browser refresh replay. */
     agentTranscripts?: {
         getAllSessions(): import('@wrongstack/core/coordination').AgentVirtualSession[];
-        loadSessionsFromDisk(): Promise<import('@wrongstack/core/coordination').AgentVirtualSession[]>;
+        loadSessionsFromDisk(only?: readonly string[]): Promise<import('@wrongstack/core/coordination').AgentVirtualSession[]>;
     } | undefined;
     /**
      * Pre-computed update info from the CLI's preflight version check.
@@ -83,6 +83,8 @@ export interface WebUIDispatchContext {
         model?: string | undefined;
         fallbackModels?: string[] | undefined;
         fallbackProfile?: string | undefined;
+        tier?: string | undefined;
+        role?: string | undefined;
         skills?: string[] | undefined;
         tools?: string[] | undefined;
         name?: string | undefined;
@@ -95,6 +97,8 @@ export interface WebUIDispatchContext {
     }) => Promise<string>) | undefined;
     /** Live fleet budget for WebUI concurrency/spawn gauges (issue #323). */
     getFleetBudget?: CliWebUIOptions['getFleetBudget'];
+    stopSessionFleet?: CliWebUIOptions['stopSessionFleet'];
+    onSessionRetired?: CliWebUIOptions['onSessionRetired'];
     /** Internal one-session child launch metadata, when --webui-session-child is active. */
     webuiSessionChild?: WebuiSessionChildOptions | undefined;
 }

package/dist/boot/event-wiring.d.ts

@@ -1,5 +1,5 @@
 import type { EventBus } from '@wrongstack/core/kernel';
-export interface EventWiringRenderer {
+interface EventWiringRenderer {
     write(text: string): void;
 }
 export type EvOn = (event: string, handler: (...args: any) => void) => void;

package/dist/boot/execution-mode.d.ts

@@ -5,6 +5,7 @@
  * launchers, and execute(): a one-shot prompt owns the process, WebUI owns
  * stdout when requested alongside TUI, and --no-tui falls back to REPL.
  */
-export type ExecutionMode = 'single-shot' | 'tui' | 'webui' | 'repl';
+type ExecutionMode = 'single-shot' | 'tui' | 'webui' | 'repl';
 export declare function resolveExecutionMode(positional: readonly string[], flags: Readonly<Record<string, string | boolean>>): ExecutionMode;
+export {};
 //# sourceMappingURL=execution-mode.d.ts.map

package/dist/boot/governance-shadow-bridge.d.ts

@@ -1,13 +1,13 @@
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { GovernanceRuntimeObservationInput, GovernanceRuntimeObservationResult } from '@wrongstack/runtime/governance-bootstrap';
 import type { GovernanceTraceContext } from './governance-trace-context.js';
-export interface GovernanceObservationSink {
+interface GovernanceObservationSink {
     observe(input: GovernanceRuntimeObservationInput): Promise<GovernanceRuntimeObservationResult>;
 }
-export interface GovernanceShadowLogger {
+interface GovernanceShadowLogger {
     warn(message: string, context?: unknown): void;
 }
-export interface GovernanceShadowBridge {
+interface GovernanceShadowBridge {
     close(): void;
 }
 export declare function createGovernanceShadowBridge(input: {
@@ -16,4 +16,5 @@ export declare function createGovernanceShadowBridge(input: {
     readonly logger: GovernanceShadowLogger;
     readonly trace: GovernanceTraceContext;
 }): GovernanceShadowBridge;
+export {};
 //# sourceMappingURL=governance-shadow-bridge.d.ts.map

package/dist/boot/governance-trace-context.d.ts

@@ -1,7 +1,6 @@
 import type { WorkspaceCheckpointRef } from '@wrongstack/core/types';
 export declare const MAX_GOVERNANCE_PLAN_BYTES: number;
-export declare const MAX_GOVERNANCE_ACTIVE_STEP_IDS = 128;
-export type GovernancePlanTrace = {
+type GovernancePlanTrace = {
     readonly state: 'missing' | 'invalid' | 'unreadable';
 } | {
     readonly state: 'refreshing';
@@ -19,7 +18,7 @@ export type GovernancePlanTrace = {
     readonly activeStepIds: readonly string[];
     readonly activeStepIdsTruncated: boolean;
 };
-export type GovernanceWorkspaceTrace = {
+type GovernanceWorkspaceTrace = {
     readonly state: 'not_captured';
 } | {
     readonly state: 'unavailable';
@@ -53,7 +52,7 @@ export interface GovernanceTraceContext {
     updateWorkspaceCheckpoint(promptIndex: number, observedAt: string, checkpoint: WorkspaceCheckpointRef | undefined): void;
     snapshot(taskId: string | null, boardId?: string | undefined): GovernanceTraceContextSnapshot;
 }
-export interface GovernanceTraceContextDependencies {
+interface GovernanceTraceContextDependencies {
     readonly readFile: (filePath: string) => Promise<string>;
     readonly now: () => string;
 }
@@ -61,4 +60,5 @@ export declare function createGovernanceTraceContext(input: {
     readonly sessionId: string;
     readonly planPath: string;
 }, dependencies?: GovernanceTraceContextDependencies): Promise<GovernanceTraceContext>;
+export {};
 //# sourceMappingURL=governance-trace-context.d.ts.map

package/dist/boot/launch-menu.d.ts

@@ -34,9 +34,9 @@ import type { LaunchMenuChoice } from '@wrongstack/core/types';
 import type { ReadlineInputReader } from '../input-reader.js';
 import type { TerminalRenderer } from '../renderer.js';
 /** Top-level surfaces the user can launch from the menu. */
-export type LaunchMenuMode = LaunchMenuChoice['mode'];
+type LaunchMenuMode = LaunchMenuChoice['mode'];
 /** Resolved menu result — the caller must act on this, not re-derive. */
-export interface LaunchMenuResult extends LaunchMenuChoice {
+interface LaunchMenuResult extends LaunchMenuChoice {
     /**
      * True when the user typed `q` (or pressed Ctrl+C) at any prompt.
      * Caller should exit gracefully with code 0.

package/dist/boot/system-prompt-builder.d.ts

@@ -10,7 +10,7 @@ export interface MutableRef<T> {
  * on the full WstackPaths shape (which is huge and subject
  * to change).
  */
-export interface SystemPromptBuilderPaths {
+interface SystemPromptBuilderPaths {
     projectGoal: string;
     projectSessions: string;
     globalInstructions?: string | undefined;

package/dist/boot/system-prompt-menu.d.ts

@@ -18,24 +18,22 @@
  * `q` at any prompt throws `LaunchAbortedError` (the same cancellation
  * contract as the launch prompts), and the caller in boot.ts exits 0.
  */
-import { type SystemInstructionVariant } from '@wrongstack/core/agent';
+import { countSystemPromptTokens, persistSystemPromptVariant, readSavedSystemPromptVariant, SYSTEM_PROMPT_VARIANTS, type SystemInstructionVariant, type SystemPromptVariantPaths } from '@wrongstack/core/agent';
 import type { ReadlineInputReader } from '../input-reader.js';
 import type { TerminalRenderer } from '../renderer.js';
-/** Menu order + display labels. `default` is shown as "Standard". */
-export declare const SYSTEM_PROMPT_OPTIONS: ReadonlyArray<{
+/**
+ * Menu order + display labels, re-exported from core so the CLI menu, the
+ * WebUI picker, and any other surface offer the same three options in the same
+ * order with the same token math.
+ */
+export declare const SYSTEM_PROMPT_OPTIONS: readonly {
     variant: SystemInstructionVariant;
     label: string;
     hint: string;
-}>;
-/** All selectable variants, in menu order. */
-export declare const SYSTEM_PROMPT_VARIANTS: readonly SystemInstructionVariant[];
+}[];
+export { countSystemPromptTokens, persistSystemPromptVariant, readSavedSystemPromptVariant, SYSTEM_PROMPT_VARIANTS, };
 /** Instruction dirs used to resolve the identity text per variant. */
-export interface SystemPromptMenuPaths {
-    /** Profile override directory, e.g. `~/.wrongstack/profiles/<name>/instructions`. */
-    globalDir?: string | undefined;
-    /** Project override directory, e.g. `<project>/.wrongstack/instructions`. */
-    projectDir?: string | undefined;
-}
+export type SystemPromptMenuPaths = SystemPromptVariantPaths;
 /** True when any `--system-*` flag pins a variant (menu must not show). */
 export declare function isSystemPromptPinned(flags: Record<string, string | boolean>): boolean;
 /**
@@ -45,41 +43,6 @@ export declare function isSystemPromptPinned(flags: Record<string, string | bool
  * flag-pinned launches never prompt.
  */
 export declare function shouldSkipSystemPromptMenu(flags: Record<string, string | boolean>): boolean;
-/**
- * Estimate the tokens of the system identity block each variant injects.
- *
- * Resolution goes through the same `loadInstructionBundle` the
- * SystemPromptBuilder runs (bundled → global → project, later layers override
- * `system.identity`), and composition goes through the builder's own
- * `buildIdentityLayer`. Calling the real composer matters: when the identity
- * came from the *project* layer, WS-016 makes the builder emit the bundled
- * identity PLUS a `<project-supplied-instructions>` delimiter block PLUS the
- * project text rather than replacing the identity. Counting
- * `bundle.system.identity` alone therefore under-reports a project override by
- * the whole bundled prompt — which is exactly the case a repo that ships its
- * own `system-pro.md` hits.
- *
- * The figure is an **upper bound**, not `/context` parity: `buildIdentityLayer`
- * is called without an `InstructionTemplateContext`, which by its own contract
- * keeps the full text, so `ws:if` blocks for tools the live request never
- * registers are still counted. Erring high is the right direction for a menu
- * whose purpose is comparing variant cost, and every figure is rendered with a
- * leading `~`.
- */
-export declare function countSystemPromptTokens(paths: SystemPromptMenuPaths): Promise<Record<SystemInstructionVariant, number>>;
-/**
- * Read the variant the user explicitly saved to the profile config file.
- *
- * The config loader materializes `systemPrompt: { variant: 'default' }` for
- * every config (see `@wrongstack/core` config-loader defaults), so the
- * in-memory Config cannot distinguish "user chose Standard" from "never
- * chose". Only the raw file can: {@link persistSystemPromptVariant} writes
- * the key explicitly, so its presence on disk is the signal that a selection
- * was made. Absence (first run, or a config edited before this feature
- * existed) returns undefined and the caller shows the full menu instead of
- * the summary gate.
- */
-export declare function readSavedSystemPromptVariant(configPath: string): Promise<SystemInstructionVariant | undefined>;
 /**
  * Run the interactive system-prompt selection. Returns the chosen variant.
  * Throws {@link LaunchAbortedError} when the user presses `q` (the caller
@@ -94,17 +57,6 @@ export declare function runSystemPromptMenu(deps: {
     /** Saved variant from config — enables the summary gate. */
     lastVariant?: SystemInstructionVariant | undefined;
 }): Promise<SystemInstructionVariant>;
-/**
- * Persist the chosen variant to the profile config file so the next boot
- * can offer a one-line "Continue with these?" gate. Mirrors
- * `persistLaunchChoices`: reads the existing JSON, mutates only the
- * `systemPrompt` block, writes back atomically with mode 0600. Other fields
- * (including encrypted secrets) pass through round-trip unchanged.
- *
- * @throws when the config file exists but is corrupt (same policy as the
- * launch-choices writer — never overwrite unreadable user config silently).
- */
-export declare function persistSystemPromptVariant(configPath: string, variant: SystemInstructionVariant): Promise<void>;
 /** Outcome of {@link maybeRunSystemPromptMenu}. */
 export interface SystemPromptMenuOutcome {
     /**

package/dist/boot/system-prompt.d.ts

@@ -1,14 +1,14 @@
 import type { ProviderRegistry } from '@wrongstack/core/registry';
 import type { Config, Logger, ModelsRegistry, ResolvedProvider } from '@wrongstack/core/types';
-export type ModeId = string;
-export type ModePrompt = string;
+type ModeId = string;
+type ModePrompt = string;
 export interface ModelCapabilities {
     maxContextTokens: number;
     supportsTools: boolean;
     supportsVision: boolean;
     supportsReasoning: boolean;
 }
-export type ResolvedModeResult = {
+type ResolvedModeResult = {
     kind: 'ok';
     resolvedProvider: ResolvedProvider;
     providerRegistry: ProviderRegistry;

package/dist/boot/tool-registry.d.ts

@@ -1,7 +1,7 @@
 /** CLI boot adapter for canonical runtime tool registration and host policies. */
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { ToolRegistry } from '@wrongstack/core/registry';
-import type { MemoryPort, TokenSavingTier, ToolDescriptionModeConfig, ToolResultRenderModeConfig } from '@wrongstack/core/types';
+import type { AutoThinConfig, DisabledToolMeta, MemoryPort, TokenSavingTier, ToolDescriptionModeConfig, ToolResultRenderModeConfig } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { VectorMemoryStore } from '@wrongstack/vector-memory';
 interface RegisterBuiltinToolsDeps {
@@ -16,6 +16,8 @@ interface RegisterBuiltinToolsDeps {
             descriptionMode?: ToolDescriptionModeConfig | undefined;
             resultRenderMode?: ToolResultRenderModeConfig | undefined;
             disabledTools?: string[] | undefined;
+            disabledToolMeta?: Record<string, DisabledToolMeta> | undefined;
+            autoThin?: AutoThinConfig | undefined;
             nextsteps?: {
                 enabled?: boolean | undefined;
             } | undefined;

package/dist/boot/tui-coordinator-callbacks.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { AutonomousCoordinator, CoordinatorEvent } from '@wrongstack/core/coordination';
 import type { TuiRuntimeState } from './tui-runtime-state.js';
-export interface TuiCoordinatorCallbacksContext {
+interface TuiCoordinatorCallbacksContext {
     state: TuiRuntimeState;
     context: Context;
     coordinatorEvents: Set<(event: CoordinatorEvent) => void>;
@@ -42,4 +42,5 @@ export declare function createTuiCoordinatorCallbacks({ state, context, coordina
         };
     } | null>;
 };
+export {};
 //# sourceMappingURL=tui-coordinator-callbacks.d.ts.map

package/dist/boot/tui-coordinator-setup.d.ts

@@ -3,7 +3,7 @@ import { AutonomousCoordinator, type Director } from '@wrongstack/core/coordinat
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { TuiRuntimeState } from './tui-runtime-state.js';
-export interface CoordinatorSetupContext {
+interface CoordinatorSetupContext {
     /** The shared mutable runtime state. */
     state: TuiRuntimeState;
     /** The main EventBus — used for the Director lifecycle hook. */
@@ -23,7 +23,7 @@ export interface CoordinatorSetupContext {
     /** Set by this module so execute()'s finally block can stop the coordinator. */
     onCoordinatorStopSetter: (fn: (() => void) | undefined) => void;
 }
-export interface CoordinatorSetupResult {
+interface CoordinatorSetupResult {
     /** The ensureAutonomousCoordinator function (idempotent). */
     ensure: () => AutonomousCoordinator | null;
     /** Call to remove the Director lifecycle listener (for TUI cleanup). */
@@ -37,4 +37,5 @@ export interface CoordinatorSetupResult {
  * the event listener.
  */
 export declare function setupAutonomousCoordinator(ctx: CoordinatorSetupContext): CoordinatorSetupResult;
+export {};
 //# sourceMappingURL=tui-coordinator-setup.d.ts.map

package/dist/boot/tui-goal-wiring.d.ts

@@ -1,5 +1,5 @@
 import type { EventBus } from '@wrongstack/core/kernel';
-export interface GoalWiring {
+interface GoalWiring {
     /**
      * Called by the TUI to receive forwarded events. Each call registers
      * one listener per event name; the returned function unregisters all.
@@ -20,4 +20,5 @@ export interface GoalWiring {
  * and throw the moment Goal subscribes.
  */
 export declare function wireGoal(events: EventBus): GoalWiring;
+export {};
 //# sourceMappingURL=tui-goal-wiring.d.ts.map

package/dist/boot/tui-live-sessions.d.ts

@@ -1,5 +1,5 @@
 import type { TuiRuntimeState } from './tui-runtime-state.js';
-export interface LiveSessionsContext {
+interface LiveSessionsContext {
     state: TuiRuntimeState;
 }
 /**
@@ -15,6 +15,7 @@ export declare function getLiveSessions(ctx: LiveSessionsContext): Promise<{
     gitBranch: string | undefined;
     status: import("@wrongstack/core/storage").SessionLiveStatus;
     pid: number;
+    clientType: string | undefined;
     startedAt: string;
     agentCount: number;
     agents: {
@@ -36,4 +37,5 @@ export declare function getLiveSessions(ctx: LiveSessionsContext): Promise<{
  * We open the target project fresh instead.
  */
 export declare function onSwitchToSession(ctx: LiveSessionsContext, _sessionId: string, targetRoot: string, projectName: string): void;
+export {};
 //# sourceMappingURL=tui-live-sessions.d.ts.map

package/dist/boot/tui-session-resume.d.ts

@@ -1,34 +1,106 @@
 import type { Agent } from '@wrongstack/core/agent';
 import type { EventBus } from '@wrongstack/core/kernel';
-import type { ContextSnapshot, TokenCounter } from '@wrongstack/core/types';
+import type { ContextSnapshot, SessionLoadProgress, TokenCounter } from '@wrongstack/core/types';
 import type { TuiRuntimeState } from './tui-runtime-state.js';
-export interface SessionResumeContext {
+interface SessionResumeContext {
     state: TuiRuntimeState;
     agent: Agent;
     tokenCounter: TokenCounter;
     switchProviderAndModel: ((providerId: string, modelId: string) => string | null | void | Promise<unknown>) | undefined;
     /** App EventBus — forwarded to the re-pointed todos checkpoint for storage.* events. */
     events?: EventBus | undefined;
+    /**
+     * Byte-level parse progress sink for large journals. When provided, the
+     * store's JSONL loader throttles it to ~4 updates/sec so the TUI picker
+     * hint can stream load progress instead of a static line.
+     */
+    onLoadProgress?: ((progress: SessionLoadProgress) => void) | undefined;
+    /**
+     * Why a resume returned `null`.
+     *
+     * `resumeSession` deliberately keeps returning `null` on failure — every
+     * rollback test pins that contract, and a throw escaping mid-rollback would
+     * be worse than a clean `null`. But `null` alone reaches the user as a bare
+     * "Failed to resume session <id>." with no reason, on every surface, which
+     * makes a broken resume undiagnosable. This sink carries the reason (and the
+     * STAGE it died at) out to the caller, which turns it into the message the
+     * user actually reads.
+     */
+    onFailure?: ((failure: SessionResumeFailure) => void) | undefined;
+    /**
+     * Live stage reporter.
+     *
+     * The same `stage` string the failure sink reports, but emitted as each step
+     * BEGINS rather than only when one fails. The TUI turns it into the rolling
+     * "what is happening right now" rows of the resume block — without it the
+     * only honest thing that surface could show during a multi-second journal
+     * parse was a spinner.
+     */
+    onStage?: ((stage: string) => void) | undefined;
+}
+/** The stage a failed resume died at, plus the underlying error text. */
+export interface SessionResumeFailure {
+    /** Machine-readable step name, e.g. `resolve_id`, `open_writer`, `hydrate`. */
+    stage: string;
+    /** Error text from the failing step — never empty. */
+    message: string;
 }
-export interface SessionResumeResult {
+interface SessionResumeResult {
     entries: unknown[];
     nextId: number;
     sessionId: string;
+    /**
+     * Whether the agent is now WRITING to this session.
+     *
+     * `false` means the transcript is on screen but ownership was never taken:
+     * the session stays read-only and the next prompt continues the session the
+     * user was already in. Showing the transcript anyway is deliberate — the
+     * expensive, safe half of a resume (read the journal, render the timeline)
+     * has no reason to be discarded because the risky half (claim the journal
+     * for writing) failed.
+     */
+    attached: boolean;
+    /**
+     * Non-fatal problems the user should see, e.g. a sidecar that could not be
+     * re-pointed or a provider that is no longer configured. These used to abort
+     * the whole resume and roll back a transcript that had already loaded.
+     */
+    warnings: string[];
     /**
      * Optional context-window snapshot for the resumed session. `tokens` is a
-     * flat `number` (sum of `tokenCounter.currentRequestTokens()?.`'s
-     * `{ input, cacheRead, cacheWrite }` fields) — the TUI consumer
-     * (`packages/tui/src/reducers/composer.ts:561-577`) reads `tokens` as a
-     * flat number and gates on `snap.tokens > 0`. Forwarding the raw object
-     * would coerce to NaN and silently drop the snapshot at runtime.
+     * flat `number` — the prompt size of the session's LAST request, read from
+     * its journal by `projectLastRequestTokens`. The TUI consumer
+     * (`packages/tui/src/reducers/composer.ts:561-577`) reads it as a flat
+     * number and gates on `snap.tokens > 0`, so a session that never reached the
+     * model reports 0 and simply leaves the chip alone.
      */
     contextSnapshot?: ContextSnapshot | undefined;
+    /**
+     * Text of the LAST assistant message in the resumed transcript.
+     *
+     * The caller parses `<nextsteps>` out of it. Deterministic by construction —
+     * the TUI's per-entry parser fires on whichever assistant entry happens to
+     * mount last during a replay, which is not necessarily the final turn, so a
+     * resume needs the authoritative one from the transcript itself.
+     */
+    lastAssistantText?: string | undefined;
 }
 /**
  * Resume a past session by id.
  *
- * Returns the replayed history entries + new session id, or null on
- * failure. Throws if the session is live in another process.
+ * Three outcomes, in decreasing order of success:
+ *
+ * 1. `{ attached: true }` — transcript replayed AND the agent now writes to
+ *    this session. `warnings` may still list best-effort steps that failed
+ *    (sidecars, provider restore, token accounting); none of them are worth
+ *    throwing away a working resume for.
+ * 2. `{ attached: false }` — ownership could not be taken (another process
+ *    holds it, the reservation lapsed, the writer would not open), but the
+ *    journal read fine, so the transcript is shown read-only with the reason
+ *    in `warnings`. The agent stays on the session it was already writing.
+ * 3. `null` — the journal itself could not be read. `onFailure` carries the
+ *    stage and reason.
  */
 export declare function resumeSession(ctx: SessionResumeContext, sessionId: string): Promise<SessionResumeResult | null>;
+export {};
 //# sourceMappingURL=tui-session-resume.d.ts.map