@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/tui/components/transcript.js

@@ -10,6 +10,11 @@
  *   - tool calls: single-line trace with status glyph, name, arg preview,
  *     error result preview
  *   - synthetic rows (interrupt, compaction, notices) rendered as notices
+ *
+ * Horizontal geometry: every surface shares one left rail (see
+ * TRANSCRIPT_RAIL_COLUMNS). The rail carries per-surface chrome and the body
+ * always starts at the same column, so user text, tool entries, reasoning and
+ * the final answer line up no matter which projector drew the row.
  */
 import chalk from "chalk";
 import stringWidth from "string-width";
@@ -77,10 +82,21 @@ export function createTranscriptTheme(getTheme) {
     };
 }
 export const defaultTranscriptTheme = createTranscriptTheme(() => darkTheme);
+/**
+ * Width of the shared left rail. Column 0..2 belong to surface chrome
+ * (user `›`, hovered tool `│`, reasoning `┃`); the body starts at column 3.
+ * Changing this moves every transcript surface together.
+ */
+export const TRANSCRIPT_RAIL_COLUMNS = 3;
+/**
+ * Cells left unpainted on the right. Painting the physical last column can
+ * trigger an automatic wrap in several terminals and leaves a broken bg patch.
+ */
+const TRANSCRIPT_RIGHT_MARGIN = 2;
 const TRACE_BORDER_MIN_COLUMNS = 4;
 const IMAGE_LABEL_SPACE_SENTINEL = "\uE000";
-const TRACE_CONTENT_LEFT_PAD = 2;
-const TRACE_RESERVED_COLUMNS = 4; // left border + content pad + right border
+const TRACE_CONTENT_LEFT_PAD = TRANSCRIPT_RAIL_COLUMNS - 1; // cells between the hover border and the body
+const TRACE_RESERVED_COLUMNS = TRANSCRIPT_RAIL_COLUMNS + 1; // rail + right border
 // Keep a zero-width row in projection joins without painting a terminal cell.
 // The row exists in layout at rest, so hover can add corners without reflow.
 const TRACE_IDLE_VPAD = "\x1b[0m";
@@ -88,22 +104,43 @@ const TRACE_IDLE_VPAD = "\x1b[0m";
 function truncateVisible(text, maxColumns) {
     return truncateVisual(text, maxColumns);
 }
+/**
+ * Compose one transcript row from rail chrome and body. `rail` may be styled
+ * and is padded to exactly TRANSCRIPT_RAIL_COLUMNS cells, so the body column
+ * is identical for every surface regardless of which glyph the rail carries.
+ */
+function railRow(rail, body) {
+    const pad = Math.max(0, TRANSCRIPT_RAIL_COLUMNS - stringWidth(rail));
+    return `${rail}${" ".repeat(pad)}${body}`;
+}
+/**
+ * Shared body-width computation. Below the same threshold the tool frame uses
+ * to drop its border, surfaces give up the rail rather than squeezing text
+ * into a one-cell column.
+ */
+function railGeometry(columns) {
+    const width = Math.max(1, Math.floor(columns));
+    const frameColumns = width > TRANSCRIPT_RIGHT_MARGIN ? width - TRANSCRIPT_RIGHT_MARGIN : width;
+    const rail = frameColumns >= TRACE_BORDER_MIN_COLUMNS;
+    return {
+        rail,
+        bodyColumns: rail ? Math.max(1, frameColumns - TRANSCRIPT_RAIL_COLUMNS) : frameColumns,
+    };
+}
 export function renderUserCard(content, options, images = [], messageKey = "user") {
     const theme = options.theme ?? defaultTranscriptTheme;
     const terminalWidth = Math.max(1, Math.floor(options.columns));
-    // Leave two terminal cells unpainted. Painting the physical last column can
-    // trigger an automatic wrap in several terminals and leaves a broken bg
-    // patch at the right edge. At one or two columns there is no room to reserve
-    // that margin, so use every available cell.
-    const width = terminalWidth > 2 ? terminalWidth - 2 : terminalWidth;
-    // The normal card gutter is four cells (marker + trailing pad). On an
+    // At one or two columns there is no room to reserve the right margin, so
+    // use every available cell.
+    const width = terminalWidth > TRANSCRIPT_RIGHT_MARGIN ? terminalWidth - TRANSCRIPT_RIGHT_MARGIN : terminalWidth;
+    // The card gutter is the shared rail plus one trailing pad cell. On an
     // extremely narrow terminal, degrade to a plain painted row; forcing the
     // historical 20-column minimum is what made settled rows overflow after a
     // 20x5 resize even though the live trace itself was width-safe.
-    if (width < 5) {
+    if (width < TRANSCRIPT_RAIL_COLUMNS + 2) {
         return wrapPlain(content, width).map((line) => theme.userBg(truncateVisible(line, width)));
     }
-    const textWidth = width - 4; // " › " + trailing pad
+    const textWidth = width - TRANSCRIPT_RAIL_COLUMNS - 1; // rail + trailing pad
     const split = images.length > 0 ? splitImageDisplayContent(content) : undefined;
     const body = split?.bodyLines.join("\n") ?? content;
     // Preserve the label's visible width while preventing the generic word
@@ -137,7 +174,7 @@ export function renderUserCard(content, options, images = [], messageKey = "user
             renderedLine = renderedLine.replace(image.label, chip);
         }
         const padded = `${renderedLine}${" ".repeat(Math.max(0, textWidth - stringWidth(renderedLine)))}`;
-        const filled = (index === 0 ? theme.accent(" › ") : "   ") + theme.userText(padded) + " ";
+        const filled = railRow(index === 0 ? theme.accent(" › ") : "", theme.userText(padded)) + " ";
         rows.push(theme.userBg(filled));
     });
     // Keep the painted padding symmetric so the message body is vertically
@@ -177,62 +214,98 @@ function projectUserCard(message, options) {
     return { rows, traceTargets: targets };
 }
 export function wrapPlain(text, columns) {
-    const out = [];
-    const splitToken = (token) => {
-        const chunks = [];
+    return Array.from(iteratePlainRows(text, columns));
+}
+/** Stream rows so collapsed reasoning need not retain its entire wrapped body. */
+function* iteratePlainRows(text, columns) {
+    const widths = new Map();
+    const ascii = { width: 1, additive: true };
+    const measureChar = (char) => {
+        const code = char.charCodeAt(0);
+        if (code >= 0x20 && code <= 0x7e)
+            return ascii;
+        let cached = widths.get(char);
+        if (!cached) {
+            cached = {
+                width: stringWidth(char),
+                // These scalars cannot combine with each other. Other text (marks,
+                // emoji, joiners, ANSI, Jamo, etc.) still uses whole-chunk measurement.
+                additive: /^[\p{Unified_Ideograph}\p{Punctuation}]$/u.test(char),
+            };
+            widths.set(char, cached);
+        }
+        return cached;
+    };
+    function* splitToken(token) {
         let chunk = "";
         let width = 0;
+        let additive = true;
         for (const char of token) {
-            const charWidth = stringWidth(char);
-            if (chunk && width + charWidth > columns) {
-                chunks.push(chunk);
+            const metric = measureChar(char);
+            if (chunk && width + metric.width > columns) {
+                yield { text: chunk, width: additive ? width : stringWidth(chunk) };
                 chunk = "";
                 width = 0;
+                additive = true;
             }
             chunk += char;
-            width += charWidth;
+            width += metric.width;
+            additive &&= metric.additive;
         }
         if (chunk)
-            chunks.push(chunk);
-        return chunks;
-    };
-    for (const paragraph of text.split("\n")) {
-        if (paragraph === "") {
-            out.push("");
-            continue;
-        }
+            yield { text: chunk, width: additive ? width : stringWidth(chunk) };
+    }
+    // Scan paragraphs/tokens lazily: a head preview can stop early, and a tail
+    // preview never allocates arrays for all paragraphs, tokens or wrapped rows.
+    let start = 0;
+    while (start <= text.length) {
+        const newline = text.indexOf("\n", start);
+        const end = newline === -1 ? text.length : newline;
+        const paragraph = text.slice(start, end);
+        if (paragraph === "")
+            yield "";
         let line = "";
-        for (const word of paragraph.split(/\s+/)) {
-            for (const chunk of splitToken(word)) {
-                const candidate = line ? `${line} ${chunk}` : chunk;
-                if (line && stringWidth(candidate) > columns) {
-                    out.push(line);
-                    line = chunk;
+        let lineWidth = 0;
+        for (const match of paragraph.matchAll(/\S+/g)) {
+            for (const chunk of splitToken(match[0])) {
+                const candidateWidth = line ? lineWidth + 1 + chunk.width : chunk.width;
+                if (line && candidateWidth > columns) {
+                    yield line;
+                    line = chunk.text;
+                    lineWidth = chunk.width;
                 }
                 else {
-                    line = candidate;
+                    line = line ? `${line} ${chunk.text}` : chunk.text;
+                    lineWidth = candidateWidth;
                 }
             }
         }
         if (line)
-            out.push(line);
+            yield line;
+        if (newline === -1)
+            break;
+        start = newline + 1;
     }
-    return out;
 }
 /**
  * Project assistant prose without transcript spacing. Live streaming and
  * settled history both call this function, so completing a turn cannot change
- * the answer gutter or wrapping width.
+ * the answer gutter or wrapping width. Prose carries an empty rail: its body
+ * sits in the same column as user text and tool entries.
  */
 export function projectAssistantRows(content, options) {
-    const terminalWidth = Math.max(1, Math.floor(options.columns));
-    const width = Math.max(1, terminalWidth - 2);
-    if (options.markdownRenderer) {
-        return options.markdownRenderer(content, width)
-            .map((row) => truncateVisible(row, terminalWidth));
-    }
-    return wrapPlain(content, width)
-        .map((row) => truncateVisible(row, terminalWidth));
+    const geometry = railGeometry(options.columns);
+    const body = options.markdownRenderer
+        ? options.markdownRenderer(content, geometry.bodyColumns)
+        : wrapPlain(content, geometry.bodyColumns);
+    return body.map((row) => {
+        const clipped = truncateVisible(row, geometry.bodyColumns);
+        // Paragraph breaks stay genuinely empty so projection joins still treat
+        // them as spacers instead of three painted cells.
+        if (stringWidth(clipped) === 0)
+            return "";
+        return geometry.rail ? railRow("", clipped) : clipped;
+    });
 }
 export function renderAssistant(content, options) {
     return [...projectAssistantRows(content, options), ""];
@@ -262,35 +335,46 @@ export function joinTranscriptBlocks(blocks) {
 /** Grok minimal mode keeps the same rolling reasoning surface live/settled. */
 export const MINIMAL_REASONING_BODY_ROWS = 5;
 /**
- * Grok-style reasoning surface. Reasoning alone owns a one-cell rail; normal
- * assistant prose never inherits this gutter. The same projection is used by
- * the live row pool and committed transcript.
+ * Grok-style reasoning surface. Reasoning paints a `┃` in the shared rail so
+ * its body lines up with prose and tool entries. The same projection is used
+ * by the live row pool and committed transcript.
  */
 export function projectReasoningRows(content, options, projection = {}) {
     const theme = options.theme ?? defaultTranscriptTheme;
-    const columns = Math.max(1, Math.floor(options.columns));
-    const bodyWidth = Math.max(1, columns - 1);
-    const body = content
-        .split("\n")
-        .filter((line) => line.trim() !== "")
-        .flatMap((line) => wrapPlain(line, bodyWidth));
-    if (body.length === 0)
-        return [];
-    const limit = Math.max(0, projection.maxBodyRows ?? (options.showReasoning ? body.length : MINIMAL_REASONING_BODY_ROWS));
+    const geometry = railGeometry(options.columns);
+    const limit = Math.max(0, Math.floor(projection.maxBodyRows ?? (options.showReasoning ? Infinity : MINIMAL_REASONING_BODY_ROWS)));
     const fromEnd = projection.fromEnd ?? !options.showReasoning;
-    const visible = limit === 0
-        ? []
-        : fromEnd
-            ? body.slice(-limit)
+    const body = [];
+    let count = 0;
+    for (const line of iteratePlainRows(content, geometry.bodyColumns)) {
+        if (!line)
+            continue;
+        count += 1;
+        if (limit === 0)
+            break;
+        if (limit === Infinity || !fromEnd)
+            body.push(line);
+        else
+            body[(count - 1) % limit] = line;
+        // One extra row suffices to detect hidden content in a head preview.
+        if (!fromEnd && count > limit)
+            break;
+    }
+    if (count === 0)
+        return [];
+    const visible = limit === 0 ? []
+        : fromEnd && count > limit
+            ? [...body.slice(count % limit), ...body.slice(0, count % limit)]
             : body.slice(0, limit);
     const style = (text) => theme.dim(chalk.italic(text));
-    const rows = [style(truncateVisible(`┃◆ Thinking${projection.running ? "…" : ""}`, columns))];
-    for (const line of visible) {
-        rows.push(style(truncateVisible(`┃${line}`, columns)));
-    }
-    if (body.length > visible.length) {
-        const suffix = options.showReasoning ? "┃…" : "┃… (Ctrl+T to expand)";
-        rows.push(style(truncateVisible(suffix, columns)));
+    const row = (text) => style(geometry.rail
+        ? railRow("┃", truncateVisible(text, geometry.bodyColumns))
+        : truncateVisible(text, geometry.bodyColumns));
+    const rows = [row(`◆ Thinking${projection.running ? "…" : ""}`)];
+    for (const line of visible)
+        rows.push(row(line));
+    if (count > visible.length) {
+        rows.push(row(options.showReasoning ? "…" : "… (Ctrl+T to expand)"));
     }
     return rows;
 }
@@ -358,7 +442,7 @@ export function projectToolTraceGroups(toolCalls, options, renderOptions = {}) {
 function projectTraceGroup(group, options) {
     const theme = options.theme ?? defaultTranscriptTheme;
     const columns = Math.max(1, options.columns);
-    const frameColumns = columns > 2 ? columns - 2 : columns;
+    const frameColumns = columns > TRANSCRIPT_RIGHT_MARGIN ? columns - TRANSCRIPT_RIGHT_MARGIN : columns;
     const contentColumns = frameColumns >= TRACE_BORDER_MIN_COLUMNS
         ? Math.max(1, frameColumns - TRACE_RESERVED_COLUMNS)
         : frameColumns;
@@ -545,7 +629,7 @@ function decorateTraceGroup(projection, target, groupKey, columns, theme, intera
         : TRACE_IDLE_VPAD;
     const rows = projection.rows.map((row) => {
         if (!active)
-            return `${" ".repeat(TRACE_CONTENT_LEFT_PAD + 1)}${row}`;
+            return railRow("", row);
         const interior = `${" ".repeat(TRACE_CONTENT_LEFT_PAD)}${row}`;
         const padding = " ".repeat(Math.max(0, columns - 2 - stringWidth(interior)));
         return `${border("│")}${background(`${interior}${padding}`)}${border("│")}`;
@@ -613,7 +697,7 @@ function appendReadPreview(rows, traceTargets, tool, target, columns, theme, ind
 function projectCompactionSummary(message, options) {
     const theme = options.theme ?? defaultTranscriptTheme;
     const columns = Math.max(1, options.columns);
-    const frameColumns = columns > 2 ? columns - 2 : columns;
+    const frameColumns = columns > TRANSCRIPT_RIGHT_MARGIN ? columns - TRANSCRIPT_RIGHT_MARGIN : columns;
     const contentColumns = frameColumns >= TRACE_BORDER_MIN_COLUMNS
         ? Math.max(1, frameColumns - TRACE_RESERVED_COLUMNS)
         : frameColumns;
@@ -760,9 +844,12 @@ export function projectTranscript(messages, options) {
     // The transcript owns the sole separator before a live assistant surface.
     // When that surface settles, the same row becomes the transcript's trailing
     // separator, so user -> Thinking geometry cannot change at commit time.
+    // A transcript that already ends in a spacer (a tool group's bottom padding)
+    // must not gain a second one, or the next turn's live Thinking sits one row
+    // lower than it will after commit.
     if (projection.rows.length === 0)
         return projection;
-    if (options.trailingSpacer !== false) {
+    if (options.trailingSpacer !== false && !projection.trailingSpacer) {
         projection.rows.push("");
         projection.traceTargets.push(undefined);
         projection.trailingSpacer = true;

package/dist/tui/composer-autocomplete.d.ts

@@ -16,21 +16,35 @@ export interface ComposerAutocompleteSources {
     providerId?(): string;
     themeMode?(): ThemeMode;
     detectedTheme?(): ResolvedTheme;
+    /** True while the session is bound to the legacy Grok external runtime. */
+    grokRuntimeActive?(): boolean;
     onModelSuggestionsChanged?(): void;
     fdPath?: string | null;
 }
 type ModelCompletionSource = (argumentPrefix: string) => AutocompleteArgumentSuggestions | AutocompleteItem[] | null;
 type ProviderCompletionSource = ModelCompletionSource;
 type ThemeCompletionSource = ModelCompletionSource;
-type ComposerPickerRegistry = ModelPickerRegistry & Pick<ProviderRegistry, "getConfigured" | "getDefault">;
+export type AuthCommandName = "login" | "logout";
+type AuthCompletionSource = (command: AuthCommandName, argumentPrefix: string) => AutocompleteArgumentSuggestions | AutocompleteItem[] | null;
+type ComposerPickerRegistry = ModelPickerRegistry & Pick<ProviderRegistry, "getConfigured" | "getDefault"> & Partial<Pick<ProviderRegistry, "getOAuthLoginKeys">>;
 export declare function buildModelAutocompleteItems(groups: ModelProviderGroup[], argumentPrefix?: string, currentThinkingLevel?: ThinkingLevel): AutocompleteItem[];
 export declare function buildProviderAutocompleteItems(registry: Pick<ProviderRegistry, "getConfigured" | "getModelConfig">, argumentPrefix?: string, currentProviderId?: string): AutocompleteItem[];
+export interface AuthAccountState {
+    isSignedIn(providerId: string): boolean;
+    /** Session is bound to the legacy Grok external runtime. */
+    grokRuntimeActive?: boolean;
+}
+/**
+ * Accounts for /login and /logout. Derived from the catalog so a new OAuth
+ * provider is offered without touching this list.
+ */
+export declare function buildAuthAutocompleteItems(command: AuthCommandName, argumentPrefix?: string, state?: AuthAccountState): AutocompleteItem[];
 export declare function buildThemeAutocompleteItems(argumentPrefix?: string, detectedTheme?: ResolvedTheme): AutocompleteItem[];
 /**
  * Build the command surface in execution-priority order. The registry remains
  * live so MCP prompts that connect after startup appear on the next keypress.
  */
-export declare function buildComposerSlashCommands(commands: UnifiedCommand[], skills: SkillSummary[], uiMode?: TuiMode, modelCompletions?: ModelCompletionSource, providerCompletions?: ProviderCompletionSource, themeCompletions?: ThemeCompletionSource): TuiSlashCommand[];
+export declare function buildComposerSlashCommands(commands: UnifiedCommand[], skills: SkillSummary[], uiMode?: TuiMode, modelCompletions?: ModelCompletionSource, providerCompletions?: ProviderCompletionSource, themeCompletions?: ThemeCompletionSource, authCompletions?: AuthCompletionSource): TuiSlashCommand[];
 /** A live adapter around pi-tui's command/file completion implementation. */
 export declare class ComposerAutocompleteProvider implements AutocompleteProvider {
     private readonly sources;
@@ -48,6 +62,7 @@ export declare class ComposerAutocompleteProvider implements AutocompleteProvide
     };
     shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
     private delegate;
+    private getAuthCompletions;
     private getThemeCompletions;
     private getProviderCompletions;
     private getModelCompletions;

package/dist/tui/composer-autocomplete.js

@@ -1,11 +1,16 @@
 import { CombinedAutocompleteProvider, } from "@bubblebrain-ai/pi-tui";
 import { BUILTIN_PROVIDERS, encodeModel, isUserVisibleProvider, } from "../provider-registry.js";
 import { getAvailableThinkingLevels, isThinkingToggleModel, normalizeThinkingLevel, } from "../provider-transform.js";
+import { GROK_SUBSCRIPTION_PROVIDER_ID, isGrokSubscriptionProviderId, } from "../external-runtime/grok-provider.js";
 import { discoverModelProviderGroups, getVisibleModelProviders, localModelsForProvider, } from "./model-picker-data.js";
 const MODEL_COMMAND_PREFIX = "/model ";
 const REASONING_EFFORT_SEPARATOR = " --reasoning-effort ";
 const PROVIDER_COMMAND_PREFIX = "/provider ";
 const THEME_COMMAND_PREFIX = "/theme ";
+const AUTH_COMMAND_PREFIX = {
+    login: "/login ",
+    logout: "/logout ",
+};
 const EFFORT_DESCRIPTIONS = {
     off: "no reasoning effort",
     minimal: "fastest reasoning",
@@ -160,6 +165,47 @@ export function buildProviderAutocompleteItems(registry, argumentPrefix = "", cu
             }];
     });
 }
+/**
+ * What picking a row will actually do. Provider-specific because the handlers
+ * differ: /login openai always runs a fresh OAuth flow, while /login grok
+ * reuses stored credentials and only opens the browser when they fail.
+ */
+function authActionHint(command, providerId, signedIn, grokRuntimeActive) {
+    const grok = isGrokSubscriptionProviderId(providerId);
+    if (command === "login") {
+        if (!signedIn)
+            return "opens the browser";
+        return grok ? "reuses the stored sign-in · /logout grok first to switch accounts" : "sign in again";
+    }
+    if (grok && grokRuntimeActive)
+        return "ends the active Grok session and starts a fresh one";
+    return signedIn ? "removes this device's credentials" : "nothing to remove";
+}
+/**
+ * Accounts for /login and /logout. Derived from the catalog so a new OAuth
+ * provider is offered without touching this list.
+ */
+export function buildAuthAutocompleteItems(command, argumentPrefix = "", state = { isSignedIn: () => false }) {
+    const query = argumentPrefix.trim().toLowerCase();
+    return BUILTIN_PROVIDERS.flatMap((provider) => {
+        if (!provider.supportsOAuth || !isUserVisibleProvider(provider.id))
+            return [];
+        const grok = isGrokSubscriptionProviderId(provider.id);
+        const runtimeActive = grok && state.grokRuntimeActive === true;
+        const signedIn = state.isSignedIn(provider.id);
+        const status = signedIn ? "Signed in" : runtimeActive ? "Active session" : "Not signed in";
+        const hint = authActionHint(command, provider.id, signedIn, runtimeActive);
+        const description = `${provider.id} · ${status} · ${hint}`;
+        // Match the account only. The status/hint prose is shared by every row,
+        // so searching it would make "open" match Grok via "opens the browser".
+        // Include every id the handler accepts so a typed alias still matches.
+        const aliases = grok ? ` ${GROK_SUBSCRIPTION_PROVIDER_ID}` : "";
+        const searchable = `${provider.id} ${provider.name}${aliases}`.toLowerCase();
+        if (query && !searchable.includes(query))
+            return [];
+        return [{ value: provider.id, label: provider.name, description, submitOnSelect: true }];
+    });
+}
 export function buildThemeAutocompleteItems(argumentPrefix = "", detectedTheme = "dark") {
     const query = argumentPrefix.trim().toLowerCase();
     const candidates = [
@@ -178,7 +224,7 @@ export function buildThemeAutocompleteItems(argumentPrefix = "", detectedTheme =
  * Build the command surface in execution-priority order. The registry remains
  * live so MCP prompts that connect after startup appear on the next keypress.
  */
-export function buildComposerSlashCommands(commands, skills, uiMode = "regular", modelCompletions, providerCompletions, themeCompletions) {
+export function buildComposerSlashCommands(commands, skills, uiMode = "regular", modelCompletions, providerCompletions, themeCompletions, authCompletions) {
     const result = new Map();
     const add = (command) => {
         if (!result.has(command.name))
@@ -237,6 +283,23 @@ export function buildComposerSlashCommands(commands, skills, uiMode = "regular",
                 getArgumentCompletions: themeCompletions,
             });
         }
+        else if ((command.name === "login" || command.name === "logout") && authCompletions) {
+            const authCommand = command.name;
+            add({
+                name: command.name,
+                description: command.description,
+                argumentHint: "<account>",
+                submitOnSelect: false,
+                argumentInputHint: {
+                    prompt: "⌕ ",
+                    placeholder: "Select account…",
+                    valuePrefix: AUTH_COMMAND_PREFIX[authCommand],
+                },
+                // No keep-open-on-empty: an empty menu swallows Enter, and a typed id
+                // the list does not show must still reach the handler's own error.
+                getArgumentCompletions: (prefix) => authCompletions(authCommand, prefix),
+            });
+        }
         else {
             add({ name: command.name, description: command.description });
         }
@@ -274,7 +337,21 @@ export class ComposerAutocompleteProvider {
         return this.delegate().shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
     }
     delegate() {
-        return new CombinedAutocompleteProvider(buildComposerSlashCommands(this.sources.commands(), this.sources.skills(), this.sources.uiMode?.() ?? "regular", this.sources.registry ? (prefix) => this.getModelCompletions(prefix) : undefined, this.sources.registry ? (prefix) => this.getProviderCompletions(prefix) : undefined, (prefix) => this.getThemeCompletions(prefix)), this.sources.cwd, this.sources.fdPath ?? null);
+        return new CombinedAutocompleteProvider(buildComposerSlashCommands(this.sources.commands(), this.sources.skills(), this.sources.uiMode?.() ?? "regular", this.sources.registry ? (prefix) => this.getModelCompletions(prefix) : undefined, this.sources.registry ? (prefix) => this.getProviderCompletions(prefix) : undefined, (prefix) => this.getThemeCompletions(prefix), (command, prefix) => this.getAuthCompletions(command, prefix)), this.sources.cwd, this.sources.fdPath ?? null);
+    }
+    getAuthCompletions(command, argumentPrefix) {
+        const registry = this.sources.registry;
+        return {
+            items: buildAuthAutocompleteItems(command, argumentPrefix, {
+                isSignedIn: (id) => (registry?.getOAuthLoginKeys?.(id).length ?? 0) > 0,
+                grokRuntimeActive: this.sources.grokRuntimeActive?.() ?? false,
+            }),
+            inputHint: {
+                prompt: "⌕ ",
+                placeholder: "Select account…",
+                valuePrefix: AUTH_COMMAND_PREFIX[command],
+            },
+        };
     }
     getThemeCompletions(argumentPrefix) {
         const items = buildThemeAutocompleteItems(argumentPrefix, this.sources.detectedTheme?.() ?? "dark");

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

@@ -60,6 +60,7 @@ export declare class BubbleTuiController {
     private readonly queue;
     private readonly sessionTransition;
     private readonly startedAtMs;
+    private turnStartedAt;
     private readonly goalRuntime?;
     private readonly taskRuntime?;
     private readonly pendingTaskAnnouncements;
@@ -67,9 +68,6 @@ export declare class BubbleTuiController {
     private transcript;
     private runActive;
     private runState;
-    /** Background subagent updates can outlive the provider turn that launched
-     * them. Keep their latest synthetic tool snapshot in the live trace. */
-    private readonly liveSubagentTools;
     /** Provider-turn accumulators for true child-session inspection. */
     private readonly childRuns;
     private activeInputController;
@@ -81,7 +79,6 @@ export declare class BubbleTuiController {
     private disposed;
     constructor(deps: BubbleTuiControllerDeps);
     private externalGeneration;
-    private liveSubagentVersion;
     subscribe(listener: (version: number) => void): () => void;
     getSnapshotVersion(): number;
     getTranscript(): readonly DisplayMessage[];
@@ -89,6 +86,12 @@ export declare class BubbleTuiController {
     getGoalIndicator(): string | undefined;
     handleGoalCommand(input: string, cwd: string): void;
     getSubagentGroups(): SubagentGroup[];
+    /**
+     * Start of the current (or, when idle, the latest) agent run. The tasks pane
+     * keeps finished work that was launched since then; wall clock on purpose,
+     * it is compared with subagent/task/workflow creation stamps.
+     */
+    getTurnStartedAt(): number | undefined;
     getWorkflows(): WorkflowRunSnapshot[];
     getBackgroundTasks(): BackgroundTaskInfo[];
     getChildTranscript(agentId: string): DisplayMessage[];
@@ -106,6 +109,8 @@ export declare class BubbleTuiController {
     persistFinalTaskMarkers(): void;
     private appendTaskMarker;
     private announceTaskCompletion;
+    /** Pending completions whose launch row has settled since they arrived. */
+    private landPendingTaskAnnouncementsInLiveRound;
     /** Move the newest live Bash Execute into the unified task manager. */
     promoteActiveBash(): string | undefined;
     /** Drop every transcript row (/clear). */