@bubblebrain-ai/bubble 0.0.3 → 0.0.4

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/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,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 /**
  * Main entry point - assembles all layers and runs the agent.
  */

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 { buildTaskSummaryReminder, 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,12 @@ 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;
+                }
+                else if (ctx.state.codeChanged && isVerificationResult(ctx.toolCall, ctx.result)) {
+                    ctx.state.verificationCompleted = true;
+                }
                 if (ctx.toolCall.name === "task") {
                     ctx.queueReminder(buildTaskSummaryReminder());
                 }
@@ -90,7 +101,48 @@ 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.verificationCompleted && !ctx.state.verificationReminderQueued) {
+                    ctx.state.verificationReminderQueued = true;
+                    ctx.queueReminder(buildVerificationReminder("The previous turn changed files and no verification evidence has been observed yet."));
+                }
+            },
+            afterTurn(ctx) {
+                if (ctx.state.codeChanged && !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 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") {
+        return false;
+    }
+    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(vitest|tsc|pytest|ruff|cargo\s+test|go\s+test|swift\s+test)\b/.test(normalized);
+}

package/dist/orchestrator/hooks.d.ts

@@ -12,6 +12,11 @@ export interface TurnHookState {
     workflowKey?: string;
     turnCount?: number;
     forceTextOnlyReason?: string;
+    forceContinuationReason?: string;
+    codeChanged?: boolean;
+    verificationCompleted?: boolean;
+    verificationReminderQueued?: boolean;
+    finalVerificationReminderSent?: boolean;
     taskBudget?: {
         total: number;
         spent: number;

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";
@@ -39,6 +42,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/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

@@ -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,4 @@ export declare function buildWorkflowPhaseReminder(input: {
     pending: string[];
 }): string;
 export declare function buildTaskSummaryReminder(): string;
+export declare function buildVerificationReminder(reason: string): string;

package/dist/prompt/reminders.js

@@ -22,6 +22,7 @@ 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.
 - 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) {
@@ -86,11 +89,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 +107,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 +172,13 @@ 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.
+`);
+}

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",
+    "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/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/tools/bash.js

@@ -5,7 +5,7 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { platform } from "node:os";
 import { gateToolAction } from "../approval/tool-helper.js";
-import { parseSearchBashCommand } from "../agent/tool-intent.js";
+import { parseReadBashCommand, parseSearchBashCommand } from "../agent/tool-intent.js";
 import { referencesSensitivePath } from "./sensitive-paths.js";
 const MAX_OUTPUT = 50 * 1024;
 export function createBashTool(cwd, approval) {
@@ -27,6 +27,7 @@ export function createBashTool(cwd, approval) {
             const command = String(args.command);
             const timeoutSec = typeof args.timeout === "number" ? args.timeout : 60;
             const parsedSearch = parseSearchBashCommand(command);
+            const parsedRead = parsedSearch ? undefined : parseReadBashCommand(command);
             if (referencesSensitivePath(command)) {
                 return {
                     content: "Error: Bash access to sensitive credential storage is blocked.",
@@ -95,9 +96,9 @@ export function createBashTool(cwd, approval) {
                             isError: true,
                             status: "timeout",
                             metadata: {
-                                kind: parsedSearch ? "search" : "shell",
+                                kind: parsedSearch ? "search" : parsedRead ? "read" : "shell",
                                 pattern: parsedSearch?.pattern,
-                                path: parsedSearch?.path,
+                                path: parsedSearch?.path ?? parsedRead?.path,
                             },
                         });
                         return;
@@ -109,9 +110,9 @@ export function createBashTool(cwd, approval) {
                             isError: true,
                             status: "blocked",
                             metadata: {
-                                kind: parsedSearch ? "search" : "shell",
+                                kind: parsedSearch ? "search" : parsedRead ? "read" : "shell",
                                 pattern: parsedSearch?.pattern,
-                                path: parsedSearch?.path,
+                                path: parsedSearch?.path ?? parsedRead?.path,
                                 reason: "cancelled",
                             },
                         });
@@ -131,6 +132,7 @@ export function createBashTool(cwd, approval) {
                                 kind: "search",
                                 pattern: parsedSearch.pattern,
                                 path: parsedSearch.path,
+                                command,
                                 matches: 0,
                             },
                         });
@@ -142,9 +144,10 @@ export function createBashTool(cwd, approval) {
                         isError,
                         status: isError ? "command_error" : "success",
                         metadata: {
-                            kind: parsedSearch ? "search" : "shell",
+                            kind: parsedSearch ? "search" : parsedRead ? "read" : "shell",
                             pattern: parsedSearch?.pattern,
-                            path: parsedSearch?.path,
+                            path: parsedSearch?.path ?? parsedRead?.path,
+                            command,
                             matches: parsedSearch ? countSearchMatches(stdout) : undefined,
                         },
                     });

package/dist/tools/edit.js

@@ -89,6 +89,11 @@ export function createEditTool(cwd, approval, lsp) {
             }
             return {
                 content: output,
+                status: "success",
+                metadata: {
+                    kind: "edit",
+                    path: filePath,
+                },
             };
         },
     };

package/dist/tools/write.js

@@ -67,7 +67,14 @@ export function createWriteTool(cwd, options = {}, approval, lsp) {
                         // LSP diagnostics should not turn a successful write into a failed tool call.
                     }
                 }
-                return { content };
+                return {
+                    content,
+                    status: "success",
+                    metadata: {
+                        kind: "write",
+                        path: filePath,
+                    },
+                };
             }
             catch (err) {
                 return { content: `Error: ${err.message}`, isError: true };

package/dist/tui/image-paste.d.ts

@@ -7,6 +7,7 @@
  * TemporaryItems path and the clipboard — the path often gets cleaned up before
  * we can read it, so we fall back to the clipboard.
  */
+import type { ContentPart } from "../types.js";
 export interface ImageAttachment {
     base64: string;
     mediaType: string;
@@ -17,7 +18,41 @@ export interface ImageAttachment {
     filename?: string;
     sourcePath?: string;
 }
+export interface ImagePathToken {
+    rawPath: string;
+    start: number;
+    end: number;
+}
+export interface ImageInputResolution {
+    actualInput: string | ContentPart[];
+    displayInput: string;
+    errors: string[];
+    attachments: ImageAttachment[];
+    imagePathCount: number;
+}
+export interface LabeledImageAttachment extends ImageAttachment {
+    label: string;
+}
+export interface ComposerImageResolution {
+    text: string;
+    attachments: LabeledImageAttachment[];
+    errors: string[];
+    imagePathCount: number;
+    nextLabelIndex: number;
+}
 export declare function isImageFilePath(raw: string): boolean;
+export declare function extractImagePathTokens(input: string): ImagePathToken[];
+export declare function removeImagePathTokens(input: string, tokens: ImagePathToken[]): string;
+export declare function imageAttachmentLabel(att: ImageAttachment, index: number): string;
+export declare function imageAttachmentReference(att: ImageAttachment, index: number): string;
+export declare function imageAttachmentLabelPattern(): RegExp;
+export declare function buildImageContentParts(promptText: string, attachments: ImageAttachment[]): ContentPart[];
+export declare function formatImageDisplayInput(promptText: string, attachments: ImageAttachment[], labelStart?: number): string;
+export declare function buildImageContentPartsFromLabels(input: string, attachmentsByLabel: Map<string, ImageAttachment>): {
+    actualInput?: ContentPart[];
+    displayInput: string;
+    usedLabels: string[];
+};
 /**
  * Split a pasted blob into candidate path tokens.
  *
@@ -52,3 +87,9 @@ export declare function ingestClipboardImage(): Promise<{
     attachment?: ImageAttachment;
     error?: string;
 }>;
+export declare function resolveImageInput(input: string, options?: {
+    labelStart?: number;
+}): Promise<ImageInputResolution>;
+export declare function resolveComposerImagePaths(input: string, options?: {
+    labelStart?: number;
+}): Promise<ComposerImageResolution>;