@wrongstack/cli 0.299.0 → 0.300.0

package/dist/{acp-S4LZQB66.js → acp-IDNS2YVE.js}

@@ -3,8 +3,8 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-4HH3YGG4.js";
-import "./chunk-GO3TJICK.js";
+} from "./chunk-MRLYDHQ7.js";
+import "./chunk-PYTFS4MC.js";
 import "./chunk-PJHET45A.js";
 import "./chunk-7OCVIDC7.js";
 
@@ -889,4 +889,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-S4LZQB66.js.map
+//# sourceMappingURL=acp-IDNS2YVE.js.map

package/dist/{auth-G5YKKSRH.js → auth-6T6ZOT2R.js}

@@ -13,12 +13,12 @@ import {
   runOAuthLoginKind,
   runOAuthLoginMenu,
   validateFamily
-} from "./chunk-L5CE52XW.js";
+} from "./chunk-V76R7DC5.js";
 import {
   parseAuthFlags
-} from "./chunk-ZNZJ34RF.js";
-import "./chunk-66T43Q4Y.js";
-import "./chunk-GO3TJICK.js";
+} from "./chunk-PEMN4T5O.js";
+import "./chunk-N7ULWBO5.js";
+import "./chunk-PYTFS4MC.js";
 import {
   loadConfigProviders,
   maskedKey,
@@ -501,4 +501,4 @@ async function runAuthRemove(deps, providerId) {
 export {
   authCmd
 };
-//# sourceMappingURL=auth-G5YKKSRH.js.map
+//# sourceMappingURL=auth-6T6ZOT2R.js.map

package/dist/auth-menu/loopback-server.d.ts

@@ -1,40 +1,29 @@
 /**
- * Shared loopback OAuth server — HTTP callback listener for OAuth flows.
+ * Terminal-side adapter for the OAuth loopback callback server.
  *
- * Both the Codex ("Sign in with ChatGPT") and Anthropic ("Sign in with Claude")
- * OAuth flows start a local HTTP server on a loopback port to receive the
- * authorization code redirect from the provider's browser flow. Before this
- * module existed, each flow duplicated:
+ * The server itself — HTTP listener, port fallback, `state` validation, the
+ * static callback page and its CSP/anti-framing headers, abort handling — lives
+ * in `@wrongstack/providers/oauth`. This file used to carry a second, complete
+ * implementation of all of it.
  *
- *   - `escapeHtml` / `callbackHtml` — render success/error HTML pages
- *   - `openBrowser` — best-effort platform browser opener
- *   - `startLoopbackServer` — HTTP server with port fallback, abort handling,
- *     state validation, and callback URL parsing
+ * The copies were not identical, and the difference mattered: this one
+ * registered its abort listener with `{ once: true }` and never removed it, so
+ * every completed login leaked a listener on the caller's long-lived
+ * AbortSignal (the TUI hands the same signal to each attempt). The providers
+ * copy had the `detachAbort` cleanup. Neither file had any way to notice the
+ * other had drifted.
  *
- * Usage:
- * ```ts
- * import { startLoopbackServer, callbackHtml, openBrowser } from './loopback-server.js';
+ * What legitimately stays here is {@link openBrowser}: spawning the platform
+ * browser is terminal-only behaviour, and the headless WebUI flows deliberately
+ * hand the authorize URL to the client instead of opening anything.
  *
- * const server = await startLoopbackServer(state, [1455, 1457], signal);
- * const code = await server.waitForCode();
- * ```
+ * The positional signature below is preserved so the three CLI OAuth flows and
+ * their tests keep working unchanged.
  *
  * @module auth-menu/loopback-server
  */
-/**
- * Render a simple dark-themed HTML response for the browser callback page.
- * Shared by all loopback-based OAuth flows so the success/error page styling
- * is consistent and the HTML generation isn't duplicated.
- */
-export declare function callbackHtml(ok: boolean, message: string): string;
-/**
- * Open a URL in the user's default browser. Best-effort — never throws.
- *
- * - Windows: `cmd /c start "" <url>`
- * - macOS: `open <url>`
- * - Linux: `xdg-open <url>`
- */
-export declare function openBrowser(url: string): void;
+import { type LoopbackServer } from '@wrongstack/providers/oauth';
+export { callbackHtml, type LoopbackServer } from '@wrongstack/providers/oauth';
 /** Result of waiting for the OAuth callback. */
 export interface LoopbackCallback {
     /** The authorization code from the provider. */
@@ -42,35 +31,32 @@ export interface LoopbackCallback {
     /** The OAuth state parameter from the callback (validated against expected). */
     state: string;
 }
-export interface LoopbackServer {
-    /**
-     * Wait for the browser to redirect back with the authorization code.
-     * Resolves with the code and state, or `null` if cancelled/failed.
-     */
-    waitForCode(): Promise<LoopbackCallback | null>;
-    /** Close the HTTP server and release the port. */
-    close(): void;
-    /** True when the server bound to a registered callback port. */
-    readonly bound: boolean;
-    /** The actual port the server is listening on (matches the authorize URL redirect_uri). */
-    readonly port: number;
-}
 /**
- * Start a loopback HTTP server for OAuth authorization code callback.
- *
- * The server listens on the first available port from `ports`. If all ports
- * are busy, `bound` is `false` and the caller should fall back to a manual
- * paste prompt.
+ * Open a URL in the user's default browser. Best-effort — never throws.
  *
- * When `signal` aborts (user pressed Ctrl+C or TUI Esc), the pending
- * `waitForCode()` promise resolves to `null` and the server is torn down
- * so the login flow can return promptly.
+ * - Windows: `cmd /c start "" <url>`
+ * - macOS: `open <url>`
+ * - Linux: `xdg-open <url>`
  *
- * @param expectedState - The OAuth `state` value to validate against the callback
- * @param ports - Ordered list of TCP ports to try (first available wins)
- * @param signal - Optional external cancellation signal
- * @param callbackPath - The URL path the provider redirects to (default `/auth/callback`)
- * @param redirectHost - The hostname to listen on (default `127.0.0.1`)
+ * Not `detached`: the CLI flows wait on the loopback callback in the
+ * foreground, so the opener is a short-lived handoff. (The WebUI server's
+ * `openBrowser` is deliberately different — it detaches and registers the pid
+ * as protected because it launches a browser the session must outlive.)
+ */
+export declare function openBrowser(url: string): void;
+/**
+ * Start a loopback HTTP server for the OAuth authorization-code callback.
+ *
+ * Binds the first available port from `ports`. If all are busy, `bound` is
+ * `false` and the caller falls back to a manual paste prompt. When `signal`
+ * aborts (Ctrl+C, TUI Esc), the pending `waitForCode()` resolves to `null` and
+ * the server is torn down.
+ *
+ * @param expectedState - the OAuth `state` to validate the callback against
+ * @param ports - ordered ports to try; first available wins
+ * @param signal - optional external cancellation
+ * @param callbackPath - path the provider redirects to (default `/auth/callback`)
+ * @param redirectHost - hostname to listen on (default `127.0.0.1`)
  */
 export declare function startLoopbackServer(expectedState: string, ports: readonly number[], signal?: AbortSignal, callbackPath?: string, redirectHost?: string): Promise<LoopbackServer>;
 //# sourceMappingURL=loopback-server.d.ts.map

package/dist/auth-menu/openai-codex-oauth.d.ts

@@ -1,138 +1,51 @@
 /**
- * OpenAI Codex — "Sign in with ChatGPT" OAuth (Authorization Code + PKCE).
+ * OpenAI Codex — "Sign in with ChatGPT", terminal flow.
  *
- * This is the ONLY login flow that actually works for using a ChatGPT
- * Plus/Pro/Team subscription programmatically. It mirrors the real Codex CLI:
+ * This module is now only the *terminal* half of the login: the rendered
+ * instructions, the SIGINT / TUI-signal cancellation contract, the
+ * manual-paste prompt, and writing the resulting tokens into the encrypted
+ * profile config.
  *
- *   1. Generate a PKCE verifier/challenge (S256) + CSRF state.
- *   2. Start a loopback HTTP server on http://localhost:1455/auth/callback.
- *   3. Open the browser to https://auth.openai.com/oauth/authorize.
- *   4. The browser redirects back to the loopback with `?code=...&state=...`.
- *   5. Exchange the code at https://auth.openai.com/oauth/token for an
- *      access_token + refresh_token (and an id_token carrying the account id).
- *   6. Store the tokens in the vault as an `oauth` ProviderApiKey.
+ * The protocol itself — client id, endpoints, PKCE, the authorize URL, the
+ * token exchange and refresh, the JWT account-id claim, and model discovery —
+ * lives in `@wrongstack/providers/oauth`. It used to live here AND in
+ * `providers/src/oauth/chatgpt.ts` (the headless WebUI flow) AND in
+ * `providers/src/openai-codex.ts` (the runtime refresh path), whose header
+ * said outright that it was mirroring this file.
  *
- * The resulting access token is a JWT whose `https://api.openai.com/auth`
- * claim contains `chatgpt_account_id`. Requests then go to the ChatGPT
- * backend (`chatgpt.com/backend-api/codex/responses`) — NOT api.openai.com —
- * which is what the `openai-codex` wire family handles. The standard
- * API-key flow (`family: openai` → api.openai.com/chat/completions) is left
- * completely untouched.
+ * Three copies is what let the OAuth abort-listener leak sit in two of them
+ * while a third flow in this same directory was already correct — nothing
+ * forced them to agree, so a fix applied to one silently left the others
+ * broken. A rotated client id or a changed token-endpoint contract carries the
+ * same risk, with the failure being "one surface stops authenticating" rather
+ * than a compile error.
  *
- * NOTE: a ChatGPT web *session cookie* is NOT an API token. The old
- * device-code + cookie-scraping attempts could never produce a usable
- * credential; this module replaces them.
+ * The protocol constants live in `providers` (not here) because the dependency
+ * edge runs `cli → providers → core`: the runtime provider needs them to
+ * refresh a token and must never import from `cli`.
+ *
+ * Everything the protocol layer defines is re-exported below, so existing
+ * importers (`auth-menu/index.ts`, `wiring/provider.ts`, the CLI tests) keep
+ * working against this module unchanged.
  */
+import { buildCodexAuthorizeUrl, exchangeCodexAuthorizationCode, refreshCodexTokens } from '@wrongstack/providers/oauth';
 import { type LoopbackServer } from './loopback-server.js';
-import { type ModelsRegistry } from '@wrongstack/core/types';
 import type { AuthMenuDeps } from './types.js';
-/** Canonical provider id under which ChatGPT-login credentials are stored. */
-export declare const CODEX_PROVIDER_ID = "openai-codex";
-/** Default ChatGPT backend base. The wire family appends `/codex/responses`. */
-export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
-/**
- * Codex-specific compatibility wrapper retained for callers that imported the
- * helper from this module before the shared OAuth loopback server extraction.
- */
-export declare function startLoopbackServer(expectedState: string, signal?: AbortSignal): Promise<LoopbackServer>;
-/**
- * Fallback model list used when BOTH the live backend AND the models.dev
- * catalog are unreachable. This should never happen in practice — the
- * catalog is cached locally and the only scenario where both fail is a
- * fresh install with no network on first login.
- *
- * The primary resolution order in `resolveCodexModels()` is:
- *  1. Live backend (`GET /models`)
- *  2. models.dev catalog (`family: gpt-codex*` under `openai` provider)
- *  3. This inline fallback
- */
-export interface CodexTokens {
-    access: string;
-    refresh: string;
-    /** Absolute expiry in epoch milliseconds. */
-    expires: number;
-    idToken?: string | undefined;
-}
-export interface Pkce {
-    verifier: string;
-    challenge: string;
-}
-/** Generate a PKCE verifier + S256 challenge. */
-export declare function generatePkce(): Pkce;
-/** Build the full authorize URL with all Codex-required query params. */
-export declare function buildAuthorizeUrl(challenge: string, state: string, port?: number): string;
-/**
- * Extract `chatgpt_account_id` from an access/id token JWT. Returns null when
- * the token isn't a JWT or lacks the claim (the caller decides whether that
- * is fatal — for login it is; for a cached display value it isn't).
- */
-export declare function extractAccountId(token: string): string | null;
-/**
- * Recommended Codex models for ChatGPT sign-in. Live backend discovery
- * wins; these values are only used when the backend/catalog cannot
- * provide a list. Derived from `CODEX_MODELS` in core (the single source of
- * truth for Codex id/name/description) — used both by OAuth login
- * (resolveCodexModels → tier 3) and by the provider-boot synthesis
- * path (wiring/provider.ts when the catalog is unavailable).
- */
-export declare const FALLBACK_CODEX_MODELS: ReadonlyArray<{
-    id: string;
-    name: string;
-}>;
-/** Families in the models.dev catalog that indicate Codex / Responses API compatibility. */
-export declare const CODEX_CATALOG_FAMILIES: Set<string>;
-export declare function fallbackCodexModelIds(): string[];
-export declare function fallbackCodexProviderModels(): Array<{
-    id: string;
-    name: string;
-}>;
-/**
- * Filter a list of available model ids down to the ones that are still
- * current for ChatGPT sign-in (i.e. present in FALLBACK_CODEX_MODELS).
- * Used by both OAuth login (to drop deprecated ids from the live /models
- * response) and by the provider-boot synthesis (to pick current ids out
- * of the models.dev catalog).
- */
-export declare function filterCurrentCodexModelIds(ids: Iterable<string>): string[];
-export declare function isCodexCatalogModel(model: {
-    family?: string | undefined;
-}): boolean;
-/**
- * Resolve the list of available Codex models using a 3-tier fallback chain:
- *
- *  1. **Live backend** — `fetchCodexModels()` hits `GET <baseUrl>/models`
- *     and keeps only current Codex model ids.
- *  2. **models.dev catalog** — queries the `openai` provider in the cached
- *     models.dev registry and picks models whose `family` is `gpt-codex` or
- *     `gpt-codex-spark` and whose ids are current for ChatGPT sign-in.
- *  3. **Inline fallback** — a minimal list of documented mainstream models
- *     (`gpt-5.6-sol`, `gpt-5.5`, `gpt-5.6-terra`, `gpt-5.6-luna`,
- *     `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.3-codex-spark`).
- *
- * The live/catalog tiers gate account availability, while the shared current
- * model list filters out deprecated ChatGPT sign-in ids before config is saved.
- */
-export declare function resolveCodexModels(modelsRegistry: ModelsRegistry, accessToken: Promise<string> | string, baseUrl?: string | undefined, signal?: AbortSignal): Promise<string[]>;
+export { CODEX_BASE_URL, CODEX_CATALOG_FAMILIES, CODEX_PROVIDER_ID, type CodexTokens, extractAccountId, FALLBACK_CODEX_MODELS, fallbackCodexModelIds, fallbackCodexProviderModels, fetchCodexModels, filterCurrentCodexModelIds, generatePkce, isCodexCatalogModel, parseAuthorizationInput, type Pkce, resolveCodexModels, } from '@wrongstack/providers/oauth';
+/** Build the Codex authorize URL. Alias kept for the historical local name. */
+export declare const buildAuthorizeUrl: typeof buildCodexAuthorizeUrl;
+/** Exchange an authorization code (+ PKCE verifier) for tokens. */
+export declare const exchangeAuthorizationCode: typeof exchangeCodexAuthorizationCode;
 /**
- * Fetch the account's available Codex model ids live from the ChatGPT backend.
- *
- * Hits `GET <baseUrl>/models` — the standard OpenAI-compatible model listing
- * endpoint, which the Codex backend may expose. Best-effort: returns an empty
- * array on any failure so login still succeeds with the hardcoded fallback.
+ * Refresh an expired access token. Alias kept for the historical local name;
+ * `wiring/provider.ts` and the CLI tests import it from here.
  */
-export declare function fetchCodexModels(accessToken: string, baseUrl?: string | undefined, signal?: AbortSignal): Promise<string[]>;
-/** Exchange an authorization code (+ PKCE verifier) for tokens. */
-export declare function exchangeAuthorizationCode(code: string, verifier: string, signal?: AbortSignal, port?: number): Promise<CodexTokens>;
+export declare const refreshCodexToken: typeof refreshCodexTokens;
 /**
- * Refresh an expired access token using the stored refresh token. Exported for
- * the `openai-codex` provider, which calls it transparently before requests.
+ * Codex-specific loopback wrapper. Stays CLI-side because this flow pairs it
+ * with {@link openBrowser}, which is terminal-only.
  */
-export declare function refreshCodexToken(refreshToken: string, signal?: AbortSignal): Promise<CodexTokens>;
-/** Parse a pasted authorization code or full redirect URL into { code, state }. */
-export declare function parseAuthorizationInput(input: string): {
-    code?: string | undefined;
-    state?: string | undefined;
-};
+export declare function startLoopbackServer(expectedState: string, signal?: AbortSignal): Promise<LoopbackServer>;
 export interface CodexLoginOptions {
     /** Storage provider id. Defaults to the canonical `openai-codex`. */
     providerId?: string;

package/dist/auto-discover-providers-DRW4OZHG.js

@@ -0,0 +1,8 @@
+import {
+  discoverAndMergeProviders
+} from "./chunk-4GVH7V3S.js";
+import "./chunk-7OCVIDC7.js";
+export {
+  discoverAndMergeProviders
+};
+//# sourceMappingURL=auto-discover-providers-DRW4OZHG.js.map

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

@@ -22,6 +22,7 @@ import type { Config, MemoryPort, ModelsRegistry, ModeStore, SessionStore, Sessi
 import type { MCPRegistry } from '@wrongstack/mcp';
 import type { TerminalRenderer } from '../renderer.js';
 import type { AutonomyMode } from '../services/autonomy-mode.js';
+import type { CliWebUIOptions } from '../webui-server-options.js';
 export interface WebUIDispatchContext {
     agent: Agent;
     events: EventBus;
@@ -96,6 +97,8 @@ export interface WebUIDispatchContext {
             error?: string | undefined;
         }) => void | Promise<void>) | undefined;
     }) => Promise<string>) | undefined;
+    /** Live fleet budget for WebUI concurrency/spawn gauges (issue #323). */
+    getFleetBudget?: CliWebUIOptions['getFleetBudget'];
 }
 /**
  * Run the WebUI server and block until it shuts down.

package/dist/{chunk-PEKUKUCH.js → chunk-3MWUZMOL.js}

@@ -2,6 +2,9 @@
 // src/plugin-management.ts
 import * as fs from "node:fs/promises";
 import { atomicWrite } from "@wrongstack/core/utils";
+import {
+  resolvePluginEnablement
+} from "@wrongstack/core/plugin";
 import {
   PLUGIN_AUDIT_ENTRIES
 } from "@wrongstack/plugins/plugin-audit-catalog";
@@ -311,6 +314,7 @@ function renderPluginAuditReport(config) {
   const lines = [
     "Plugin audit report:",
     "  State shows the effective boot state. Default-active plugins run unless disabled in config.",
+    "  Source: config = plugins[] entry, ext = extensions.<name>.enabled, feature = features.plugins.",
     "  Built-in audit rows are toggleable unless a future row explicitly marks itself locked.",
     "",
     "  Built-in audit entries:"
@@ -359,19 +363,22 @@ function pluginMatchesToggleSpec(p, spec) {
   if (spec === "telegram") return name === "telegram" || name === "@wrongstack/telegram";
   return name === spec;
 }
+var AUDIT_STATE_SOURCE_LABEL = {
+  "feature-flag": "feature",
+  "plugin-entry": "config",
+  extension: "ext",
+  default: "default"
+};
 function effectiveAuditState(config, entry) {
-  const configured = (config.plugins ?? []).find(
-    (plugin) => pluginMatchesToggleSpec(plugin, entry.name)
-  );
-  if (configured) {
-    return {
-      state: typeof configured === "object" && configured.enabled === false ? "disabled" : "enabled",
-      source: "config"
-    };
-  }
+  const { enabled, source } = resolvePluginEnablement({
+    name: entry.name,
+    defaultState: entry.defaultState,
+    config,
+    matches: (spec) => pluginMatchesToggleSpec(spec, entry.name)
+  });
   return {
-    state: entry.defaultState === "active" ? "enabled" : "disabled",
-    source: "default"
+    state: enabled ? "enabled" : "disabled",
+    source: AUDIT_STATE_SOURCE_LABEL[source]
   };
 }
 function lockedReason(entry) {
@@ -490,4 +497,4 @@ export {
   PLUGIN_AUDIT_ENTRIES,
   runPluginManagementCommand
 };
-//# sourceMappingURL=chunk-PEKUKUCH.js.map
+//# sourceMappingURL=chunk-3MWUZMOL.js.map

package/dist/{chunk-TGDHN4LM.js → chunk-4GVH7V3S.js}

@@ -2,26 +2,7 @@
 // src/boot/auto-discover-providers.ts
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from "@wrongstack/providers";
-function resolveKey(cfg) {
-  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
-    const active = cfg.activeKey ? cfg.apiKeys.find((k) => k.label === cfg.activeKey) : void 0;
-    return (active ?? cfg.apiKeys[0])?.apiKey;
-  }
-  return cfg.apiKey && cfg.apiKey.length > 0 ? cfg.apiKey : void 0;
-}
-function eligibleProviders(config) {
-  const out = [];
-  for (const [id, cfg] of Object.entries(config.providers ?? {})) {
-    const preset = COMPATIBLE_PRESETS[id];
-    const enabled = cfg.autoDiscoverModels ?? preset?.autoDiscover ?? false;
-    if (!enabled) continue;
-    const baseUrl = cfg.baseUrl ?? preset?.defaultBaseUrl;
-    if (!baseUrl) continue;
-    out.push({ id, cfg, baseUrl, apiKey: resolveKey(cfg) });
-  }
-  return out;
-}
+import { discoverOpenAICompatibleModels, resolveDiscoveryTargets } from "@wrongstack/providers";
 async function readCache(file) {
   try {
     return JSON.parse(await fs.readFile(file, "utf8"));
@@ -30,14 +11,13 @@ async function readCache(file) {
   }
 }
 async function discoverAndMergeProviders(opts) {
-  const targets = eligibleProviders(opts.config);
+  const targets = resolveDiscoveryTargets(opts.config);
   if (targets.length === 0) return;
   const cacheFile = path.join(opts.cacheDir, "discovered-models-cache.json");
   const cache = await readCache(cacheFile);
   let cacheDirty = false;
   await Promise.all(
-    targets.map(async ({ id, cfg, baseUrl, apiKey }) => {
-      const cacheKey = `${id}\0${baseUrl}`;
+    targets.map(async ({ id, cfg, baseUrl, apiKey, cacheKey }) => {
       const provider = await discoverOpenAICompatibleModels(id, {
         baseUrl,
         apiKey,
@@ -78,4 +58,4 @@ async function discoverAndMergeProviders(opts) {
 export {
   discoverAndMergeProviders
 };
-//# sourceMappingURL=chunk-TGDHN4LM.js.map
+//# sourceMappingURL=chunk-4GVH7V3S.js.map

package/dist/{chunk-4U3DMA2Y.js → chunk-4WJKVQJY.js}

@@ -1,13 +1,13 @@
 import {
   PLUGIN_AUDIT_ENTRIES
-} from "./chunk-PEKUKUCH.js";
+} from "./chunk-3MWUZMOL.js";
 import {
   patchConfig
 } from "./chunk-TYO2OVAD.js";
 
 // src/wiring/plugins.ts
 import { join } from "node:path";
-import { loadPlugins, resolvePluginConfig } from "@wrongstack/core/plugin";
+import { loadPlugins, resolvePluginConfig, resolvePluginEnablement } from "@wrongstack/core/plugin";
 import { OFFICIAL_PLUGIN_FACTORIES } from "@wrongstack/plugins/factories";
 
 // src/plugin-api-factory.ts
@@ -112,30 +112,25 @@ async function setupPlugins(params) {
     hookRegistry
   } = params;
   const builtinPlugins = [];
-  const disabledBuiltins = new Set(
-    (config.plugins ?? []).filter(
-      (p) => typeof p === "object" && p.enabled === false
-    ).flatMap((p) => {
-      const builtinName = builtinPluginNameFromSpec(p.name);
-      return builtinName && builtinName !== p.name ? [p.name, builtinName] : [p.name];
-    })
-  );
   if (paths && config.features?.plugins !== false) {
     for (const factory of BUILTIN_PLUGIN_FACTORIES) {
       try {
         const plugin = await factory();
         if (!plugin) continue;
         const auditEntry = PLUGIN_AUDIT_ENTRIES.find((entry) => entry.name === plugin.name);
-        const explicitlyEnabled = (config.plugins ?? []).some((entry) => {
-          const spec = typeof entry === "string" ? entry : entry.name;
-          if (typeof entry === "object" && entry.enabled === false) return false;
-          return (builtinPluginNameFromSpec(spec) ?? spec) === plugin.name;
+        const { enabled, source } = resolvePluginEnablement({
+          name: plugin.name,
+          aliases: plugin.configAliases,
+          // Built-ins outside the audit catalog (prompts, sync, skills, …)
+          // are infrastructure — they run unless explicitly turned off.
+          defaultState: auditEntry?.defaultState ?? "active",
+          config,
+          matches: (spec) => (builtinPluginNameFromSpec(spec) ?? spec) === plugin.name
         });
-        if (auditEntry?.defaultState === "inactive" && !explicitlyEnabled) {
-          continue;
-        }
-        if (disabledBuiltins.has(plugin.name)) {
-          log.info(`[setupPlugins] built-in plugin "${plugin.name}" disabled by config`);
+        if (!enabled) {
+          if (source !== "default") {
+            log.info(`[setupPlugins] built-in plugin "${plugin.name}" disabled by ${source}`);
+          }
           continue;
         }
         if (warnIfDeprecatedPluginName(plugin.name, log)) continue;
@@ -255,4 +250,4 @@ export {
   BUILTIN_PLUGIN_FACTORIES,
   setupPlugins
 };
-//# sourceMappingURL=chunk-4U3DMA2Y.js.map
+//# sourceMappingURL=chunk-4WJKVQJY.js.map