@bubblebrain-ai/bubble 0.0.3 → 0.0.5

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,8 +20,9 @@ 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.
 - Call exit_plan_mode with a concrete step-by-step plan after the important questions are resolved.
 - Do not use the question tool to ask whether the plan is approved; exit_plan_mode is the approval step.
@@ -34,11 +35,13 @@ Permission mode is now: bypassPermissions.
 ALL tool calls auto-approve with no user confirmation. The user has explicitly opted into this.
 Proceed with extra care — explain risky actions in the chat BEFORE performing them, and
 prefer reversible operations when possible.
+Do not perform destructive operations, credential exposure, or unrelated reversions just because approvals are bypassed.
 `;
 const DEFAULT_ENTER = `
 Permission mode is now: default Build mode.
 
 File edits and writes auto-approve. Bash commands and other destructive tools still require explicit approval unless allowed by rules.
+Execute the requested change end to end; do not stop at analysis unless blocked or the user explicitly asks for discussion only.
 `;
 /** Picks the correct reminder text for a transition TO a given mode. */
 export function reminderForMode(mode) {
@@ -52,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");
 /**
@@ -86,11 +88,11 @@ Stop once these categories are covered. Do not keep repeating near-identical sea
 }
 export function buildLoopWarningReminder(reason) {
     return wrapInSystemReminder(`
-Search loop warning.
+Tool loop warning.
 
 ${reason}
 
-Do not repeat near-identical grep/bash searches unless you are changing the path or testing a genuinely new hypothesis.
+Do not repeat near-identical reads or searches unless you are changing the path or testing a genuinely new hypothesis.
 If current evidence is sufficient, summarize your findings now.
 `);
 }
@@ -104,6 +106,19 @@ Do not continue blind keyword searching. Use the evidence already gathered to re
 You may still read specific files if you already know where the relevant configuration or persistence logic lives.
 `);
 }
+export function buildExplorationFreezeReminder(reason) {
+    return wrapInSystemReminder(`
+Implementation phase has advanced from exploration to modification.
+
+Reason: ${reason}
+
+You have enough context to act. Do not continue reading, searching, or delegating exploration.
+Choose one of:
+1. Use edit/write to make the requested change.
+2. If no safe change can be made from the gathered context, explain the concrete blocker.
+3. If files were already changed, run the narrowest meaningful verification or finish with the result.
+`);
+}
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`
 CRITICAL - MAXIMUM STEPS REACHED
@@ -156,3 +171,33 @@ Treat the task output as a bounded subtask result:
 - do not re-run the same exploratory search unless the subtask uncovered a concrete contradiction
 `);
 }
+export function buildVerificationReminder(reason) {
+    return wrapInSystemReminder(`
+Verification required before final answer.
+
+${reason}
+
+You have changed files in this turn. Run the narrowest meaningful verification command or runtime check before finalizing.
+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

@@ -1,18 +1,31 @@
 const defaultGuidelines = [
+    "Inspect relevant files, command output, or runtime state before making claims about code behavior",
+    "Separate confirmed facts from inference when the evidence is incomplete",
+    "Prefer runtime and call-chain evidence over README text or configuration names for behavior questions",
     "Before editing or writing files, read them first if they exist",
     "Use edit for targeted changes to existing files; use write for creating new files",
-    "Be concise in your responses",
-    "Show file paths clearly when working with files",
+    "Edit only the files required for the requested change",
     "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",
 ];
 export function buildRuntimePrompt(options = {}) {
     const thinkingLevel = options.thinkingLevel ?? "off";
     const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);
     return `Current thinking level: ${thinkingLevel}
 
+Execution protocol:
+1. Understand the user's requested outcome and current constraints.
+2. Inspect the relevant files or state before making claims or edits.
+3. Choose the smallest coherent change that solves the actual problem.
+4. Edit only the necessary files.
+5. Verify with the narrowest meaningful command or runtime check when possible.
+6. Finish with changed files, verification results, and unresolved risk.
+
 Guidelines:
 ${guidelines.map((item) => `- ${item}`).join("\n")}`;
 }

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

@@ -0,0 +1,2 @@
+import type { TaskType } from "../agent/task-classifier.js";
+export declare function reminderForTaskType(taskType: TaskType): string | undefined;

package/dist/prompt/task-reminders.js

@@ -0,0 +1,56 @@
+import { wrapInSystemReminder } from "./reminders.js";
+export function reminderForTaskType(taskType) {
+    switch (taskType) {
+        case "debugging":
+            return wrapInSystemReminder(`
+Debugging workflow:
+- Reproduce or identify the failing boundary before editing.
+- Trace input, transformation, and output paths.
+- Prefer fixing the mechanism over raising thresholds or adding superficial fallbacks.
+- Verify the specific failure path after the change.
+`);
+        case "implementation":
+            return wrapInSystemReminder(`
+Implementation workflow:
+- Do not stop at a proposal when the user asked for a change.
+- Inspect the relevant files first, then make the smallest coherent edit.
+- Keep unrelated files and behavior out of scope.
+- Run a narrow verification command or explain why it cannot be run.
+`);
+        case "code_review":
+            return wrapInSystemReminder(`
+Code review workflow:
+- Lead with concrete findings, ordered by severity.
+- Reference file paths and line numbers when possible.
+- Prioritize bugs, regressions, missing tests, security, and user-visible risk.
+- Keep summaries secondary to findings.
+`);
+        case "code_explanation":
+            return wrapInSystemReminder(`
+Code explanation workflow:
+- Answer the direct question first.
+- Ground claims in concrete files, functions, and call paths.
+- Distinguish current source evidence from inference.
+- Avoid proposing changes unless the user asks for them.
+`);
+        case "repo_orientation":
+            return wrapInSystemReminder(`
+Repository orientation workflow:
+- Start with the repo purpose and main execution paths.
+- Inspect README/package metadata plus core runtime files before summarizing.
+- Keep the first pass read-only unless the user asks for changes or runtime verification.
+`);
+        case "product_discussion":
+            return wrapInSystemReminder(`
+Product discussion workflow:
+- Clarify the product goal, user workflow, and tradeoffs before suggesting implementation.
+- Give direct product judgment when the user asks for direction.
+- Avoid drifting into code changes unless the user explicitly asks to execute.
+`);
+        case "security_investigation":
+        case "code_search":
+        case "general":
+        default:
+            return undefined;
+    }
+}

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;
+}

package/dist/provider.d.ts

@@ -3,9 +3,9 @@
  *
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
-import type { Message, Provider, StreamChunk, ThinkingLevel } from "./types.js";
+import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
 type ReasoningContentEcho = "tool_calls" | "all";
-export declare function toChatCompletionsMessage(message: Message, options?: {
+export declare function toChatCompletionsMessage(message: ProviderMessage, options?: {
     reasoningContentEcho?: ReasoningContentEcho;
 }): Record<string, unknown>;
 export interface ProviderInstanceOptions {
@@ -21,11 +21,10 @@ export declare function normalizeToolArgs(raw: string): string;
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
- * Multi-tool-call streams are buffered by `index` and emitted in index order at
- * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
- * (isStart -> args -> isEnd) sequence per call. This matters for providers like
- * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
- * previous single-slot implementation silently dropped every call but the last.
+ * Multi-tool-call streams are tracked by `index`, but tool-call starts and
+ * argument deltas are emitted as soon as they arrive so the TUI can render
+ * partial write previews before the tool executes. End events are still flushed
+ * in index order to keep multi-call turns deterministic.
  */
 export declare function translateOpenAIStream(stream: AsyncIterable<any>): AsyncIterable<StreamChunk>;
 export {};

package/dist/provider.js

@@ -5,6 +5,7 @@
  */
 import OpenAI from "openai";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
+import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 export function toChatCompletionsMessage(message, options = {}) {
     const reasoningContentEcho = options.reasoningContentEcho ?? "tool_calls";
@@ -189,14 +190,14 @@ function extractBalancedJson(s, start) {
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
- * Multi-tool-call streams are buffered by `index` and emitted in index order at
- * `finish_reason === "tool_calls"`, so the agent layer always sees a clean
- * (isStart -> args -> isEnd) sequence per call. This matters for providers like
- * Kimi K2.5 that emit several parallel tool calls per assistant turn -- the
- * previous single-slot implementation silently dropped every call but the last.
+ * Multi-tool-call streams are tracked by `index`, but tool-call starts and
+ * argument deltas are emitted as soon as they arrive so the TUI can render
+ * partial write previews before the tool executes. End events are still flushed
+ * in index order to keep multi-call turns deterministic.
  */
 export async function* translateOpenAIStream(stream) {
     const toolCalls = new Map();
+    const textFilter = createProviderProtocolArtifactFilter();
     function* flushToolCalls() {
         if (toolCalls.size === 0)
             return;
@@ -204,13 +205,34 @@ export async function* translateOpenAIStream(stream) {
         for (const [, entry] of sorted) {
             if (!entry.id || !entry.name)
                 continue;
-            const args = normalizeToolArgs(entry.args);
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: args, isStart: false, isEnd: false };
-            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: false, isEnd: true };
+            if (!entry.started) {
+                yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
+                entry.started = true;
+                if (entry.args) {
+                    yield { type: "tool_call", id: entry.id, name: entry.name, arguments: entry.args, isStart: false, isEnd: false };
+                }
+            }
+            yield {
+                type: "tool_call",
+                id: entry.id,
+                name: entry.name,
+                arguments: "",
+                argumentsFull: normalizeToolArgs(entry.args),
+                isStart: false,
+                isEnd: true,
+            };
         }
         toolCalls.clear();
     }
+    function* startToolCallIfReady(entry) {
+        if (entry.started || !entry.id || !entry.name)
+            return;
+        entry.started = true;
+        yield { type: "tool_call", id: entry.id, name: entry.name, arguments: "", isStart: true, isEnd: false };
+        if (entry.args) {
+            yield { type: "tool_call", id: entry.id, name: entry.name, arguments: entry.args, isStart: false, isEnd: false };
+        }
+    }
     for await (const chunk of stream) {
         const delta = chunk.choices?.[0]?.delta;
         const usage = chunk.usage;
@@ -240,12 +262,16 @@ export async function* translateOpenAIStream(stream) {
                     yield { type: "reasoning_delta", content: thinkMatch[1] };
                 }
                 const remaining = delta.content.replace(/<think>[\s\S]*?<\/think>/, "");
-                if (remaining) {
-                    yield { type: "text", content: remaining };
+                const cleaned = textFilter.push(remaining);
+                if (cleaned) {
+                    yield { type: "text", content: cleaned };
                 }
             }
             else {
-                yield { type: "text", content: delta.content };
+                const cleaned = textFilter.push(delta.content);
+                if (cleaned) {
+                    yield { type: "text", content: cleaned };
+                }
             }
         }
         if (delta?.tool_calls) {
@@ -253,15 +279,28 @@ export async function* translateOpenAIStream(stream) {
                 const idx = typeof tc.index === "number" ? tc.index : 0;
                 let entry = toolCalls.get(idx);
                 if (!entry) {
-                    entry = { id: "", name: "", args: "" };
+                    entry = { id: "", name: "", args: "", started: false };
                     toolCalls.set(idx, entry);
                 }
                 if (tc.id)
                     entry.id = tc.id;
                 if (tc.function?.name)
                     entry.name = tc.function.name;
-                if (typeof tc.function?.arguments === "string")
-                    entry.args += tc.function.arguments;
+                yield* startToolCallIfReady(entry);
+                if (typeof tc.function?.arguments === "string" && tc.function.arguments) {
+                    const merged = mergeToolArgumentDelta(entry.args, tc.function.arguments);
+                    entry.args = merged.args;
+                    if (entry.started && merged.delta) {
+                        yield {
+                            type: "tool_call",
+                            id: entry.id,
+                            name: entry.name,
+                            arguments: merged.delta,
+                            isStart: false,
+                            isEnd: false,
+                        };
+                    }
+                }
             }
         }
         const finishReason = chunk.choices?.[0]?.finish_reason;
@@ -269,5 +308,28 @@ export async function* translateOpenAIStream(stream) {
             yield* flushToolCalls();
         }
     }
+    const remainingText = textFilter.flush();
+    if (remainingText) {
+        yield { type: "text", content: remainingText };
+    }
     yield* flushToolCalls();
 }
+function mergeToolArgumentDelta(current, incoming) {
+    if (!current)
+        return { args: incoming, delta: incoming };
+    if (!incoming)
+        return { args: current, delta: "" };
+    // Standard OpenAI-compatible streams send incremental argument deltas. Some
+    // providers send cumulative snapshots instead. If the incoming chunk already
+    // contains what we have, emit only the new suffix so downstream state remains
+    // append-only.
+    if (incoming.startsWith(current)) {
+        return { args: incoming, delta: incoming.slice(current.length) };
+    }
+    // Repeated identical snapshots should not duplicate the TUI preview or final
+    // JSON arguments.
+    if (incoming === current || current.endsWith(incoming)) {
+        return { args: current, delta: "" };
+    }
+    return { args: current + incoming, delta: incoming };
+}

package/dist/session-log.js

@@ -193,6 +193,8 @@ function normalizeMessageToEntries(message, id, timestamp) {
         }
         case "tool":
             return [{ id, type: "tool_result", message, timestamp }];
+        case "meta":
+            return [];
         case "system":
             return [{
                     id,
@@ -241,7 +243,7 @@ function pruneIncompleteTail(messages) {
     let sawNonUserInCurrentTurn = false;
     for (let i = 0; i < messages.length; i++) {
         const message = messages[i];
-        if (message.role === "system")
+        if (message.role === "system" || message.role === "meta")
             continue;
         if (message.role === "user") {
             currentTurnStart = i;

package/dist/slash-commands/commands.js

@@ -157,7 +157,7 @@ async function handleMemoryCommand(args, ctx) {
         return lines.join("\n");
     }
     if (sub === "add") {
-        return "Manual memory writes are disabled. Bubble now follows the Codex-style automatic startup memory pipeline.";
+        return "Manual memory writes are disabled. Bubble now follows the automatic startup memory pipeline.";
     }
     if (sub === "search") {
         const query = rest.join(" ").trim();
@@ -265,7 +265,7 @@ const builtinSlashCommandEntries = [
     },
     {
         name: "memory",
-        description: "Inspect and maintain Codex-style automatic persistent memory. Usage: /memory [status|search|compact|summarize|refresh|reset]",
+        description: "Inspect and maintain Bubble's automatic persistent memory. Usage: /memory [status|search|compact|summarize|refresh|reset]",
         async handler(args, ctx) {
             return handleMemoryCommand(args, ctx);
         },
@@ -737,7 +737,6 @@ const builtinSlashCommandEntries = [
                 return "Session is already compact enough.";
             }
             const systemMessage = ctx.agent.messages.find((message) => message.role === "system");
-            ctx.clearMessages();
             ctx.agent.messages = [
                 ...(systemMessage ? [systemMessage] : []),
                 ...ctx.sessionManager.getMessages(),

package/dist/system-prompt.d.ts

@@ -30,5 +30,7 @@ export interface SystemPromptOptions {
     skills?: SkillSummary[];
     /** Prompt-visible memory guidance and summaries */
     memoryPrompt?: string;
+    /** Durable child-agent profile prompt used for subagents. */
+    agentProfilePrompt?: string;
 }
 export declare function buildSystemPrompt(options?: SystemPromptOptions): string;

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

@@ -0,0 +1,6 @@
+import type { ToolRegistryEntry } from "../types.js";
+export declare function createSpawnAgentTool(): ToolRegistryEntry;
+export declare function createWaitAgentTool(): ToolRegistryEntry;
+export declare function createSendInputTool(): ToolRegistryEntry;
+export declare function createCloseAgentTool(): ToolRegistryEntry;
+export declare function createAgentLifecycleTools(): ToolRegistryEntry[];