@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/dist/provider-transform.js

@@ -16,6 +16,11 @@ const KIMI_K3_FAMILY = new Set(["k3", "k3-256k", "kimi-k3"]);
 const KIMI_TOGGLE_THINKING_FAMILY = new Set(["kimi-k2.5", "kimi-k2.6"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
 const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
+const DEEPSEEK_V4_FAMILY = new Set([
+    "deepseek-v4-flash",
+    "deepseek-v4-flash-vision-exp",
+    "deepseek-v4-pro",
+]);
 function isFireworksKimi(providerId, modelId) {
     const model = modelId.toLowerCase();
     return providerId === "fireworks" && (model.includes("kimi")
@@ -52,6 +57,21 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 : { reasoning_effort: effectiveThinkingLevel },
         };
     }
+    // Ox Alpha exposes mandatory low/high/max reasoning. Treat unsupported state
+    // restored from an older session as inherited state and fall back to the
+    // model's declared default (max), never OpenRouter's disabling "none" value.
+    if (providerId === "openrouter") {
+        const openRouterThinkingLevel = normalizeInheritedThinkingLevel(providerId, modelId, requestedLevel);
+        return {
+            effectiveThinkingLevel: openRouterThinkingLevel,
+            reasoningContentEcho: "tool_calls",
+            extraBody: {
+                reasoning: {
+                    effort: openRouterThinkingLevel,
+                },
+            },
+        };
+    }
     if (isFireworksKimi(providerId, modelId)) {
         return {
             effectiveThinkingLevel,
@@ -60,7 +80,16 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
             maxTokens: KIMI_K26_DEFAULT_MAX_TOKENS,
         };
     }
-    if (providerId === "deepseek" && (modelId === "deepseek-v4-flash" || modelId === "deepseek-v4-pro")) {
+    if (providerId === "deepseek" && DEEPSEEK_V4_FAMILY.has(modelId)) {
+        if (effectiveThinkingLevel === "off") {
+            return {
+                effectiveThinkingLevel,
+                // Non-thinking requests do not need prior reasoning replayed. Omitting
+                // reasoning_content also keeps the history valid when switching modes.
+                reasoningContentEcho: "none",
+                extraBody: { thinking: { type: "disabled" } },
+            };
+        }
         return {
             effectiveThinkingLevel,
             reasoningContentEcho: "all",
@@ -115,11 +144,11 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {
         // GLM-5.2+ also accept `reasoning_effort`. GLM-5.2 can disable thinking;
-        // GLM-5.3 requires thinking and Coding Plan normalizes its effort into
+        // the GLM-5.3 family requires thinking and normalizes its effort into
         // low/high/max. The catalog clamps 5.3 choices before this serialization
         // boundary. The effort field rides inside the body alongside `thinking`,
         // so it goes in extraBody, not the OpenRouter-style config field.
-        if (modelId === "glm-5.2" || modelId === "glm-5.3") {
+        if (modelId === "glm-5.2" || modelId === "glm-5.3" || modelId === "glm-5.3-flash") {
             return {
                 effectiveThinkingLevel,
                 extraBody: modelId === "glm-5.2" && effectiveThinkingLevel === "off"
@@ -185,7 +214,6 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
         return { effectiveThinkingLevel };
     }
     if (providerId === "openai"
-        || providerId === "openrouter"
         || providerId === "google"
         || providerId === "azure"
         || providerId === "openai-compatible") {

package/dist/provider.d.ts

@@ -64,8 +64,12 @@ export declare function translateOpenAIFullResponse(response: any): AsyncIterabl
  * in index order to keep multi-call turns deterministic.
  */
 export declare function translateOpenAIStream(stream: AsyncIterable<any>, options?: TranslateOpenAIStreamOptions): AsyncIterable<StreamChunk>;
-/** Largest value Node's 32-bit timers accept; ~24.8 days. */
-export declare const MAX_TIMER_MS = 2147483647;
+/**
+ * Largest value that survives the OpenAI SDK's internal `timeout + 1000`
+ * agent-grace (core.js minAgentTimeout) without overflowing Node's 32-bit
+ * timers; ~24.8 days.
+ */
+export declare const MAX_TIMER_MS = 2147482647;
 /**
  * Resolve the provider request timeout (ms) from the operator override.
  *

package/dist/provider.js

@@ -14,8 +14,9 @@ import { getChatGptFetch } from "./network/chatgpt-transport.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
-import { RateLimitError } from "./network/errors.js";
-import { ProviderStreamInterruptedError } from "./network/retry.js";
+import { isProviderResponseError, ProviderResponseError, RateLimitError, } from "./network/errors.js";
+import { isRetryableHttpStatus, ProviderStreamInterruptedError } from "./network/retry.js";
+import { assertProviderModelAllowed } from "./provider-model-policy.js";
 // Diagnostic logger for tool-args byte-loss investigation. Activate with
 //   BUBBLE_DEBUG_TOOL_ARGS=/path/to/log.jsonl   (any writable path)
 // Each line is a JSON record describing a transition. When debugging is off,
@@ -123,6 +124,7 @@ export function createProviderInstance(options) {
     });
     const fallbackModel = "gpt-4o";
     async function* streamChat(messages, chatOptions) {
+        assertProviderModelAllowed(options.providerId || "", chatOptions.model);
         const requestConfig = resolveProviderRequestConfig(options.providerId || "", chatOptions.model, chatOptions.thinkingLevel ?? options.thinkingLevel ?? "off");
         const tools = chatOptions.tools?.map((t) => ({
             type: "function",
@@ -201,9 +203,9 @@ export function createProviderInstance(options) {
         // paths already wrap — this generic chat-completions path did not).
         try {
             yield* translateOpenAIStream(stream, {
-                toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
-                reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),
-                textMergeMode: resolveTextMergeMode(options.providerId || "", options.baseURL),
+                toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL || ""),
+                reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL || ""),
+                textMergeMode: resolveTextMergeMode(options.providerId || "", options.baseURL || ""),
                 debugProviderId: options.providerId || "",
                 debugModelId: chatOptions.model,
             });
@@ -211,14 +213,38 @@ export function createProviderInstance(options) {
         catch (error) {
             if (chatOptions.abortSignal?.aborted)
                 throw error;
+            if (isProviderResponseError(error)) {
+                const rateLimited = error.status === 429 || error.errorType === "rate_limit_exceeded";
+                if (rateLimited && chatOptions.rateLimitPolicy === "defer") {
+                    throw new RateLimitError(error.message, {
+                        status: error.status ?? 429,
+                        retryAfterMs: error.retryAfterMs,
+                        cause: error,
+                    });
+                }
+                if (isRetryableProviderResponseError(error)) {
+                    // OpenRouter has already exhausted any pre-stream fallback before it
+                    // emits a terminal SSE error. One client retry is useful for a fresh
+                    // route; repeating the previous two-retry socket budget turns a
+                    // five-minute upstream timeout into a fifteen-minute apparent hang.
+                    throw new ProviderStreamInterruptedError(error.message, {
+                        cause: error,
+                        retryAfterMs: error.retryAfterMs,
+                        maxRetries: 1,
+                    });
+                }
+                throw error;
+            }
             throw new ProviderStreamInterruptedError(`Provider stream interrupted: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
         yield { type: "done" };
     }
     async function complete(messages, chatOptions) {
-        const requestConfig = resolveProviderRequestConfig(options.providerId || "", chatOptions?.model ?? fallbackModel, chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "off");
+        const model = chatOptions?.model ?? fallbackModel;
+        assertProviderModelAllowed(options.providerId || "", model);
+        const requestConfig = resolveProviderRequestConfig(options.providerId || "", model, chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "off");
         const body = {
-            model: chatOptions?.model ?? fallbackModel,
+            model,
             messages: messages.map((message) => toChatCompletionsMessage(message, {
                 reasoningContentEcho: requestConfig.reasoningContentEcho ?? "tool_calls",
             })),
@@ -246,7 +272,7 @@ function resolveProviderProtocol(options) {
     if (options.protocol)
         return options.protocol;
     const providerId = (options.providerId || "").toLowerCase();
-    const baseURL = options.baseURL.toLowerCase();
+    const baseURL = (options.baseURL || "").toLowerCase();
     if (providerId === "doubao"
         && baseURL.replace(/\/+$/, "") === "https://ark.cn-beijing.volces.com/api/v3") {
         return "ark-responses";
@@ -260,7 +286,7 @@ function resolveProviderProtocol(options) {
 }
 function isMiniMaxOpenAICompatible(options) {
     const providerId = (options.providerId || "").toLowerCase();
-    const baseURL = options.baseURL.toLowerCase();
+    const baseURL = (options.baseURL || "").toLowerCase();
     return providerId === "minimax-openai"
         || (providerId === "minimax" && !baseURL.includes("/anthropic"))
         || baseURL.includes("api.minimaxi.com/v1")
@@ -488,6 +514,62 @@ function usageToStreamChunk(usage) {
         },
     };
 }
+const RETRYABLE_PROVIDER_ERROR_TYPES = new Set([
+    "capacity_exhausted",
+    "provider_timeout",
+    "rate_limit_exceeded",
+    "server",
+    "temporarily_unavailable",
+]);
+function isRetryableProviderResponseError(error) {
+    return (error.status !== undefined && isRetryableHttpStatus(error.status))
+        || (error.errorType !== undefined && RETRYABLE_PROVIDER_ERROR_TYPES.has(error.errorType));
+}
+function positiveSecondsToMs(value) {
+    const seconds = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(seconds) && seconds >= 0 ? Math.round(seconds * 1000) : undefined;
+}
+/** Parse HTTP-200 in-band provider errors such as OpenRouter's SSE format. */
+function providerResponseErrorFromChunk(chunk, providerId) {
+    const finishReason = chunk?.choices?.[0]?.finish_reason;
+    const rawError = chunk?.error;
+    if ((!rawError || typeof rawError !== "object") && finishReason !== "error")
+        return undefined;
+    const metadata = rawError && typeof rawError.metadata === "object" && rawError.metadata !== null
+        ? rawError.metadata
+        : undefined;
+    const availability = metadata && typeof metadata.availability === "object" && metadata.availability !== null
+        ? metadata.availability
+        : undefined;
+    const status = typeof rawError?.code === "number"
+        ? rawError.code
+        : typeof rawError?.status === "number"
+            ? rawError.status
+            : undefined;
+    const errorType = typeof metadata?.error_type === "string"
+        ? metadata.error_type
+        : typeof rawError?.type === "string"
+            ? rawError.type
+            : undefined;
+    const retryAfterMs = positiveSecondsToMs(availability?.retry_after ?? metadata?.retry_after ?? rawError?.retry_after);
+    const provider = typeof chunk?.provider === "string" && chunk.provider.trim()
+        ? chunk.provider.trim()
+        : providerId?.trim() || "Provider";
+    const details = [
+        status !== undefined ? String(status) : undefined,
+        errorType,
+    ].filter(Boolean).join(", ");
+    const rawMessage = typeof rawError?.message === "string" && rawError.message.trim()
+        ? rawError.message.trim()
+        : "Generation ended with finish_reason=error.";
+    const message = `${provider} stream error${details ? ` (${details})` : ""}: ${rawMessage}`;
+    return new ProviderResponseError(message, {
+        status,
+        errorType,
+        retryAfterMs,
+        cause: rawError,
+    });
+}
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
@@ -557,6 +639,9 @@ export async function* translateOpenAIStream(stream, options = {}) {
         const delta = choice?.delta;
         const usage = chunk.usage ?? choice?.usage;
         const finishReason = choice?.finish_reason;
+        const providerError = providerResponseErrorFromChunk(chunk, options.debugProviderId);
+        if (providerError)
+            throw providerError;
         if (typeof chunk?.system_fingerprint === "string"
             && chunk.system_fingerprint
             && chunk.system_fingerprint !== systemFingerprint) {
@@ -764,8 +849,12 @@ function parsePositiveInt(raw) {
     const value = Number(raw);
     return Number.isInteger(value) && value > 0 ? value : undefined;
 }
-/** Largest value Node's 32-bit timers accept; ~24.8 days. */
-export const MAX_TIMER_MS = 2_147_483_647; // 2**31 - 1
+/**
+ * Largest value that survives the OpenAI SDK's internal `timeout + 1000`
+ * agent-grace (core.js minAgentTimeout) without overflowing Node's 32-bit
+ * timers; ~24.8 days.
+ */
+export const MAX_TIMER_MS = 2_147_482_647; // 2**31 - 1 - 1000
 /**
  * Resolve the provider request timeout (ms) from the operator override.
  *

package/dist/question/controller.js

@@ -1,4 +1,5 @@
 import { QuestionRejectedError } from "./types.js";
+import { normalizeQuestionInlineText } from "./normalize.js";
 export class QuestionController {
     pending = new Map();
     listeners = new Set();
@@ -74,12 +75,12 @@ export class QuestionController {
 }
 function normalizePrompt(input) {
     return {
-        header: String(input.header ?? "").trim(),
-        question: String(input.question ?? "").trim(),
+        header: normalizeQuestionInlineText(input.header),
+        question: normalizeQuestionInlineText(input.question),
         options: Array.isArray(input.options)
             ? input.options.map((option) => ({
-                label: String(option?.label ?? "").trim(),
-                description: String(option?.description ?? "").trim(),
+                label: normalizeQuestionInlineText(option?.label),
+                description: normalizeQuestionInlineText(option?.description),
             }))
             : [],
         multiple: input.multiple === true,

package/dist/question/normalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Structured-question fields are rendered as single terminal rows. Models can
+ * still return embedded CR/LF/tab whitespace, so collapse it at the question
+ * boundary instead of letting terminal control characters reach a renderer.
+ */
+export declare function normalizeQuestionInlineText(value: unknown): string;

package/dist/question/normalize.js

@@ -0,0 +1,11 @@
+/**
+ * Structured-question fields are rendered as single terminal rows. Models can
+ * still return embedded CR/LF/tab whitespace, so collapse it at the question
+ * boundary instead of letting terminal control characters reach a renderer.
+ */
+export function normalizeQuestionInlineText(value) {
+    return String(value ?? "")
+        .replace(/\s+/gu, " ")
+        .replace(/\s+([,.;:!?，。；：！？、）)\]}])/gu, "$1")
+        .trim();
+}

package/dist/rewind.d.ts

@@ -0,0 +1,20 @@
+import type { CheckpointRestoreResult } from "./checkpoints.js";
+import type { SessionManager, UserTurn } from "./session.js";
+import type { Message } from "./types.js";
+export type RewindScope = "all" | "chat" | "code";
+export interface RewindAgentState {
+    messages: Message[];
+    resetContextUsageAnchor(): void;
+}
+export interface RewindExecutionResult {
+    target: UserTurn;
+    scope: RewindScope;
+    files: CheckpointRestoreResult;
+    removedEntries: number;
+}
+/**
+ * Apply the persistent rewind exactly once. Renderers layer their own visual
+ * transaction around this function, but the session log and Agent transcript
+ * always move together here.
+ */
+export declare function executeRewind(session: SessionManager, agent: RewindAgentState, targetId: string, scope: RewindScope): Promise<RewindExecutionResult>;

package/dist/rewind.js

@@ -0,0 +1,29 @@
+const EMPTY_FILE_RESULT = {
+    restored: [],
+    deleted: [],
+    failed: [],
+};
+/**
+ * Apply the persistent rewind exactly once. Renderers layer their own visual
+ * transaction around this function, but the session log and Agent transcript
+ * always move together here.
+ */
+export async function executeRewind(session, agent, targetId, scope) {
+    const target = session.listUserTurns().find((turn) => turn.id === targetId);
+    if (!target)
+        throw new Error("The selected rewind point is no longer available.");
+    const files = scope === "chat"
+        ? { ...EMPTY_FILE_RESULT, restored: [], deleted: [], failed: [] }
+        : await session.getCheckpoints().restoreTo(target.id);
+    let removedEntries = 0;
+    if (scope !== "code") {
+        const rewound = session.rewindToEntry(target.id);
+        if (!rewound)
+            throw new Error("The selected rewind point is no longer available.");
+        removedEntries = rewound.removedEntries;
+        const head = agent.messages.filter((message) => message.role === "system" || message.role === "meta");
+        agent.messages = [...head, ...session.getMessages()];
+        agent.resetContextUsageAnchor();
+    }
+    return { target, scope, files, removedEntries };
+}

package/dist/sdk/index.d.ts

@@ -133,7 +133,7 @@ export declare class BubbleSdk {
  * turn_end events; each cost covers only that step's usage, so hosts sum them.
  * Events for unpriced models (or without usage) pass through untouched.
  */
-export declare function attachTurnCost(event: AgentEvent, providerId: string, modelId: string): AgentEvent;
+export declare function attachTurnCost(event: AgentEvent, providerId: string, modelId: string, at?: Date): AgentEvent;
 /**
  * If the prompt (or its first text part) is a "/<skill-name> <task>" skill
  * invocation, rewrite it into the same explicit execution prompt the TUI

package/dist/sdk/index.js

@@ -29,6 +29,7 @@ import { ProviderRegistry, encodeModel, decodeModel, displayModel } from "../pro
 import { createProviderInstance } from "../provider.js";
 import { getDefaultThinkingLevel } from "../variant/variant-resolver.js";
 import { QuestionController } from "../question/controller.js";
+import { assertProviderModelAllowed } from "../provider-model-policy.js";
 import { SkillRegistry } from "../skills/registry.js";
 import { parseSkillInvocation } from "../skills/invocation.js";
 import { GoalStore } from "../goal/store.js";
@@ -88,6 +89,7 @@ export class BubbleSdk {
         const registry = new SkillRegistry({
             cwd: cwd || this.defaultCwd,
             skillPaths: this.userConfig.getSkillPaths(),
+            disabledSkills: this.userConfig.getDisabledSkills(),
         });
         return registry.summaries();
     }
@@ -166,7 +168,11 @@ export class BubbleSdk {
         });
         abort.signal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
         try {
-            const skillRegistry = new SkillRegistry({ cwd, skillPaths: this.userConfig.getSkillPaths() });
+            const skillRegistry = new SkillRegistry({
+                cwd,
+                skillPaths: this.userConfig.getSkillPaths(),
+                disabledSkills: this.userConfig.getDisabledSkills(),
+            });
             const tools = createAllTools(cwd, skillRegistry, {
                 approvalController,
                 fileStateTracker,
@@ -355,6 +361,8 @@ export class BubbleSdk {
             ? decodeModel(normalized)
             : { providerId: undefined, modelId: "" };
         const activeProviderId = effId || fallbackProviderId;
+        if (effModelId)
+            assertProviderModelAllowed(activeProviderId, effModelId);
         const target = this.registry.getConfigured().find((p) => p.id === activeProviderId) || defaultProvider;
         if (!target?.apiKey) {
             throw new Error("No provider with an API key configured — run the Bubble CLI once to set one up");
@@ -381,10 +389,10 @@ function sessionFileName(sessionId) {
  * turn_end events; each cost covers only that step's usage, so hosts sum them.
  * Events for unpriced models (or without usage) pass through untouched.
  */
-export function attachTurnCost(event, providerId, modelId) {
+export function attachTurnCost(event, providerId, modelId, at = new Date()) {
     if (event.type !== "turn_end" || !event.usage)
         return event;
-    const cost = calculateUsageCost(providerId, modelId, event.usage);
+    const cost = calculateUsageCost(providerId, modelId, event.usage, at);
     return cost ? { ...event, cost } : event;
 }
 /**

package/dist/session.d.ts

@@ -36,6 +36,7 @@ export declare class SessionManager {
     private sessionFile;
     private log;
     private checkpoints?;
+    private readonly metadataListeners;
     constructor(sessionFile: string);
     static create(cwd: string, sessionName?: string): SessionManager;
     static resume(cwd: string, sessionName?: string): SessionManager | undefined;
@@ -47,6 +48,12 @@ export declare class SessionManager {
     private persist;
     private rewrite;
     getMetadata(): SessionMetadata;
+    /**
+     * Subscribe to committed metadata changes (title, model, goal, runtime, ...).
+     * Renderers use this instead of polling the session file, so async title
+     * generation and runtime switches update fixed UI surfaces immediately.
+     */
+    subscribeMetadata(listener: (metadata: SessionMetadata) => void): () => void;
     getOrCreatePromptCacheKey(): string;
     setMetadata(metadata: SessionMetadata): void;
     updateMetadata(patch: Partial<SessionMetadata>): void;

package/dist/session.js

@@ -17,6 +17,7 @@ export class SessionManager {
     sessionFile;
     log = new SessionLog();
     checkpoints;
+    metadataListeners = new Set();
     constructor(sessionFile) {
         this.sessionFile = sessionFile;
         if (existsSync(sessionFile)) {
@@ -113,6 +114,15 @@ export class SessionManager {
     getMetadata() {
         return this.log.getMetadata();
     }
+    /**
+     * Subscribe to committed metadata changes (title, model, goal, runtime, ...).
+     * Renderers use this instead of polling the session file, so async title
+     * generation and runtime switches update fixed UI surfaces immediately.
+     */
+    subscribeMetadata(listener) {
+        this.metadataListeners.add(listener);
+        return () => this.metadataListeners.delete(listener);
+    }
     getOrCreatePromptCacheKey() {
         const existing = this.log.getMetadata().promptCacheKey;
         if (existing)
@@ -124,6 +134,16 @@ export class SessionManager {
     setMetadata(metadata) {
         const nextEntries = this.log.setMetadata(metadata);
         this.rewrite(nextEntries);
+        const committed = this.log.getMetadata();
+        for (const listener of this.metadataListeners) {
+            try {
+                listener(committed);
+            }
+            catch {
+                // Persistence already committed. A UI observer must never turn a
+                // successful metadata write into an application-level failure.
+            }
+        }
     }
     updateMetadata(patch) {
         this.setMetadata({

package/dist/skills/discovery.js

@@ -112,14 +112,32 @@ function normalizeMeta(attributes, fallbackName, filePath, diagnostics) {
     const tags = Array.isArray(attributes.tags)
         ? attributes.tags.filter((item) => typeof item === "string" && !!item.trim()).map((item) => item.trim())
         : undefined;
+    const author = typeof attributes.author === "string" && attributes.author.trim()
+        ? attributes.author.trim()
+        : undefined;
+    const allowedTools = normalizeStringList(attributes["allowed-tools"] ?? attributes.allowedTools);
     return {
         name,
         description,
         disableModelInvocation: attributes["disable-model-invocation"] === true,
         version: typeof attributes.version === "number" ? attributes.version : undefined,
         tags: tags && tags.length > 0 ? tags : undefined,
+        author,
+        allowedTools,
     };
 }
+function normalizeStringList(value) {
+    const raw = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? value.trim().replace(/^\[(.*)\]$/, "$1").split(",")
+            : [];
+    const items = raw
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length > 0 ? [...new Set(items)] : undefined;
+}
 function indexResources(rootDir) {
     return {
         references: listRelativeFiles(join(rootDir, "references"), rootDir),

package/dist/skills/registry.d.ts

@@ -5,14 +5,24 @@ export interface SkillRegistryOptions {
     agentsHome?: string;
     claudeHome?: string;
     skillPaths?: string[];
+    disabledSkills?: string[];
+    onDisabledSkillsChange?: (disabledSkills: string[]) => void;
 }
 export declare class SkillRegistry {
-    private readonly skills;
-    private readonly diagnostics;
+    private skills;
+    private diagnostics;
+    private readonly roots;
+    private readonly disabledSkills;
+    private readonly onDisabledSkillsChange?;
     constructor(options?: SkillRegistryOptions);
+    reload(): void;
     all(): SkillRecord[];
     promptVisible(): SkillRecord[];
     summaries(): SkillSummary[];
     get(name: string): SkillRecord | undefined;
+    getAny(name: string): SkillRecord | undefined;
+    isEnabled(name: string): boolean;
+    setEnabled(name: string, enabled: boolean): boolean;
+    getDisabledSkillNames(): string[];
     getDiagnostics(): SkillDiagnostic[];
 }

package/dist/skills/registry.js

@@ -3,21 +3,29 @@ import { homedir } from "node:os";
 import { getBubbleHome } from "../bubble-home.js";
 import { discoverSkills } from "./discovery.js";
 export class SkillRegistry {
-    skills;
-    diagnostics;
+    skills = [];
+    diagnostics = [];
+    roots;
+    disabledSkills;
+    onDisabledSkillsChange;
     constructor(options = {}) {
         const cwd = options.cwd ?? process.cwd();
         const bubbleHome = options.bubbleHome ?? getBubbleHome();
         const agentsHome = options.agentsHome ?? join(homedir(), ".agents");
         const claudeHome = options.claudeHome ?? join(homedir(), ".claude");
-        const roots = [
+        this.roots = [
             { path: join(bubbleHome, "skills"), source: "user" },
             { path: join(agentsHome, "skills"), source: "user" },
             { path: join(claudeHome, "skills"), source: "user" },
             { path: join(cwd, ".bubble", "skills"), source: "project" },
             ...(options.skillPaths ?? []).map((path) => ({ path, source: "configured" })),
         ];
-        const result = discoverSkills({ roots });
+        this.disabledSkills = new Set(options.disabledSkills ?? []);
+        this.onDisabledSkillsChange = options.onDisabledSkillsChange;
+        this.reload();
+    }
+    reload() {
+        const result = discoverSkills({ roots: this.roots });
         this.skills = result.skills;
         this.diagnostics = result.diagnostics;
     }
@@ -25,7 +33,7 @@ export class SkillRegistry {
         return this.skills.slice();
     }
     promptVisible() {
-        return this.skills.filter((skill) => !skill.meta.disableModelInvocation);
+        return this.skills.filter((skill) => (this.isEnabled(skill.meta.name) && !skill.meta.disableModelInvocation));
     }
     summaries() {
         return this.promptVisible().map((skill) => ({
@@ -36,8 +44,35 @@ export class SkillRegistry {
         }));
     }
     get(name) {
+        if (!this.isEnabled(name))
+            return undefined;
+        return this.getAny(name);
+    }
+    getAny(name) {
         return this.skills.find((skill) => skill.meta.name === name);
     }
+    isEnabled(name) {
+        return !this.disabledSkills.has(name);
+    }
+    setEnabled(name, enabled) {
+        if (!this.getAny(name))
+            return false;
+        let changed = false;
+        if (enabled) {
+            changed = this.disabledSkills.delete(name);
+        }
+        else if (!this.disabledSkills.has(name)) {
+            this.disabledSkills.add(name);
+            changed = true;
+        }
+        if (!changed)
+            return false;
+        this.onDisabledSkillsChange?.([...this.disabledSkills].sort((a, b) => a.localeCompare(b)));
+        return true;
+    }
+    getDisabledSkillNames() {
+        return [...this.disabledSkills].sort((a, b) => a.localeCompare(b));
+    }
     getDiagnostics() {
         return this.diagnostics.slice();
     }

package/dist/skills/types.d.ts

@@ -4,6 +4,8 @@ export interface SkillMeta {
     disableModelInvocation: boolean;
     version?: number;
     tags?: string[];
+    author?: string;
+    allowedTools?: string[];
 }
 export interface SkillResourceIndex {
     references: string[];