@bubblebrain-ai/bubble 0.0.23 → 0.0.25

package/dist/goal/store.js

@@ -0,0 +1,174 @@
+/**
+ * GoalStore — the in-memory source of truth for the autonomous `/goal` feature.
+ *
+ * A single GoalStore instance is shared between the goal tools (so the model's
+ * `update_goal` calls mutate the same state the TUI reads) and the TUI's
+ * auto-continuation engine / status-line indicator. State is a plain
+ * serializable object so it can be persisted to and reloaded from the session
+ * metadata.
+ */
+export class GoalStore {
+    goal = null;
+    listeners = new Set();
+    now;
+    genId;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => Date.now());
+        this.genId =
+            options.genId ??
+                (() => `goal_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`);
+    }
+    snapshot() {
+        return this.goal ? { ...this.goal } : null;
+    }
+    /** Alias for snapshot(); reads the current goal without mutating. */
+    get() {
+        return this.snapshot();
+    }
+    isActive() {
+        return this.goal?.status === "active";
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit() {
+        const snap = this.snapshot();
+        for (const listener of this.listeners)
+            listener(snap);
+    }
+    touch() {
+        if (this.goal)
+            this.goal.updatedAt = this.now();
+    }
+    set(objective, options = {}) {
+        const ts = this.now();
+        const tokenBudget = options.tokenBudget !== undefined && options.tokenBudget > 0
+            ? Math.round(options.tokenBudget)
+            : undefined;
+        this.goal = {
+            id: this.genId(),
+            objective: objective.trim(),
+            status: "active",
+            tokenBudget,
+            tokensUsed: 0,
+            untrackedTokenTurns: 0,
+            turnsSpent: 0,
+            createdAt: ts,
+            updatedAt: ts,
+        };
+        this.emit();
+        return this.snapshot();
+    }
+    clear() {
+        if (!this.goal)
+            return;
+        this.goal = null;
+        this.emit();
+    }
+    edit(objective) {
+        if (!this.goal)
+            return null;
+        this.goal.objective = objective.trim();
+        this.touch();
+        this.emit();
+        return this.snapshot();
+    }
+    /** Update the token budget without resetting accumulated progress. */
+    setBudget(tokenBudget) {
+        if (!this.goal)
+            return null;
+        this.goal.tokenBudget =
+            tokenBudget !== undefined && tokenBudget > 0 ? Math.round(tokenBudget) : undefined;
+        this.touch();
+        this.emit();
+        return this.snapshot();
+    }
+    pause() {
+        if (!this.goal)
+            return null;
+        if (this.goal.status === "active" || this.goal.status === "budget_limited") {
+            this.goal.status = "paused";
+            this.touch();
+            this.emit();
+        }
+        return this.snapshot();
+    }
+    resume() {
+        if (!this.goal)
+            return null;
+        if (this.goal.status === "paused" ||
+            this.goal.status === "blocked" ||
+            this.goal.status === "budget_limited") {
+            this.goal.status = "active";
+            this.touch();
+            this.emit();
+        }
+        return this.snapshot();
+    }
+    markComplete() {
+        return this.setStatus("complete");
+    }
+    markBlocked() {
+        return this.setStatus("blocked");
+    }
+    markBudgetLimited() {
+        return this.setStatus("budget_limited");
+    }
+    setStatus(status) {
+        if (!this.goal)
+            return null;
+        this.goal.status = status;
+        this.touch();
+        this.emit();
+        return this.snapshot();
+    }
+    addTokens(n) {
+        if (!this.goal || !Number.isFinite(n) || n <= 0)
+            return;
+        this.goal.tokensUsed += Math.round(n);
+        this.touch();
+        this.emit();
+    }
+    markTokenUsageUnavailable() {
+        if (!this.goal)
+            return;
+        this.goal.untrackedTokenTurns = (this.goal.untrackedTokenTurns ?? 0) + 1;
+        this.touch();
+        this.emit();
+    }
+    incrementTurn() {
+        if (!this.goal)
+            return;
+        this.goal.turnsSpent += 1;
+        this.touch();
+        this.emit();
+    }
+    /** True when a token budget is set and usage has reached or exceeded it. */
+    isBudgetExceeded() {
+        return (this.goal?.tokenBudget !== undefined &&
+            this.goal.tokensUsed >= this.goal.tokenBudget);
+    }
+    remainingTokens() {
+        if (this.goal?.tokenBudget === undefined)
+            return undefined;
+        return Math.max(0, this.goal.tokenBudget - this.goal.tokensUsed);
+    }
+    /** Restore from persisted state (e.g. on session resume). */
+    loadFrom(state) {
+        if (!state || !state.objective?.trim()) {
+            this.goal = null;
+        }
+        else {
+            this.goal = {
+                ...state,
+                untrackedTokenTurns: state.untrackedTokenTurns !== undefined && state.untrackedTokenTurns > 0
+                    ? Math.round(state.untrackedTokenTurns)
+                    : 0,
+            };
+        }
+        this.emit();
+    }
+}

package/dist/goal/tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Model-facing goal tools: get_goal and update_goal.
+ *
+ * Both read/write the shared GoalStore so the model's completion/blocked signal
+ * stops the TUI's auto-continuation loop. The user sets goals via `/goal`, so
+ * there is intentionally no model-facing create_goal tool.
+ */
+import type { ToolRegistryEntry } from "../types.js";
+import type { GoalStore } from "./store.js";
+export declare function createGoalTools(store: GoalStore): ToolRegistryEntry[];

package/dist/goal/tools.js

@@ -0,0 +1,70 @@
+/**
+ * Model-facing goal tools: get_goal and update_goal.
+ *
+ * Both read/write the shared GoalStore so the model's completion/blocked signal
+ * stops the TUI's auto-continuation loop. The user sets goals via `/goal`, so
+ * there is intentionally no model-facing create_goal tool.
+ */
+import { goalSummaryText } from "./format.js";
+const UPDATE_GOAL_DESCRIPTION = `Update the active thread goal's status. Use this tool only to mark the goal achieved or genuinely blocked; it returns an error if there is no active goal.
+Set status to "complete" only when the objective has actually been achieved and no required work remains — never merely because the budget is nearly exhausted or you are stopping.
+Set status to "blocked" only when the same blocking condition has repeated for at least three consecutive goal turns (counting the original turn and automatic continuations) and you cannot make meaningful progress without user input or an external-state change. Do not use "blocked" because work is hard, slow, uncertain, or incomplete.
+You cannot pause, resume, or set a budget through this tool; those are controlled by the user.`;
+export function createGoalTools(store) {
+    const getGoal = {
+        name: "get_goal",
+        description: "Get the current thread goal: objective, status, turns and tokens used, and remaining token budget. Returns an error if there is no goal.",
+        parameters: { type: "object", properties: {}, required: [], additionalProperties: false },
+        readOnly: true,
+        effect: "read",
+        promptSnippet: "Inspect the active goal's status and remaining token budget.",
+        async execute() {
+            const goal = store.snapshot();
+            if (!goal)
+                return { content: "No active goal.", isError: true };
+            return { content: goalSummaryText(goal) };
+        },
+    };
+    const updateGoal = {
+        name: "update_goal",
+        description: UPDATE_GOAL_DESCRIPTION,
+        parameters: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["complete", "blocked"],
+                    description: 'Set to "complete" only when the objective is achieved and verified; set to "blocked" only after the strict blocked audit is satisfied.',
+                },
+            },
+            required: ["status"],
+            additionalProperties: false,
+        },
+        effect: "unknown",
+        promptSnippet: "Mark the goal complete (objective achieved) or blocked (true impasse).",
+        async execute(args) {
+            const goal = store.snapshot();
+            if (!goal)
+                return { content: "No active goal to update.", isError: true };
+            const status = String(args.status ?? "").toLowerCase();
+            if (status === "complete") {
+                store.markComplete();
+                // The current turn's token usage is only reported at turn_end (after
+                // tools run), so goal.tokensUsed is necessarily stale here. The harness
+                // reports the accurate final total to the user once the run settles.
+                return { content: "Goal marked complete." };
+            }
+            if (status === "blocked") {
+                store.markBlocked();
+                return {
+                    content: "Goal marked blocked. Automatic continuation has stopped; the user can resume it with /goal resume.",
+                };
+            }
+            return {
+                content: `Invalid status "${args.status}". Use "complete" or "blocked".`,
+                isError: true,
+            };
+        },
+    };
+    return [getGoal, updateGoal];
+}

package/dist/goal/usage.d.ts

@@ -0,0 +1,2 @@
+import type { TokenUsage } from "../types.js";
+export declare function tokenUsageTotal(usage: TokenUsage): number;

package/dist/goal/usage.js

@@ -0,0 +1,3 @@
+export function tokenUsageTotal(usage) {
+    return usage.totalTokens ?? ((usage.promptTokens || 0) + (usage.completionTokens || 0));
+}

package/dist/main.js

@@ -6,7 +6,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 { effectiveThemeModeForTerminal, shouldProbeTerminalTheme, UserConfig } from "./config.js";
 import { createProviderInstance, createUnavailableProvider } from "./provider.js";
 import { resolveConfiguredModel } from "./model-selection.js";
 import { getDefaultThinkingLevel } from "./provider-transform.js";
@@ -17,6 +17,7 @@ import { buildSystemPrompt } from "./system-prompt.js";
 import { SkillRegistry } from "./skills/registry.js";
 import { buildToolPromptOptions, createAllTools } from "./tools/index.js";
 import { FileStateTracker } from "./tools/file-state.js";
+import { GoalStore } from "./goal/store.js";
 import { PermissionAwareApprovalController } from "./approval/controller.js";
 import { BashAllowlist } from "./approval/session-cache.js";
 import { SettingsManager } from "./permissions/settings.js";
@@ -30,10 +31,6 @@ import { basename } from "node:path";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 import { configureDebugTrace, summarizeAgentEventForTrace, summarizeTraceMessage, traceEvent, } from "./debug-trace.js";
-// OpenTUI is the default renderer. The React Ink implementation (alt-screen
-// viewport, src/tui-ink) is feature-complete but still maturing — opt in with
-// BUBBLE_TUI=ink.
-const USE_OPENTUI = process.env.BUBBLE_TUI !== "ink";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -159,6 +156,9 @@ async function main() {
     };
     const lspService = getLspService(args.cwd, settingsManager.getMerged().lsp);
     const fileStateTracker = new FileStateTracker(args.cwd);
+    // Shared between the goal tools (model-facing get_goal/update_goal) and the
+    // TUI's auto-continuation engine / status-line indicator.
+    const goalStore = new GoalStore();
     const tools = createAllTools(args.cwd, skillRegistry, {
         todoStore,
         planController,
@@ -167,6 +167,7 @@ async function main() {
         toolSearchController,
         lspService,
         fileStateTracker,
+        goalStore,
         // Lazy: sessionManager is resolved after tools are created.
         checkpoints: () => sessionManager?.getCheckpoints(),
     });
@@ -224,21 +225,21 @@ async function main() {
         }
         else {
             const themeConfig = userConfig.getTheme();
-            if (themeConfig.mode === "auto") {
+            if (shouldProbeTerminalTheme(themeConfig)) {
                 const { detectTerminalTheme } = await import("./tui/detect-theme.js");
                 preResolvedTheme = await detectTerminalTheme();
             }
             else {
-                preResolvedTheme = themeConfig.mode;
+                preResolvedTheme = themeConfig.mode === "light" ? "light" : "dark";
             }
-            const { runSessionPicker } = USE_OPENTUI
-                ? await import("./tui-opentui/run-session-picker.js")
-                : await import("./tui-ink/run-session-picker.js");
+            const pickerThemeMode = effectiveThemeModeForTerminal(themeConfig, preResolvedTheme);
+            const pickerResolvedTheme = pickerThemeMode === "auto" ? preResolvedTheme : pickerThemeMode;
+            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
                 allSessions,
-                resolvedTheme: preResolvedTheme,
+                resolvedTheme: pickerResolvedTheme,
                 themeOverrides: themeConfig.overrides,
             });
             if (picked) {
@@ -312,7 +313,7 @@ async function main() {
         sessionFile: sessionManager?.getSessionFile(),
         provider: activeProviderId || "none",
         model: activeModel || "none",
-        renderer: printMode ? "print" : USE_OPENTUI ? "opentui-core" : "ink",
+        renderer: printMode ? "print" : "ink",
     });
     if (traceInfo.enabled) {
         traceEvent("run_start", {
@@ -503,15 +504,16 @@ async function main() {
         if (preResolvedTheme) {
             detectedTheme = preResolvedTheme;
         }
-        else if (themeConfig.mode === "auto") {
-            // Probe before OpenTUI owns stdin. OSC 11 needs raw mode, and the
+        else if (shouldProbeTerminalTheme(themeConfig)) {
+            // Probe before the renderer owns stdin. OSC 11 needs raw mode, and the
             // runtime renderer can consume the reply before startup code sees it.
             const { detectTerminalTheme } = await import("./tui/detect-theme.js");
             detectedTheme = await detectTerminalTheme();
         }
         else {
-            detectedTheme = themeConfig.mode;
+            detectedTheme = themeConfig.mode === "light" ? "light" : "dark";
         }
+        const effectiveThemeMode = effectiveThemeModeForTerminal(themeConfig, detectedTheme);
         // In-place session switch for the /session picker: rebind every closure
         // that persists to the session (onMessageAppend, markers, title updater)
         // by reassigning the outer `sessionManager`, then replace the agent's
@@ -557,6 +559,7 @@ async function main() {
             settingsManager,
             lspService,
             mcpManager,
+            goalStore,
             hookController,
             flushMemory,
             runMemoryCompaction,
@@ -566,33 +569,17 @@ async function main() {
         const { startStartupUpdateCheck } = await import("./update/index.js");
         const updateCheck = await startStartupUpdateCheck();
         const updateNotice = updateCheck.notice;
-        // Two explicit branches (not a dynamic ternary import) so TypeScript
-        // checks each renderer's RunTuiOptions shape independently.
-        let exitWallMs;
-        if (USE_OPENTUI) {
-            const { runTui } = await import("./tui/run.js");
-            await runTui(agent, args, {
-                ...commonOptions,
-                themeMode: themeConfig.mode,
-                themeOverrides: themeConfig.overrides,
-                detectedTheme,
-                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-                updateNotice: updateNotice ?? undefined,
-                updateNoticeRefresh: updateCheck.refreshed,
-            });
-        }
-        else {
-            const { runTui } = await import("./tui-ink/run.js");
-            const summary = await runTui(agent, args, {
-                ...commonOptions,
-                themeMode: themeConfig.mode,
-                themeOverrides: themeConfig.overrides,
-                detectedTheme,
-                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-                updateNotice: updateNotice ?? undefined,
-            });
-            exitWallMs = summary?.wallMs;
-        }
+        const { runTui } = await import("./tui-ink/run.js");
+        const summary = await runTui(agent, args, {
+            ...commonOptions,
+            themeMode: effectiveThemeMode,
+            themeOverrides: themeConfig.overrides,
+            detectedTheme,
+            onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+            updateNotice: updateNotice ?? undefined,
+            updateNoticeRefresh: updateCheck.refreshed,
+        });
+        const exitWallMs = summary?.wallMs;
         if (sessionManager) {
             printExitSummary(sessionManager, {
                 resumed: resumedExistingSession,

package/dist/model-catalog.js

@@ -28,6 +28,13 @@ const GPT51_CODEX_MAX_LEVELS = ["off", "low", "medium", "high", "xhigh"];
 const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 const OPENAI_CHAT_LEVELS = ["off"];
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
+// GLM-5.2 is the first GLM to accept OpenAI-style `reasoning_effort`. The API
+// enum is none/minimal/low/medium/high/xhigh/max; we expose high and max (the
+// two effort tiers worth offering a coding agent) plus "off", which disables
+// thinking outright via `thinking: {type: "disabled"}`. Order matters: "high"
+// is first so it is the default (getDefaultThinkingLevel falls back to levels[0]
+// when "medium" is absent), since GLM-5.2 is a thinking-on-by-default model.
+const GLM_5_2_LEVELS = ["high", "max", "off"];
 // kimi-k2.7-code only supports thinking mode (disabling it errors), so "off" is
 // not offered — the model is always in its thinking variant.
 const KIMI_THINKING_ONLY_LEVELS = ["medium"];
@@ -63,15 +70,19 @@ export const BUILTIN_MODELS = [
     { id: "gemini-2.5-pro-preview-03-25", name: "gemini-2.5-pro-preview-03-25", providerId: "google", reasoningLevels: ["off", "low", "high"], contextWindow: 128000 },
     { id: "gemini-2.0-flash-001", name: "gemini-2.0-flash-001", providerId: "google", reasoningLevels: ["off"], contextWindow: 128000 },
     { id: "gemini-1.5-pro-latest", name: "gemini-1.5-pro-latest", providerId: "google", reasoningLevels: ["off"], contextWindow: 128000 },
+    { id: "glm-5.2", name: "GLM-5.2", providerId: "zhipuai", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
+    { id: "glm-5.2", name: "GLM-5.2", providerId: "zhipuai-coding-plan", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zhipuai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
+    { id: "glm-5.2", name: "GLM-5.2", providerId: "zai", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
+    { id: "glm-5.2", name: "GLM-5.2", providerId: "zai-coding-plan", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5-turbo", name: "GLM-5-Turbo", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },

package/dist/provider-transform.js

@@ -63,6 +63,23 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {
+        // GLM-5.2 is the only GLM that also accepts `reasoning_effort` (we expose
+        // high/max, which map 1:1 onto the API enum). "off" disables thinking via
+        // `thinking: {type: "disabled"}` — otherwise the server default (thinking
+        // on, effort max) would make "off" a no-op. The effort field rides inside
+        // the body alongside `thinking`, so it goes in extraBody, not the
+        // OpenRouter-style `reasoningEffort` config field.
+        if (modelId === "glm-5.2") {
+            return {
+                effectiveThinkingLevel,
+                extraBody: effectiveThinkingLevel === "off"
+                    ? { thinking: { type: "disabled" } }
+                    : {
+                        thinking: { type: "enabled", clear_thinking: false },
+                        reasoning_effort: effectiveThinkingLevel,
+                    },
+            };
+        }
         return {
             effectiveThinkingLevel,
             extraBody: effectiveThinkingLevel === "off"

package/dist/provider.js

@@ -110,8 +110,10 @@ export function createProviderInstance(options) {
             tool_choice: tools && tools.length > 0 ? chatOptions.toolChoice ?? "auto" : undefined,
             stream: true,
         };
-        // DeepSeek and MiniMax only emit final usage in streaming mode when this flag is set.
-        if (options.providerId === "deepseek" || isMiniMaxOpenAICompatible(options)) {
+        // Several OpenAI-compatible streaming APIs only emit final usage when this
+        // flag is set. Without it, downstream goal/stat accounting can only report
+        // "usage unavailable".
+        if (shouldRequestStreamUsage(options)) {
             body.stream_options = { include_usage: true };
         }
         if (!requestConfig.omitTemperature) {
@@ -207,6 +209,18 @@ function isMiniMaxOpenAICompatible(options) {
         || baseURL.includes("api.minimaxi.com/v1")
         || baseURL.includes("api.minimax.io/v1");
 }
+function shouldRequestStreamUsage(options) {
+    const providerId = (options.providerId || "").toLowerCase();
+    return providerId === "openai"
+        || providerId === "deepseek"
+        || providerId === "moonshot-cn"
+        || providerId === "moonshot-intl"
+        || providerId === "zhipuai"
+        || providerId === "zhipuai-coding-plan"
+        || providerId === "zai"
+        || providerId === "zai-coding-plan"
+        || isMiniMaxOpenAICompatible(options);
+}
 export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
     if (!s) {
@@ -370,9 +384,10 @@ export async function* translateOpenAIStream(stream, options = {}) {
     }
     for await (const chunk of stream) {
         rawChunkSeq += 1;
-        const delta = chunk.choices?.[0]?.delta;
-        const usage = chunk.usage;
-        const finishReason = chunk.choices?.[0]?.finish_reason;
+        const choice = chunk.choices?.[0];
+        const delta = choice?.delta;
+        const usage = chunk.usage ?? choice?.usage;
+        const finishReason = choice?.finish_reason;
         debugReasoningStream({
             stage: "provider_raw",
             providerId: options.debugProviderId,

package/dist/session-types.d.ts

@@ -1,4 +1,5 @@
 import type { AssistantMessage, Message, ThinkingLevel, Todo, ToolCall, ToolMessage, UserMessage } from "./types.js";
+import type { GoalState } from "./goal/store.js";
 export interface SessionMetadata {
     model?: string;
     thinkingLevel?: ThinkingLevel;
@@ -9,6 +10,8 @@ export interface SessionMetadata {
     titleUpdatedAt?: number;
     titleUserMessageId?: string;
     promptCacheKey?: string;
+    /** Persisted autonomous goal (see src/goal). Survives /session resume. */
+    goal?: GoalState;
 }
 export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "conversation_clear";
 interface BaseSessionLogEntry {

package/dist/tools/index.d.ts

@@ -30,6 +30,7 @@ import { type ToolSearchController } from "./tool-search.js";
 import type { QuestionController } from "../question/index.js";
 import type { CheckpointStore } from "../checkpoints.js";
 import { FileStateTracker } from "./file-state.js";
+import type { GoalStore } from "../goal/store.js";
 export interface CreateAllToolsOptions {
     todoStore?: TodoStore;
     planController?: PlanController;
@@ -44,5 +45,7 @@ export interface CreateAllToolsOptions {
      * files before mutating them so /rewind can restore.
      */
     checkpoints?: () => CheckpointStore | undefined;
+    /** Shared goal state; when present, registers the get_goal/update_goal tools. */
+    goalStore?: GoalStore;
 }
 export declare function createAllTools(cwd: string, skillRegistry?: SkillRegistry, options?: CreateAllToolsOptions): ToolRegistryEntry[];

package/dist/tools/index.js

@@ -40,6 +40,7 @@ import { createWriteTool } from "./write.js";
 import { createQuestionTool } from "./question.js";
 import { createMemoryReadSummaryTool, createMemorySearchTool } from "./memory.js";
 import { FileStateTracker } from "./file-state.js";
+import { createGoalTools } from "../goal/tools.js";
 export function createAllTools(cwd, skillRegistry, options = {}) {
     const approval = options.approvalController;
     const lsp = options.lspService ?? getLspService(cwd);
@@ -63,5 +64,6 @@ export function createAllTools(cwd, skillRegistry, options = {}) {
         ...(options.todoStore ? [createTodoTool(options.todoStore)] : []),
         ...(options.planController ? [createExitPlanModeTool(options.planController)] : []),
         ...(options.toolSearchController ? [createToolSearchTool(options.toolSearchController)] : []),
+        ...(options.goalStore ? createGoalTools(options.goalStore) : []),
     ];
 }

package/dist/tui/detect-theme.d.ts

@@ -1,2 +1,3 @@
 export type ResolvedTheme = "light" | "dark";
 export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;
+export declare function themeFromMacOsAppearance(output: string | null | undefined): ResolvedTheme;

package/dist/tui/detect-theme.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 export async function detectTerminalTheme(timeoutMs = 150) {
     const fromEnv = parseColorFgBg(process.env.COLORFGBG);
     if (fromEnv)
@@ -7,6 +8,9 @@ export async function detectTerminalTheme(timeoutMs = 150) {
         if (fromOsc)
             return fromOsc;
     }
+    const fromOs = detectOsAppearanceTheme();
+    if (fromOs)
+        return fromOs;
     return "dark";
 }
 function parseColorFgBg(value) {
@@ -85,3 +89,22 @@ function relativeLuminance(r, g, b) {
     const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
     return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
 }
+function detectOsAppearanceTheme() {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        const output = execFileSync("/usr/bin/defaults", ["read", "-g", "AppleInterfaceStyle"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 100,
+        });
+        return themeFromMacOsAppearance(output);
+    }
+    catch {
+        // On macOS the key is absent in Light mode, and `defaults read` exits 1.
+        return "light";
+    }
+}
+export function themeFromMacOsAppearance(output) {
+    return output?.trim().toLowerCase() === "dark" ? "dark" : "light";
+}

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

@@ -0,0 +1,13 @@
+export interface ImageDisplayMessage {
+    content?: string | null;
+}
+export declare function imageDisplayLabel(index: number): string;
+export declare function imageDisplayLabels(count: number, labelStart?: number): string[];
+export declare function imageDisplayReferenceLine(label: string): string;
+export declare function isImageDisplayReferenceLine(line: string): boolean;
+export declare function splitImageDisplayContent(content: string): {
+    bodyLines: string[];
+    referenceLines: string[];
+};
+export declare function formatImageUserDisplayText(input: string, imageCount: number, labelStart?: number): string;
+export declare function nextImageDisplayLabelStart(messages: Iterable<ImageDisplayMessage>): number;