@bubblebrain-ai/bubble 0.0.34 → 0.0.35

package/dist/main.js

@@ -235,12 +235,20 @@ async function main() {
             const pickerThemeMode = effectiveThemeModeForTerminal(themeConfig, preResolvedTheme);
             const pickerResolvedTheme = pickerThemeMode === "auto" ? preResolvedTheme : pickerThemeMode;
             const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
+            const { canvasBackgroundFor } = await import("./tui-ink/theme.js");
+            // Same rule as the main TUI: a forced theme mismatching the terminal
+            // paints its canvas so its foregrounds stay readable.
+            const pickerCanvas = themeConfig.overrides?.background
+                ? undefined
+                : canvasBackgroundFor(pickerThemeMode, pickerResolvedTheme, preResolvedTheme);
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
                 allSessions,
                 resolvedTheme: pickerResolvedTheme,
-                themeOverrides: themeConfig.overrides,
+                themeOverrides: pickerCanvas
+                    ? { ...themeConfig.overrides, background: pickerCanvas }
+                    : themeConfig.overrides,
             });
             if (picked) {
                 sessionManager = new SessionManager(picked);

package/dist/model-catalog.js

@@ -30,6 +30,8 @@ const GPT51_LEVELS = ["off", "low", "medium", "high"];
 const GPT51_CODEX_MAX_LEVELS = ["off", "low", "medium", "high", "xhigh"];
 const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 const OPENAI_CHAT_LEVELS = ["off"];
+// Internal representation for APIs that expose thinking as enabled/disabled.
+// UI code must render supported toggle models as on/off, not as "medium" effort.
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
 // GLM-5.2 is the first GLM to accept OpenAI-style `reasoning_effort`. The API
 // enum is none/minimal/low/medium/high/xhigh/max; we expose high and max (the
@@ -38,8 +40,8 @@ const TOGGLE_THINKING_LEVELS = ["off", "medium"];
 // is first so it is the default (getDefaultThinkingLevel falls back to levels[0]
 // when "medium" is absent), since GLM-5.2 is a thinking-on-by-default model.
 const GLM_5_2_LEVELS = ["high", "max", "off"];
-// kimi-k2.7-code only supports thinking mode (disabling it errors), so "off" is
-// not offered — the model is always in its thinking variant.
+// Kimi K2.7 Code variants only support thinking mode (disabling it errors), so
+// "off" is not offered — the model is always in its thinking variant.
 const KIMI_THINKING_ONLY_LEVELS = ["medium"];
 const DEEPSEEK_V4_LEVELS = ["high", "max"];
 const STEPFUN_REASONING_LEVELS = ["off", "low", "medium", "high"];
@@ -119,25 +121,17 @@ export const BUILTIN_MODELS = [
     { id: "step-3.5-flash", name: "Step 3.5 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-router-v1", name: "Step Router V1", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-cn", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "moonshot-cn", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "moonshot-cn", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-0905-preview", name: "Kimi K2 0905", providerId: "moonshot-cn", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-thinking", name: "Kimi K2 Thinking", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-intl", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "moonshot-intl", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "moonshot-intl", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-0905-preview", name: "Kimi K2 0905", providerId: "moonshot-intl", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-thinking", name: "Kimi K2 Thinking", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "kimi-for-coding", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "kimi-for-coding", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "k2.6-code-preview", name: "Kimi K2.6 Code Preview", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
-    { id: "kimi-k2-turbo-preview", name: "Kimi K2 Turbo", providerId: "kimi-for-coding", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-0905-preview", name: "Kimi K2 0905", providerId: "kimi-for-coding", reasoningLevels: ["off"], contextWindow: 256000 },
-    { id: "kimi-k2-thinking", name: "Kimi K2 Thinking", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
+    { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "kimi-for-coding", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "llama-3.3-70b-versatile", name: "llama-3.3-70b-versatile", providerId: "groq", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "mixtral-8x7b-32768", name: "mixtral-8x7b-32768", providerId: "groq", reasoningLevels: ["off"], contextWindow: 32768 },
     { id: "gemma-2-9b-it", name: "gemma-2-9b-it", providerId: "groq", reasoningLevels: ["off"], contextWindow: 32768 },

package/dist/orchestrator/default-hooks.js

@@ -5,7 +5,7 @@ import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
 import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildTaskSummaryReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
-import { reminderForTaskType } from "../prompt/task-reminders.js";
+import { orchestrationRequestReminder, reminderForTaskType } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-reminder.js";
 export function createDefaultHooks() {
@@ -28,6 +28,12 @@ export function createDefaultHooks() {
                 if (taskReminder) {
                     ctx.queueReminder(taskReminder);
                 }
+                // User named the mechanism ("agent team" / workflow / 编排): remind at
+                // the decision turn, where it outweighs the parallel-spawns prior.
+                const orchestrationReminder = orchestrationRequestReminder(ctx.input, ctx.agent.hasToolAvailable("run_workflow"));
+                if (orchestrationReminder) {
+                    ctx.queueReminder(orchestrationReminder);
+                }
                 // Small-task hint: counterweight to the default protocol's exploration
                 // bias, only fires once per run on focused one-shot requests like
                 // "写个 HTML 介绍元旦". Don't issue for the same input twice.

package/dist/prompt/delegation.d.ts

@@ -5,7 +5,7 @@
  * and read-only-scoped, negative clauses get equal weight — the user's hard
  * constraint is "proactive, but never delegate-everything". Gated on the
  * delegation tools being present, so child agents (whose tool sets never
- * include spawn_agent/agent_team) never see it.
+ * include spawn_agent/run_workflow) never see it.
  */
 /**
  * Returns the delegation policy section when the agent actually has the

package/dist/prompt/delegation.js

@@ -5,12 +5,19 @@
  * and read-only-scoped, negative clauses get equal weight — the user's hard
  * constraint is "proactive, but never delegate-everything". Gated on the
  * delegation tools being present, so child agents (whose tool sets never
- * include spawn_agent/agent_team) never see it.
+ * include spawn_agent/run_workflow) never see it.
  */
 const DELEGATION_POLICY = `## Delegation policy (subagents)
 
-You can delegate work to background subagents (spawn_agent) and batch
-fan-outs (agent_team). Delegate deliberately, not by default.
+You can delegate work two ways: a single background subagent (spawn_agent),
+or an orchestration script coordinating many subagents (run_workflow).
+Delegate deliberately, not by default.
+
+Explicit requests win, before any other rule: when the user names a
+coordinated multi-agent run in any phrasing — a workflow, an orchestration,
+an agent team, "fan out agents" — that means run_workflow, NOT a row of
+spawn_agent calls. When they ask for a subagent, spawn one. Only when the
+user has not named a mechanism do you choose by shape (below).
 
 Delegate when:
 - An investigation will clearly require more than four search or read
@@ -18,9 +25,16 @@ Delegate when:
   needs the conclusion — delegate to a subagent so the intermediate noise
   stays out of the main context. Launch multiple subagents concurrently for
   independent questions.
-- The task naturally splits into the same read-only investigation or
-  analysis (review, audit, summarize) over several independent items (files,
-  modules, endpoints) — use agent_team.
+- The task fans out over many independent items (review, audit, summarize
+  across files, modules, endpoints) or needs staged orchestration — consider
+  run_workflow. Choose by shape, not by rule: a handful of subagents whose
+  results you want to read and react to individually favor spawn_agent; a
+  uniform sweep over many items, results that should be aggregated or
+  filtered before they reach this conversation, or control flow between
+  stages (pipelines, loops, retry rounds) favor a run_workflow script — each
+  member's full handoff stays out of your context and the script returns one
+  digested result. Failed agent() calls resolve to null, so report which
+  items came back null instead of silently dropping them.
 - A side-investigation is independent of your current main-line work and can
   run in the background while you continue.
 
@@ -51,7 +65,7 @@ Do NOT delegate when:
 When in doubt about a one-off task, do it yourself. When a task is clearly
 the same read-only operation over three or more independent items — where
 each item alone would take more than a couple of tool calls — prefer
-agent_team over doing them sequentially yourself. For just two small items,
+run_workflow over doing them sequentially yourself. For just two small items,
 do them yourself with parallel tool calls.`;
 /**
  * Returns the delegation policy section when the agent actually has the

package/dist/prompt/task-reminders.d.ts

@@ -4,3 +4,4 @@ export interface TaskReminderOptions {
     canDelegate?: boolean;
 }
 export declare function reminderForTaskType(taskType: TaskType, options?: TaskReminderOptions): string | undefined;
+export declare function orchestrationRequestReminder(input: string | import("../types.js").ContentPart[], canRunWorkflow: boolean): string | undefined;

package/dist/prompt/task-reminders.js

@@ -6,7 +6,7 @@ import { wrapInSystemReminder } from "./reminders.js";
  * keeps it away from ordinary implementation/debugging turns, so it cannot
  * amplify over-delegation.
  */
-const DELEGATION_NUDGE = "- If answering needs scanning many files and only the conclusion matters, delegate to a background subagent (spawn_agent); when it is the same read-only question over several independent items, fan out with agent_team.";
+const DELEGATION_NUDGE = "- If answering needs scanning many files and only the conclusion matters, delegate to a background subagent (spawn_agent); when it is the same read-only question over several independent items, fan out with a run_workflow script.";
 export function reminderForTaskType(taskType, options = {}) {
     switch (taskType) {
         case "debugging":
@@ -62,3 +62,26 @@ Product discussion workflow:
             return undefined;
     }
 }
+/**
+ * Deterministic detector for an explicit user request for a coordinated
+ * multi-agent run. Three rounds of prompt wording lost to the model's
+ * "agent team = parallel spawns" prior in live tests (opus-4.8, 2026-07-06);
+ * per the task-reminder principle above, a reminder injected at the decision
+ * turn is the lever that actually works — the harness remembers so the model
+ * does not have to.
+ */
+const ORCHESTRATION_REQUEST = /\b(?:workflows?|orchestrat\w*|agent[ -]?teams?|fan[ -]?out)\b|工作流|编排|(?:智能体|代理|agent)\s*(?:团队|小队)/i;
+export function orchestrationRequestReminder(input, canRunWorkflow) {
+    if (!canRunWorkflow)
+        return undefined;
+    const text = typeof input === "string"
+        ? input
+        : input.map((part) => ("text" in part ? String(part.text ?? "") : "")).join(" ");
+    if (!ORCHESTRATION_REQUEST.test(text))
+        return undefined;
+    return [
+        "- This message explicitly asks for a coordinated multi-agent run (a workflow / orchestration / agent team).",
+        "Honor it with ONE run_workflow call whose script covers the whole fan-out.",
+        "Do not substitute parallel spawn_agent calls this turn — the user named the mechanism.",
+    ].join(" ");
+}

package/dist/provider-transform.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "./types.js";
-export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;

package/dist/provider-transform.js

@@ -1,9 +1,8 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./variant/variant-resolver.js";
-export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
-const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code"]);
-const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
-const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
+const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code", "kimi-k2.7-code-highspeed"]);
+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"]);
 function isFireworksKimi(providerId, modelId) {
@@ -99,12 +98,11 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
         };
     }
-    // Moonshot / Kimi: kimi-k2.5 family (incl. k2.6-code-preview, kimi-k2.6) locks
-    // temperature/top_p/n/penalties and exposes thinking via extra_body.thinking;
-    // kimi-k2-thinking family locks temperature=1.
+    // Moonshot / Kimi: K2.5/K2.6 lock temperature/top_p/n/penalties and expose
+    // thinking via extra_body.thinking.
     if (MOONSHOT_PROVIDER_IDS.has(providerId)) {
-        // kimi-k2.7-code is thinking-only: temperature is locked to 1.0 server-side
-        // (any explicit value errors), thinking can never be disabled, and
+        // Kimi K2.7 Code variants are thinking-only: temperature is locked to 1.0
+        // server-side (any explicit value errors), thinking can never be disabled, and
         // reasoning_content must be echoed back on tool-call turns.
         if (KIMI_K27_FAMILY.has(modelId)) {
             return {
@@ -116,7 +114,7 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
-        if (KIMI_K25_FAMILY.has(modelId)) {
+        if (KIMI_TOGGLE_THINKING_FAMILY.has(modelId)) {
             return {
                 effectiveThinkingLevel,
                 omitTemperature: true,
@@ -126,9 +124,6 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
-        if (KIMI_THINKING_FAMILY.has(modelId)) {
-            return { effectiveThinkingLevel, omitTemperature: true };
-        }
         return { effectiveThinkingLevel };
     }
     if (providerId === "openai"

package/dist/tools/agent-lifecycle.d.ts

@@ -24,15 +24,7 @@ export declare function createWaitAgentTool(): ToolRegistryEntry;
 export declare function createSendInputTool(): ToolRegistryEntry;
 export declare function createCloseAgentTool(): ToolRegistryEntry;
 export declare function createListAgentsTool(): ToolRegistryEntry;
-/** Items bound for one agent_team call (design §1.2). */
-export declare const AGENT_TEAM_MIN_ITEMS = 2;
-export declare const AGENT_TEAM_MAX_ITEMS = 32;
-export declare function createAgentTeamTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
-/** Specs bound for one agent_batch call (design v2 §1.3). */
-export declare const AGENT_BATCH_MIN_SPECS = 2;
-export declare const AGENT_BATCH_MAX_SPECS = 32;
-export declare function createAgentBatchTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
-export declare function createRunWorkflowTool(options?: AgentLifecycleToolOptions): ToolRegistryEntry;
+export declare function createRunWorkflowTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
 export declare function createWaitWorkflowTool(): ToolRegistryEntry;
 export declare function createAgentLifecycleTools(options?: AgentLifecycleToolOptions): ToolRegistryEntry[];
 export {};