@wrongstack/core 0.300.0 → 0.302.0

package/dist/tools/one-shot-llm-tool.d.ts

@@ -18,6 +18,7 @@ export interface CreateOneShotLLMToolOptions {
     fallbackProfileManager: OneShotOrchestratorOptions['fallbackProfileManager'];
     modelRouter?: OneShotOrchestratorOptions['modelRouter'];
     logger?: OneShotOrchestratorOptions['logger'];
+    wrapProviderCall?: OneShotOrchestratorOptions['wrapProviderCall'];
     /**
      * Default provider to use when the caller doesn't specify one.
      * When absent, callers MUST provide `providerId` explicitly.

package/dist/tools/plugin-manager.d.ts

@@ -16,6 +16,25 @@ export interface PluginManagerMutationResult {
     message: string;
     restartRequired?: boolean | undefined;
 }
+/**
+ * Structural view of the session's PreToolUse hook pipeline — satisfied by
+ * `HookRunner` without depending on the class. `use` runs the pipeline
+ * before a nested `execute()` so policy hooks (path-guard & co.) rule on
+ * plugin-tool calls exactly as they would on the direct path.
+ */
+export interface PluginManagerHookRunner {
+    preToolUse(toolName: string, toolInput: Record<string, unknown>, env: {
+        cwd: string;
+        signal?: AbortSignal | undefined;
+    }, toolMeta?: {
+        capabilities?: readonly string[] | undefined;
+        mutating?: boolean | undefined;
+    }): Promise<{
+        block?: boolean | undefined;
+        reason?: string | undefined;
+        input?: Record<string, unknown>;
+    }>;
+}
 export interface CreatePluginManagerToolOptions {
     /** Re-read on every call so config changes made during the session are visible. */
     getConfig: () => Config;
@@ -25,6 +44,14 @@ export interface CreatePluginManagerToolOptions {
     toolRegistry: ToolRegistry;
     /** Persist an enable/disable decision in the host's active config. */
     setEnabled: (plugin: string, enabled: boolean) => Promise<PluginManagerMutationResult>;
+    /**
+     * Late-bound source for the session's policy-hook runner, resolved on
+     * every `use` call. Late-bound because the hook pipeline is wired after
+     * the management tools register (same pattern as OneShotOrchestrator's
+     * `wrapProviderCall`); optional so minimal hosts and tests without a
+     * hook pipeline keep the previous behavior bit-for-bit.
+     */
+    getHookRunner?: (() => PluginManagerHookRunner | null | undefined) | undefined;
 }
 export declare function createPluginManagerTool(opts: CreatePluginManagerToolOptions): Tool;
 //# sourceMappingURL=plugin-manager.d.ts.map

package/dist/types/config/mcp-features.d.ts

@@ -162,15 +162,22 @@ export interface FeaturesConfig {
     allowOutsideProjectRoot?: boolean | undefined;
     /**
      * Auto-bootstrap the mailbox HTTP bridge from any WrongStack surface
-     * (REPL/TUI/WebUI/eternal). When 'auto' (the default), the first
-     * surface to come up for a given project joins or spawns the bridge
-     * so external agents can connect without the user running
-     * `wstack mailbox serve` themselves. 'off' disables this — operators
-     * must start the bridge explicitly (e.g. via the `/mailbox-serve`
-     * slash command or the standalone `wstack mailbox serve` subcommand).
-     * The per-project lock + token-persistence model means a second
-     * surface on the same project joins the first's bridge rather than
-     * spawning a duplicate.
+     * (REPL/TUI/WebUI/eternal).
+     *
+     * **Default: 'off'.** The bridge is a loopback HTTP façade that exists
+     * only so EXTERNAL agents (Claude Code, Aider, scripts) can reach the
+     * project mailbox. No WrongStack-internal surface consumes it — every
+     * in-process caller goes through `RemoteMailbox` over IPC — so booting
+     * it by default bought nothing and cost a full detached CLI process
+     * (~130 MB resident, with no idle shutdown) per project, forever.
+     *
+     * Set 'auto' to restore boot-time bootstrap: the first surface to come
+     * up for a given project joins or spawns the bridge. The per-project
+     * lock + token-persistence model means a second surface on the same
+     * project joins the first's bridge rather than spawning a duplicate.
+     *
+     * Either way the bridge can always be started on demand via the
+     * `/mailbox-serve` slash command or `wstack mailbox serve`.
      */
     mailboxBridge?: 'auto' | 'off' | undefined;
 }
@@ -200,9 +207,9 @@ export interface SageConfig {
          * the result they get appended to.
          */
         taskAware?: boolean | undefined;
-        /** Maximum diverse, structurally related hints appended to a single tool result. Default: 8. */
+        /** Maximum diverse, structurally related hints selected for one tool-memory evidence slot. Default: 8. */
         maxHintsPerTool?: number | undefined;
-        /** Maximum characters appended to a single tool result. Default: 2800. */
+        /** Maximum characters retained in the tool-memory evidence slot. Default: 2800. */
         maxCharsPerTool?: number | undefined;
         /** Maximum memories appended to ordinary turn context. Default: 8. */
         maxTurnMemories?: number | undefined;

package/dist/types/config/root.d.ts

@@ -3,7 +3,7 @@ import type { AutonomyConfig, ChronicleConfig, IndexingConfig, LaunchConfig, Ses
 import type { AdaptiveConcurrencyConfig, CircuitBreakerRuntimeConfig, ContextConfig } from './context.js';
 import type { FeaturesConfig, LogConfig, MCPServerConfig, PluginConfig, PluginManagerConfig, SageConfig } from './mcp-features.js';
 import type { CustomModelDefinition, ModelMatrixEntry, ProviderConfig } from './providers.js';
-import type { HqClientConfig, ModelRuntimeConfig, SystemPromptConfig } from './runtime.js';
+import type { CloudSyncConfig, HqClientConfig, ModelRuntimeConfig, SystemPromptConfig } from './runtime.js';
 import type { BrainConfig, FleetConfig, SkillsConfig } from './skills-fleet-brain.js';
 import type { ToolsConfig } from './tools.js';
 export interface GitBehaviorConfig {
@@ -225,6 +225,13 @@ export interface Config {
      * accidentally committing the GitHub token to project configs.
      */
     sync?: SyncConfig | undefined;
+    /**
+     * my.wrongstack.com config synchronization (namespaced sync API v1).
+     * SECURITY: in the in-project config DENY list — carries the machine
+     * bearer token credential and the portal endpoint URL. Only honoured
+     * from the user's active-profile config.
+     */
+    cloudSync?: CloudSyncConfig | undefined;
     /**
      * Git behavior overrides for agent-run git commands.
      *

package/dist/types/config/runtime.d.ts

@@ -91,6 +91,22 @@ export interface HqClientConfig {
     /** Override project display name in HQ. */
     projectAlias?: string | undefined;
 }
+/**
+ * Cloud config-sync settings for my.wrongstack.com (the account portal —
+ * distinct from the local HQ command center configured via `hq`). The full
+ * client contract, including which config sections sync and which stay
+ * local, is the server repo's docs/CLIENT_SYNC_CONTRACT.md.
+ */
+export interface CloudSyncConfig {
+    /** Enable background config synchronization. */
+    enabled?: boolean | undefined;
+    /** Portal base URL, e.g. https://my.wrongstack.com. */
+    url?: string | undefined;
+    /** Machine bearer token (wst_…). Stored encrypted by SecretVault when persisted. */
+    token?: string | undefined;
+    /** Seconds between background sync passes. Default 300, minimum 60. */
+    intervalSeconds?: number | undefined;
+}
 /**
  * Token-saving mode tier levels. Controls how aggressively the system prompt
  * is compacted to reduce per-request token consumption.
@@ -115,12 +131,10 @@ export type ConcreteTokenSavingTier = Exclude<TokenSavingTier, 'auto'>;
  * Normalize a TokenSavingTier value, handling backward-compatible boolean inputs.
  * - `true`  → 'medium' (existing behavior)
  * - `false` → 'off'
- * - `'auto'` → `'off'` — the `'auto'` sentinel is window-dependent, so EVERY
- *   consumer that isn't the prompt builder (tool selection, lazy-load gate, TUI
- *   display) must treat it as the safe no-op `'off'`: it must NOT reduce the
- *   registered tool set or enable lazy loading on its own. Only the prompt
- *   builder expands `'auto'` — via {@link resolveTokenSavingTier} — and only for
- *   the (cache-stable) prompt prose. This keeps auto-tiering capability-neutral.
+ * - `'auto'` → `'medium'` — consumers without model-window context use a stable,
+ *   useful development baseline instead of silently expanding to the full tool
+ *   catalog. The prompt builder may refine `'auto'` with
+ *   {@link resolveTokenSavingTier} when the model window is known.
  * - other valid strings are returned as-is; `undefined`/invalid → 'off'
  */
 export declare function normalizeTokenSavingTier(val?: TokenSavingTier | boolean): ConcreteTokenSavingTier;

package/dist/types/config/skills-fleet-brain.d.ts

@@ -18,9 +18,9 @@ export interface SkillsConfig {
     foreignSources?: boolean | string[] | undefined;
     /**
      * How skill bodies reach the system prompt.
-     * - `'eager'` (default): inject every discovered skill body into the prompt.
-     * - `'progressive'`: inject only the metadata manifest; the agent loads a
+     * - `'progressive'` (default): inject only the metadata manifest; the agent loads a
      *   skill body on demand via the `skill` tool (the agentskills.io model).
+     * - `'eager'`: inject discovered skill bodies up to `eagerMaxChars`.
      */
     mode?: 'eager' | 'progressive' | undefined;
     /**
@@ -203,8 +203,9 @@ export interface BrainCouncilConfig {
     approval?: number | undefined;
     /**
      * Per-seat completion timeout (ms). Defaults to `brain.decisionTimeoutMs`,
-     * then 15000 — set it when council seats need a longer budget than the
-     * single-LLM tier.
+     * then 45000 — the council convenes for high-stakes decisions only, and
+     * reasoning models often need well over the single-LLM tier's 15s before
+     * their first token.
      */
     perCallTimeoutMs?: number | undefined;
     /** Seats polled concurrently, 1..8. Default 3. */
@@ -216,6 +217,13 @@ export interface BrainCouncilConfig {
      * independence.
      */
     distinctness?: 'none' | 'model' | 'provider' | undefined;
+    /**
+     * Output budget per voter seat call. Default 2000. Reasoning models spend
+     * their thinking tokens from this same budget, so a small value starves
+     * them into `invalid` votes (empty or truncated JSON) — raise it if seat
+     * errors report "response truncated at maxTokens".
+     */
+    voterMaxTokens?: number | undefined;
     /** Output budget for the judge call. Default follows the seat budget. */
     judgeMaxTokens?: number | undefined;
     /**

package/dist/types/config/tools.d.ts

@@ -76,6 +76,22 @@ export interface ToolsConfig {
      * defaults (see DEFAULT_TOOLS_CONFIG.loopDetection).
      */
     loopDetection?: LoopDetectionConfig | undefined;
+    /**
+     * Opt-in `nextsteps` tool — a structured alternative to typing a
+     * `<nextsteps>` block into the final message. Both routes stay valid and
+     * produce identical results; the tool merely lets the schema enforce the
+     * shape. Disabled by default, so the prompt contract and every suggestion
+     * surface behave exactly as before unless the user turns it on.
+     *
+     * Registered for the leader only, and read at boot — a change takes effect
+     * in the next session (same as `features.tokenSavingMode`).
+     */
+    nextsteps?: NextStepsToolConfig | undefined;
+}
+/** Opt-in switch for the agent-callable `nextsteps` tool (`tools.nextsteps`). */
+export interface NextStepsToolConfig {
+    /** Register the tool for the leader agent. Default: false. */
+    enabled?: boolean | undefined;
 }
 /** Tuning for the agent-loop repetition detector (`tools.loopDetection`). */
 export interface LoopDetectionConfig {

package/dist/types/context-window.d.ts

@@ -29,6 +29,7 @@ export interface ContextWindowMode {
     thresholds: ContextWindowThresholds;
     aggressiveOn: ContextWindowAggressiveOn;
     preserveK: number;
+    /** Per-block elision baseline used to derive the bounded recent raw tool-I/O window. */
     eliseThreshold: number;
     targetLoad: number;
 }

package/dist/types/hooks.d.ts

@@ -69,6 +69,20 @@ export interface HookInput {
     toolName?: string | undefined;
     /** Tool arguments (PreToolUse / PostToolUse). */
     toolInput?: unknown | undefined;
+    /**
+     * The tool's declared capabilities (PreToolUse), so a policy hook can key on
+     * WHAT a tool does instead of what it is called.
+     *
+     * `matcher` is a list of tool names, which is the only vocabulary a hook had
+     * for "tools that write". `path-guard` matched `write|edit|bash|exec` and
+     * therefore never saw `patch`, `scaffold`, or any plugin- or MCP-registered
+     * writer — a protected path was guarded through four doors and open through
+     * the rest. Names cannot be enumerated ahead of a plugin that has not been
+     * written yet; capabilities can.
+     */
+    toolCapabilities?: readonly string[] | undefined;
+    /** The tool's `mutating` flag (PreToolUse). See `toolCapabilities`. */
+    toolMutating?: boolean | undefined;
     /** Tool result preview (PostToolUse only). */
     toolResult?: {
         content: string;

package/dist/types/index.d.ts

@@ -10,11 +10,11 @@ export type { SideEffect, SideEffectRisk } from './side-effect.js';
 export type { SecretScrubber } from './secret-scrubber.js';
 export type { FileEventRecord } from './file-event-record.js';
 export { ProviderError, classifyProviderError, effectiveInputTokens, isContextOverflowShaped, isFallbackWorthy, isRetryableKind } from './provider.js';
-export type { CacheTtl, Capabilities, JsonSchemaSpec, Provider, ProviderErrorBody, ProviderErrorKind, ReasoningConfig, ReasoningEffort, ReasoningRequest, Request, RequestCacheControl, Response, ResponseFormat, SafetySetting, StopReason, StreamEvent, Usage } from './provider.js';
+export type { CacheTtl, Capabilities, JsonSchemaSpec, Provider, ProviderContextLimit, ProviderErrorBody, ProviderErrorKind, ReasoningConfig, ReasoningEffort, ReasoningRequest, Request, RequestCacheControl, Response, ResponseFormat, SafetySetting, StopReason, StreamEvent, Usage } from './provider.js';
 export { StreamHangError } from './provider.js';
 export type { ProviderRunner, RunProviderOptions } from './provider-runner.js';
 export { DEFAULT_TUI_THINKING_WORD, FLEET_CHAT_VERBOSITY_VALUES, MAX_TUI_THINKING_WORD_LENGTH, normalizeTokenSavingTier, normalizeTuiThinkingWord, resolveFleetChatVerbosity, resolveTokenSavingTier } from './config.js';
-export type { AdaptiveConcurrencyConfig, AutonomyConfig, BrainConfig, BrainCouncilConfig, BrainCouncilVoterConfig, BrainModelEntry, CircuitBreakerRuntimeConfig, ConcreteTokenSavingTier, Config, ConfigLoader, ConfigStore, ContextConfig, CouncilPersonaDefinition, CouncilToolConfig, CouncilToolProfileDefinition, CustomModelDefinition, ExecDangerConfig, ExecToolConfig, FeaturesConfig, FleetChatVerbosity, FleetConfig, FleetSupervisorConfig, GitBehaviorConfig, HqClientConfig, IndexingConfig, InputHistoryConfig, LaunchConfig, LaunchMenuChoice, LogConfig, LoopDetectionConfig, MCPHealthConfig, MCPHealthThresholds, MCPServerConfig, ModelMatrixEntry, ModelRuntimeCacheConfig, ModelRuntimeConfig, ModelRuntimeParametersConfig, ModelRuntimeReasoningConfig, PluginConfig, PluginManagerConfig, ProviderApiKey, ProviderConfig, SageConfig, SessionLoggingConfig, SkillsConfig, SyncCategory, SyncConfig, TokenSavingTier, ToolDescriptionMode, ToolDescriptionModeConfig, ToolResultRenderMode, ToolResultRenderModeConfig, ToolsConfig } from './config.js';
+export type { AdaptiveConcurrencyConfig, AutonomyConfig, BrainConfig, BrainCouncilConfig, BrainCouncilVoterConfig, BrainModelEntry, CircuitBreakerRuntimeConfig, ConcreteTokenSavingTier, Config, ConfigLoader, ConfigStore, ContextConfig, CouncilPersonaDefinition, CouncilToolConfig, CouncilToolProfileDefinition, CustomModelDefinition, ExecDangerConfig, ExecToolConfig, FeaturesConfig, FleetChatVerbosity, FleetConfig, FleetSupervisorConfig, GitBehaviorConfig, HqClientConfig, IndexingConfig, InputHistoryConfig, LaunchConfig, LaunchMenuChoice, LogConfig, LoopDetectionConfig, MCPHealthConfig, MCPHealthThresholds, MCPServerConfig, ModelMatrixEntry, ModelRuntimeCacheConfig, ModelRuntimeConfig, ModelRuntimeParametersConfig, ModelRuntimeReasoningConfig, NextStepsToolConfig, PluginConfig, PluginManagerConfig, ProviderApiKey, ProviderConfig, SageConfig, SessionLoggingConfig, SkillsConfig, SyncCategory, SyncConfig, TokenSavingTier, ToolDescriptionMode, ToolDescriptionModeConfig, ToolResultRenderMode, ToolResultRenderModeConfig, ToolsConfig } from './config.js';
 export type { AnyHookOutcome, ConfiguredHook, HookEntry, HookEvent, HookFailurePolicy, HookInput, HookInvocationContext, HookMatcher, HookOutcome, HookRegistrationOptions, HttpHook, InProcessHook, PreToolUseOutcome, PreToolUseStage, ShellHook } from './hooks.js';
 export type { Compactor, CompactReport } from './compactor.js';
 export type { DirectoryPolicy, DirectoryRule, PermissionDecision, PermissionPolicy, PermissionTrace, PermissionTraceStep, TrustPolicy } from './permission.js';

package/dist/types/index.js

@@ -542,6 +542,7 @@ function resolveFleetChatVerbosity(autonomy) {
 function normalizeTokenSavingTier(val) {
   if (val === void 0) return "off";
   if (typeof val === "boolean") return val ? "medium" : "off";
+  if (val === "auto") return "medium";
   const validTiers = /* @__PURE__ */ new Set([
     "off",
     "minimal",

package/dist/types/multi-agent.d.ts

@@ -44,6 +44,8 @@ export interface SubagentConfig {
      * higher values fire closer to the deadline. Ignored when `timeoutMs` is unset.
      */
     preemptFraction?: number | undefined;
+    /** Stable capability ids resolved to the host's concrete tool surface. */
+    capabilities?: string[] | undefined;
     tools?: string[] | undefined;
     /**
      * Tools to explicitly disable for this subagent. These tools will be

package/dist/types/one-shot-llm.d.ts

@@ -161,5 +161,21 @@ export interface OneShotOrchestratorOptions {
      * fallback chain.
      */
     statusTracker?: import('../coordination/provider-status-tracker.js').ProviderModelStatusTracker | undefined;
+    /**
+     * The host's composed `wrapProviderRunner` chain, if it has one.
+     *
+     * The agent loop runs every provider call through
+     * `extensions.wrapProviderRunner(...)`; this orchestrator called
+     * `provider.complete()` directly, so `api.llm`, the `one_shot_llm` tool and
+     * the council each reached a third-party provider with the chain skipped.
+     * That chain is where `prompt-firewall` redacts credentials, where
+     * `llm-cache` short-circuits, where `model-router` re-routes and where the
+     * token budgeter throttles — none of which applied to a plugin's own
+     * completions.
+     *
+     * Optional because a host may have no extension registry (focused tests,
+     * minimal embeddings). Absent, behaviour is exactly as before.
+     */
+    wrapProviderCall?: ((request: import('./provider.js').Request, inner: (request: import('./provider.js').Request) => Promise<import('./provider.js').Response>) => Promise<import('./provider.js').Response>) | undefined;
 }
 //# sourceMappingURL=one-shot-llm.d.ts.map

package/dist/types/provider.d.ts

@@ -284,9 +284,25 @@ export type StreamEvent = {
     stopReason: StopReason;
     usage: Usage;
 };
+export interface ProviderContextLimit {
+    /** Provider-authoritative context ceiling for the selected route/model. */
+    maxContext: number;
+    /** Origin of the live value, surfaced in diagnostics and UI warnings. */
+    source: 'provider';
+}
 export interface Provider {
     readonly id: string;
     readonly capabilities: Capabilities;
+    /**
+     * Optional live capability probe. The agent calls this at request boundaries
+     * before context-window middleware runs, allowing a provider-side limit
+     * decrease to trigger compaction before the oversized request is sent.
+     * Implementations must fail open (return undefined) on transient discovery
+     * failures and retain their last verified value locally.
+     */
+    refreshContextLimit?(model: string, opts: {
+        signal: AbortSignal;
+    }): Promise<ProviderContextLimit | undefined>;
     /** Canonical streaming entry point. `complete()` defaults to a wrapper that
      * aggregates this stream — providers may override for non-streaming wires. */
     stream(req: Request, opts: {

package/dist/types/runtime-capability-manifest.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Stable runtime capabilities for roster agents and prompt contracts.
+ *
+ * Agent definitions refer to these capability ids; concrete tool names remain
+ * an implementation detail of the active host. Optional providers (MCP,
+ * browser automation, plugins) are represented by their stable gateway tools
+ * instead of server-specific names.
+ */
+export type RuntimeCapabilityPack = 'core' | 'development' | 'memory' | 'fleet' | 'browser' | 'mcp' | 'admin';
+export type RuntimeCapabilityExposure = 'direct' | 'on-demand' | 'internal';
+export interface RuntimeCapabilityDefinition {
+    id: string;
+    pack: RuntimeCapabilityPack;
+    exposure: RuntimeCapabilityExposure;
+    tools: readonly string[];
+    aliases?: Readonly<Record<string, string>> | undefined;
+}
+export declare const RUNTIME_CAPABILITY_MANIFEST: readonly [{
+    readonly id: 'filesystem.read';
+    readonly pack: 'core';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["read", "grep", "glob", "tree"];
+}, {
+    readonly id: 'code.inspect';
+    readonly pack: 'core';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["codebase-stats", "codebase-search", "codebase-incoming-calls", "codebase-outgoing-calls", "codebase-index", "dead-code-scan", "diff", "json", "logs"];
+}, {
+    readonly id: 'filesystem.write';
+    readonly pack: 'development';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["write", "edit", "replace", "patch"];
+}, {
+    readonly id: 'execution.shell';
+    readonly pack: 'development';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["bash", "exec", "language", "language_info", "language_package"];
+}, {
+    readonly id: 'verification.run';
+    readonly pack: 'development';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["lint", "format", "typecheck", "test", "e2e_plan"];
+}, {
+    readonly id: 'version-control.manage';
+    readonly pack: 'development';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["git"];
+}, {
+    readonly id: 'dependencies.manage';
+    readonly pack: 'development';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["install", "outdated", "audit"];
+}, {
+    readonly id: 'documentation.author';
+    readonly pack: 'development';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["document", "design", "scaffold"];
+}, {
+    readonly id: 'web.research';
+    readonly pack: 'core';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["search", "fetch"];
+}, {
+    readonly id: 'work.plan';
+    readonly pack: 'core';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["todo", "plan", "task", "kanban", "nextsteps"];
+}, {
+    readonly id: 'coordination.mailbox';
+    readonly pack: 'fleet';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["mailbox", "mail_send", "mail_inbox", "fleet_status"];
+}, {
+    readonly id: 'fleet.delegate';
+    readonly pack: 'fleet';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["delegate", "spawn_subagent", "assign_task", "kanban_queue", "await_tasks", "ask_subagent", "ask_result", "roll_up", "quality_gate", "terminate_subagent", "terminate_all", "work_complete", "collab_debug", "fleet_emit", "fleet"];
+}, {
+    readonly id: 'reasoning.oneshot';
+    readonly pack: 'core';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["llm", "council"];
+}, {
+    readonly id: 'memory.manage';
+    readonly pack: 'memory';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["remember", "search_memory", "find_related_memories", "forget"];
+}, {
+    readonly id: 'memory.curate';
+    readonly pack: 'memory';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["memory_candidates", "memory_update", "memory_delete", "memory_recover", "memory_backfill_recoverable", "memory_for_file", "memory_for_path", "memory_search", "memory_graph", "memory_gather_batch", "memory_verify", "memory_hygiene"];
+}, {
+    readonly id: 'browser.interact';
+    readonly pack: 'browser';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["browser_open", "browser_status", "browser_list", "browser_navigate", "browser_snapshot", "browser_screenshot", "browser_click", "browser_type", "browser_select", "browser_press", "browser_hover", "browser_drag", "browser_wait", "browser_evaluate", "browser_upload", "browser_close"];
+    readonly aliases: {
+        readonly playwright_navigate: 'browser_navigate';
+        readonly playwright_screenshot: 'browser_screenshot';
+        readonly playwright_click: 'browser_click';
+        readonly playwright_type: 'browser_type';
+        readonly playwright_evaluate: 'browser_evaluate';
+        readonly playwright_select_option: 'browser_select';
+        readonly playwright_hover: 'browser_hover';
+        readonly playwright_fill_form: 'browser_type';
+        readonly playwright_wait_for: 'browser_wait';
+        readonly playwright_press_key: 'browser_press';
+        readonly playwright_drag: 'browser_drag';
+    };
+}, {
+    readonly id: 'mcp.dynamic';
+    readonly pack: 'mcp';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["mcp_use"];
+}, {
+    readonly id: 'automation.manage';
+    readonly pack: 'admin';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["cron_schedule", "cron_list", "cron_cancel", "watch_start", "watch_list", "watch_stop"];
+}, {
+    readonly id: 'context.pin';
+    readonly pack: 'admin';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["pin_add", "pin_list", "pin_remove"];
+}, {
+    readonly id: 'quality.analyze';
+    readonly pack: 'development';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["dead_code_scan", "detect_duplicate_code", "secret_scanner_test", "error_lens_history"];
+}, {
+    readonly id: 'release.manage';
+    readonly pack: 'development';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["git_autocommit", "semver_current", "semver_bump", "semver_changelog"];
+}, {
+    readonly id: 'messaging.telegram';
+    readonly pack: 'fleet';
+    readonly exposure: 'on-demand';
+    readonly tools: readonly ["telegram_send", "telegram_read", "telegram_approve"];
+}, {
+    readonly id: 'tools.discover';
+    readonly pack: 'admin';
+    readonly exposure: 'direct';
+    readonly tools: readonly ["tool_search", "tool_use", "tool_help", "batch_tool_use"];
+}, {
+    readonly id: 'runtime.admin';
+    readonly pack: 'admin';
+    readonly exposure: 'internal';
+    readonly tools: readonly ["set_working_dir", "context_manager", "mode", "skill", "mcp_control"];
+}];
+export type RuntimeCapabilityId = (typeof RUNTIME_CAPABILITY_MANIFEST)[number]['id'];
+export declare function toolsForRuntimeCapabilities(capabilityIds: readonly RuntimeCapabilityId[]): string[];
+export declare function normalizeRuntimeToolName(name: string): string;
+export declare function runtimeCapabilityForTool(name: string): RuntimeCapabilityId | undefined;
+export declare function isKnownRuntimeCapability(id: string): id is RuntimeCapabilityId;
+export declare function inferRuntimeCapabilities(toolNames: readonly string[]): RuntimeCapabilityId[];
+export declare function missingRuntimeCapabilities(required: readonly string[] | undefined, toolNames: readonly string[]): string[];
+export declare function missingRequiredRuntimeTools(required: readonly string[] | undefined, toolNames: readonly string[]): string[];
+/**
+ * Extract tool-shaped references from skill/instruction prose. Canonical names
+ * are recognized anywhere inside inline code. Unknown names are included only
+ * when the prose presents them imperatively or explicitly calls them a tool,
+ * avoiding false positives for ordinary APIs and config fields.
+ */
+export declare function runtimeToolReferencesFromText(text: string): string[];
+export declare function isDeprecatedRuntimeToolAlias(name: string): boolean;
+//# sourceMappingURL=runtime-capability-manifest.d.ts.map

package/dist/types/skill.d.ts

@@ -19,6 +19,11 @@ export interface SkillManifest {
      * grants nor restricts any tool.
      */
     allowedTools?: string[] | undefined;
+    /** Stable WrongStack runtime capabilities required to activate this skill. */
+    requiredCapabilities?: string[] | undefined;
+    requiredTools?: string[] | undefined;
+    /** Optional capabilities; the skill must remain useful when these are absent. */
+    optionalCapabilities?: string[] | undefined;
     path: string;
     /**
      * Discovery layer the skill came from. `claude-*`, `foreign`, and `extra` are

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

@@ -1,6 +1,6 @@
+import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
 import type { TextBlock } from './blocks.js';
 import type { Tool } from './tool.js';
-import type { MailboxAgentStatus } from '../coordination/mailbox-types.js';
 /** Model capabilities relevant to prompt composition. */
 export interface ModelCapabilities {
     maxContextTokens: number;
@@ -12,6 +12,8 @@ export interface BuildContext {
     cwd: string;
     projectRoot: string;
     tools: Tool[];
+    /** Complete enabled catalog, including tools reachable only through lazy gateways. */
+    catalogTools?: Tool[] | undefined;
     /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
     provider?: string | undefined;
     /** Model id (e.g. "configured-model", "MiniMax-M2.7"). */

package/dist/types/tool-executor.d.ts

@@ -102,6 +102,10 @@ export interface ToolConfirmPendingResult {
     toolUseId: string;
     toolName: string;
     input: unknown;
+    preToolContext?: {
+        text: string;
+        contextAs: 'inline' | 'separate';
+    } | undefined;
     suggestedPattern: string;
     decisionSource?: import('./permission.js').PermissionDecision['source'] | undefined;
     riskTier?: import('./tool.js').RiskTier | undefined;
@@ -139,7 +143,10 @@ export interface ToolExecutorLike {
      * `bytes` from the running budget — no second `Buffer.byteLength`
      * walk, and no `JSON.stringify` fallback for structured results.
      */
-    executeTool(tool: Tool, use: ToolUseBlock, ctx: import('../core/context.js').Context, budget: number): Promise<{
+    executeTool(tool: Tool, use: ToolUseBlock, ctx: import('../core/context.js').Context, budget: number, preToolContext?: {
+        text: string;
+        contextAs: 'inline' | 'separate';
+    }): Promise<{
         block: ToolResultBlock;
         bytes: number;
     }>;

package/dist/utils/context-breakdown.d.ts

@@ -1,5 +1,5 @@
-import { type SystemBlockSource } from '../core/system-prompt-builder.js';
 import type { Context } from '../core/context.js';
+import { type SystemBlockSource } from '../core/system-prompt-builder.js';
 /**
  * Real, per-category token accounting for the live context window — the data
  * behind an honest `/context` display. Every number is measured from the actual
@@ -25,10 +25,16 @@ export interface ContextBreakdown {
     };
     history: {
         total: number;
-        /** User/assistant text + tool_use inputs + thinking. */
+        /** User/assistant/system text only. */
         text: number;
+        /** Serialized tool_use arguments. Optional for backward-compatible UI snapshots. */
+        toolInputs?: number | undefined;
         /** tool_result output content. */
         toolResults: number;
+        /** Preserved provider reasoning/thinking blocks. */
+        thinking?: number | undefined;
+        /** Images and future/unknown content block kinds. */
+        other?: number | undefined;
         messageCount: number;
     };
     volatile: {

package/dist/utils/index.d.ts

@@ -32,7 +32,7 @@ export { getPerfProfile, indexParallelBatchSize, isFrugalPerf, type PerfProfile,
 export { isPidAlive } from './pid.js';
 export * from './project-identity.js';
 export { type ProjectWatchEvent, type ProjectWatchSubscription, watchProjectTree, } from './project-watch.js';
-export { type CompileFail, type CompileResult, compileUserRegex } from './regex-guard.js';
+export { capSubject, type CompileFail, type CompileResult, compileUserRegex, MAX_SUBJECT_LEN, } from './regex-guard.js';
 export * from './safe-json.js';
 export { sessionScopedPath } from './session-scoped-path.js';
 export * from './sleep.js';