@bubblebrain-ai/bubble 0.0.3 → 0.0.5

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const mainPath = fileURLToPath(new URL("./main.js", import.meta.url));
+if (process.versions.bun) {
+    await import("./main.js");
+}
+else {
+    const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
+    if (bunCheck.error) {
+        console.error([
+            "Bubble requires Bun to run.",
+            "",
+            "Install Bun, then run bubble again:",
+            "  curl -fsSL https://bun.sh/install | bash",
+            "",
+            "After installation, restart your terminal if the bun command is not found.",
+        ].join("\n"));
+        process.exit(1);
+    }
+    const child = spawn("bun", [mainPath, ...process.argv.slice(2)], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    child.on("error", (error) => {
+        console.error(`Failed to start Bubble with Bun: ${error.message}`);
+        process.exit(1);
+    });
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.on(signal, () => {
+            if (!child.killed) {
+                child.kill(signal);
+            }
+        });
+    }
+    const result = await new Promise((resolve) => {
+        child.on("exit", (code, signal) => resolve({ code, signal }));
+    });
+    if (result.signal) {
+        process.kill(process.pid, result.signal);
+    }
+    else {
+        process.exit(result.code ?? 1);
+    }
+}

package/dist/context/budget.js

@@ -6,6 +6,7 @@ export const MIN_WINDOW_FOR_RESERVE = 40_000;
 export function estimateMessageTokens(message) {
     switch (message.role) {
         case "system":
+        case "meta":
         case "tool":
             return estimateTextTokens(message.content);
         case "assistant":

package/dist/context/compact-llm.js

@@ -44,9 +44,9 @@ content, write "None".
    - The single most natural next action, if obvious.`;
 export async function compactMessagesWithLLM(messages, options) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
-    const systemMessages = messages.filter((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const turnStartIndexes = nonSystemMessages
+    const preservedContextMessages = messages.filter((m) => m.role === "system" || m.role === "meta");
+    const conversationalMessages = messages.filter((m) => m.role !== "system" && m.role !== "meta");
+    const turnStartIndexes = conversationalMessages
         .map((m, i) => (m.role === "user" ? i : -1))
         .filter((i) => i >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
@@ -56,8 +56,8 @@ export async function compactMessagesWithLLM(messages, options) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = nonSystemMessages.slice(0, keepStartIndex);
-    const keptMessages = nonSystemMessages.slice(keepStartIndex);
+    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
+    const keptMessages = conversationalMessages.slice(keepStartIndex);
     let summary;
     try {
         summary = await generateSummary(oldMessages, options);
@@ -72,7 +72,7 @@ export async function compactMessagesWithLLM(messages, options) {
         compacted: true,
         summary,
         messages: [
-            ...systemMessages,
+            ...preservedContextMessages,
             { role: "system", content: `Previous conversation summary:\n${summary}` },
             ...keptMessages,
         ],
@@ -112,6 +112,7 @@ function serializeTranscript(messages) {
                 lines.push(`[tool] ${truncate(message.content, 800)}`);
                 break;
             case "system":
+            case "meta":
                 break;
         }
     }

package/dist/context/compact.js

@@ -43,9 +43,9 @@ export function compactSessionEntries(entries, options = {}) {
 export function compactMessages(messages, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
     const maxSummaryItems = options.maxSummaryItems ?? 4;
-    const systemMessages = messages.filter((message) => message.role === "system");
-    const nonSystemMessages = messages.filter((message) => message.role !== "system");
-    const turnStartIndexes = nonSystemMessages
+    const preservedContextMessages = messages.filter((message) => message.role === "system" || message.role === "meta");
+    const conversationalMessages = messages.filter((message) => message.role !== "system" && message.role !== "meta");
+    const turnStartIndexes = conversationalMessages
         .map((message, index) => (message.role === "user" ? index : -1))
         .filter((index) => index >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
@@ -55,14 +55,14 @@ export function compactMessages(messages, options = {}) {
     if (keepStartIndex <= 0) {
         return { compacted: false };
     }
-    const oldMessages = nonSystemMessages.slice(0, keepStartIndex);
-    const keptMessages = nonSystemMessages.slice(keepStartIndex);
+    const oldMessages = conversationalMessages.slice(0, keepStartIndex);
+    const keptMessages = conversationalMessages.slice(keepStartIndex);
     const summary = buildMessageSummary(oldMessages, maxSummaryItems);
     if (!summary) {
         return { compacted: false };
     }
     const compactedMessages = [
-        ...systemMessages.map((message) => cloneMessage(message)),
+        ...preservedContextMessages.map((message) => cloneMessage(message)),
         {
             role: "system",
             content: `Previous conversation summary:\n${summary}`,

package/dist/context/projector.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "../types.js";
+import type { Message, ProviderMessage } from "../types.js";
 export interface ProjectionOptions {
     mode?: "full" | "pruned" | "budgeted";
     providerId?: string;
@@ -6,7 +6,7 @@ export interface ProjectionOptions {
     usageAnchorTokens?: number;
     anchorMessageCount?: number;
 }
-export declare function projectMessages(messages: Message[], options?: ProjectionOptions): Message[];
+export declare function projectMessages(messages: Message[], options?: ProjectionOptions): ProviderMessage[];
 /**
  * Ensures every assistant `tool_calls` is followed (in order) by tool messages
  * responding to each tool_call_id, with no foreign messages interleaved.
@@ -23,4 +23,4 @@ export declare function projectMessages(messages: Message[], options?: Projectio
  * synthesize placeholder tool messages for any tool_call_id with no captured
  * result. Other messages keep their original order.
  */
-export declare function repairToolCallChains(messages: Message[]): Message[];
+export declare function repairToolCallChains(messages: ProviderMessage[]): ProviderMessage[];

package/dist/context/projector.js

@@ -3,29 +3,33 @@ import { compactMessages } from "./compact.js";
 import { pruneMessages } from "./prune.js";
 export function projectMessages(messages, options = {}) {
     const mode = options.mode ?? "full";
-    const projected = [];
-    let systemBuffer = [];
-    const flushSystemBuffer = () => {
-        if (systemBuffer.length === 0)
-            return;
-        projected.push({
-            role: "system",
-            content: systemBuffer.join("\n\n"),
-        });
-        systemBuffer = [];
-    };
+    const projectedBody = [];
+    const systemContext = [];
     for (const message of messages) {
         if (message.role === "system") {
-            systemBuffer.push(message.content);
+            systemContext.push(message.content);
+            continue;
+        }
+        if (message.role === "meta") {
+            if (message.includeInLlm !== false) {
+                systemContext.push(formatMetaMessage(message));
+            }
             continue;
         }
-        flushSystemBuffer();
         if (message.role === "assistant" && isEmptyAssistantMessage(message)) {
             continue;
         }
-        projected.push(cloneMessage(message));
+        projectedBody.push(cloneMessage(message));
     }
-    flushSystemBuffer();
+    const projected = [
+        ...(systemContext.length > 0
+            ? [{
+                    role: "system",
+                    content: systemContext.join("\n\n"),
+                }]
+            : []),
+        ...projectedBody,
+    ];
     const repaired = repairToolCallChains(projected);
     if (mode === "pruned") {
         return pruneMessages(repaired);
@@ -48,12 +52,13 @@ export function projectMessages(messages, options = {}) {
         if (!compacted.compacted || !compacted.messages) {
             return pruned;
         }
-        const afterFirstPass = getContextBudget(options.providerId, options.modelId, compacted.messages);
+        const compactedMessages = compacted.messages;
+        const afterFirstPass = getContextBudget(options.providerId, options.modelId, compactedMessages);
         if (!afterFirstPass.shouldCompact) {
-            return repairToolCallChains(compacted.messages);
+            return repairToolCallChains(compactedMessages);
         }
         const tighter = compactMessages(pruned, { keepRecentTurns: 1 });
-        const finalMessages = tighter.compacted && tighter.messages ? tighter.messages : compacted.messages;
+        const finalMessages = (tighter.compacted && tighter.messages ? tighter.messages : compactedMessages);
         return repairToolCallChains(finalMessages);
     }
     return repaired;
@@ -130,6 +135,15 @@ function isEmptyAssistantMessage(message) {
     const hasToolCalls = !!message.toolCalls && message.toolCalls.length > 0;
     return !hasContent && !hasReasoning && !hasToolCalls;
 }
+function formatMetaMessage(message) {
+    switch (message.kind) {
+        case "system-reminder":
+            return `Runtime reminder:\n${message.content}`;
+        case "runtime-context":
+        default:
+            return `Runtime context:\n${message.content}`;
+    }
+}
 function cloneMessage(message) {
     if (message.role === "assistant") {
         return {

package/dist/context/prune.d.ts

@@ -1,9 +1,9 @@
 import type { Message } from "../types.js";
-export declare function pruneMessages(messages: Message[]): Message[];
+export declare function pruneMessages<T extends Message>(messages: T[]): T[];
 /**
  * Aggressive variant of pruneMessages: drops the content of every prunable
  * tool output except the latest unresolved tool turn that the model still
  * needs to reason over. Used as a last-resort microcompact pass when a
  * standard prune hasn't reclaimed enough budget.
  */
-export declare function aggressivePruneMessages(messages: Message[]): Message[];
+export declare function aggressivePruneMessages<T extends Message>(messages: T[]): T[];

package/dist/context/prune.js

@@ -96,10 +96,7 @@ export function aggressivePruneMessages(messages) {
 function collectProtectedToolCallIds(messages) {
     for (let index = messages.length - 1; index >= 0; index--) {
         const message = messages[index];
-        if (message.role === "tool" || message.role === "system") {
-            continue;
-        }
-        if (message.role === "user" && message.isMeta) {
+        if (message.role === "tool" || message.role === "system" || message.role === "meta") {
             continue;
         }
         if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {

package/dist/main.d.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /**
  * Main entry point - assembles all layers and runs the agent.
  */

package/dist/main.js

@@ -1,9 +1,10 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /**
  * Main entry point - assembles all layers and runs the agent.
  */
 import chalk from "chalk";
 import { Agent } from "./agent.js";
+import { BudgetLedger } from "./agent/budget-ledger.js";
 import { parseArgs, printHelp } from "./cli.js";
 import { UserConfig } from "./config.js";
 import { createProviderInstance, createUnavailableProvider } from "./provider.js";
@@ -185,6 +186,8 @@ async function main() {
         : (sessionThinkingLevel ?? args.thinkingLevel ?? configuredThinkingLevel ?? "off");
     const restoredTodos = sessionManager?.getTodos() ?? [];
     const initialMode = args.mode ?? "default";
+    const skillSummaries = skillRegistry.summaries();
+    const memoryPrompt = buildMemoryPrompt(args.cwd);
     const systemPrompt = buildSystemPrompt({
         agentName: "Bubble",
         configuredProvider: activeProviderId || "none",
@@ -194,9 +197,10 @@ async function main() {
         mode: initialMode,
         workingDir: args.cwd,
         tools: tools.map((tool) => tool.name),
-        skills: skillRegistry.summaries(),
-        memoryPrompt: buildMemoryPrompt(args.cwd),
+        skills: skillSummaries,
+        memoryPrompt,
     });
+    const budgetLedger = new BudgetLedger();
     const agent = new Agent({
         provider: activeProvider
             ? createProvider(activeProviderId, activeProvider.apiKey, activeProvider.baseURL)
@@ -215,9 +219,9 @@ async function main() {
                 return;
             if (message.role === "system")
                 return;
-            // <system-reminder> injections are runtime/ephemeral; don't persist them —
+            // Runtime meta messages are ephemeral; don't persist them —
             // they will be re-injected as needed on resume based on the current mode.
-            if (message.role === "user" && message.isMeta)
+            if (message.role === "meta")
                 return;
             sessionManager.appendMessage(message);
             if (message.role === "assistant") {
@@ -240,6 +244,9 @@ async function main() {
         onModeUpdate: (mode) => {
             sessionManager?.appendMarker("mode_switch", mode);
         },
+        budgetLedger,
+        skills: skillSummaries,
+        memoryPrompt,
     });
     agentRef = agent;
     if (sessionManager) {
@@ -281,7 +288,7 @@ async function main() {
         const history = sessionManager.getMessages();
         if (history.length > 0) {
             agent.messages = [{ role: "system", content: systemPrompt }, ...history];
-            // Reassigning agent.messages drops any <system-reminder> we injected during
+            // Reassigning agent.messages drops any runtime meta reminder injected during
             // construction. Re-inject if the agent is starting in plan mode.
             if (agent.mode === "plan") {
                 agent.injectModeReminder();

package/dist/mcp/manager.js

@@ -164,6 +164,7 @@ function buildToolEntry(serverName, tool, getClient) {
         description,
         parameters,
         readOnly: false, // Conservative default; user can allow-list.
+        effect: "unknown",
         deferred: true, // Load schema on demand via tool_search to keep context small.
         async execute(args) {
             const client = getClient();

package/dist/orchestrator/default-hooks.js

@@ -2,7 +2,8 @@ import { classifyTask } from "../agent/task-classifier.js";
 import { EvidenceTracker } from "../agent/evidence-tracker.js";
 import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
-import { buildTaskSummaryReminder, buildWorkflowPhaseReminder } from "../prompt/reminders.js";
+import { buildFinalizeOpportunityReminder, buildTaskSummaryReminder, buildVerificationFailureReminder, buildVerificationReminder, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
+import { reminderForTaskType } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 export function createDefaultHooks() {
     return [
@@ -11,6 +12,10 @@ export function createDefaultHooks() {
                 const taskType = classifyTask(ctx.input);
                 ctx.state.taskType = taskType;
                 ctx.state.governor = new ExecutionGovernor(taskType);
+                const taskReminder = reminderForTaskType(taskType);
+                if (taskReminder) {
+                    ctx.queueReminder(taskReminder);
+                }
                 if (taskType === "security_investigation") {
                     ctx.state.evidenceTracker = new EvidenceTracker();
                     ctx.state.workflowPhase = "investigate";
@@ -70,6 +75,21 @@ export function createDefaultHooks() {
                 }
                 ctx.state.evidenceTracker?.observe(ctx.toolCall, ctx.result);
                 ctx.state.governor?.afterToolResult(ctx.toolCall, ctx.result);
+                if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
+                    markCodeChanged(ctx.state);
+                }
+                else if (ctx.state.codeChanged && isVerificationAttempt(ctx.toolCall, ctx.result)) {
+                    ctx.state.verificationAttempted = true;
+                    if (isSuccessfulToolResult(ctx.result)) {
+                        ctx.state.verificationCompleted = true;
+                        ctx.state.verificationFailed = false;
+                    }
+                    else {
+                        ctx.state.verificationCompleted = false;
+                        ctx.state.verificationFailed = true;
+                        ctx.state.finalizeReminderQueued = false;
+                    }
+                }
                 if (ctx.toolCall.name === "task") {
                     ctx.queueReminder(buildTaskSummaryReminder());
                 }
@@ -90,7 +110,78 @@ export function createDefaultHooks() {
                 if (ctx.state.governor?.snapshot().searchFrozen && allSearchResultsWereLowSignal) {
                     ctx.requestTextOnlyTurn("Search continuation has become low-yield. Summarize the strongest evidence already collected instead of continuing broad exploration.");
                 }
+                const changedThisTurn = ctx.toolResults.some((result) => result.metadata?.kind === "write" || result.metadata?.kind === "edit");
+                if (changedThisTurn && !ctx.state.verificationAttempted && !ctx.state.verificationCompleted && !ctx.state.verificationReminderQueued) {
+                    ctx.state.verificationReminderQueued = true;
+                    ctx.queueReminder(buildVerificationReminder("The previous turn changed files and no verification evidence has been observed yet."));
+                }
+                if (ctx.state.codeChanged && ctx.state.verificationFailed && !ctx.state.verificationFailureReminderQueued) {
+                    ctx.state.verificationFailureReminderQueued = true;
+                    ctx.queueReminder(buildVerificationFailureReminder("A verification command or runtime check was attempted after file changes, but it did not pass."));
+                }
+                if (ctx.state.codeChanged && ctx.state.verificationCompleted && !ctx.state.finalizeReminderQueued) {
+                    ctx.state.finalizeReminderQueued = true;
+                    ctx.queueReminder(buildFinalizeOpportunityReminder("A relevant verification command or runtime check passed after file changes."));
+                }
+            },
+            afterTurn(ctx) {
+                if (ctx.state.codeChanged && ctx.state.verificationFailed && !ctx.state.verificationFailureReminderSent) {
+                    ctx.state.verificationFailureReminderSent = true;
+                    ctx.state.forceContinuationReason = "Files were changed, but the latest verification evidence failed.";
+                    ctx.queueReminder(buildVerificationFailureReminder(ctx.state.forceContinuationReason));
+                    return;
+                }
+                if (ctx.state.codeChanged && !ctx.state.verificationAttempted && !ctx.state.verificationCompleted && !ctx.state.finalVerificationReminderSent) {
+                    ctx.state.finalVerificationReminderSent = true;
+                    ctx.state.forceContinuationReason = "Files were changed but no verification evidence was observed before the final answer.";
+                    ctx.queueReminder(buildVerificationReminder(ctx.state.forceContinuationReason));
+                }
             },
         },
     ];
 }
+function markCodeChanged(state) {
+    state.codeChanged = true;
+    state.verificationAttempted = false;
+    state.verificationCompleted = false;
+    state.verificationFailed = false;
+    state.verificationReminderQueued = false;
+    state.finalVerificationReminderSent = false;
+    state.verificationFailureReminderQueued = false;
+    state.verificationFailureReminderSent = false;
+    state.finalizeReminderQueued = false;
+}
+function isCodeWriteResult(_toolCall, result) {
+    if (result.isError || result.status === "blocked" || result.status === "command_error") {
+        return false;
+    }
+    return result.metadata?.kind === "write" || result.metadata?.kind === "edit";
+}
+function isSuccessfulToolResult(result) {
+    if (result.isError) {
+        return false;
+    }
+    return result.status !== "blocked" && result.status !== "command_error" && result.status !== "timeout";
+}
+function isVerificationAttempt(toolCall, result) {
+    if (toolCall.name === "lsp") {
+        return true;
+    }
+    if (toolCall.name !== "bash") {
+        return false;
+    }
+    const command = typeof result.metadata?.command === "string"
+        ? result.metadata.command
+        : typeof toolCall.parsedArgs.command === "string"
+            ? toolCall.parsedArgs.command
+            : "";
+    return isVerificationCommand(command);
+}
+function isVerificationCommand(command) {
+    const normalized = command.trim().toLowerCase();
+    return /\b(npm|pnpm|yarn|bun)\s+(test|run\s+(test|build|typecheck|lint|check|tsc)|exec\s+tsc)\b/.test(normalized)
+        || /\b(npx|pnpm\s+exec|bunx)\s+(vitest|tsc|eslint|playwright)\b/.test(normalized)
+        || /\b(python3?|uv\s+run\s+python3?|poetry\s+run\s+python3?)\s+(-m\s+)?(pytest|unittest|ruff|mypy)\b/.test(normalized)
+        || /\b(make|cmake)\s+(test|check)\b/.test(normalized)
+        || /\b(vitest|tsc|pytest|ruff|mypy|ctest|cargo\s+test|go\s+test|swift\s+test|mvn\s+test|gradle\s+test|\.\/gradlew\s+test)\b/.test(normalized);
+}

package/dist/orchestrator/hooks.d.ts

@@ -12,6 +12,16 @@ export interface TurnHookState {
     workflowKey?: string;
     turnCount?: number;
     forceTextOnlyReason?: string;
+    forceContinuationReason?: string;
+    codeChanged?: boolean;
+    verificationAttempted?: boolean;
+    verificationCompleted?: boolean;
+    verificationFailed?: boolean;
+    verificationReminderQueued?: boolean;
+    finalVerificationReminderSent?: boolean;
+    verificationFailureReminderQueued?: boolean;
+    verificationFailureReminderSent?: boolean;
+    finalizeReminderQueued?: boolean;
     taskBudget?: {
         total: number;
         spent: number;

package/dist/prompt/compose.d.ts

@@ -8,5 +8,6 @@ export interface ComposeSystemPromptOptions extends EnvironmentPromptOptions {
     mode?: PermissionMode;
     skills?: SkillSummary[];
     memoryPrompt?: string;
+    agentProfilePrompt?: string;
 }
 export declare function composeSystemPrompt(options?: ComposeSystemPromptOptions): string;

package/dist/prompt/compose.js

@@ -1,8 +1,11 @@
 import { buildAnthropicProviderPrompt } from "./provider-prompts/anthropic.js";
 import { buildCodexProviderPrompt } from "./provider-prompts/codex.js";
 import { buildDefaultProviderPrompt } from "./provider-prompts/default.js";
+import { buildDeepSeekProviderPrompt } from "./provider-prompts/deepseek.js";
 import { buildGeminiProviderPrompt } from "./provider-prompts/gemini.js";
+import { buildGlmProviderPrompt } from "./provider-prompts/glm.js";
 import { buildGptProviderPrompt } from "./provider-prompts/gpt.js";
+import { buildKimiProviderPrompt } from "./provider-prompts/kimi.js";
 import { buildEnvironmentPrompt, defaultToolNames } from "./environment.js";
 import { buildRuntimePrompt } from "./runtime.js";
 import { buildSkillsPrompt } from "./skills.js";
@@ -24,7 +27,14 @@ export function composeSystemPrompt(options = {}) {
         guidelines: buildGuidelines(options.tools ?? defaultToolNames, options.guidelines ?? []),
     });
     const skillsPrompt = buildSkillsPrompt(options.skills ?? []);
-    return [providerPrompt, environmentPrompt, runtimePrompt, options.memoryPrompt, skillsPrompt].filter(Boolean).join("\n\n");
+    return [
+        providerPrompt,
+        environmentPrompt,
+        runtimePrompt,
+        options.agentProfilePrompt,
+        options.memoryPrompt,
+        skillsPrompt,
+    ].filter(Boolean).join("\n\n");
 }
 function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     const provider = providerId ?? "";
@@ -39,6 +49,15 @@ function buildProviderPrompt(agentName, providerId, modelId, modelName) {
     if (provider === "openai-codex" || model.includes("codex") || model.startsWith("gpt-5")) {
         return buildCodexProviderPrompt(agentName);
     }
+    if (provider === "deepseek" || model.startsWith("deepseek")) {
+        return buildDeepSeekProviderPrompt(agentName);
+    }
+    if (["moonshot-cn", "moonshot-intl", "kimi-for-coding"].includes(provider) || model.startsWith("kimi") || model.startsWith("k2.")) {
+        return buildKimiProviderPrompt(agentName);
+    }
+    if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(provider) || model.startsWith("glm")) {
+        return buildGlmProviderPrompt(agentName);
+    }
     if (provider === "openai" || provider === "openrouter" || model.startsWith("gpt") || model.startsWith("o1")) {
         return buildGptProviderPrompt(agentName);
     }

package/dist/prompt/environment.js

@@ -9,11 +9,30 @@ export const defaultToolSnippets = {
     lsp: "Use the language server for code navigation, symbols, call hierarchy, and type-aware lookup",
     web_search: "Search the public web for current information",
     web_fetch: "Fetch and extract the contents of a specific webpage",
-    task: "Delegate a bounded investigative subtask to a read-only sub-agent",
+    spawn_agent: "Start a child subagent thread and return its agent id plus nickname",
+    wait_agent: "Wait for one or more spawned subagents to finish",
+    send_input: "Send follow-up input to an existing subagent thread",
+    close_agent: "Close or cancel a spawned subagent thread",
     question: "Ask the user structured questions when clarification or preference choices would materially improve the work",
     skill: "Load a named skill with specialized instructions and bundled resources",
 };
-export const defaultToolNames = ["read", "glob", "bash", "edit", "write", "grep", "lsp", "web_search", "web_fetch", "task", "question", "skill"];
+export const defaultToolNames = [
+    "read",
+    "glob",
+    "bash",
+    "edit",
+    "write",
+    "grep",
+    "lsp",
+    "web_search",
+    "web_fetch",
+    "spawn_agent",
+    "wait_agent",
+    "send_input",
+    "close_agent",
+    "question",
+    "skill",
+];
 export function buildEnvironmentPrompt(options = {}) {
     const configuredProvider = options.configuredProvider ?? "unknown";
     const configuredModel = options.configuredModel ?? "unknown";

package/dist/prompt/provider-prompts/deepseek.d.ts

@@ -0,0 +1 @@
+export declare function buildDeepSeekProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/deepseek.js

@@ -0,0 +1,8 @@
+export function buildDeepSeekProviderPrompt(agentName) {
+    return `You are ${agentName}, a direct coding agent running on a DeepSeek model.
+
+Prefer short plans followed by concrete tool use. Avoid broad speculation.
+After each tool result, update your understanding before choosing the next action.
+Do not repeat equivalent searches unless the previous result changed the search space.
+When provider/API behavior is involved, inspect serialization and request-shape code before changing generic agent logic.`;
+}

package/dist/prompt/provider-prompts/glm.d.ts

@@ -0,0 +1 @@
+export declare function buildGlmProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/glm.js

@@ -0,0 +1,7 @@
+export function buildGlmProviderPrompt(agentName) {
+    return `You are ${agentName}, a pragmatic coding agent running on a GLM/Z.AI model.
+
+Be specific and evidence-driven. Prefer source inspection and verification over generic recommendations.
+When debugging, identify the failing boundary before editing.
+When implementing, finish the requested change end to end and verify the relevant path.`;
+}

package/dist/prompt/provider-prompts/kimi.d.ts

@@ -0,0 +1 @@
+export declare function buildKimiProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/kimi.js

@@ -0,0 +1,7 @@
+export function buildKimiProviderPrompt(agentName) {
+    return `You are ${agentName}, a terminal coding agent running on a Kimi/Moonshot model.
+
+Keep tool use disciplined: pursue one concrete hypothesis at a time, read results carefully, and converge after evidence is sufficient.
+Do not fan out into many parallel search directions unless the task truly requires it.
+For tool-call or reasoning-mode issues, inspect message history serialization before changing unrelated agent behavior.`;
+}

package/dist/prompt/reminders.d.ts

@@ -1,6 +1,6 @@
 /**
  * System reminders - short, runtime-variable instructions injected into the
- * message stream as <system-reminder>-wrapped user messages with isMeta=true.
+ * message stream as hidden meta messages.
  *
  * Rationale: the static system prompt is stable and cacheable. Mode transitions
  * and other ephemeral state are signaled via reminders so we do not invalidate
@@ -22,6 +22,7 @@ export declare function buildDeferredToolsReminder(names: string[]): string;
 export declare function buildInvestigationReminder(): string;
 export declare function buildLoopWarningReminder(reason: string): string;
 export declare function buildSearchFreezeReminder(reason: string): string;
+export declare function buildExplorationFreezeReminder(reason: string): string;
 export declare function buildToolFreezeReminder(reason: string): string;
 export declare function buildWorkflowPhaseReminder(input: {
     phase: "investigate" | "correlate" | "conclude";
@@ -29,3 +30,6 @@ export declare function buildWorkflowPhaseReminder(input: {
     pending: string[];
 }): string;
 export declare function buildTaskSummaryReminder(): string;
+export declare function buildVerificationReminder(reason: string): string;
+export declare function buildVerificationFailureReminder(reason: string): string;
+export declare function buildFinalizeOpportunityReminder(reason: string): string;