@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/controller/effects.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Effects are the controller's only vocabulary for side effects. The pure
+ * reducers (agent-event-reducer, input-queue) return them; the controller
+ * applies them against its state and ports. Renderers observe state changes
+ * through snapshots, never effects.
+ */
+import type { DisplayMessage } from "../model/display-history.js";
+export type ControllerEffect = {
+    kind: "stream-cleared";
+} | {
+    kind: "stream-flushed";
+} | {
+    kind: "tools-updated";
+} | {
+    kind: "live-subagent-changed";
+} | {
+    kind: "assistant-committed";
+    taskElapsedMs?: number;
+} | {
+    kind: "permission-mode-changed";
+    mode: string;
+} | {
+    kind: "transcript-append";
+    message: DisplayMessage;
+} | {
+    kind: "transcript-move-message";
+    displayKey: string;
+    fullReprint: boolean;
+} | {
+    kind: "transcript-rebuild-from-agent";
+    fullReprint: boolean;
+} | {
+    kind: "session-append-message";
+    role: "user";
+    content: string;
+} | {
+    kind: "queue-updated";
+    pending?: number;
+} | {
+    kind: "external-cancel";
+    sessionId: string;
+} | {
+    kind: "external-cancel-policy";
+} | {
+    kind: "steer-applied";
+    id: string;
+    displayKey: string;
+} | {
+    kind: "steer-requeued";
+    id: string;
+    displayKey: string;
+} | {
+    kind: "steers-drained";
+    cancelled: boolean;
+    leftovers: Array<{
+        input: import("../../types.js").AgentRunInput;
+        displayKey?: string;
+        sessionFile?: string;
+    }>;
+} | {
+    kind: "run-finished";
+    cancelled: boolean;
+    errored: boolean;
+} | {
+    kind: "run-error";
+    error: unknown;
+} | {
+    kind: "notice";
+    role: "assistant" | "error";
+    text: string;
+};

package/dist/tui/controller/effects.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/controller/goal-runtime-controller.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Autonomous Goal runtime for the framework-neutral TUI controller.
+ *
+ * The GoalStore remains the single source of truth shared with the model-facing
+ * update_goal tool. This class owns the host lifecycle around it: slash command
+ * handling, session persistence, hidden continuation turns, usage accounting,
+ * and stop/resume semantics. Renderers only read the resulting snapshot.
+ */
+import type { SessionManager } from "../../session.js";
+import type { GoalState, GoalStatus, GoalStore } from "../../goal/store.js";
+export interface GoalRunSummary {
+    goalRun: boolean;
+    goalStatusAtStart?: GoalStatus;
+    cancelled: boolean;
+    errored: boolean;
+    usageTokens: number;
+    usageReported: boolean;
+}
+export interface GoalRuntimeControllerDeps {
+    store: GoalStore;
+    getSessionManager(): SessionManager;
+    isRunActive(): boolean;
+    queuedInputs(): number;
+    isDisposed(): boolean;
+    startRun(input: string, cwd: string): void;
+    appendMessage(role: "user" | "assistant" | "error", content: string): void;
+    onStateChanged(): void;
+    schedule?(callback: () => void): void;
+}
+export declare class GoalRuntimeController {
+    private readonly deps;
+    private persistSuspended;
+    private readonly unsubscribe;
+    constructor(deps: GoalRuntimeControllerDeps);
+    dispose(): void;
+    snapshot(): GoalState | null;
+    indicatorLine(): string | undefined;
+    /** Restore the newly bound session without resurrecting an autonomous run. */
+    loadCurrentSession(): void;
+    handleCommand(input: string, cwd: string): void;
+    /** Called once after every controller run, before queued next-turn input drains. */
+    afterRun(summary: GoalRunSummary, cwd: string): void;
+    private scheduleGoalTurn;
+    private persistGoal;
+    private externalRuntimeBound;
+    private notice;
+}

package/dist/tui/controller/goal-runtime-controller.js

@@ -0,0 +1,202 @@
+import { formatInternalContextBlock } from "../../agent/internal-reminder-sanitizer.js";
+import { parseGoalCommand } from "../../goal/command.js";
+import { shouldContinueGoal, stopReasonNotice } from "../../goal/engine.js";
+import { goalCompleteNotice, goalIndicatorLine, goalSummaryText } from "../../goal/format.js";
+import { continuationPrompt, initialPrompt } from "../../goal/prompts.js";
+export class GoalRuntimeController {
+    deps;
+    persistSuspended = false;
+    unsubscribe;
+    constructor(deps) {
+        this.deps = deps;
+        this.unsubscribe = deps.store.onChange((goal) => {
+            if (!this.persistSuspended)
+                this.persistGoal(goal);
+            this.deps.onStateChanged();
+        });
+        this.loadCurrentSession();
+    }
+    dispose() {
+        this.unsubscribe();
+    }
+    snapshot() {
+        return this.deps.store.snapshot();
+    }
+    indicatorLine() {
+        const goal = this.snapshot();
+        return goal ? goalIndicatorLine(goal) : undefined;
+    }
+    /** Restore the newly bound session without resurrecting an autonomous run. */
+    loadCurrentSession() {
+        let persisted;
+        try {
+            persisted = this.deps.getSessionManager().getMetadata().goal;
+        }
+        catch {
+            persisted = undefined;
+        }
+        this.persistSuspended = true;
+        try {
+            this.deps.store.loadFrom(persisted?.status === "active" ? { ...persisted, status: "paused" } : persisted);
+        }
+        finally {
+            this.persistSuspended = false;
+        }
+    }
+    handleCommand(input, cwd) {
+        if (this.externalRuntimeBound()) {
+            this.deps.appendMessage("error", "/goal is available in native Bubble sessions, not in the current external runtime session.");
+            return;
+        }
+        const command = parseGoalCommand(input);
+        if (command.error) {
+            this.deps.appendMessage("error", command.error);
+            return;
+        }
+        const existing = this.snapshot();
+        switch (command.kind) {
+            case "show":
+                this.notice(existing ? goalSummaryText(existing) : "No active goal. Set one with /goal <objective>");
+                return;
+            case "clear":
+                if (!existing) {
+                    this.notice("No active goal to clear");
+                    return;
+                }
+                this.deps.store.clear();
+                this.notice("Goal cleared");
+                return;
+            case "pause":
+                if (!existing) {
+                    this.notice("No active goal to pause");
+                    return;
+                }
+                this.deps.store.pause();
+                this.notice("Goal paused — /goal resume to continue");
+                return;
+            case "resume": {
+                if (!existing) {
+                    this.notice("No goal to resume. Set one with /goal <objective>");
+                    return;
+                }
+                const resumed = this.deps.store.resume();
+                if (resumed?.status !== "active") {
+                    this.notice("Goal cannot be resumed (already complete)");
+                    return;
+                }
+                this.notice("Goal resumed");
+                this.scheduleGoalTurn(resumed, cwd, false);
+                return;
+            }
+            case "edit":
+                if (!existing) {
+                    this.notice("No active goal to edit. Set one with /goal <objective>");
+                    return;
+                }
+                this.deps.store.edit(command.objective);
+                if (command.tokenBudget !== undefined)
+                    this.deps.store.setBudget(command.tokenBudget);
+                this.notice(`Goal updated: ${truncate(this.snapshot().objective, 60)}`);
+                return;
+            case "set": {
+                const goal = this.deps.store.set(command.objective, { tokenBudget: command.tokenBudget });
+                this.deps.appendMessage("user", input.trim());
+                const budgetNote = goal.tokenBudget !== undefined ? ` (budget ${goal.tokenBudget} tok)` : "";
+                this.notice(`Goal set${budgetNote} — working autonomously. /goal pause to stop.`);
+                this.scheduleGoalTurn(goal, cwd, true);
+            }
+        }
+    }
+    /** Called once after every controller run, before queued next-turn input drains. */
+    afterRun(summary, cwd) {
+        if (this.deps.isDisposed())
+            return;
+        const before = this.snapshot();
+        if (!before)
+            return;
+        const belongsToGoal = summary.goalRun
+            || summary.goalStatusAtStart === "active"
+            || before.status === "active";
+        if (!belongsToGoal)
+            return;
+        if (summary.cancelled || summary.errored) {
+            if (before.status === "active") {
+                this.deps.store.pause();
+                this.notice(stopReasonNotice(summary.errored ? "error" : "cancelled"));
+            }
+            return;
+        }
+        if (summary.goalRun) {
+            if (summary.usageReported) {
+                if (summary.usageTokens > 0)
+                    this.deps.store.addTokens(summary.usageTokens);
+            }
+            else {
+                this.deps.store.markTokenUsageUnavailable();
+            }
+            this.deps.store.incrementTurn();
+        }
+        const goal = this.snapshot();
+        if (!goal)
+            return;
+        const decision = shouldContinueGoal({
+            goal,
+            queuedInputs: this.deps.queuedInputs(),
+        });
+        if (decision.continue) {
+            this.scheduleGoalTurn(goal, cwd, false);
+            return;
+        }
+        if (decision.reason === "budget" && goal.status === "active") {
+            this.deps.store.markBudgetLimited();
+        }
+        if (decision.reason === "complete") {
+            this.notice(goalCompleteNotice(goal));
+            return;
+        }
+        // An explicit /goal pause already emitted its user-facing notice. Other
+        // stop causes (blocked, budget, queued input) originate at this boundary.
+        if (decision.reason === "paused")
+            return;
+        const note = stopReasonNotice(decision.reason);
+        if (note)
+            this.notice(note);
+    }
+    scheduleGoalTurn(goal, cwd, initial) {
+        if (this.deps.isRunActive() || this.deps.isDisposed())
+            return;
+        const schedule = this.deps.schedule ?? queueMicrotask;
+        schedule(() => {
+            if (this.deps.isDisposed() || this.deps.isRunActive())
+                return;
+            const current = this.snapshot();
+            if (!current || current.id !== goal.id || current.status !== "active")
+                return;
+            const prompt = initial ? initialPrompt(current) : continuationPrompt(current);
+            this.deps.startRun(formatInternalContextBlock("goal", prompt), cwd);
+        });
+    }
+    persistGoal(goal) {
+        try {
+            const manager = this.deps.getSessionManager();
+            manager.mutateMetadata((current) => ({ ...current, goal: goal ?? undefined }));
+        }
+        catch {
+            // Persistence is best-effort; a filesystem failure must not break a run.
+        }
+    }
+    externalRuntimeBound() {
+        try {
+            return this.deps.getSessionManager().getMetadata().externalRuntime !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    notice(content) {
+        this.deps.appendMessage("assistant", content);
+    }
+}
+function truncate(value, max) {
+    return value.length <= max ? value : `${value.slice(0, Math.max(0, max - 1))}…`;
+}

package/dist/tui/controller/input-queue-machine.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Pure steer/queue input state machine (controller extraction §2.3).
+ *
+ * Encodes the lifecycle that app.tsx:1768-1813 and the run-finally block
+ * (app.tsx:1888-1930) implement inline:
+ *
+ *   queued ──(submit while running & steer-eligible)──▶ steering(pending_steer)
+ *   steering ──input_applied──▶ applied (row moves to transcript end)
+ *   steering ──input_rejected──▶ queued (badge flips, row kept)
+ *   steering ──run cancel + leftover──▶ dropped (row deleted)
+ *   steering ──run normal end + leftover──▶ queued (requeued)
+ *   queued ──drain (gates pass)──▶ submitted (placeholder row removed)
+ *   any ──session switch──▶ purged
+ *
+ * No rendering, no timers, no Ink: state in, (state, effects) out.
+ */
+import type { AgentEvent } from "../../types.js";
+import type { ControllerEffect } from "./effects.js";
+import type { PendingSteerMeta, QueuedInput } from "../model/input-queue.js";
+export type { PendingSteerMeta, QueuedInput };
+export interface InputQueueState {
+    queued: QueuedInput[];
+    pendingSteers: Map<string, PendingSteerMeta>;
+}
+export interface QueueDrainGate {
+    runActive: boolean;
+    startingSubmit: boolean;
+    overlayOpen: boolean;
+    currentSessionFile?: string;
+}
+export interface QueueTransition {
+    readonly state: InputQueueState;
+    readonly effects: readonly ControllerEffect[];
+}
+export declare function createInputQueueState(): InputQueueState;
+/** Submit while a run is active and the input is steer-eligible. */
+export declare function beginSteer(state: InputQueueState, input: {
+    id: string;
+    content: string;
+    displayKey: string;
+    sessionFile?: string;
+}): QueueTransition;
+/** Queue an input for the next turn (Tab or steer-ineligible while running). */
+export declare function enqueue(state: InputQueueState, input: QueuedInput): QueueTransition;
+/** Reduce an agent event against the queue state (input_* events only). */
+export declare function reduceInputQueueEvent(state: InputQueueState, event: AgentEvent, ctx: {
+    isMultiplexed: boolean;
+    runSessionFile?: string;
+}): QueueTransition;
+/**
+ * Run-end drain for leftover steers (app.tsx:1904-1930):
+ * cancelled → drop rows; normal end → requeue for the next turn.
+ */
+export declare function drainLeftoverSteers(state: InputQueueState, leftovers: Array<{
+    id: string;
+    content: string;
+}>, opts: {
+    cancelled: boolean;
+    runSessionFile?: string;
+}): QueueTransition;
+/**
+ * Attempt to submit the next queued input (app.tsx:2422-2435): all gates
+ * must pass and the input must belong to the current session.
+ */
+export declare function drainNextQueued(state: InputQueueState, gate: QueueDrainGate): {
+    state: InputQueueState;
+    submit?: QueuedInput;
+    droppedKeys: string[];
+};
+/** Session switch: purge everything (app.tsx:989-995). */
+export declare function purgeForSessionSwitch(state: InputQueueState): QueueTransition;

package/dist/tui/controller/input-queue-machine.js

@@ -0,0 +1,121 @@
+export function createInputQueueState() {
+    return { queued: [], pendingSteers: new Map() };
+}
+/** Submit while a run is active and the input is steer-eligible. */
+export function beginSteer(state, input) {
+    state.pendingSteers.set(input.id, { displayKey: input.displayKey, sessionFile: input.sessionFile });
+    return {
+        state,
+        effects: [{ kind: "queue-updated", pending: state.pendingSteers.size }],
+    };
+}
+/** Queue an input for the next turn (Tab or steer-ineligible while running). */
+export function enqueue(state, input) {
+    state.queued.push(input);
+    return {
+        state,
+        effects: [{ kind: "queue-updated", pending: state.pendingSteers.size }],
+    };
+}
+/** Reduce an agent event against the queue state (input_* events only). */
+export function reduceInputQueueEvent(state, event, ctx) {
+    switch (event.type) {
+        case "input_applied": {
+            const steer = state.pendingSteers.get(event.id);
+            if (!steer)
+                return { state, effects: [] };
+            state.pendingSteers.delete(event.id);
+            // app.tsx:1768-1789 — moving the steer out of the live region is an
+            // append off a multiplexer but needs a full reprint under tmux/screen.
+            return {
+                state,
+                effects: [
+                    { kind: "transcript-move-message", displayKey: steer.displayKey, fullReprint: ctx.isMultiplexed },
+                    { kind: "queue-updated", pending: state.pendingSteers.size },
+                ],
+            };
+        }
+        case "input_rejected": {
+            // app.tsx:1791-1806 — no continuation left: badge flips to QUEUED and
+            // the text is queued for the next turn.
+            const steer = state.pendingSteers.get(event.id);
+            if (!steer)
+                return { state, effects: [] };
+            state.pendingSteers.delete(event.id);
+            state.queued.push({
+                payload: { text: event.content, images: [] },
+                displayKey: steer.displayKey,
+                sessionFile: steer.sessionFile ?? ctx.runSessionFile,
+            });
+            return {
+                state,
+                effects: [
+                    { kind: "steer-requeued", id: event.id, displayKey: steer.displayKey },
+                    { kind: "queue-updated", pending: state.pendingSteers.size },
+                ],
+            };
+        }
+        case "input_pending_changed": {
+            if (event.pending === 0 && state.pendingSteers.size > 0) {
+                state.pendingSteers.clear();
+            }
+            return { state, effects: [{ kind: "queue-updated", pending: event.pending === 0 ? 0 : event.pending }] };
+        }
+        default:
+            return { state, effects: [] };
+    }
+}
+/**
+ * Run-end drain for leftover steers (app.tsx:1904-1930):
+ * cancelled → drop rows; normal end → requeue for the next turn.
+ */
+export function drainLeftoverSteers(state, leftovers, opts) {
+    for (const leftover of leftovers) {
+        const steer = state.pendingSteers.get(leftover.id);
+        state.pendingSteers.delete(leftover.id);
+        if (opts.cancelled) {
+            if (steer) {
+                // Row removal is a transcript effect the controller applies.
+                void steer;
+            }
+            continue;
+        }
+        state.queued.push({
+            payload: { text: leftover.content, images: [] },
+            displayKey: steer?.displayKey,
+            sessionFile: steer?.sessionFile ?? opts.runSessionFile,
+        });
+    }
+    return {
+        state,
+        effects: [{ kind: "queue-updated", pending: state.pendingSteers.size }],
+    };
+}
+/**
+ * Attempt to submit the next queued input (app.tsx:2422-2435): all gates
+ * must pass and the input must belong to the current session.
+ */
+export function drainNextQueued(state, gate) {
+    if (gate.runActive || gate.startingSubmit || gate.overlayOpen) {
+        return { state, submit: undefined, droppedKeys: [] };
+    }
+    while (state.queued.length > 0) {
+        const next = state.queued.shift();
+        if (!isQueuedInputForCurrentSession(next, gate.currentSessionFile)) {
+            continue; // Stale placeholder from a switched-away session: skip.
+        }
+        return { state, submit: next, droppedKeys: [] };
+    }
+    return { state, submit: undefined, droppedKeys: [] };
+}
+/** Session switch: purge everything (app.tsx:989-995). */
+export function purgeForSessionSwitch(state) {
+    state.queued.length = 0;
+    state.pendingSteers.clear();
+    return { state, effects: [{ kind: "queue-updated", pending: 0 }] };
+}
+function isQueuedInputForCurrentSession(input, currentSessionFile) {
+    if (!input.sessionFile || !currentSessionFile)
+        return true;
+    return input.sessionFile === currentSessionFile;
+}

package/dist/tui/controller/intents.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Intents are the single entry point into the controller. UI layers
+ * (composer, pickers, dialogs, keyboard shortcuts) translate raw input into
+ * intents; the controller owns validation, ordering, and state transitions.
+ */
+export type ShutdownReason = "user-quit" | "sigterm" | "sigint" | "error";
+export type BubbleTuiIntent = {
+    type: "submit";
+    text: string;
+    images?: unknown[];
+} | {
+    type: "cancel-run";
+} | {
+    type: "steer";
+    text: string;
+} | {
+    type: "queue-input";
+    text: string;
+    images?: unknown[];
+} | {
+    type: "open-picker";
+    picker: string;
+} | {
+    type: "close-picker";
+} | {
+    type: "toggle-thinking";
+} | {
+    type: "toggle-verbose-trace";
+} | {
+    type: "cycle-thinking";
+} | {
+    type: "cycle-permission";
+} | {
+    type: "switch-session";
+    file: string;
+} | {
+    type: "start-fresh-session";
+} | {
+    type: "execute-command";
+    command: string;
+} | {
+    type: "set-composer-draft";
+    text: string | null;
+} | {
+    type: "promote-task";
+    taskId: string;
+} | {
+    type: "kill-task";
+    taskId: string;
+} | {
+    type: "set-focus";
+    target: "composer" | "subagent-entry";
+} | {
+    type: "shutdown";
+    reason: ShutdownReason;
+};

package/dist/tui/controller/intents.js

@@ -0,0 +1,6 @@
+/**
+ * Intents are the single entry point into the controller. UI layers
+ * (composer, pickers, dialogs, keyboard shortcuts) translate raw input into
+ * intents; the controller owns validation, ordering, and state transitions.
+ */
+export {};

package/dist/tui/controller/overlay-controller.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Blocking-interaction lifecycle (controller extraction §3).
+ *
+ * Models plan approvals, tool approvals, questions, and feedback as owned
+ * requests with exactly one terminal state. Legacy wiring lives in
+ * app.tsx:542-583 (promise-resolver refs + question subscription) but never
+ * settles requests on session switch or shutdown — this controller makes
+ * that guarantee explicit (design doc behavior delta).
+ */
+import type { ApprovalDecision, ApprovalRequest } from "../../approval/types.js";
+import type { PlanDecision } from "../../types.js";
+import type { QuestionController } from "../../question/controller.js";
+export type OverlayTerminalState = "accepted" | "rejected" | "cancelled" | "disposed";
+export type SettleVia = "user" | "session-switch" | "shutdown" | "replaced";
+export interface PlanRequestPayload {
+    plan: string;
+}
+export declare class OwnedRequest<TDecision> {
+    readonly id: string;
+    readonly kind: "plan" | "approval" | "question" | "feedback";
+    private readonly onSettle?;
+    state: "pending" | OverlayTerminalState;
+    private resolvers;
+    readonly result: Promise<TDecision>;
+    constructor(id: string, kind: "plan" | "approval" | "question" | "feedback", onSettle?: ((request: OwnedRequest<TDecision>, via: SettleVia) => void) | undefined);
+    settle(decision: TDecision, via: SettleVia): boolean;
+}
+export interface OverlaySnapshot {
+    plan?: {
+        id: string;
+        plan: string;
+    };
+    approval?: {
+        id: string;
+        request: ApprovalRequest;
+    };
+    question?: {
+        id: string;
+    };
+}
+export declare class OverlayRequestController {
+    private readonly deps;
+    private readonly requests;
+    private questionUnsubscribe?;
+    private notifyChange;
+    constructor(deps?: {
+        questionController?: QuestionController;
+    });
+    /** Host wires change notification (snapshot rebuild). */
+    onChange(listener: () => void): void;
+    installPlanHandler(ref: {
+        current?: (plan: string) => Promise<PlanDecision>;
+    }): void;
+    installApprovalHandler(ref: {
+        current?: (request: ApprovalRequest) => Promise<ApprovalDecision>;
+    }): void;
+    adoptQuestionStream(): void;
+    openFeedback(initialDescription: string): OwnedRequest<"dismissed">;
+    /** Settle every pending request (session switch, shutdown, replacement). */
+    settleAll(via: "session-switch" | "shutdown"): number;
+    /** Drain the question subscription (controller shutdown). */
+    dispose(): void;
+    pendingCount(): number;
+}