@bubblebrain-ai/bubble 0.0.22 → 0.0.24

package/README.md

@@ -1,38 +1,37 @@
 # Bubble
 
-Bubble is a terminal coding agent for working inside local project folders. It can read and edit files, run commands with approval controls, use project skills, connect MCP tools, and keep persistent memory across sessions.
+Bubble is a terminal coding agent. It works inside a local project folder: it reads and edits files, runs commands behind configurable approval controls, searches and navigates code with language-server intelligence, browses the web, loads reusable skills, connects MCP tools, fans work out to subagents, and keeps persistent memory across sessions.
+
+It is provider-agnostic. Bring an API key for OpenAI, Anthropic, Google, DeepSeek, Moonshot/Kimi, Zhipu, Z.AI, MiniMax, Groq, Together, Fireworks, a local OpenAI-compatible endpoint, and more — or sign in to ChatGPT with OAuth and drive the Codex models directly.
+
+---
 
 ## Requirements
 
-- Node.js 20+ and npm for installation
-- Bun for running Bubble
+- Node.js 20 or newer (used to install the launcher)
+- [Bun](https://bun.sh) (used to run the agent)
 
-Install Bun if it is not already available:
+Install Bun if you do not already have it:
 
 ```bash
 curl -fsSL https://bun.sh/install | bash
 ```
 
-## Install
+The `npm install` step puts a small Node.js launcher named `bubble` on your PATH. When you run `bubble`, the launcher locates Bun and starts the real runtime under it. If Bun is missing, it prints the install command above instead of failing with a low-level error.
 
-From npm:
+## Install
 
 ```bash
 npm install -g @bubblebrain-ai/bubble
 ```
 
-From a local package tarball:
+To install from a local tarball:
 
 ```bash
-npm install -g ./bubblebrain-ai-bubble-0.0.3.tgz
+npm install -g ./bubblebrain-ai-bubble-<version>.tgz
 ```
 
-The npm command installs a small Node.js launcher named `bubble`. When you run
-`bubble`, the launcher checks for Bun and starts the real Bubble runtime with
-`bun`. If Bun is missing, it prints the install command above instead of failing
-with a low-level runtime error.
-
-## Usage
+## Quick start
 
 Start Bubble in the current directory:
 
@@ -40,31 +39,192 @@ Start Bubble in the current directory:
 bubble
 ```
 
-Start Bubble for a specific project:
+On first launch, connect a model:
+
+- Run `/login` to sign in to ChatGPT (OAuth) and use the Codex models, or
+- Run `/provider` to add any other provider with an API key.
+
+Then just type what you want done. Bubble plans, edits files, and runs commands, asking for approval where the current permission mode requires it.
+
+Point Bubble at a different project:
 
 ```bash
 bubble --cwd /path/to/project
 ```
 
-Show CLI options:
+Resume your last conversation:
 
 ```bash
-bubble --help
+bubble --resume
+```
+
+## Model providers
+
+Bubble ships with a catalog of built-in providers. Configure them inside the app — no environment variables required.
+
+| How | What it does |
+| --- | --- |
+| `/login` | OAuth sign-in for ChatGPT; unlocks the OpenAI Codex models without an API key. |
+| `/provider` | Open a picker to connect, switch, add, or remove a provider. |
+| `/key <provider> <key>` | Set the API key for a provider. |
+| `/model` | Pick the active model and reasoning effort. |
+
+Built-in providers include OpenAI, Anthropic, Google, DeepSeek, Moonshot (CN and international), Kimi for Coding, Zhipu AI, Z.AI, Alibaba DashScope, MiniMax, StepFun, Groq, Together AI, Fireworks, and a `local` profile for any OpenAI-compatible endpoint (Ollama, vLLM, LM Studio, etc.).
+
+### Custom providers and models
+
+For full control — custom base URLs, self-hosted gateways, extra models, or pinning a protocol — define providers in `~/.bubble/models.json`:
+
+```json
+{
+  "providers": {
+    "my-gateway": {
+      "baseURL": "https://gateway.internal/v1",
+      "apiKey": "sk-...",
+      "protocol": "openai-chat",
+      "models": [
+        { "id": "my-model", "name": "My Model" }
+      ]
+    }
+  }
+}
+```
+
+`protocol` accepts `openai-chat` (default) or `anthropic-messages`. Entries in `models.json` take precedence over the built-in catalog.
+
+### Reasoning effort
+
+Models that support it expose a reasoning-effort control: `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. Set it with `/model <id> --reasoning-effort <level>` in the app, or at launch with `--reasoning` (medium) or `--reasoning-effort <level>`.
+
+## Permission modes
+
+Bubble gates risky actions behind a permission mode. Press `Tab` to cycle modes during a session, or set a default with `--plan` / `--dangerously-skip-permissions` / project settings.
+
+| Mode | Behavior |
+| --- | --- |
+| Default (Build) | File edits and writes auto-approve; bash and other tools prompt unless covered by an allow rule. |
+| Plan | Read-only investigation. The agent proposes a plan and waits for your approval before making changes. |
+| Bypass | Auto-approves every tool and disables all safety prompts. Enable deliberately with `--dangerously-skip-permissions`. |
+
+Allow/deny rules are configured per scope and persisted across sessions. Manage them in-app with `/permissions`, or edit the settings files directly:
+
+- `~/.bubble/settings.json` — user scope (applies everywhere)
+- `<project>/.bubble/settings.json` — project scope (commit to share with your team)
+- `<project>/.bubble/settings.local.json` — local overrides (gitignore)
+
+Rules use a simple pattern syntax, for example:
+
+```json
+{
+  "permissions": {
+    "defaultMode": "default",
+    "allow": [
+      "Bash(git status)",
+      "Bash(npm run:*)",
+      "Read(./src/**)",
+      "WebFetch(domain:github.com)"
+    ],
+    "deny": ["Read(~/.ssh/**)"]
+  }
+}
 ```
 
-## Configuration
+## What Bubble can do
 
-Bubble stores user configuration, sessions, permissions, skills, and memory under:
+**Files and code.** Read, write, and make targeted edits; find files by glob; search contents with ripgrep; and navigate with language-server operations (go-to-definition, find references, hover, document/workspace symbols, call hierarchy).
+
+**Shell and dev servers.** Run bounded bash commands with streaming output, and start/stop/inspect long-running dev servers (`npm run dev`, Vite, Next, etc.) with readiness checks and captured logs.
+
+**Web.** Search the web and fetch/extract page contents on demand.
+
+**Skills.** Drop reusable instructions and assets into a `SKILL.md`-based directory and invoke them with `/<skill-name>`. Bubble discovers skills from `~/.bubble/skills`, `~/.agents/skills`, `~/.claude/skills`, and the project's `.bubble/skills`. Browse them with `/skills`.
+
+**MCP tools.** Connect Model Context Protocol servers (stdio, HTTP, or SSE) under the `mcpServers` key of any settings file. Their tools and prompts become available to the agent; manage connections with `/mcp`.
+
+**Subagents.** Bubble can spawn background subagents with independent context, send them follow-ups, wait on their results, and fan a task out across a team — with concurrency limits and token budgets. Define custom agent profiles in `~/.bubble/agents` or a project's `.bubble/agents`.
+
+**Persistent memory.** A background pipeline distills durable facts, preferences, and decisions from past sessions and recalls them later. Inspect and maintain it with `/memory status`, `/memory search <query>`, and `/memory refresh`.
+
+**Sessions.** Every conversation is saved. Resume the latest with `bubble --resume`, or browse and switch sessions in-app with `/session`. Use `/rewind` to roll the conversation — and optionally your file edits — back to an earlier point.
+
+## Useful slash commands
+
+| Command | Description |
+| --- | --- |
+| `/help` | List available commands. |
+| `/model` | Switch model and reasoning effort. |
+| `/provider`, `/login`, `/logout`, `/key` | Connect and manage providers. |
+| `/session`, `/rewind`, `/clear` | Manage conversation history. |
+| `/skills` | Open the searchable skills picker. |
+| `/mcp` | List or reconnect MCP servers. |
+| `/memory` | Inspect and maintain persistent memory. |
+| `/permissions` | View or edit allow/deny rules. |
+| `/context`, `/stats`, `/compact` | Inspect context usage, model stats, and compact the session. |
+| `/lsp`, `/hooks` | Manage language servers and lifecycle hooks. |
+| `/theme`, `/sidebar` | Adjust the interface. |
+| `/feedback` | Send feedback or report a bug. |
+
+## Non-interactive mode
+
+Run a single prompt and print the result — useful for scripts and pipelines:
+
+```bash
+bubble --print "summarize what this repo does"
+echo "fix the failing test" | bubble --print
+```
+
+Combine with `--model`, `--cwd`, and `--plan` as needed.
+
+## CLI reference
 
 ```text
-~/.bubble
+Usage:
+  bubble [options] [prompt]              Start interactive TUI
+  bubble update [--check]                Update to the latest version (alias: upgrade)
+  bubble serve --feishu [options]        Run as a Feishu bot host
+
+Options (default):
+  -m, --model <model>      Model to use
+  --cwd <dir>              Working directory (default: current)
+  -k, --api-key <key>      API key for the active provider
+  -r, --resume             Resume a previous session (latest by default)
+  --session <name>         Session name to create or resume
+  --reasoning              Enable reasoning mode at medium effort
+  --reasoning-effort <l>   Set reasoning effort: off|minimal|low|medium|high|xhigh|max
+  --plan                   Start in plan mode (read-only investigation; propose before executing)
+  --dangerously-skip-permissions
+                           Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)
+  -p, --print              Non-interactive mode (single prompt)
+  -v, --version            Print the installed version and exit
+  -h, --help               Show this help
 ```
 
-In the app, use `/login` or provider commands to configure model access.
+Run `bubble update` at any time to upgrade to the latest published version.
+
+## Configuration and storage
 
-### ChatGPT Network Configuration
+Bubble keeps everything under `~/.bubble`:
+
+```text
+~/.bubble/
+  config.json          User preferences (theme, default model, recent models)
+  models.json          Custom providers and models
+  auth.json            OAuth credentials (file mode 0600)
+  settings.json        User-scope permissions, MCP servers, hooks
+  sessions/            Saved conversations, grouped by project directory
+  memories/            Persistent memory store
+  skills/              User skills
+  agents/              Custom subagent profiles
+```
 
-ChatGPT OAuth and GPT/Codex requests respect standard proxy variables:
+Environment variables:
+
+- `BUBBLE_HOME` — override the data directory (defaults to `~/.bubble`).
+- `BUBBLE_DEV=1` — use `~/.bubble-dev` instead, for development.
+
+### Network configuration
+
+ChatGPT OAuth and GPT/Codex requests respect the standard proxy variables:
 
 ```bash
 export HTTPS_PROXY=http://proxy.example.com:8080
@@ -72,28 +232,31 @@ export HTTP_PROXY=http://proxy.example.com:8080
 export NO_PROXY=localhost,127.0.0.1
 ```
 
-If your network uses a corporate or custom HTTPS CA, start Bubble with:
+If your network uses a corporate or custom HTTPS CA:
 
 ```bash
 NODE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
 ```
 
-You can also use `BUBBLE_EXTRA_CA_CERTS` for Bubble's ChatGPT requests:
+`BUBBLE_EXTRA_CA_CERTS` applies the same trust to Bubble's ChatGPT requests specifically. Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+
+## Development
 
 ```bash
-BUBBLE_EXTRA_CA_CERTS=/absolute/path/to/ca.pem bubble
+bun install        # install dependencies
+npm run build      # compile TypeScript to dist/
+npm test           # run the test suite (vitest)
+npm start          # run the built agent
 ```
 
-Do not disable TLS verification with `NODE_TLS_REJECT_UNAUTHORIZED=0`.
+`npm run dev` compiles and launches in one step. The TUI is built on [OpenTUI](https://github.com/anomalyco/opentui) and Solid.
 
-## Memory
+## Feishu host (optional)
 
-Bubble maintains persistent memory automatically from prior sessions. Useful commands:
+Bubble can also run as a Feishu (Lark) bot host:
 
-```text
-/memory status
-/memory search <query>
-/memory refresh
+```bash
+bubble serve --feishu --setup
 ```
 
-Memory is maintained by a background pipeline and can be refreshed manually when you want new session information to be indexed immediately.
+`--setup` runs the binding wizard, `--kill-old` replaces a conflicting instance for the same App ID, and `--dry-run` connects once and exits as a smoke test.

package/dist/agent/internal-reminder-sanitizer.js

@@ -54,17 +54,37 @@ export function sanitizeAssistantProviderMetadata(metadata) {
     if (!metadata || !anthropic || !blocks?.length)
         return metadata;
     let changed = false;
-    const sanitizedBlocks = blocks.map((block) => {
-        if (block.type !== "text" || typeof block.text !== "string") {
-            return block;
+    const sanitizedBlocks = [];
+    for (const block of blocks) {
+        // Plaintext text blocks are unsigned, so rewriting them in place is safe.
+        if (block.type === "text" && typeof block.text === "string") {
+            const sanitizedText = sanitizeInternalReminderBlocks(block.text);
+            if (sanitizedText !== block.text) {
+                changed = true;
+                sanitizedBlocks.push({ ...block, text: sanitizedText });
+            }
+            else {
+                sanitizedBlocks.push(block);
+            }
+            continue;
         }
-        const sanitizedText = sanitizeInternalReminderBlocks(block.text);
-        if (sanitizedText === block.text) {
-            return block;
+        // Extended-thinking blocks carry an Anthropic signature over their exact
+        // text; rewriting the text would invalidate the signature and the API
+        // would reject the replayed block. So when a thinking block's text carries
+        // internal markup (e.g. an echoed system reminder), DROP the whole block
+        // rather than mutate it. Thinking text is never user-visible — the display
+        // path renders message.reasoning, not contentBlocks — so dropping loses
+        // nothing on screen; it only keeps the verbatim reminder out of the
+        // persisted metadata and the Anthropic replay payload. redacted_thinking
+        // holds encrypted `data` (no plaintext field) and cannot carry a reminder.
+        if (block.type === "thinking" && typeof block.thinking === "string") {
+            if (sanitizeInternalReminderBlocks(block.thinking) !== block.thinking) {
+                changed = true;
+                continue;
+            }
         }
-        changed = true;
-        return { ...block, text: sanitizedText };
-    });
+        sanitizedBlocks.push(block);
+    }
     if (!changed)
         return metadata;
     return {

package/dist/goal/command.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure parser for the `/goal` slash command.
+ *
+ * Forms:
+ *   /goal                      -> show summary
+ *   /goal <objective> [--budget N]  -> set a new goal
+ *   /goal clear | pause | resume
+ *   /goal edit <new objective>
+ *
+ * --budget accepts plain integers and k/m suffixes: 200000, 200k, 1.5m.
+ */
+export type GoalCommandKind = "show" | "set" | "clear" | "pause" | "resume" | "edit";
+export interface GoalCommand {
+    kind: GoalCommandKind;
+    objective?: string;
+    tokenBudget?: number;
+    error?: string;
+}
+export declare function parseGoalCommand(input: string): GoalCommand;
+export declare function parseBudgetValue(raw: string): number | undefined;

package/dist/goal/command.js

@@ -0,0 +1,71 @@
+/**
+ * Pure parser for the `/goal` slash command.
+ *
+ * Forms:
+ *   /goal                      -> show summary
+ *   /goal <objective> [--budget N]  -> set a new goal
+ *   /goal clear | pause | resume
+ *   /goal edit <new objective>
+ *
+ * --budget accepts plain integers and k/m suffixes: 200000, 200k, 1.5m.
+ */
+const SUBCOMMANDS = new Set(["clear", "pause", "resume", "edit"]);
+export function parseGoalCommand(input) {
+    const body = input.trim().replace(/^\/goal\b/, "").trim();
+    if (!body)
+        return { kind: "show" };
+    const firstToken = body.split(/\s+/, 1)[0].toLowerCase();
+    const rest = body.slice(firstToken.length).trim();
+    if (SUBCOMMANDS.has(firstToken)) {
+        if (firstToken === "edit") {
+            if (!rest)
+                return { kind: "edit", error: "Usage: /goal edit <new objective>" };
+            const { text, tokenBudget, error } = extractBudget(rest);
+            if (error)
+                return { kind: "edit", error };
+            const objective = text.trim();
+            if (!objective)
+                return { kind: "edit", error: "Usage: /goal edit <new objective>" };
+            return { kind: "edit", objective, tokenBudget };
+        }
+        // clear / pause / resume take no arguments.
+        if (rest)
+            return { kind: firstToken, error: `/goal ${firstToken} takes no arguments` };
+        return { kind: firstToken };
+    }
+    // Anything else is a new objective.
+    const { text, tokenBudget, error } = extractBudget(body);
+    if (error)
+        return { kind: "set", error };
+    const objective = text.trim();
+    if (!objective)
+        return { kind: "set", error: "Usage: /goal <objective> [--budget N]" };
+    return { kind: "set", objective, tokenBudget };
+}
+function extractBudget(s) {
+    const match = s.match(/--budget(?:=|\s+)(\S+)/);
+    if (!match || match.index === undefined)
+        return { text: s };
+    const value = parseBudgetValue(match[1]);
+    if (value === undefined || value <= 0) {
+        return { text: s, error: `Invalid --budget value: "${match[1]}" (use e.g. 200000, 200k, 1.5m)` };
+    }
+    const text = (s.slice(0, match.index) + s.slice(match.index + match[0].length))
+        .replace(/\s+/g, " ")
+        .trim();
+    return { text, tokenBudget: value };
+}
+export function parseBudgetValue(raw) {
+    const match = raw.trim().match(/^(\d+(?:\.\d+)?)([kmKM]?)$/);
+    if (!match)
+        return undefined;
+    let value = parseFloat(match[1]);
+    if (!Number.isFinite(value))
+        return undefined;
+    const suffix = match[2].toLowerCase();
+    if (suffix === "k")
+        value *= 1_000;
+    else if (suffix === "m")
+        value *= 1_000_000;
+    return Math.round(value);
+}

package/dist/goal/engine.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure decision logic for the goal auto-continuation loop.
+ *
+ * Kept out of the TUI so the stop conditions can be unit-tested directly. The
+ * TUI calls shouldContinueGoal() after each goal turn finishes and either fires
+ * another turn or stops with the returned reason.
+ *
+ * The agent decides when the work is done — there is intentionally NO turn-count
+ * cap (unlike a fixed iteration limit). The loop only stops when:
+ *   - the model marks the goal complete/blocked (via update_goal),
+ *   - the user pauses/clears it,
+ *   - the run is interrupted or the provider errors (out of quota, network, …),
+ *   - or a user-set token budget is exhausted.
+ * Otherwise it keeps going.
+ */
+import type { GoalState } from "./store.js";
+export type GoalStopReason = "complete" | "blocked" | "paused" | "budget" | "error" | "cancelled" | "user_input" | "no_goal";
+export interface ContinueDecisionInput {
+    goal: GoalState | null;
+    /** The last run was interrupted/cancelled by the user. */
+    cancelled?: boolean;
+    /** The last run failed with a provider/run error (quota, network, API). */
+    errored?: boolean;
+    /** Number of user inputs queued to run next (a real message preempts the goal). */
+    queuedInputs?: number;
+}
+export interface ContinueDecision {
+    continue: boolean;
+    reason?: GoalStopReason;
+}
+export declare function shouldContinueGoal(input: ContinueDecisionInput): ContinueDecision;
+/** Human-readable one-liner explaining why auto-continuation stopped. */
+export declare function stopReasonNotice(reason: GoalStopReason | undefined): string;

package/dist/goal/engine.js

@@ -0,0 +1,65 @@
+/**
+ * Pure decision logic for the goal auto-continuation loop.
+ *
+ * Kept out of the TUI so the stop conditions can be unit-tested directly. The
+ * TUI calls shouldContinueGoal() after each goal turn finishes and either fires
+ * another turn or stops with the returned reason.
+ *
+ * The agent decides when the work is done — there is intentionally NO turn-count
+ * cap (unlike a fixed iteration limit). The loop only stops when:
+ *   - the model marks the goal complete/blocked (via update_goal),
+ *   - the user pauses/clears it,
+ *   - the run is interrupted or the provider errors (out of quota, network, …),
+ *   - or a user-set token budget is exhausted.
+ * Otherwise it keeps going.
+ */
+export function shouldContinueGoal(input) {
+    const { goal } = input;
+    if (!goal)
+        return { continue: false, reason: "no_goal" };
+    if (input.errored)
+        return { continue: false, reason: "error" };
+    if (input.cancelled)
+        return { continue: false, reason: "cancelled" };
+    if ((input.queuedInputs ?? 0) > 0)
+        return { continue: false, reason: "user_input" };
+    switch (goal.status) {
+        case "complete":
+            return { continue: false, reason: "complete" };
+        case "blocked":
+            return { continue: false, reason: "blocked" };
+        case "paused":
+            return { continue: false, reason: "paused" };
+        case "budget_limited":
+            return { continue: false, reason: "budget" };
+        case "active":
+            break;
+    }
+    // Only an explicit, user-set token budget bounds the loop; with no budget it
+    // runs until the model finishes, the user stops it, or the provider errors.
+    if (goal.tokenBudget !== undefined && goal.tokensUsed >= goal.tokenBudget) {
+        return { continue: false, reason: "budget" };
+    }
+    return { continue: true };
+}
+/** Human-readable one-liner explaining why auto-continuation stopped. */
+export function stopReasonNotice(reason) {
+    switch (reason) {
+        case "complete":
+            return "Goal complete.";
+        case "blocked":
+            return "Goal marked blocked — /goal resume to retry.";
+        case "paused":
+            return "Goal paused — /goal resume to continue.";
+        case "budget":
+            return "Goal hit its token budget — /goal resume to continue.";
+        case "error":
+            return "Goal paused — the provider errored. Fix it, then /goal resume.";
+        case "cancelled":
+            return "Goal paused (interrupted) — /goal resume to continue.";
+        case "user_input":
+            return "Goal paused for your input — it resumes after this turn.";
+        default:
+            return "";
+    }
+}

package/dist/goal/format.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Display helpers for the goal feature — shared by the goal tools (model-facing
+ * summary), the `/goal` summary command, and the TUI status-line indicator.
+ */
+import type { GoalState, GoalStatus } from "./store.js";
+export declare function goalStatusLabel(status: GoalStatus): string;
+/** Compact token count: 950, 1.2K, 63.9K, 1.5M. */
+export declare function formatTokensCompact(tokens: number): string;
+/** Full multi-detail summary, e.g. for the model's get_goal result. */
+export declare function goalSummaryText(goal: GoalState): string;
+/**
+ * Terminal notice shown when a goal finishes, with the accurate final token
+ * spend. Call only after the finishing run's tokens have been accounted (the
+ * update_goal tool can't report this — see goal/tools.ts).
+ */
+export declare function goalCompleteNotice(goal: GoalState): string;
+/** Compact single-line indicator for the status line / sidebar. */
+export declare function goalIndicatorLine(goal: GoalState, maxObjective?: number): string;

package/dist/goal/format.js

@@ -0,0 +1,82 @@
+/**
+ * Display helpers for the goal feature — shared by the goal tools (model-facing
+ * summary), the `/goal` summary command, and the TUI status-line indicator.
+ */
+export function goalStatusLabel(status) {
+    switch (status) {
+        case "active":
+            return "active";
+        case "paused":
+            return "paused";
+        case "blocked":
+            return "blocked";
+        case "budget_limited":
+            return "budget limited";
+        case "complete":
+            return "complete";
+    }
+}
+/** Compact token count: 950, 1.2K, 63.9K, 1.5M. */
+export function formatTokensCompact(tokens) {
+    const n = Math.max(0, Math.round(tokens));
+    if (n < 1_000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${trimZero(n / 1_000)}K`;
+    return `${trimZero(n / 1_000_000)}M`;
+}
+function trimZero(value) {
+    const rounded = Math.round(value * 10) / 10;
+    return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}
+function tokensPart(goal) {
+    if (goal.tokenBudget !== undefined) {
+        return `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok`;
+    }
+    if (goal.tokensUsed > 0)
+        return `${formatTokensCompact(goal.tokensUsed)} tok`;
+    return undefined;
+}
+/** Full multi-detail summary, e.g. for the model's get_goal result. */
+export function goalSummaryText(goal) {
+    const parts = [
+        `Objective: ${goal.objective}`,
+        `Status: ${goalStatusLabel(goal.status)}.`,
+        `Turns: ${goal.turnsSpent}.`,
+    ];
+    const tokens = tokensPart(goal);
+    if (tokens)
+        parts.push(`Tokens: ${tokens}.`);
+    if (goal.tokenBudget !== undefined) {
+        const remaining = Math.max(0, goal.tokenBudget - goal.tokensUsed);
+        parts.push(`Remaining budget: ${formatTokensCompact(remaining)} tok.`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Terminal notice shown when a goal finishes, with the accurate final token
+ * spend. Call only after the finishing run's tokens have been accounted (the
+ * update_goal tool can't report this — see goal/tools.ts).
+ */
+export function goalCompleteNotice(goal) {
+    const tokens = goal.tokenBudget !== undefined
+        ? `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok`
+        : `${formatTokensCompact(goal.tokensUsed)} tok`;
+    const turns = `${goal.turnsSpent} ${goal.turnsSpent === 1 ? "turn" : "turns"}`;
+    return `Goal complete — ${tokens} used over ${turns}.`;
+}
+/** Compact single-line indicator for the status line / sidebar. */
+export function goalIndicatorLine(goal, maxObjective = 48) {
+    const segments = [`goal: ${goalStatusLabel(goal.status)}`, `${goal.turnsSpent} turns`];
+    const tokens = tokensPart(goal);
+    if (tokens)
+        segments.push(tokens);
+    const objective = truncateObjective(goal.objective, maxObjective);
+    return `${segments.join(" · ")} — ${objective}`;
+}
+function truncateObjective(objective, max) {
+    const single = objective.replace(/\s+/g, " ").trim();
+    if (single.length <= max)
+        return single;
+    return `${single.slice(0, Math.max(0, max - 1))}…`;
+}

package/dist/goal/prompts.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Model-facing prompts for the autonomous `/goal` feature.
+ *
+ * Ported and trimmed from Codex's `ext/goal/templates/goals/*.md`. These are
+ * injected into the model context (wrapped as an internal context block, so
+ * they never render as a user bubble) at the start of each goal turn. The
+ * objective is treated as untrusted data: XML-escaped and fenced in
+ * <objective> so it cannot be read as higher-priority instructions.
+ */
+import type { GoalState } from "./store.js";
+export declare function continuationPrompt(goal: GoalState): string;
+export declare function initialPrompt(goal: GoalState): string;
+export declare function budgetLimitPrompt(goal: GoalState): string;