@bubblebrain-ai/bubble 0.0.4 → 0.0.5

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.js

@@ -4,6 +4,7 @@
  */
 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,7 @@ 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, buildVerificationReminder, 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() {
@@ -76,10 +76,19 @@ 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)) {
-                    ctx.state.codeChanged = true;
+                    markCodeChanged(ctx.state);
                 }
-                else if (ctx.state.codeChanged && isVerificationResult(ctx.toolCall, ctx.result)) {
-                    ctx.state.verificationCompleted = true;
+                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());
@@ -102,13 +111,27 @@ export function createDefaultHooks() {
                     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.verificationCompleted && !ctx.state.verificationReminderQueued) {
+                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.verificationCompleted && !ctx.state.finalVerificationReminderSent) {
+                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));
@@ -117,16 +140,30 @@ export function createDefaultHooks() {
         },
     ];
 }
+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 isVerificationResult(toolCall, result) {
-    if (result.isError || result.status === "blocked" || result.status === "command_error") {
+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;
     }
@@ -144,5 +181,7 @@ 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(vitest|tsc|pytest|ruff|cargo\s+test|go\s+test|swift\s+test)\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

@@ -14,9 +14,14 @@ export interface TurnHookState {
     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

@@ -27,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 ?? "";

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/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
@@ -31,3 +31,5 @@ export declare function buildWorkflowPhaseReminder(input: {
 }): 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;

package/dist/prompt/reminders.js

@@ -1,13 +1,13 @@
 /**
  * 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
  * the prompt cache every time something changes.
  */
 export function wrapInSystemReminder(content) {
-    return `<system-reminder>\n${content.trim()}\n</system-reminder>`;
+    return content.trim();
 }
 export function isPermissionModeReminder(content) {
     if (typeof content !== "string")
@@ -20,7 +20,7 @@ const PLAN_MODE_ENTER = `
 Plan mode is now ACTIVE.
 
 Rules while in plan mode:
-- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, task, skill, todo_write, tool_search, question, and exit_plan_mode.
+- Only read-only tools are allowed, including read, glob, grep, lsp, web_search, web_fetch, spawn_agent, wait_agent, send_input, close_agent, skill, todo_write, tool_search, question, and exit_plan_mode.
 - Writes, edits, and shell commands WILL be rejected by the harness; do not try them.
 - Do not edit files or claim implementation is complete while plan mode is active.
 - Investigate the codebase, then use the question tool to clarify important ambiguities, tradeoffs, requirements, or preference choices that would materially change the plan.
@@ -55,7 +55,6 @@ export function reminderForMode(mode) {
             return wrapInSystemReminder(DEFAULT_ENTER);
     }
 }
-// Backward-compat exports kept in case external code pinned the old names.
 export const PLAN_MODE_ENTER_REMINDER = reminderForMode("plan");
 export const PLAN_MODE_EXIT_REMINDER = reminderForMode("default");
 /**
@@ -182,3 +181,23 @@ You have changed files in this turn. Run the narrowest meaningful verification c
 If verification truly cannot be run, state the concrete blocker and the residual risk.
 `);
 }
+export function buildVerificationFailureReminder(reason) {
+    return wrapInSystemReminder(`
+Verification failed after file changes.
+
+${reason}
+
+Do not finalize as complete while this failure is unresolved. Make one focused fix and rerun the most relevant verification.
+If you cannot fix it, explain the concrete blocker and the residual risk instead of claiming success.
+`);
+}
+export function buildFinalizeOpportunityReminder(reason) {
+    return wrapInSystemReminder(`
+Completion checkpoint.
+
+${reason}
+
+If this satisfies the user's request, provide the final answer now.
+Continue using tools only if there is a concrete remaining requirement, failing check, or missing deliverable.
+`);
+}

package/dist/prompt/runtime.d.ts

@@ -3,7 +3,7 @@ export interface RuntimePromptOptions {
     thinkingLevel?: ThinkingLevel;
     /**
      * Kept for API compatibility. Agent mode is no longer baked into the static
-     * system prompt — mode changes are signalled via <system-reminder> injections
+     * system prompt — mode changes are signalled via hidden runtime reminders
      * (see src/prompt/reminders.ts) so the base prompt stays stable for caching.
      */
     mode?: PermissionMode;

package/dist/prompt/runtime.js

@@ -8,7 +8,7 @@ const defaultGuidelines = [
     "Prefer structured search tools over bash for repository searches whenever possible",
     "Do not repeat near-identical searches when they are not producing new evidence",
     "When investigating configuration or security questions, stop once the relevant load path, storage path, and exposure path are identified",
-    "Use the task tool for bounded investigative subproblems instead of letting the main loop churn on repeated exploratory searches",
+    "Use spawn_agent and wait_agent for bounded investigative subproblems instead of letting the main loop churn on repeated exploratory searches",
     "After code edits, run the narrowest meaningful verification command or explain why verification is not possible",
     "When finishing a coding task, report what changed, where it changed, verification results, and remaining risk",
     "Be concise in your responses",

package/dist/provider-artifacts.d.ts

@@ -0,0 +1,7 @@
+export declare function stripProviderProtocolArtifacts(text: string): string;
+export declare function isOnlyProviderProtocolArtifacts(text: string): boolean;
+export interface ProviderProtocolArtifactFilter {
+    push(text: string): string;
+    flush(): string;
+}
+export declare function createProviderProtocolArtifactFilter(): ProviderProtocolArtifactFilter;

package/dist/provider-artifacts.js

@@ -0,0 +1,60 @@
+// Models with non-OpenAI chat templates (GLM-4.5/4.6, DeepSeek, some Kimi builds)
+// emit tool-call delimiters as inline assistant text instead of as structured
+// tool_calls deltas. The shapes vary — `<|tool_call|>`, `<｜｜DSML｜｜tool_calls>`,
+// `<｜｜DSML｜｜invoke name="x">`, closing `</｜｜DSML｜｜tool_calls>`, etc. — but
+// they always share the pattern of a tag whose name is wrapped in `|` or `｜`.
+// If we let any of that text reach the consumer it pollutes the streamed
+// assistant text and, downstream, the subagent's summary field.
+const TOOL_PROTOCOL_PATTERNS = [
+    // Generic: opening or closing tag whose name is wrapped in `|` or `｜`,
+    // optionally with attributes after the closing pipe (e.g. `invoke name="x"`).
+    /<\/?\s*[｜|]+[^<>]*?[｜|]+[^<>]*>/g,
+    // Plain ASCII variants without attributes.
+    /<\/?\|tool_calls?\|>/gi,
+];
+export function stripProviderProtocolArtifacts(text) {
+    let out = text;
+    for (const pattern of TOOL_PROTOCOL_PATTERNS) {
+        out = out.replace(pattern, "");
+    }
+    return out;
+}
+export function isOnlyProviderProtocolArtifacts(text) {
+    return !!text.trim() && stripProviderProtocolArtifacts(text).trim().length === 0;
+}
+export function createProviderProtocolArtifactFilter() {
+    let pending = "";
+    return {
+        push(text) {
+            pending = stripProviderProtocolArtifacts(pending + text);
+            const keep = trailingPossibleMarkerLength(pending);
+            const emit = pending.slice(0, pending.length - keep);
+            pending = pending.slice(pending.length - keep);
+            return emit;
+        },
+        flush() {
+            const out = stripProviderProtocolArtifacts(pending);
+            pending = "";
+            return out;
+        },
+    };
+}
+// Hold back a trailing fragment if it could be the start of a pipe-wrapped tag
+// whose closing `>` hasn't arrived yet. Without this guard, a stream that flushes
+// mid-tag (`<` ... `｜DSML｜tool_calls`) would emit the partial tag as text, then
+// emit the rest later — the stripping regex only matches complete tags.
+function trailingPossibleMarkerLength(text) {
+    const lastLt = text.lastIndexOf("<");
+    if (lastLt === -1)
+        return 0;
+    const tail = text.slice(lastLt);
+    if (tail.includes(">"))
+        return 0;
+    // Hold back only when the trailing fragment looks like the start of a protocol
+    // tag. Anything else (e.g. `if (x < y)` in source) flushes immediately.
+    if (/^<\/?$/.test(tail))
+        return tail.length;
+    if (/^<\/?\s*[｜|]/.test(tail))
+        return tail.length;
+    return 0;
+}