@wrongstack/core 0.299.0 → 0.300.0

package/dist/kernel/events/brain-events.d.ts

@@ -264,6 +264,15 @@ export interface BrainEventMap {
         completed: number;
         /** Optional fleet-wide cost total (USD) — set by the host bridge when known. */
         totalCostUsd?: number | undefined;
+        /** Concurrent-subagent ceiling (issue #323). */
+        maxConcurrent?: number | undefined;
+        /** Lifetime spawn budget snapshot (issue #323). */
+        maxSpawns?: number | undefined;
+        usedSpawns?: number | undefined;
+        remainingSpawns?: number | undefined;
+        effectiveSource?: string | undefined;
+        checkpointMaxSpawns?: number | undefined;
+        ceilingMismatch?: boolean | undefined;
         subagentStatuses: {
             subagentId: string;
             taskId: string;

package/dist/kernel/events/provider-events.d.ts

@@ -160,6 +160,8 @@ export interface ProviderEventMap {
         };
         status: number;
         providerSwitched: boolean;
+        /** Gate correlation id — set when a fallback gate mediated the switch. */
+        requestId?: string | undefined;
         contextWindowWarning?: {
             fromMaxContext: number;
             toMaxContext: number;
@@ -167,7 +169,33 @@ export interface ProviderEventMap {
         } | undefined;
     };
     /**
-     * Fired whenever a (providerId, model) pair transitions between
+     * Fired by the fallback gate function (supplied to the fallback-model
+     * extension via `FallbackModelDeps.fallbackGate`) when the chain is about
+     * to engage, BEFORE attempting any fallback entry. Carries the full
+     * candidate list so the UI can show a modal with a countdown and manual
+     * pick. The gate waits for a `provider.fallback_choice` event bus emission
+     * (or the countdown timer) before proceeding with the chosen model or
+     * auto-switching to the next candidate.
+     */
+    'provider.fallback_pending': {
+        sessionId?: string | undefined;
+        from: {
+            providerId: string;
+            model: string;
+        };
+        status: number;
+        candidates: Array<{
+            providerId: string;
+            model: string;
+        }>;
+        /** Seconds the UI should count down before auto-switching to the next model. */
+        autoSwitchSeconds: number;
+        /** Unique request id — the UI echoes this back in the choice message. */
+        requestId: string;
+        timestamp: number;
+    };
+    /**
+     * Fired when a (providerId, model) pair transitions between
      * healthy/degraded/blocked states. The tracker emits this so the
      * CLI/TUI/WebUI can render a live status indicator.
      */
@@ -180,6 +208,19 @@ export interface ProviderEventMap {
         timestamp: number;
         stateExpiresAt?: number | undefined;
     };
+    /**
+     * Fired by the UI when the user manually picks a model from the
+     * fallback modal. The fallback gate listens for this event (matched
+     * by `requestId`) to resolve with the chosen model instead of waiting
+     * for the countdown.
+     */
+    'provider.fallback_choice': {
+        requestId: string;
+        providerId?: string | undefined;
+        model?: string | undefined;
+        /** When true, auto-switch to the next candidate (countdown expired or Esc). */
+        autoSwitch?: boolean | undefined;
+    };
     /**
      * Fired when the agent's actively selected (primary, not fallback)
      * provider/model is blocked and will be skipped. The CLI/TUI should

package/dist/models/index.js

@@ -584,7 +584,7 @@ var DefaultModelsRegistry = class {
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
     if (this.seed) {
-      this.payload = this.seed;
+      this.payload = this.withExtraOverlay(this.seed);
       this.fetchedAt = /* @__PURE__ */ new Date();
       return this.payload;
     }

package/dist/plugin/api.d.ts

@@ -7,9 +7,11 @@ import type { ProviderRegistry } from '../registry/provider-registry.js';
 import type { SlashCommandRegistry } from '../registry/slash-command-registry.js';
 import type { ToolRegistry } from '../registry/tool-registry.js';
 import type { Config } from '../types/config.js';
+import type { CouncilQuestion, CouncilResult } from '../types/council.js';
 import type { HookEvent, HookMatcher, InProcessHook } from '../types/hooks.js';
 import type { Logger } from '../types/logger.js';
 import type { ModelsRegistry } from '../types/models-registry.js';
+import type { OneShotLLMInput, OneShotLLMResult } from '../types/one-shot-llm.js';
 import type { MCPRegistryView, MetricsSinkView, Notifier, PluginAPI, PluginCapabilities, PluginDependency, PluginLLM, PluginPipelines, ProviderRegistryView, SessionWriterView, SlashCommandRegistryView, ToolRegistryView } from '../types/plugin.js';
 import type { Provider } from '../types/provider.js';
 import type { SystemPromptContributor } from '../types/system-prompt-contributor.js';
@@ -91,6 +93,10 @@ export interface PluginAPIInit {
         getProvider?: (() => Provider) | undefined;
         getModel?: (() => string) | undefined;
         createProvider?: ((name: string, model?: string) => Provider) | undefined;
+        /** Preferred production path: shared One Shot runtime with fallbacks. */
+        oneShot?: ((input: OneShotLLMInput) => Promise<OneShotLLMResult>) | undefined;
+        /** Optional shared multi-model Council runtime. */
+        council?: ((question: CouncilQuestion) => Promise<CouncilResult>) | undefined;
     } | undefined;
     config: Config;
     /**

package/dist/plugin/config.d.ts

@@ -28,6 +28,61 @@ export interface PluginConfigChange {
  * beat aliases, making migrations deterministic regardless of object order.
  */
 export declare function resolvePluginConfig(input: ResolvePluginConfigInput): ResolvedPluginConfig;
+/**
+ * Default `config.plugins` name matcher: the canonical name, a declared
+ * alias, or the `@wrongstack/plugins/<name>` subpath spelling of either.
+ *
+ * Surfaces that know more pass their own `matches` — the loader has an alias
+ * table (`lsp` → `@wrongstack/plug-lsp`), the CLI folds `telegram` and
+ * `@wrongstack/telegram` into one row. This is the floor, not the ceiling.
+ */
+export declare function pluginEntryMatchesName(configuredName: string, name: string, aliases?: readonly string[]): boolean;
+export type PluginEnablementSource = 'feature-flag' | 'plugin-entry' | 'extension' | 'default';
+export interface ResolvedPluginEnablement {
+    enabled: boolean;
+    source: PluginEnablementSource;
+}
+export interface ResolvePluginEnablementInput {
+    name: string;
+    aliases?: readonly string[] | undefined;
+    /**
+     * `'active'` — runs unless something turns it off.
+     * `'inactive'` — runs only when something explicitly turns it on.
+     * Omitted behaves like `'inactive'`.
+     */
+    defaultState?: 'active' | 'inactive' | undefined;
+    config?: (Partial<Pick<Config, 'plugins' | 'extensions'>> & {
+        features?: Partial<Config['features']> | undefined;
+    }) | undefined;
+    /**
+     * Overrides how a `config.plugins` entry name is matched against this
+     * plugin. Surfaces normalize specs differently (the loader maps
+     * `@wrongstack/plugins/foo` → `foo`, the CLI treats `telegram` and
+     * `@wrongstack/telegram` as one row), so matching is per-surface —
+     * only the PRECEDENCE below is shared. Defaults to name/alias equality.
+     */
+    matches?: ((configuredName: string) => boolean) | undefined;
+}
+/**
+ * Resolve whether a plugin boots, under ONE precedence shared by every
+ * surface that reports or acts on plugin state:
+ *
+ *   1. `features.plugins === false` — kills every plugin.
+ *   2. a matching `config.plugins` entry — `{ enabled: false }` is off,
+ *      anything else is on. This is what `wstack plugin enable|disable`
+ *      writes, so it stays the highest per-plugin authority.
+ *   3. `config.extensions[name].enabled`, when it is a boolean — the
+ *      plugin's own master switch.
+ *   4. the catalog `defaultState`.
+ *
+ * Rule 3 used to be read only by the loader, and only in its `=== true`
+ * direction: a plugin switched on via `extensions` ran while every
+ * reporting surface — which looked at `config.plugins` alone — called it
+ * disabled, and `extensions[name].enabled = false` turned nothing off.
+ * Both directions now resolve here, so "what runs" and "what the report
+ * says" cannot drift apart again.
+ */
+export declare function resolvePluginEnablement(input: ResolvePluginEnablementInput): ResolvedPluginEnablement;
 export declare function resolvePluginManifestConfig(plugin: Pick<Plugin, 'name' | 'configAliases' | 'defaultConfig'>, config?: ResolvePluginConfigInput['config'], explicitOptions?: Readonly<Record<string, unknown>>): ResolvedPluginConfig;
 /** Unknown fields are immutable by default so a new option cannot silently hot-reload. */
 export declare function diffPluginConfig(previous: Readonly<Record<string, unknown>>, next: Readonly<Record<string, unknown>>, fields: Readonly<Record<string, PluginConfigFieldMetadata>>): PluginConfigChange[];

package/dist/plugin/index.d.ts

@@ -1,5 +1,5 @@
 export { DefaultPluginAPI, definePlugin, type PluginAPIInit } from './api.js';
-export { diffPluginConfig, type PluginConfigChange, type PluginConfigSource, type ResolvePluginConfigInput, type ResolvedPluginConfig, redactPluginConfig, resolvePluginConfig, resolvePluginManifestConfig, validatePluginConfigMetadata, } from './config.js';
+export { diffPluginConfig, type PluginConfigChange, type PluginConfigSource, type PluginEnablementSource, pluginEntryMatchesName, type ResolvePluginConfigInput, type ResolvePluginEnablementInput, type ResolvedPluginConfig, type ResolvedPluginEnablement, redactPluginConfig, resolvePluginConfig, resolvePluginEnablement, resolvePluginManifestConfig, validatePluginConfigMetadata, } from './config.js';
 export { KERNEL_API_VERSION, loadPlugins, type LoadPluginsOptions, type PluginHostHandle, type PluginLoadFailure, unloadPlugins, } from './loader.js';
 export type { PluginAPI } from '../types/plugin.js';
 export { buildReviewerModelPool, createAutoReviewPlugin, parseReviewSeverity, type ReviewerModelAssignment, selectRoundRobinReviewerAssignment, } from '../plugins/auto-review-plugin.js';

package/dist/plugin/index.js

@@ -1275,6 +1275,36 @@ function resolvePluginConfig(input) {
   merge(input.explicitOptions, "explicit-options");
   return { options, configured, sources };
 }
+function pluginEntryMatchesName(configuredName, name, aliases = []) {
+  for (const candidate of [name, ...aliases]) {
+    if (configuredName === candidate) return true;
+    if (configuredName === `@wrongstack/plugins/${candidate}`) return true;
+  }
+  return false;
+}
+function resolvePluginEnablement(input) {
+  if (input.config?.features?.plugins === false) {
+    return { enabled: false, source: "feature-flag" };
+  }
+  const names = [.../* @__PURE__ */ new Set([input.name, ...input.aliases ?? []])];
+  const matches2 = input.matches ?? ((configuredName) => pluginEntryMatchesName(configuredName, input.name, input.aliases ?? []));
+  const plugins = input.config?.plugins;
+  if (Array.isArray(plugins)) {
+    for (const candidate of plugins) {
+      if (typeof candidate === "string") {
+        if (matches2(candidate)) return { enabled: true, source: "plugin-entry" };
+        continue;
+      }
+      if (!isPluginEntry(candidate) || !matches2(candidate.name)) continue;
+      return { enabled: candidate.enabled !== false, source: "plugin-entry" };
+    }
+  }
+  for (const name of names) {
+    const enabled = input.config?.extensions?.[name]?.["enabled"];
+    if (typeof enabled === "boolean") return { enabled, source: "extension" };
+  }
+  return { enabled: input.defaultState === "active", source: "default" };
+}
 function resolvePluginManifestConfig(plugin, config, explicitOptions) {
   return resolvePluginConfig({
     name: plugin.name,
@@ -1740,11 +1770,12 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
   const wrappedLlm = caps.llm !== false || !api.llm ? api.llm : new Proxy(api.llm, {
     get(target, prop, receiver) {
-      if (prop === "complete") {
+      if (prop === "complete" || prop === "council") {
         return (prompt, options) => {
-          violate("llm", `complete(${prompt.length} chars)`);
-          const complete = target.complete;
-          return options === void 0 ? complete(prompt) : complete(prompt, options);
+          violate("llm", `${String(prop)}(${prompt.length} chars)`);
+          const method = target[prop];
+          if (!method) return void 0;
+          return options === void 0 ? method.call(target, prompt) : method.call(target, prompt, options);
         };
       }
       return Reflect.get(target, prop, receiver);
@@ -1973,6 +2004,8 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
   const currentModel = () => hostLLM.getModel?.() ?? hostLLM.model;
   const DEFAULT_MAX_TOKENS = 2048;
   const HARD_MAX_TOKENS = 32768;
+  const DEFAULT_TIMEOUT_MS = 3e4;
+  const HARD_TIMEOUT_MS = 12e4;
   const pluginDefaults = () => {
     const extensions = currentConfig().extensions;
     const raw = extensions?.[owner]?.["llm"];
@@ -1982,7 +2015,11 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
       ...typeof r["provider"] === "string" && r["provider"] ? { provider: r["provider"] } : {},
       ...typeof r["model"] === "string" && r["model"] ? { model: r["model"] } : {},
       ...typeof r["maxTokens"] === "number" ? { maxTokens: r["maxTokens"] } : {},
-      ...typeof r["temperature"] === "number" ? { temperature: r["temperature"] } : {}
+      ...typeof r["temperature"] === "number" ? { temperature: r["temperature"] } : {},
+      ...typeof r["role"] === "string" && r["role"] ? { role: r["role"] } : {},
+      ...Array.isArray(r["fallbackModels"]) && r["fallbackModels"].every((v) => typeof v === "string") ? { fallbackModels: [...r["fallbackModels"]] } : {},
+      ...typeof r["timeoutMs"] === "number" ? { timeoutMs: r["timeoutMs"] } : {},
+      ...typeof r["councilProfile"] === "string" && r["councilProfile"] ? { councilProfile: r["councilProfile"] } : {}
     };
   };
   const resolveProvider = (name, model) => {
@@ -2019,7 +2056,7 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
     providerCache.set(cacheKey, created);
     return { provider: created, providerName };
   };
-  return {
+  const pluginLlm = {
     defaults() {
       const d = pluginDefaults();
       return {
@@ -2030,12 +2067,49 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
     async complete(prompt, opts) {
       const defaults = pluginDefaults();
       const model = opts?.model ?? defaults.model ?? currentModel();
-      const { provider, providerName } = resolveProvider(opts?.provider, model);
+      const providerName = opts?.provider ?? defaults.provider ?? currentProvider().id;
       const maxTokens = Math.min(
         HARD_MAX_TOKENS,
         opts?.maxTokens ?? defaults.maxTokens ?? DEFAULT_MAX_TOKENS
       );
       const temperature = opts?.temperature ?? defaults.temperature;
+      const timeoutMs = Math.min(
+        HARD_TIMEOUT_MS,
+        Math.max(1, opts?.timeoutMs ?? defaults.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+      );
+      if (hostLLM.oneShot) {
+        metrics.counter("llm.calls", 1, { provider: providerName, model, engine: "one-shot" });
+        const result = await hostLLM.oneShot({
+          userPrompt: prompt,
+          providerId: providerName,
+          model,
+          maxTokens,
+          timeoutMs,
+          ...temperature !== void 0 ? { temperature } : {},
+          ...opts?.system ? { system: opts.system } : {},
+          ...opts?.responseFormat === "json" ? { responseFormat: { type: "json_object" } } : {},
+          ...opts?.signal ? { signal: opts.signal } : {},
+          ...opts?.role ?? defaults.role ? { role: opts?.role ?? defaults.role } : {},
+          ...opts?.fallbackModels ?? defaults.fallbackModels ? { fallbackModels: [...opts?.fallbackModels ?? defaults.fallbackModels ?? []] } : {}
+        });
+        if (result.error) {
+          metrics.counter("llm.errors", 1, { provider: result.provider, model: result.model });
+          throw new Error(result.error);
+        }
+        metrics.counter("llm.tokens_in", result.tokens.input);
+        metrics.counter("llm.tokens_out", result.tokens.output);
+        return {
+          text: result.text,
+          model: result.model,
+          provider: result.provider,
+          usage: { input: result.tokens.input, output: result.tokens.output },
+          stopReason: result.stopReason ?? "end_turn",
+          fromFallback: result.fromFallback,
+          attempts: result.attempts,
+          durationMs: result.durationMs
+        };
+      }
+      const { provider } = resolveProvider(providerName, model);
       const request = {
         model,
         messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
@@ -2044,7 +2118,8 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
         ...opts?.system ? { system: [{ type: "text", text: opts.system }] } : {},
         ...opts?.responseFormat === "json" ? { responseFormat: { type: "json_object" } } : {}
       };
-      const signal = opts?.signal ?? new AbortController().signal;
+      const timeoutSignal = AbortSignal.timeout(timeoutMs);
+      const signal = opts?.signal ? AbortSignal.any([opts.signal, timeoutSignal]) : timeoutSignal;
       metrics.counter("llm.calls", 1, { provider: providerName, model });
       try {
         const response = await provider.complete(request, { signal });
@@ -2069,6 +2144,33 @@ function makePluginLLM(owner, hostLLM, providerRegistry, config, getLiveConfig,
       }
     }
   };
+  const council = hostLLM.council;
+  if (council) {
+    pluginLlm.council = async (question, opts) => {
+      const trimmed = question.trim();
+      if (!trimmed) throw new Error("Plugin Council question must not be empty.");
+      if (trimmed.length > 2e4) {
+        throw new Error("Plugin Council question must not exceed 20000 characters.");
+      }
+      if ((opts?.context?.length ?? 0) > 8e4) {
+        throw new Error("Plugin Council context must not exceed 80000 characters.");
+      }
+      const defaults = pluginDefaults();
+      metrics.counter("llm.council.calls", 1, { plugin: owner });
+      const result = await council({
+        question: trimmed,
+        ...opts?.context ? { context: opts.context } : {},
+        ...opts?.options ? { options: opts.options } : {},
+        ...opts?.profile ?? defaults.councilProfile ? { profile: opts?.profile ?? defaults.councilProfile } : {},
+        ...opts?.signal ? { signal: opts.signal } : {}
+      });
+      metrics.counter("llm.tokens_in", result.usage.inputTokens);
+      metrics.counter("llm.tokens_out", result.usage.outputTokens);
+      if (result.status === "failed") metrics.counter("llm.errors", 1, { provider: "council" });
+      return result;
+    };
+  }
+  return pluginLlm;
 }
 function scopedMetrics(sink, pluginName) {
   const prefix = `plugin.${pluginName}.`;
@@ -8958,7 +9060,7 @@ function createPromptsPlugin(opts) {
     version: "1.0.0",
     description: "Prompt library with 100+ builtin prompts, search, and AI authoring",
     apiVersion: "^0.1",
-    capabilities: { slashCommands: true },
+    capabilities: { slashCommands: true, llm: true },
     defaultConfig: {},
     setup(api) {
       const rawConfig = api.config;
@@ -8969,7 +9071,7 @@ function createPromptsPlugin(opts) {
         bundledDir: rawConfig["bundledPromptsDir"]
       }) : null);
       usage = opts?.usage ?? (paths ? new PromptUsageStore(paths.promptUsage) : null);
-      api.slashCommands.register(buildPromptsCommand(() => store, () => loader));
+      api.slashCommands.register(buildPromptsCommand(() => store, () => loader, () => api.llm));
       api.slashCommands.register(buildPromptSearchCommand(() => loader, () => usage));
       api.slashCommands.register(buildPromptGenCommand(() => loader));
       api.log.info("[prompts] loaded \u2014 /prompts, /prompt, /prompt-gen available");
@@ -8985,7 +9087,7 @@ function createPromptsPlugin(opts) {
     }
   };
 }
-function buildPromptsCommand(getStore, getLoader) {
+function buildPromptsCommand(getStore, getLoader, getLlm) {
   return {
     name: "prompts",
     description: "Manage your prompt library: /prompts [list|view|add|edit|delete|favorite|extend]",
@@ -9080,16 +9182,25 @@ ${lines.join("\n")}
           const matches2 = await store.find(parsed.title);
           if (matches2.length === 0) return { message: `No prompt matching "${parsed.title}".` };
           const exact = matches2.find((m) => m.title.toLowerCase() === parsed.title?.toLowerCase()) ?? expectDefined(matches2[0]);
-          const prov = ctx.provider;
-          if (!prov?.complete) return { message: "LLM not available. Configure a provider first." };
-          const enhanced = await prov.complete(
-            ctx.model,
-            renderInstructionTemplate(readBundledInstructionText("llm/prompt-extend.md"), {
-              existingPrompt: exact.content,
-              additionalInstructions: parsed.content
-            })
-          );
-          exact.content = enhanced.trim();
+          const llm = getLlm();
+          if (!llm) return { message: "LLM not available. Configure a provider first." };
+          let enhanced;
+          try {
+            enhanced = await llm.complete(
+              renderInstructionTemplate(readBundledInstructionText("llm/prompt-extend.md"), {
+                existingPrompt: exact.content,
+                additionalInstructions: parsed.content
+              }),
+              {
+                system: "You improve reusable prompts while preserving their intent and variables.",
+                role: "prompt-refiner",
+                maxTokens: 2048
+              }
+            );
+          } catch {
+            return { message: "LLM enhancement failed. The saved prompt was not changed." };
+          }
+          exact.content = enhanced.text.trim();
           exact.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
           await store.save(exact);
           getLoader()?.invalidateCache();
@@ -11973,10 +12084,12 @@ export {
   parseChimeraReviewReport,
   parseReviewSeverity,
   persistReviewReport,
+  pluginEntryMatchesName,
   recordCompletedReview,
   recordStartedReview,
   redactPluginConfig,
   resolvePluginConfig,
+  resolvePluginEnablement,
   resolvePluginManifestConfig,
   selectRoundRobinReviewerAssignment,
   unloadPlugins,

package/dist/security/index.d.ts

@@ -10,7 +10,7 @@ export { AutoApprovePermissionPolicy, alwaysAllowUnavailableReason, DefaultPermi
 export { TRUST_POLICY_JSON_SCHEMA, TRUST_POLICY_LIMITS, TRUST_POLICY_SCHEMA_VERSION, type TrustPolicyDiagnostic, type TrustPolicyDiagnosticCode, type TrustPolicyValidationResult, validateTrustPolicy, } from './permission-policy-schema.js';
 export { ReadOnlyPermissionPolicy } from './readonly-permission-policy.js';
 export { DefaultSecretScrubber } from './secret-scrubber.js';
-export { base32Decode, base32Encode, buildOtpAuthUri, generateRecoveryCodes, generateTotpSecret, generateTotp, hashRecoveryCode, verifyRecoveryCode, verifyTotp, } from './totp.js';
+export { base32Decode, base32Encode, buildOtpAuthUri, generateRecoveryCodes, generateTotpSecret, generateTotp, hashRecoveryCode, verifyRecoveryCode, verifyTotp, verifyTotpCounter, } from './totp.js';
 export { DefaultSecretVault, migratePlaintextSecrets, rewriteConfigEncrypted, rotateConfigKeys, type SecretVaultOptions, } from './secret-vault.js';
 export type { CompatibilityTrustBoundaryOptions, TrustActor, TrustActorKind, TrustAllowDecision, TrustAttribute, TrustAuthContext, TrustAuthMethod, TrustBoundary, TrustBoundaryAuditEntry, TrustBoundaryDecision, TrustBoundaryRequest, TrustConfirmDecision, TrustDecodeIssue, TrustDecodeResult, TrustDenyDecision, TrustRisk, TrustScope, TrustScopedTokenDecision, TrustSubject, TrustSurface, } from './trust-boundary.js';
 export { createCompatibilityTrustBoundary, decodeTrustBoundaryDecision, decodeTrustBoundaryRequest, isTrustDecisionAllowed, TRUST_BOUNDARY_VERSION, } from './trust-boundary.js';