@voybio/ace-swarm 0.1.0 → 0.2.1

package/dist/tui/index.js

@@ -18,6 +18,8 @@ import { detectColorLevel, write, cursor, screen, fg, style } from "./renderer.j
 import { ALL_AGENTS, WORKSPACE_ROOT } from "../helpers.js";
 import { backfillHandoffsIntoScheduler } from "../tools-handoff.js";
 import { DEFAULT_OLLAMA_MODEL, inferProviderFromModel, normalizeLocalBaseUrl, } from "./provider-discovery.js";
+import { resolveAceStateLayout } from "../ace-state-resolver.js";
+import { withLocalModelRuntimeRepository, } from "../store/repositories/local-model-runtime-repository.js";
 const DASHBOARD_CONTROLS = ["provider", "model", "chat", "logs", "refresh"];
 // ── TUI Application ─────────────────────────────────────────────────
 export class AceTui {
@@ -48,6 +50,8 @@ export class AceTui {
     messageQueue = [];
     workspaceRoot;
     providerBaseUrls = new Map();
+    latestRuntimeStatus = null;
+    pendingCloseTabId = null;
     constructor(options = {}) {
         const workspaceRoot = options.workspaceRoot ?? WORKSPACE_ROOT;
         this.workspaceRoot = workspaceRoot;
@@ -218,10 +222,22 @@ export class AceTui {
         });
         // Dashboard: state updated
         this.dashboard.on("updated", () => {
+            this.latestRuntimeStatus = this.dashboard.getLatestRuntimeStatus() ?? null;
             const active = this.tabs.getActiveTab();
             if (active.type === "dashboard") {
                 this.renderActiveView();
             }
+            this.renderStatusBar();
+        });
+        // Dashboard: discovered providers from the store → feed into TUI provider controls
+        this.dashboard.on("providers", (discovered) => {
+            for (const d of discovered) {
+                this.ensureProvider(d.provider);
+                if (d.endpoint)
+                    this.setProviderBaseUrl(d.provider, d.endpoint);
+                if (d.models && d.models.length > 0)
+                    this.setProviderModels(d.provider, d.models, false);
+            }
         });
         // Agent runner: agent output
         this.agentRunner.on("agent_output", (role, text) => {
@@ -276,6 +292,9 @@ export class AceTui {
                 case "l":
                     this.clearView();
                     return;
+                case "w":
+                    this.closeCurrentTab();
+                    return;
             }
         }
         // Alt+number → switch tab
@@ -469,6 +488,7 @@ export class AceTui {
     renderStatusBar() {
         const snap = this.telemetry.getSnapshot();
         const agentTokens = this.agentRunner.getTotalTokens();
+        const runtimeStatus = this.getActiveRuntimeStatus();
         const state = {
             taskState: this.getTaskState(),
             provider: this.provider,
@@ -476,6 +496,29 @@ export class AceTui {
             tokensIn: snap.tokensIn + agentTokens.input,
             tokensOut: snap.tokensOut + agentTokens.output,
             startTime: this.startTime,
+            activeTabLabel: this.tabs.getActiveTab().label,
+            sessionId: runtimeStatus?.session_id,
+            turnCount: runtimeStatus?.turn_count,
+            preflightState: runtimeStatus?.preflight_state,
+            agentName: runtimeStatus?.role,
+            taskName: runtimeStatus?.current_task,
+            bridgeStatus: runtimeStatus?.bridge_status,
+            activeTool: runtimeStatus?.active_tool,
+            blockedReason: runtimeStatus?.blocked_reason,
+            nextAction: runtimeStatus?.recommended_next_action,
+            approvalState: runtimeStatus?.approval_state,
+            retryState: runtimeStatus?.retry_state
+                ? `attempt ${runtimeStatus.retry_state.attempt}${typeof runtimeStatus.retry_state.max_attempts === "number"
+                    ? `/${runtimeStatus.retry_state.max_attempts}`
+                    : ""}`
+                : undefined,
+            pollState: runtimeStatus?.poll_state
+                ? runtimeStatus.poll_state.active
+                    ? `active${typeof runtimeStatus.poll_state.interval_ms === "number"
+                        ? `/${runtimeStatus.poll_state.interval_ms}ms`
+                        : ""}`
+                    : "paused"
+                : undefined,
         };
         this.layout.renderStatusBar(state);
     }
@@ -485,6 +528,17 @@ export class AceTui {
         this.layout.renderInputLine(this.input.getBuffer(), this.input.getCursorPos(), mode, prompt);
     }
     getTaskState() {
+        const runtimeStatus = this.getActiveRuntimeStatus();
+        if (runtimeStatus &&
+            ["blocked", "failed", "needs_input", "approval_pending"].includes(runtimeStatus.bridge_status)) {
+            return "blocked";
+        }
+        if (runtimeStatus &&
+            (runtimeStatus.bridge_status === "retrying" ||
+                runtimeStatus.bridge_status === "running" ||
+                Boolean(runtimeStatus.active_tool))) {
+            return "running";
+        }
         if (this.activeChatSession?.isStreaming())
             return "running";
         if (this.agentRunner.getActiveCount() > 0)
@@ -493,6 +547,7 @@ export class AceTui {
     }
     syncTabState() {
         const tab = this.tabs.getActiveTab();
+        this.pendingCloseTabId = null;
         // Update active chat session pointer
         if (tab.type === "chat") {
             this.activeChatSession = this.chatSessions.get(tab.id) ?? null;
@@ -517,6 +572,13 @@ export class AceTui {
         const now = Date.now();
         this.messageQueue = this.messageQueue.filter(m => m.expiry > now);
     }
+    getActiveRuntimeStatus() {
+        const activeTab = this.tabs.getActiveTab();
+        if (activeTab.type === "chat") {
+            return this.chatSessions.get(activeTab.id)?.getCurrentRuntimeStatus() ?? this.latestRuntimeStatus;
+        }
+        return this.latestRuntimeStatus;
+    }
     normalizeProvider(provider) {
         if (!provider)
             return undefined;
@@ -891,6 +953,25 @@ export class AceTui {
             this.renderStatusBar();
             this.renderInputArea();
         });
+        session.on("runtime_status", (status) => {
+            this.latestRuntimeStatus = status;
+            if (this.tabs.getActiveTab().id === tab.id || this.tabs.getActiveTab().type === "dashboard") {
+                this.renderActiveView();
+            }
+            this.renderStatusBar();
+        });
+        session.on("tool_call", (tool) => {
+            this.dashboard.addEvent("bridge", `tool call → ${tool}`);
+            if (this.tabs.getActiveTab().type === "dashboard") {
+                this.renderActiveView();
+            }
+        });
+        session.on("tool_result", (tool, toolResult) => {
+            this.dashboard.addEvent("bridge", `${toolResult.ok ? "tool ok" : "tool error"} → ${tool}: ${toolResult.summary}`);
+            if (this.tabs.getActiveTab().type === "dashboard") {
+                this.renderActiveView();
+            }
+        });
         session.on("error", (msg) => {
             this.showMessage(msg, "error");
         });
@@ -907,6 +988,19 @@ export class AceTui {
     }
     closeCurrentTab() {
         const tab = this.tabs.getActiveTab();
+        if (!tab.closeable) {
+            this.showMessage(`Tab '${tab.label}' cannot be closed.`, "warn");
+            return;
+        }
+        if (tab.type === "chat") {
+            const session = this.chatSessions.get(tab.id);
+            if (session?.hasMeaningfulTranscript() && this.pendingCloseTabId !== tab.id) {
+                this.pendingCloseTabId = tab.id;
+                this.showMessage("Chat has transcript state. Use /archive to persist it, or close again to discard.", "warn");
+                return;
+            }
+        }
+        this.pendingCloseTabId = null;
         // Clean up chat session if closing a chat tab
         if (tab.type === "chat") {
             const session = this.chatSessions.get(tab.id);
@@ -923,6 +1017,51 @@ export class AceTui {
         this.syncTabState();
         this.fullRender();
     }
+    async archiveCurrentTab() {
+        const tab = this.tabs.getActiveTab();
+        if (tab.type !== "chat") {
+            this.showMessage("Archive is available only for chat tabs.", "warn");
+            return;
+        }
+        const session = this.chatSessions.get(tab.id);
+        if (!session) {
+            this.showMessage("Chat session not found for archive.", "error");
+            return;
+        }
+        if (!session.hasMeaningfulTranscript()) {
+            this.showMessage("Chat is empty. Closing without archive.", "info");
+            this.pendingCloseTabId = tab.id;
+            this.closeCurrentTab();
+            return;
+        }
+        const runtimeStatus = session.getCurrentRuntimeStatus();
+        await withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
+            await repo.archiveChat({
+                session_id: session.getSessionId(),
+                tab_id: tab.id,
+                label: tab.label,
+                provider: session.getProvider(),
+                model: session.getModel(),
+                created_at: session.getCreatedAt(),
+                last_active_at: session.getLastActiveAt(),
+                transcript_excerpt: session.getTranscriptExcerpt(),
+                transcript_summary: session.getTranscriptSummary(),
+                ace_context: {
+                    resolved_layout_mode: resolveAceStateLayout(this.workspaceRoot).physicalMode,
+                    role: runtimeStatus?.role,
+                    bridge_status: runtimeStatus?.bridge_status ?? "done",
+                    active_tool: runtimeStatus?.active_tool,
+                    blocked_reason: runtimeStatus?.blocked_reason,
+                    approval_state: runtimeStatus?.approval_state,
+                    retry_state: runtimeStatus?.retry_state,
+                    recommended_next_action: runtimeStatus?.recommended_next_action,
+                },
+            });
+        });
+        this.showMessage(`Archived chat '${tab.label}'.`, "info");
+        this.pendingCloseTabId = tab.id;
+        this.closeCurrentTab();
+    }
     showMessage(text, level = "info") {
         const colorFn = level === "error" ? fg.red : level === "warn" ? fg.yellow : fg.gray;
         const prefix = level === "error" ? "ERROR" : level === "warn" ? "WARN" : "INFO";
@@ -957,6 +1096,20 @@ export class AceTui {
         this.layout.fullRedraw();
         this.fullRender();
     }
+    setApprovalState(state) {
+        const session = this.activeChatSession;
+        if (!session) {
+            this.showMessage("No active chat runtime to update approval state.", "warn");
+            return false;
+        }
+        const ok = session.setApprovalState(state);
+        if (!ok) {
+            this.showMessage("No active runtime packet to update approval state.", "warn");
+            return false;
+        }
+        this.renderStatusBar();
+        return true;
+    }
     getStatus() {
         const snap = this.telemetry.getSnapshot();
         return {
@@ -969,6 +1122,7 @@ export class AceTui {
             requests: snap.requestCount,
             activeAgents: this.agentRunner.getActiveCount(),
             tabs: this.tabs.getTabs().length,
+            bridgeStatus: this.latestRuntimeStatus?.bridge_status,
         };
     }
     quit() {

package/dist/tui/input.js

@@ -101,6 +101,11 @@ export class InputHandler extends EventEmitter {
                 this.emit("key", { name: "l", sequence: ch, ctrl: true, meta: false, shift: false });
                 continue;
             }
+            // Ctrl+W — close/archive current tab
+            if (code === 23) {
+                this.emit("key", { name: "w", sequence: ch, ctrl: true, meta: false, shift: false });
+                continue;
+            }
             // Tab
             if (code === 9) {
                 if ((this.mode === "command" || this.mode === "chat") && this.buffer.length > 0) {

package/dist/tui/layout.d.ts

@@ -24,6 +24,17 @@ export interface StatusBarState {
     tokensIn: number;
     tokensOut: number;
     startTime: number;
+    activeTabLabel?: string;
+    sessionId?: string;
+    turnCount?: number;
+    preflightState?: string;
+    bridgeStatus?: string;
+    activeTool?: string;
+    blockedReason?: string;
+    nextAction?: string;
+    approvalState?: string;
+    retryState?: string;
+    pollState?: string;
     taskName?: string;
     agentName?: string;
 }
@@ -44,6 +55,17 @@ export interface DashboardControlState {
     selectedIndex: number;
     items: DashboardControlItem[];
 }
+export declare function formatRuntimeStatusSummary(state: Pick<StatusBarState, "sessionId" | "turnCount" | "preflightState" | "taskName" | "agentName" | "approvalState" | "retryState" | "pollState">): string | undefined;
+interface RuntimeStatusSummary {
+    bridge_status: string;
+    preflight_state: string;
+    role?: string;
+    approval_state?: string;
+    active_tool?: string;
+    active_tool_role?: string;
+    recommended_next_action?: string;
+    blocked_reason?: string;
+}
 export declare class LayoutManager {
     private zones;
     private cols;
@@ -94,6 +116,7 @@ export interface DashboardData {
     tokensIn: number;
     tokensOut: number;
     tokensPerSec: number;
+    runtimeStatus?: RuntimeStatusSummary;
     tasks: TaskItem[];
     events: ActivityEvent[];
 }
@@ -113,4 +136,5 @@ export interface ChatMessage {
     timestamp?: number;
     tokens?: number;
 }
+export {};
 //# sourceMappingURL=layout.d.ts.map

package/dist/tui/layout.js

@@ -5,6 +5,34 @@
  * Arttime-inspired: defined zones for each UI element.
  */
 import { getTermSize, write, writeAt, drawBox, clearRegion, cursor, screen, style, fg, bg, padRight, truncate, visibleWidth, box, symbols, formatTime, formatElapsed, formatNumber, hline, } from "./renderer.js";
+export function formatRuntimeStatusSummary(state) {
+    const parts = [];
+    if (state.sessionId) {
+        parts.push(`sid:${truncate(state.sessionId, 10)}`);
+    }
+    if (typeof state.turnCount === "number") {
+        parts.push(`turn:${state.turnCount}`);
+    }
+    if (state.agentName) {
+        parts.push(`role:${truncate(state.agentName, 12)}`);
+    }
+    if (state.taskName) {
+        parts.push(`task:${truncate(state.taskName, 18)}`);
+    }
+    if (state.preflightState) {
+        parts.push(`pf:${state.preflightState}`);
+    }
+    if (state.approvalState) {
+        parts.push(`approval:${state.approvalState}`);
+    }
+    if (state.retryState) {
+        parts.push(`retry:${state.retryState}`);
+    }
+    if (state.pollState) {
+        parts.push(`poll:${state.pollState}`);
+    }
+    return parts.length > 0 ? parts.join(" ") : undefined;
+}
 // ── Layout manager ───────────────────────────────────────────────────
 export class LayoutManager {
     zones;
@@ -116,12 +144,39 @@ export class LayoutManager {
                 stateIndicator = `${fg.red}${style.bold}${symbols.bullet} OVERDUE${style.reset}`;
                 break;
         }
+        if (state.bridgeStatus === "approval_pending") {
+            stateIndicator = `${fg.yellow}${symbols.bullet} approval${style.reset}`;
+        }
+        else if (state.bridgeStatus === "retrying") {
+            stateIndicator = `${fg.yellow}${symbols.bullet} retrying${style.reset}`;
+        }
+        else if (state.bridgeStatus === "needs_input") {
+            stateIndicator = `${fg.yellow}${symbols.bullet} needs_input${style.reset}`;
+        }
+        if (state.activeTool) {
+            stateIndicator = `${fg.green}${symbols.bullet} ${state.activeTool}${style.reset}`;
+        }
+        const tabSeg = state.activeTabLabel
+            ? `${fg.gray}tab: ${fg.white}${state.activeTabLabel}${style.reset}`
+            : undefined;
         const providerSeg = `${fg.cyan}provider: ${fg.brightCyan}${state.provider}${style.reset}`;
         const modelSeg = `${fg.cyan}model: ${fg.brightCyan}${state.model}${style.reset}`;
+        const runtimeSummary = formatRuntimeStatusSummary(state);
+        const runtimeSeg = runtimeSummary
+            ? `${fg.gray}${runtimeSummary}${style.reset}`
+            : undefined;
         const tokenSeg = `${fg.gray}tokens: ${fg.white}${formatNumber(state.tokensIn)}/${formatNumber(state.tokensOut)}${style.reset}`;
         const timeSeg = `${fg.gray}${elapsed}${style.reset}`;
         const clockSeg = `${fg.gray}${style.underline}${time}${style.reset}`;
-        const segments = [stateIndicator, providerSeg, modelSeg, tokenSeg, timeSeg, clockSeg];
+        const contextSeg = state.blockedReason
+            ? `${fg.red}${truncate(state.blockedReason, Math.max(18, Math.floor(this.cols * 0.22)))}${style.reset}`
+            : state.nextAction
+                ? `${fg.gray}next: ${fg.white}${truncate(state.nextAction, Math.max(18, Math.floor(this.cols * 0.18)))}${style.reset}`
+                : state.bridgeStatus
+                    ? `${fg.gray}${state.bridgeStatus}${style.reset}`
+                    : undefined;
+        const segments = [stateIndicator, tabSeg, providerSeg, modelSeg, runtimeSeg, contextSeg, tokenSeg, timeSeg, clockSeg]
+            .filter((segment) => Boolean(segment));
         const sep = ` ${fg.gray}│${style.reset} `;
         const line = ` ${segments.join(sep)} `;
         // Clear and write
@@ -198,13 +253,32 @@ export class LayoutManager {
     renderStatusPanel(x, y, w, h, data) {
         const lines = [
             `${fg.gray}Phase:   ${fg.brightWhite}${data.phase}`,
+            data.runtimeStatus?.bridge_status
+                ? `${fg.gray}Bridge:  ${fg.brightYellow}${data.runtimeStatus.bridge_status}`
+                : undefined,
+            data.runtimeStatus?.preflight_state
+                ? `${fg.gray}Preflt:  ${data.runtimeStatus.preflight_state === "blocked"
+                    ? fg.brightRed
+                    : data.runtimeStatus.preflight_state === "attention_required"
+                        ? fg.yellow
+                        : fg.brightGreen}${data.runtimeStatus.preflight_state}`
+                : undefined,
+            data.runtimeStatus?.role
+                ? `${fg.gray}Role:    ${fg.brightCyan}${data.runtimeStatus.role}`
+                : undefined,
+            data.runtimeStatus?.blocked_reason
+                ? `${fg.gray}Blocker: ${fg.brightRed}${data.runtimeStatus.blocked_reason}`
+                : undefined,
+            data.runtimeStatus?.recommended_next_action
+                ? `${fg.gray}Next:    ${fg.white}${data.runtimeStatus.recommended_next_action}`
+                : undefined,
             `${fg.gray}Provider:${fg.brightCyan} ${padRight(data.provider, 8)}`,
             `${fg.gray}Model:   ${fg.brightCyan}${data.model}`,
             `${fg.gray}Agents:  ${fg.brightGreen}${data.activeAgents}${fg.gray}/${data.totalAgents} active`,
             `${fg.gray}Uptime:  ${fg.white}${formatElapsed(Date.now() - data.startTime)}`,
             `${fg.gray}Tokens:  ${fg.white}${formatNumber(data.tokensIn)} in / ${formatNumber(data.tokensOut)} out`,
             `${fg.gray}Speed:   ${fg.white}${data.tokensPerSec.toFixed(0)} tok/s`,
-        ];
+        ].filter((line) => Boolean(line));
         for (let i = 0; i < Math.min(lines.length, h); i++) {
             writeAt(x, y + i, truncate(lines[i] + style.reset, w));
         }

package/dist/tui/local-model-contract.d.ts

@@ -0,0 +1,50 @@
+import { type AceStateResolution } from "../ace-state-resolver.js";
+import type { AceRuntimeStatusPacket, AceSessionActivationLedger, AceSessionContinuityRecord } from "../store/repositories/local-model-runtime-repository.js";
+export interface AcePreflightPacket {
+    session_id: string;
+    workspace_root: string;
+    state_resolution: AceStateResolution;
+    preflight_state: "ready" | "attention_required" | "blocked";
+    bridge_status: "running" | "needs_input" | "approval_pending" | "retrying" | "blocked" | "failed" | "done";
+    quartet_health: "healthy" | "thin" | "incomplete" | "contradictory";
+    task_contract_health: "healthy" | "thin" | "blocked";
+    recommended_role?: string;
+    recommended_next_action?: string;
+    blockers: string[];
+    warnings: string[];
+    recall_summary?: string;
+    should_synthesize_plan: boolean;
+}
+export interface StartupNudge {
+    id: string;
+    text: string;
+    recommended_action: string;
+}
+export declare function shouldSynthesizeShortPlan(task: string): boolean;
+export declare function buildAcePreflightPacket(input: {
+    sessionId: string;
+    workspaceRoot: string;
+    task: string;
+    preferredRole?: string;
+}): AcePreflightPacket;
+export declare function nextActivationLedger(sessionId: string, current: AceSessionActivationLedger | undefined, recommendedAction: string | undefined): AceSessionActivationLedger;
+export declare function buildStartupNudge(preflight: AcePreflightPacket, ledger: AceSessionActivationLedger): StartupNudge | undefined;
+export declare function buildBridgeTaskInput(conversation: string, preflight: AcePreflightPacket): string;
+export declare function mapBridgeResultToRuntimeStatus(input: {
+    current: AceRuntimeStatusPacket;
+    summary: string;
+    toolNames: string[];
+}): AceRuntimeStatusPacket;
+export declare function buildContinuityRecord(input: {
+    preflight: AcePreflightPacket;
+    role: string;
+    activeTool?: string;
+    bridgeStatus: AceRuntimeStatusPacket["bridge_status"];
+    evidenceRefs?: string[];
+}): AceSessionContinuityRecord;
+export declare function containsVerificationLanguage(text: string): boolean;
+export declare function hasEvidenceLikeTool(toolNames: readonly string[]): boolean;
+export declare function applyEvidenceGuardrail(summary: string, toolNames: readonly string[]): string;
+export declare function readRuntimeWorkflowHint(workspaceRoot: string): string | undefined;
+export declare function readStatusHint(workspaceRoot: string): string | undefined;
+//# sourceMappingURL=local-model-contract.d.ts.map