@webpresso/agent-kit 3.1.26 → 3.1.30

package/dist/esm/cli/commands/dash/tui/runtime.js

@@ -3,8 +3,8 @@
 import { spawnSync } from "node:child_process";
 import { DashPaneController } from "#cli/commands/dash/pane-controller.js";
 import { DASH_REFRESH_INTERVALS_MS, initialAgentEntries, initialLaunchSelection, loadAgentEntriesWithDiagnostics, projectDashboardRuns, projectRunState, shouldRunInitialLaunch, } from "#cli/commands/dash/menu-helpers.js";
-import { parseDashPermissionMode, } from "#cli/commands/dash/provider-capabilities.js";
-import { resolveLaunchPermissionMode } from "#cli/commands/dash/launch-preferences.js";
+import { isDashProvider, parseDashPermissionMode, } from "#cli/commands/dash/provider-capabilities.js";
+import { readChatModePreference, resolveLaunchPermissionMode, writeChatModePreference, } from "#cli/commands/dash/launch-preferences.js";
 import { buildDashRuntimeArgv } from "#cli/commands/dash/runtime-invocation.js";
 import { emitDashE2eState } from "#cli/commands/dash/e2e-state.js";
 import { loadDashUsageSnapshot } from "#cli/commands/dash/usage.js";
@@ -12,16 +12,18 @@ import { formatUltragoalSummaryLine } from "#cli/commands/dash/menu-state.js";
 import { readUltragoalSummary } from "#ultragoal/summary.js";
 import { browserFrameChromeRows, renderFrame, } from "#cli/commands/dash/tui/frame.js";
 import { CONTROL_PLANE_HOSTS, HOST_CAPABILITIES, projectHostAvailability, } from "#cli/commands/dash/tui/hosts.js";
-import { applyWizardNewWorktreeProbe, createInitialTuiState, reduceTuiChunk, rebindPermissionMode, seedBlueprintBrowser, seedWizardItems, withAgents, } from "#cli/commands/dash/tui/state.js";
+import { applyChatBridgeSession, applyPreferredChatModeSeed, applyWizardNewWorktreeProbe, createInitialTuiState, reduceTuiChunk, rebindPermissionMode, seedBlueprintBrowser, seedWizardItems, withAgents, } from "#cli/commands/dash/tui/state.js";
+import { createHermeticChatBridge } from "#cli/commands/dash/tui/chat-bridge.js";
 import { BlueprintViewLoader } from "#cli/commands/dash/blueprints.js";
 import { DashLaunchCoordinator } from "#cli/commands/dash/launch-coordinator.js";
 import { sanitizeTuiText } from "#cli/commands/dash/tui/sanitize.js";
 import { defaultLoadWorktreePickerItems, isProjectClean } from "#cli/commands/dash/menu-helpers.js";
-import { attentionItemsFromRunStatuses, formatAttentionLine, formatResourceLine, } from "#cli/commands/dash/tui/attention-hud.js";
+import { attentionItemsFromRunStatuses, formatAttentionLine, formatResourceLine, selectAttentionLine, } from "#cli/commands/dash/tui/attention-hud.js";
 import { blueprintRowsFromView, browserOverlayLines } from "#cli/commands/dash/tui/browser.js";
 import { BlueprintActionController } from "#cli/commands/dash/blueprint-actions.js";
 import { controlBlueprintExec, executeBlueprint, readBlueprintExecutionLogs, startBlueprint, } from "#cli/commands/blueprint/router.js";
 import { isDashRunProvider } from "#cli/commands/dash/run-types.js";
+import { formatMergeOperatorSurface, formatPrimaryMergeAttentionLine, projectAllMergeSets, } from "#cli/commands/dash/plan-once-merge.js";
 function whichOnPath(binary) {
     const result = spawnSync("which", [binary], { encoding: "utf8" });
     return result.status === 0 && Boolean(result.stdout?.trim());
@@ -117,6 +119,7 @@ function toViewModel(state, input) {
         width: input.width,
         height: input.height,
         permissionMode: state.permissionMode,
+        chatMode: state.chatMode,
         agents: state.agents,
         menu: state.menu,
         hostAvailability: state.hostAvailability,
@@ -219,11 +222,16 @@ export async function runTuiMenu(input) {
         });
     }
     const hostAvailability = projectHostAvailability(detectHostBinaries());
+    // Preferred integrated-chat never seeds chrome here — only after agents load
+    // when host/run gates can pass (applyPreferredChatModeSeed).
+    const preferredChatMode = readChatModePreference();
     let state = createInitialTuiState({
         agents: initialAgentEntries(seededMode),
         permissionMode: seededMode,
         hostAvailability,
+        chatMode: "host-pane",
     });
+    let preferredChatModeSeeded = false;
     // Seed prepared-launch diagnostics (optional-tool refresh failures, etc.).
     if (input.initialLaunch?.warnings.length) {
         state = {
@@ -234,6 +242,8 @@ export async function runTuiMenu(input) {
     let dirty = true;
     let lastFrame = "";
     let running = true;
+    /** When set, domain state paints via the native shell instead of pure-ANSI. */
+    let nativePushView = null;
     /** Once true, no new launch effects may call selectAgent. */
     let shuttingDown = false;
     let initialLaunchConsumed = false;
@@ -261,6 +271,14 @@ export async function runTuiMenu(input) {
     const paint = () => {
         if (shuttingDown)
             return;
+        // Native shell owns the terminal; never write pure-ANSI frames over it.
+        if (nativePushView) {
+            if (!dirty && !input.smokeOnce)
+                return;
+            nativePushView();
+            dirty = false;
+            return;
+        }
         if (!dirty && !input.smokeOnce)
             return;
         const frame = renderFrame(toViewModel(state, {
@@ -274,6 +292,32 @@ export async function runTuiMenu(input) {
         }
         dirty = false;
     };
+    let mergeHudGeneration = 0;
+    /**
+     * Prefer plan-once merge rollup only for incomplete/partial/all-failed.
+     * all-ok is omitted so generic per-run attention stays visible.
+     */
+    const refreshMergeAttention = async () => {
+        const gen = ++mergeHudGeneration;
+        try {
+            const projections = await projectAllMergeSets({ cwd: input.cwd });
+            if (gen !== mergeHudGeneration || shuttingDown)
+                return;
+            // null when no memberships or only all-ok — keep generic attention.
+            const mergeLine = formatPrimaryMergeAttentionLine(projections);
+            const next = selectAttentionLine({
+                mergeLine,
+                genericLine: state.attentionLine,
+            });
+            if (next === state.attentionLine)
+                return;
+            state = { ...state, attentionLine: next };
+            dirty = true;
+        }
+        catch {
+            // Merge HUD is best-effort; generic attention remains.
+        }
+    };
     const mergeRunStatuses = (statuses) => {
         runStatuses = statuses;
         // Always rebind from the discovery snapshot so async status refresh cannot
@@ -288,6 +332,7 @@ export async function runTuiMenu(input) {
         }, projected);
         void projectRunState;
         dirty = true;
+        void refreshMergeAttention();
     };
     const applyEffects = async (effects) => {
         for (const effect of effects) {
@@ -295,6 +340,15 @@ export async function runTuiMenu(input) {
                 running = false;
                 continue;
             }
+            if (effect.kind === "persist-chat-mode") {
+                try {
+                    writeChatModePreference(effect.mode);
+                }
+                catch {
+                    // Preference write is best-effort; never block the control plane.
+                }
+                continue;
+            }
             if (effect.kind === "e2e-group") {
                 emitDashE2eState({
                     kind: "group",
@@ -480,6 +534,188 @@ export async function runTuiMenu(input) {
                 dirty = true;
                 continue;
             }
+            if (effect.kind === "palette-command" && effect.id === "merge.status") {
+                const loadGen = ++browserLoadGeneration;
+                try {
+                    const projections = await projectAllMergeSets({ cwd: input.cwd });
+                    if (loadGen !== browserLoadGeneration || shuttingDown)
+                        continue;
+                    if (state.overlay.kind !== "browser")
+                        continue;
+                    if (projections.length === 0) {
+                        state = {
+                            ...state,
+                            browser: null,
+                            overlay: {
+                                kind: "browser",
+                                title: "Plan-once merge",
+                                lines: [
+                                    "No plan-once membership records.",
+                                    "Confirm a multi-host plan first.",
+                                    "git/PR auto-merge out of scope — status/summary only",
+                                ],
+                            },
+                        };
+                    }
+                    else {
+                        const lines = [];
+                        for (const projection of projections) {
+                            const surface = formatMergeOperatorSurface(projection);
+                            lines.push(surface.summary);
+                            for (const row of surface.matrix)
+                                lines.push(`  ${row}`);
+                            lines.push(surface.scopeNote);
+                            lines.push("");
+                        }
+                        if (lines.at(-1) === "")
+                            lines.pop();
+                        state = {
+                            ...state,
+                            browser: null,
+                            overlay: {
+                                kind: "browser",
+                                title: "Plan-once merge",
+                                lines: lines.map((line) => sanitizeTuiText(line)),
+                            },
+                        };
+                    }
+                }
+                catch (error) {
+                    if (loadGen !== browserLoadGeneration || shuttingDown)
+                        continue;
+                    if (state.overlay.kind !== "browser")
+                        continue;
+                    state = {
+                        ...state,
+                        browser: null,
+                        overlay: {
+                            kind: "browser",
+                            title: "Plan-once merge",
+                            lines: [
+                                sanitizeTuiText(error instanceof Error ? error.message : "failed to load merge status"),
+                            ],
+                        },
+                    };
+                }
+                dirty = true;
+                continue;
+            }
+            if (effect.kind === "palette-command" && effect.id === "chat.mode.open") {
+                // Hermetic bridge for CI/MVP: uses existing dash run identity only.
+                const expectedGeneration = state.chatOpenGeneration;
+                try {
+                    const hostKey = state.menu.selectedKey?.startsWith("group:")
+                        ? state.menu.selectedKey.slice("group:".length)
+                        : state.agents.find((agent) => agent.sessions.some((session) => state.menu.selectedKey === `run:${session.id}` ||
+                            state.menu.selectedKey === `run:${session.runId ?? ""}`))?.key;
+                    const host = hostKey && isDashProvider(hostKey)
+                        ? hostKey
+                        : state.chatSession?.host && isDashProvider(state.chatSession.host)
+                            ? state.chatSession.host
+                            : null;
+                    let runId = state.chatSession?.runId ?? null;
+                    let label = state.chatSession?.label ?? null;
+                    if (!runId) {
+                        const key = state.menu.selectedKey;
+                        if (key?.startsWith("run:")) {
+                            const id = key.slice("run:".length);
+                            for (const agent of state.agents) {
+                                const session = agent.sessions.find((s) => s.id === id || s.runId === id);
+                                if (session) {
+                                    runId = session.runId ?? session.id;
+                                    label = session.label;
+                                    break;
+                                }
+                            }
+                        }
+                        else if (host) {
+                            const agent = state.agents.find((entry) => entry.key === host);
+                            const owned = agent?.sessions.find((s) => s.runId);
+                            if (owned) {
+                                runId = owned.runId ?? owned.id;
+                                label = owned.label;
+                            }
+                        }
+                    }
+                    if (!host || !runId) {
+                        state = applyChatBridgeSession(state, null, "Select a host session (run) before switching to integrated chat", { expectedGeneration });
+                    }
+                    else {
+                        const bridge = createHermeticChatBridge();
+                        const opened = await bridge.open({ host, runId, label });
+                        if (state.chatOpenGeneration !== expectedGeneration ||
+                            state.chatMode !== "integrated-chat") {
+                            // Operator left chat while open was in flight — discard.
+                            continue;
+                        }
+                        if (!opened.ok) {
+                            state = applyChatBridgeSession(state, null, opened.error, { expectedGeneration });
+                        }
+                        else {
+                            // Open only (no auto-send); operator composes and presses Enter.
+                            state = applyChatBridgeSession(state, opened.session, undefined, {
+                                expectedGeneration,
+                            });
+                            // Successful enter: persist preferred integrated-chat.
+                            if (state.chatMode === "integrated-chat") {
+                                try {
+                                    writeChatModePreference("integrated-chat");
+                                }
+                                catch {
+                                    /* best-effort */
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    state = applyChatBridgeSession(state, null, error instanceof Error ? error.message : "chat bridge failed", { expectedGeneration });
+                }
+                dirty = true;
+                continue;
+            }
+            if (effect.kind === "palette-command" && effect.id === "chat.mode.send") {
+                const expectedGeneration = state.chatOpenGeneration;
+                const session = state.chatSession;
+                const text = state.chatDraft.trim();
+                if (!session || !text) {
+                    state = {
+                        ...state,
+                        status: !session ? "chat session not open yet" : "type a message before send",
+                    };
+                    dirty = true;
+                    continue;
+                }
+                try {
+                    const bridge = createHermeticChatBridge();
+                    const sent = await bridge.send(session, text);
+                    if (state.chatOpenGeneration !== expectedGeneration ||
+                        state.chatMode !== "integrated-chat") {
+                        continue;
+                    }
+                    if (!sent.ok) {
+                        state = {
+                            ...state,
+                            status: sanitizeTuiText(sent.error),
+                        };
+                    }
+                    else {
+                        state = applyChatBridgeSession({ ...state, chatDraft: "" }, sent.session, undefined, {
+                            expectedGeneration,
+                        });
+                    }
+                }
+                catch (error) {
+                    if (state.chatOpenGeneration === expectedGeneration) {
+                        state = {
+                            ...state,
+                            status: sanitizeTuiText(error instanceof Error ? error.message : "chat send failed"),
+                        };
+                    }
+                }
+                dirty = true;
+                continue;
+            }
             if (effect.kind === "palette-command" && effect.id === "wizard.open") {
                 // Seed worktree picker items when the wizard opens (or re-emit cursor).
                 if (state.wizard && state.wizard.allItems.length === 0) {
@@ -527,6 +763,15 @@ export async function runTuiMenu(input) {
             return;
         baseAgents = [...loaded.agents];
         state = withAgents({ ...state, warnings: [...state.warnings, ...loaded.warnings.map(sanitizeTuiText)] }, rebindPermissionMode(loaded.agents, state.permissionMode));
+        // One post-load preferred-chat seed when gates pass (no continuous retry).
+        if (!preferredChatModeSeeded && !isSmoke && !shuttingDown) {
+            preferredChatModeSeeded = true;
+            const seeded = applyPreferredChatModeSeed(state, preferredChatMode);
+            state = seeded.state;
+            if (seeded.effects.length > 0) {
+                await enqueueEffects(seeded.effects);
+            }
+        }
         emitDashE2eState({ kind: "providers-rendered" });
         dirty = true;
         paint();
@@ -621,6 +866,68 @@ export async function runTuiMenu(input) {
             stdout.write(`\n${note}\n`);
         return 0;
     }
+    // Primary path: native Ratatui shell when binary is available (WP_DASH_NATIVE=0 forces pure-ANSI).
+    const { shouldPreferNativeDashTui, resolveNativeDashTuiBinary } = await import("#cli/commands/dash/tui/native-path.js");
+    const nativeBinary = shouldPreferNativeDashTui() && !process.env["WP_DASH_FORCE_ANSI"]
+        ? resolveNativeDashTuiBinary()
+        : null;
+    if (nativeBinary) {
+        try {
+            const { runNativeTuiHost } = await import("#cli/commands/dash/tui/native-host.js");
+            process.stderr.write(`wp dash: native control-plane shell (${nativeBinary})\n`);
+            // Ensure agent list is loaded before first native frame when possible.
+            state = { ...state, loading: false };
+            const code = await runNativeTuiHost({
+                binaryPath: nativeBinary,
+                repoLabel: input.repoLabel,
+                getState: () => state,
+                setState: (next) => {
+                    state = next;
+                },
+                onBridge: (bridge) => {
+                    nativePushView = bridge.pushView;
+                },
+                handlers: {
+                    onEffect: (effect) => {
+                        // Match pure-ANSI: repaint after async effects settle so launch /
+                        // browser / status mutations reach the native shell without waiting
+                        // for the next key or timer tick.
+                        void enqueueEffects([effect]).then(() => {
+                            if (!shuttingDown)
+                                paint();
+                        });
+                    },
+                    onQuit: () => {
+                        shuttingDown = true;
+                        running = false;
+                        coordinator.discardPending();
+                    },
+                },
+            });
+            nativePushView = null;
+            if (code !== 0) {
+                throw new Error(`native shell exited with code ${code}`);
+            }
+            shuttingDown = true;
+            running = false;
+            coordinator.discardPending();
+            clearInterval(usageTimer);
+            clearInterval(ultragoalTimer);
+            clearInterval(statusTimer);
+            stopObservingLayout?.();
+            const note = await controller?.dispose();
+            await effectQueue.catch(() => {
+                /* best-effort drain after dispose */
+            });
+            if (note)
+                stdout.write(`\n${note}\n`);
+            return code;
+        }
+        catch (error) {
+            nativePushView = null;
+            process.stderr.write(`wp dash: native shell failed (${error instanceof Error ? error.message : String(error)}); falling back to pure-ANSI\n`);
+        }
+    }
     const wasRaw = stdin.isRaw;
     if (typeof stdin.setRawMode === "function")
         stdin.setRawMode(true);

package/dist/esm/cli/commands/dash/tui/state.d.ts

@@ -8,6 +8,8 @@ import type { LifecycleAction } from "#cli/commands/dash/pane-controller.js";
 import { type DashWizardProvider } from "#cli/commands/dash/session-wizard.js";
 import { type BlueprintBrowserState, type TuiBlueprintRow } from "#cli/commands/dash/tui/browser.js";
 import type { BlueprintAction } from "#cli/commands/dash/blueprint-actions.js";
+import type { ChatSession } from "#cli/commands/dash/tui/chat-bridge.js";
+import { type ControlPlaneChatMode } from "#cli/commands/dash/tui/chat-mode.js";
 export type TuiWizardItem = {
     readonly kind: "current" | "existing" | "new";
     readonly path?: string;
@@ -17,6 +19,17 @@ export type TuiAppState = {
     readonly menu: MenuState;
     readonly agents: readonly AgentEntry[];
     readonly permissionMode: DashPermissionMode;
+    /** host-pane (default escape hatch) vs integrated-chat ACP surface */
+    readonly chatMode: ControlPlaneChatMode;
+    /** Active hermetic/real chat session when in integrated-chat (uses dash run identity). */
+    readonly chatSession: ChatSession | null;
+    /** Composer draft while integrated-chat overlay is active. */
+    readonly chatDraft: string;
+    /**
+     * Monotonic open generation: runtime open/send completions only apply when
+     * this still matches the generation that issued the effect (stale-cancel).
+     */
+    readonly chatOpenGeneration: number;
     readonly overlay: TuiOverlay;
     readonly status: string | null;
     readonly warnings: readonly string[];
@@ -83,6 +96,9 @@ export type TuiEffect = {
 } | {
     readonly kind: "palette-command";
     readonly id: PaletteCommandId;
+} | {
+    readonly kind: "persist-chat-mode";
+    readonly mode: ControlPlaneChatMode;
 } | {
     readonly kind: "e2e-group";
     readonly agent: string;
@@ -100,6 +116,11 @@ export declare function createInitialTuiState(input: {
     readonly agents: readonly AgentEntry[];
     readonly permissionMode: DashPermissionMode;
     readonly hostAvailability?: readonly HostAvailability[];
+    /**
+     * Cold-start seed. Callers must only pass host-pane for preferred integrated-chat
+     * until host/run gates can open chat (see applyPreferredChatModeSeed).
+     */
+    readonly chatMode?: ControlPlaneChatMode;
 }): TuiAppState;
 export declare function reduceTuiChunk(state: TuiAppState, chunk: string): {
     readonly state: TuiAppState;
@@ -113,6 +134,26 @@ export declare function applyPaletteCommand(state: TuiAppState, id: PaletteComma
     readonly state: TuiAppState;
     readonly effects: readonly TuiEffect[];
 };
+/**
+ * Toggle host-pane ↔ integrated-chat. Integrated chat requires an ACP-capable
+ * selected host and an existing dash run identity (no second registry).
+ */
+export declare function toggleChatMode(state: TuiAppState): {
+    readonly state: TuiAppState;
+    readonly effects: readonly TuiEffect[];
+};
+/**
+ * After agents load: if preferred is integrated-chat and gates pass, apply the
+ * normal toggle path once. Never forces integrated-chat chrome without host/run.
+ */
+export declare function applyPreferredChatModeSeed(state: TuiAppState, preferred: ControlPlaneChatMode): {
+    readonly state: TuiAppState;
+    readonly effects: readonly TuiEffect[];
+};
+/** Runtime applies hermetic/real bridge result into state + overlay. */
+export declare function applyChatBridgeSession(state: TuiAppState, session: ChatSession | null, error?: string, options?: {
+    readonly expectedGeneration?: number;
+}): TuiAppState;
 /** Open the worktree/permission wizard with a real wizard object (not overlay-only). */
 export declare function openLaunchWizard(state: TuiAppState, provider: DashWizardProvider): {
     readonly state: TuiAppState;