@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/tasks/promotion.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ctrl+B send-to-background promotion channel (background-tasks design §2.5).
+ *
+ * A running foreground bash tool call registers a promotion handler keyed by
+ * its toolCall id at spawn; the TUI requests promotion when the user presses
+ * Ctrl+B. The handler returns the new task id on success, or undefined when
+ * it is too late (the command already reached a terminal state — exit,
+ * timeout, cancel — a benign race, not an error).
+ */
+export type PromotionHandler = () => string | undefined;
+export declare class PromotionChannel {
+    private readonly handlers;
+    register(toolCallId: string, handler: PromotionHandler): () => void;
+    /** Returns the promoted task id, or undefined when nothing was promotable. */
+    requestPromotion(toolCallId: string): string | undefined;
+    hasPromotable(toolCallId: string): boolean;
+}

package/dist/tasks/promotion.js

@@ -0,0 +1,30 @@
+/**
+ * Ctrl+B send-to-background promotion channel (background-tasks design §2.5).
+ *
+ * A running foreground bash tool call registers a promotion handler keyed by
+ * its toolCall id at spawn; the TUI requests promotion when the user presses
+ * Ctrl+B. The handler returns the new task id on success, or undefined when
+ * it is too late (the command already reached a terminal state — exit,
+ * timeout, cancel — a benign race, not an error).
+ */
+export class PromotionChannel {
+    handlers = new Map();
+    register(toolCallId, handler) {
+        this.handlers.set(toolCallId, handler);
+        return () => {
+            if (this.handlers.get(toolCallId) === handler) {
+                this.handlers.delete(toolCallId);
+            }
+        };
+    }
+    /** Returns the promoted task id, or undefined when nothing was promotable. */
+    requestPromotion(toolCallId) {
+        const handler = this.handlers.get(toolCallId);
+        if (!handler)
+            return undefined;
+        return handler();
+    }
+    hasPromotable(toolCallId) {
+        return this.handlers.has(toolCallId);
+    }
+}

package/dist/tasks/wake.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Auto-resume wake decision + coalescing (background-tasks design §2.3b).
+ *
+ * Kept pure and out of the TUI so the guard rails are unit-testable:
+ * - debounce-before-fire coalescing (the idle input queue drains in ~0ms, so
+ *   merging can only happen BEFORE the wake is submitted);
+ * - user preemption (queued user input or a running turn suppresses the wake
+ *   — the state-change reminder covers the completion on the next turn);
+ * - config kill switch (tasks.auto_resume = false);
+ * - killed tasks never wake (killing is an explicit decision, not news).
+ */
+import type { BackgroundTaskInfo } from "./manager.js";
+export interface TaskWakeGateInput {
+    autoResume: boolean;
+    turnRunning: boolean;
+    queuedInputs: number;
+    exiting?: boolean;
+}
+export declare function shouldFireTaskWake(input: TaskWakeGateInput): boolean;
+export declare function taskEligibleForWake(task: BackgroundTaskInfo): boolean;
+export declare function formatTaskWakeSummary(tasks: BackgroundTaskInfo[], outputTail: (id: string) => string | undefined): string;
+export interface DanglingTaskStart {
+    id: string;
+    pid?: number;
+    startedAt?: number;
+    command?: string;
+    description?: string;
+}
+/**
+ * Resume-time orphan detection (design §2.2c): task_started markers with no
+ * matching task_finished/task_killed belong to a previous process. The caller
+ * probes pid liveness before reporting.
+ */
+export declare function findDanglingTaskStarts(entries: Array<{
+    type: string;
+    kind?: string;
+    value?: string;
+}>): DanglingTaskStart[];
+export declare function isPidAlive(pid: number | undefined): boolean;
+/**
+ * Debounce-then-fire coalescer: the first eligible completion arms a timer;
+ * completions inside the window fold into one wake payload.
+ */
+export declare class TaskWakeCoalescer {
+    private readonly delayMs;
+    private readonly fire;
+    private pending;
+    private timer;
+    constructor(delayMs: number, fire: (tasks: BackgroundTaskInfo[]) => void);
+    add(task: BackgroundTaskInfo): void;
+    /** Drop everything armed (session switch / exit). Returns what was pending. */
+    cancel(): BackgroundTaskInfo[];
+}

package/dist/tasks/wake.js

@@ -0,0 +1,125 @@
+/**
+ * Auto-resume wake decision + coalescing (background-tasks design §2.3b).
+ *
+ * Kept pure and out of the TUI so the guard rails are unit-testable:
+ * - debounce-before-fire coalescing (the idle input queue drains in ~0ms, so
+ *   merging can only happen BEFORE the wake is submitted);
+ * - user preemption (queued user input or a running turn suppresses the wake
+ *   — the state-change reminder covers the completion on the next turn);
+ * - config kill switch (tasks.auto_resume = false);
+ * - killed tasks never wake (killing is an explicit decision, not news).
+ */
+export function shouldFireTaskWake(input) {
+    if (!input.autoResume)
+        return false;
+    if (input.exiting)
+        return false;
+    if (input.turnRunning)
+        return false;
+    if (input.queuedInputs > 0)
+        return false;
+    return true;
+}
+export function taskEligibleForWake(task) {
+    return task.status === "completed" || task.status === "failed";
+}
+export function formatTaskWakeSummary(tasks, outputTail) {
+    const lines = [
+        tasks.length === 1
+            ? "A background task you started has finished."
+            : `${tasks.length} background tasks you started have finished.`,
+    ];
+    for (const task of tasks) {
+        const elapsed = Math.round(((task.endedAt ?? Date.now()) - task.startedAt) / 1000);
+        lines.push(`- ${task.id}${task.description ? ` (${task.description})` : ""}: ${task.status}${task.exitCode != null ? ` exit ${task.exitCode}` : ""} in ${elapsed}s`);
+        lines.push(`  command: ${task.command}`);
+        const tail = outputTail(task.id)?.trim();
+        if (tail) {
+            lines.push("  output tail:");
+            lines.push(...tail.split("\n").slice(-30).map((line) => `    ${line}`));
+        }
+    }
+    // Field-test lesson (2026-07-19): an unconditional "continue the work"
+    // nudge pushed the model to invent follow-up work when nothing was left.
+    lines.push("If unfinished work depends on these results, continue it now. "
+        + "If nothing does, report the outcome to the user in one or two sentences and stop — do not invent new work. "
+        + "Never re-run what already finished.");
+    return lines.join("\n");
+}
+/**
+ * Resume-time orphan detection (design §2.2c): task_started markers with no
+ * matching task_finished/task_killed belong to a previous process. The caller
+ * probes pid liveness before reporting.
+ */
+export function findDanglingTaskStarts(entries) {
+    const started = new Map();
+    for (const entry of entries) {
+        if (entry.type !== "marker" || !entry.value)
+            continue;
+        if (entry.kind === "task_started") {
+            const parsed = parseMarker(entry.value);
+            if (parsed?.id)
+                started.set(parsed.id, parsed);
+        }
+        else if (entry.kind === "task_finished" || entry.kind === "task_killed") {
+            const parsed = parseMarker(entry.value);
+            if (parsed?.id)
+                started.delete(parsed.id);
+        }
+    }
+    return [...started.values()];
+}
+export function isPidAlive(pid) {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseMarker(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Debounce-then-fire coalescer: the first eligible completion arms a timer;
+ * completions inside the window fold into one wake payload.
+ */
+export class TaskWakeCoalescer {
+    delayMs;
+    fire;
+    pending = [];
+    timer;
+    constructor(delayMs, fire) {
+        this.delayMs = delayMs;
+        this.fire = fire;
+    }
+    add(task) {
+        this.pending.push(task);
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            const tasks = this.pending.splice(0);
+            if (tasks.length > 0)
+                this.fire(tasks);
+        }, this.delayMs);
+        this.timer.unref?.();
+    }
+    /** Drop everything armed (session switch / exit). Returns what was pending. */
+    cancel() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        return this.pending.splice(0);
+    }
+}

package/dist/text-display.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeSingleLine(text: string): string;
+export declare function truncateVisual(text: string, maxWidth: number): string;
+export declare function padVisual(text: string, width: number): string;

package/dist/text-display.js

@@ -0,0 +1,25 @@
+import stringWidth from "string-width";
+export function normalizeSingleLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function truncateVisual(text, maxWidth) {
+    if (maxWidth <= 0)
+        return "";
+    if (stringWidth(text) <= maxWidth)
+        return text;
+    if (maxWidth === 1)
+        return "…";
+    let out = "";
+    let width = 0;
+    for (const ch of text) {
+        const chWidth = stringWidth(ch);
+        if (width + chWidth > maxWidth - 1)
+            break;
+        out += ch;
+        width += chWidth;
+    }
+    return `${out}…`;
+}
+export function padVisual(text, width) {
+    return `${text}${" ".repeat(Math.max(0, width - stringWidth(text)))}`;
+}

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

@@ -0,0 +1,30 @@
+import type { AgentProfile } from "../agent/profiles.js";
+import type { ApprovalController } from "../approval/types.js";
+import type { ToolRegistryEntry, ToolResult } from "../types.js";
+export interface AgentLifecycleToolOptions {
+    /** Working directory used for profile discovery in tool descriptions. */
+    cwd?: string;
+    /** Trust gate for project-local .bubble/agents profiles (design §10.2). */
+    approval?: ApprovalController;
+}
+/**
+ * Session-scoped trust decisions for project profiles, keyed by file path +
+ * content hash so an edited file re-prompts (design §10.2). Shared across the
+ * lifecycle tools created by one factory call.
+ */
+declare class ProjectProfileTrust {
+    private readonly approval?;
+    private readonly approved;
+    constructor(approval?: ApprovalController | undefined);
+    /** Returns undefined when trusted, else a blocked ToolResult. */
+    ensureTrusted(profile: AgentProfile): Promise<ToolResult | undefined>;
+}
+export declare function createSpawnAgentTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
+export declare function createWaitAgentTool(): ToolRegistryEntry;
+export declare function createSendInputTool(): ToolRegistryEntry;
+export declare function createCloseAgentTool(): ToolRegistryEntry;
+export declare function createListAgentsTool(): ToolRegistryEntry;
+export declare function createRunWorkflowTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
+export declare function createWaitWorkflowTool(): ToolRegistryEntry;
+export declare function createAgentLifecycleTools(options?: AgentLifecycleToolOptions): ToolRegistryEntry[];
+export {};