@voybio/ace-swarm 0.2.0 → 0.2.1

package/dist/tui/chat.js

@@ -7,9 +7,12 @@
 import { diagnoseChatRuntimeConfig, } from "./openai-compatible.js";
 import { estimateTokenCount } from "./telemetry.js";
 import { EventEmitter } from "node:events";
-import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
 import { ModelBridge } from "../model-bridge.js";
+import { resolveAceStateLayout } from "../ace-state-resolver.js";
+import { applyEvidenceGuardrail, buildAcePreflightPacket, buildBridgeTaskInput, buildContinuityRecord, buildStartupNudge, mapBridgeResultToRuntimeStatus, nextActivationLedger, } from "./local-model-contract.js";
+import { withLocalModelRuntimeRepository, } from "../store/repositories/local-model-runtime-repository.js";
 export class ChatSession extends EventEmitter {
     clients;
     telemetry;
@@ -32,6 +35,11 @@ export class ChatSession extends EventEmitter {
     aceBridge;
     activeAceBridge = false;
     providerBaseUrls;
+    sessionId = randomUUID();
+    createdAt = Date.now();
+    lastActiveAt = this.createdAt;
+    currentRuntimeStatus = null;
+    activationLedger = null;
     constructor(clients, telemetry, options) {
         super();
         this.clients = clients;
@@ -63,6 +71,35 @@ export class ChatSession extends EventEmitter {
     getDisplayMessages() {
         return this.displayMessages;
     }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getCreatedAt() {
+        return this.createdAt;
+    }
+    getLastActiveAt() {
+        return this.lastActiveAt;
+    }
+    getCurrentRuntimeStatus() {
+        return this.currentRuntimeStatus ?? undefined;
+    }
+    hasMeaningfulTranscript() {
+        return this.messages.some((message) => message.role !== "system" && String(message.content ?? "").trim().length > 0);
+    }
+    getTranscriptExcerpt(maxMessages = 6) {
+        const excerpt = this.messages
+            .filter((message) => message.role !== "system")
+            .slice(-maxMessages)
+            .map((message) => `${message.role}: ${oneLine(String(message.content ?? ""))}`)
+            .join(" | ");
+        return excerpt ? clip(excerpt, 720) : undefined;
+    }
+    getTranscriptSummary() {
+        const lastAssistant = [...this.messages]
+            .reverse()
+            .find((message) => message.role === "assistant" && String(message.content ?? "").trim().length > 0);
+        return lastAssistant ? clip(oneLine(String(lastAssistant.content ?? "")), 240) : undefined;
+    }
     /** Is currently streaming a response? */
     isStreaming() {
         return this.streaming;
@@ -115,6 +152,7 @@ export class ChatSession extends EventEmitter {
             timestamp: Date.now(),
             tokens: estimateTokenCount(text),
         });
+        this.noteActivity();
         this.emit("updated");
         // Start streaming response
         this.streaming = true;
@@ -161,6 +199,7 @@ export class ChatSession extends EventEmitter {
                 timestamp: Date.now(),
                 tokens: estimateTokenCount(this.currentStreamText),
             });
+            this.noteActivity();
         }
         catch (err) {
             if (err?.name === "AbortError") {
@@ -210,6 +249,7 @@ export class ChatSession extends EventEmitter {
     clear() {
         this.messages = [];
         this.displayMessages = [];
+        this.currentRuntimeStatus = null;
         if (this.systemPrompt) {
             this.messages.push({ role: "system", content: this.systemPrompt });
             this.displayMessages.push({
@@ -274,10 +314,7 @@ export class ChatSession extends EventEmitter {
             return false;
         if (!this.workspaceRoot)
             return false;
-        if (!existsSync(resolve(this.workspaceRoot, ".agents", "ACE", "agent-state", "TASK.md"))) {
-            return false;
-        }
-        return true;
+        return resolveAceStateLayout(this.workspaceRoot).isAcePresent;
     }
     buildBridgeTask() {
         const recentConversation = this.messages
@@ -293,39 +330,206 @@ export class ChatSession extends EventEmitter {
             content,
             timestamp: Date.now(),
         });
+        this.noteActivity();
         this.emit("updated");
     }
+    noteActivity() {
+        this.lastActiveAt = Date.now();
+    }
+    buildRuntimeStatusPacket(input) {
+        return {
+            session_id: this.sessionId,
+            process_id: process.pid,
+            turn_count: this.messages.filter((message) => message.role === "user").length,
+            role: input.role,
+            bridge_status: input.bridgeStatus,
+            preflight_state: input.preflightState,
+            approval_state: this.currentRuntimeStatus?.approval_state ?? "not_required",
+            current_task: input.task,
+            recommended_next_action: input.recommendedNextAction,
+            blocked_reason: input.blockedReason,
+            updated_at: Date.now(),
+        };
+    }
+    setRuntimeStatus(status) {
+        this.currentRuntimeStatus = status;
+        this.emit("runtime_status", status);
+    }
+    setApprovalState(state) {
+        if (!this.currentRuntimeStatus) {
+            return false;
+        }
+        const next = {
+            ...this.currentRuntimeStatus,
+            approval_state: state,
+            updated_at: Date.now(),
+        };
+        this.setRuntimeStatus(next);
+        this.persistRuntimeStatus(next);
+        this.displayMessages.push({
+            role: "system",
+            content: `Approval state set to: ${state}`,
+            timestamp: Date.now(),
+        });
+        this.emit("updated");
+        this.noteActivity();
+        return true;
+    }
+    persistRuntimeStatus(status) {
+        if (!this.workspaceRoot)
+            return;
+        const { updated_at: _updatedAt, ...record } = status;
+        void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
+            await repo.upsertRuntimeStatus(record);
+        }).catch((error) => {
+            this.emit("error", `Runtime status persistence failed: ${formatErrorMessage(error)}`);
+        });
+    }
+    persistRuntimeSessionArtifacts(input) {
+        if (!this.workspaceRoot)
+            return;
+        void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
+            if (input.activationLedger) {
+                await repo.upsertActivationLedger(input.activationLedger);
+            }
+            if (input.runtimeStatus) {
+                const { updated_at: _updatedAt, ...statusRecord } = input.runtimeStatus;
+                await repo.upsertRuntimeStatus(statusRecord);
+            }
+            if (input.continuity) {
+                await repo.upsertContinuityRecord(input.continuity);
+            }
+        }).catch((error) => {
+            this.emit("error", `ACE runtime persistence failed: ${formatErrorMessage(error)}`);
+        });
+    }
     async runAceBridge(text, startTime, streamProvider, streamModel) {
         if (!this.workspaceRoot) {
             throw new Error("ACE bridge requires a workspace root.");
         }
         this.activeAceBridge = true;
+        const recentConversation = this.buildBridgeTask();
+        const preflight = buildAcePreflightPacket({
+            sessionId: this.sessionId,
+            workspaceRoot: this.workspaceRoot,
+            task: recentConversation,
+            preferredRole: this.aceRole,
+        });
+        const executionRole = preflight.recommended_role ?? this.aceRole;
+        let activationLedger = nextActivationLedger(this.sessionId, this.activationLedger ?? undefined, preflight.recommended_next_action);
+        const startupNudge = buildStartupNudge(preflight, activationLedger);
+        if (startupNudge) {
+            activationLedger = {
+                ...activationLedger,
+                shown_nudges: uniqueStrings([...activationLedger.shown_nudges, startupNudge.id]),
+            };
+            this.pushSystemMessage(`Hint: ${startupNudge.text}`);
+            this.emit("startup_nudge", startupNudge);
+        }
+        let runtimeStatus = this.buildRuntimeStatusPacket({
+            role: executionRole,
+            task: text,
+            preflightState: preflight.preflight_state,
+            bridgeStatus: preflight.bridge_status,
+            recommendedNextAction: preflight.recommended_next_action,
+            blockedReason: preflight.blockers[0],
+        });
+        this.setRuntimeStatus(runtimeStatus);
+        this.persistRuntimeSessionArtifacts({
+            activationLedger,
+            runtimeStatus,
+        });
+        this.activationLedger = activationLedger;
+        if (preflight.preflight_state === "blocked") {
+            const blockerText = preflight.blockers.join("; ");
+            this.pushSystemMessage(`ACE preflight blocked: ${blockerText}`);
+            const blockedContinuity = buildContinuityRecord({
+                preflight,
+                role: executionRole,
+                bridgeStatus: runtimeStatus.bridge_status,
+            });
+            this.persistRuntimeSessionArtifacts({
+                activationLedger,
+                runtimeStatus,
+                continuity: blockedContinuity,
+            });
+            this.activationLedger = activationLedger;
+            return;
+        }
         let bridgeOutput = "";
+        const toolNames = [];
+        let retryAttempt = 0;
         const result = await this.aceBridge.run({
-            task: this.buildBridgeTask(),
-            role: this.aceRole,
+            task: buildBridgeTaskInput(recentConversation, preflight),
+            role: executionRole,
             workspace: this.workspaceRoot,
-            tier: this.aceTier ?? (this.aceRole === "orchestrator" ? "compressed" : "brief"),
+            tier: this.aceTier ?? (executionRole === "orchestrator" ? "compressed" : "brief"),
             maxTurns: this.maxTurns,
             provider: streamProvider,
             model: streamModel,
             numCtx: this.numCtx,
             onThinking: (thinking) => {
                 this.pushSystemMessage(`Thinking: ${thinking}`);
+                if (/\bretrying\b/i.test(thinking)) {
+                    retryAttempt += 1;
+                    runtimeStatus = {
+                        ...runtimeStatus,
+                        bridge_status: "retrying",
+                        retry_state: {
+                            attempt: retryAttempt,
+                            max_attempts: 2,
+                            reason: thinking,
+                        },
+                        updated_at: Date.now(),
+                    };
+                    this.setRuntimeStatus(runtimeStatus);
+                    this.persistRuntimeStatus(runtimeStatus);
+                }
             },
             onToolCall: (tool, args) => {
+                toolNames.push(tool);
+                activationLedger = {
+                    ...activationLedger,
+                    updated_at: Date.now(),
+                    activated_tools: uniqueStrings([...activationLedger.activated_tools, tool]),
+                    activated_roles: uniqueStrings([...activationLedger.activated_roles, executionRole]),
+                    accepted_nudges: tool === startupNudge?.recommended_action
+                        ? uniqueStrings([...activationLedger.accepted_nudges, startupNudge.id])
+                        : activationLedger.accepted_nudges,
+                };
+                runtimeStatus = {
+                    ...runtimeStatus,
+                    bridge_status: "running",
+                    active_tool: tool,
+                    active_tool_role: executionRole,
+                    updated_at: Date.now(),
+                };
+                this.setRuntimeStatus(runtimeStatus);
+                this.persistRuntimeSessionArtifacts({ activationLedger, runtimeStatus });
+                this.activationLedger = activationLedger;
                 this.pushSystemMessage(`Tool call: ${tool} ${safeStringify(args)}`);
                 this.emit("tool_call", tool, args);
             },
             onToolResult: (tool, toolResult) => {
+                runtimeStatus = {
+                    ...runtimeStatus,
+                    bridge_status: toolResult.isError ? "needs_input" : "running",
+                    active_tool: undefined,
+                    blocked_reason: toolResult.isError ? `${tool}: ${toolResult.summary}` : undefined,
+                    updated_at: Date.now(),
+                };
+                this.setRuntimeStatus(runtimeStatus);
+                this.persistRuntimeStatus(runtimeStatus);
                 this.pushSystemMessage(`Tool ${toolResult.ok ? "ok" : "error"}: ${tool} — ${toolResult.summary}`);
                 this.emit("tool_result", tool, toolResult);
             },
             onOutput: (output) => {
                 bridgeOutput = output;
+                this.noteActivity();
             },
         });
-        const assistantText = bridgeOutput.trim() || result.summary.trim() || "ACE bridge completed.";
+        const rawAssistantText = bridgeOutput.trim() || result.summary.trim() || "ACE bridge completed.";
+        const assistantText = applyEvidenceGuardrail(rawAssistantText, toolNames);
         this.messages.push({ role: "assistant", content: assistantText });
         this.displayMessages.push({
             role: "assistant",
@@ -333,9 +537,57 @@ export class ChatSession extends EventEmitter {
             timestamp: Date.now(),
             tokens: estimateTokenCount(assistantText),
         });
+        this.noteActivity();
         if (result.status === "needs_input") {
             this.pushSystemMessage("[Awaiting operator follow-up]");
         }
+        if (result.status === "failed") {
+            runtimeStatus = {
+                ...runtimeStatus,
+                bridge_status: "failed",
+                blocked_reason: assistantText,
+                active_tool: undefined,
+                updated_at: Date.now(),
+            };
+        }
+        else if (result.status === "max_turns") {
+            runtimeStatus = {
+                ...runtimeStatus,
+                bridge_status: "needs_input",
+                blocked_reason: "ACE bridge reached max turns before completion.",
+                active_tool: undefined,
+                updated_at: Date.now(),
+            };
+        }
+        else if (result.status === "needs_input") {
+            runtimeStatus = {
+                ...runtimeStatus,
+                bridge_status: "needs_input",
+                active_tool: undefined,
+                updated_at: Date.now(),
+            };
+        }
+        else {
+            runtimeStatus = mapBridgeResultToRuntimeStatus({
+                current: runtimeStatus,
+                summary: assistantText,
+                toolNames,
+            });
+        }
+        this.setRuntimeStatus(runtimeStatus);
+        const continuity = buildContinuityRecord({
+            preflight,
+            role: executionRole,
+            activeTool: runtimeStatus.active_tool,
+            bridgeStatus: runtimeStatus.bridge_status,
+            evidenceRefs: toolNames.map((tool) => `tool:${tool}`),
+        });
+        this.persistRuntimeSessionArtifacts({
+            activationLedger,
+            runtimeStatus,
+            continuity,
+        });
+        this.activationLedger = activationLedger;
         this.telemetry.recordRequest({
             startTime,
             endTime: Date.now(),
@@ -365,4 +617,18 @@ function safeStringify(value) {
         return "{}";
     }
 }
+function oneLine(input) {
+    return input.replace(/\s+/g, " ").trim();
+}
+function clip(input, max) {
+    if (input.length <= max)
+        return input;
+    return `${input.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 //# sourceMappingURL=chat.js.map

package/dist/tui/commands.d.ts

@@ -34,9 +34,11 @@ export interface TuiController {
     createChatTab(): void;
     createLogTab(): void;
     closeCurrentTab(): void;
+    archiveCurrentTab(): Promise<void>;
     showMessage(text: string, level?: "info" | "warn" | "error"): void;
     clearView(): void;
     refresh(): void;
+    setApprovalState(state: "not_required" | "pending" | "approved" | "rejected"): boolean;
     getStatus(): Record<string, unknown>;
     quit(): void;
     sendChatMessage(text: string): Promise<void>;

package/dist/tui/commands.js

@@ -304,6 +304,48 @@ export function registerBuiltinCommands(registry) {
             ctx.tui.showMessage(lines);
         },
     });
+    // /approve — Mark the active runtime approval as approved
+    registry.register({
+        name: "approve",
+        aliases: [],
+        description: "Approve the active runtime packet",
+        usage: "/approve",
+        handler: (_args, ctx) => {
+            if (!ctx.tui.setApprovalState("approved")) {
+                ctx.tui.showMessage("No active runtime packet to approve.", "warn");
+                return;
+            }
+            ctx.tui.showMessage("Approval state set to: approved");
+        },
+    });
+    // /reject — Mark the active runtime approval as rejected
+    registry.register({
+        name: "reject",
+        aliases: [],
+        description: "Reject the active runtime packet",
+        usage: "/reject",
+        handler: (_args, ctx) => {
+            if (!ctx.tui.setApprovalState("rejected")) {
+                ctx.tui.showMessage("No active runtime packet to reject.", "warn");
+                return;
+            }
+            ctx.tui.showMessage("Approval state set to: rejected");
+        },
+    });
+    // /trust — Keep the active runtime approved until revoked
+    registry.register({
+        name: "trust",
+        aliases: ["remember"],
+        description: "Trust the active runtime session until revoked",
+        usage: "/trust",
+        handler: (_args, ctx) => {
+            if (!ctx.tui.setApprovalState("approved")) {
+                ctx.tui.showMessage("No active runtime packet to trust.", "warn");
+                return;
+            }
+            ctx.tui.showMessage("Session trusted until /reject.");
+        },
+    });
     // /skill <name> — Load a skill
     registry.register({
         name: "skill",
@@ -386,6 +428,26 @@ export function registerBuiltinCommands(registry) {
             ctx.tui.createLogTab();
         },
     });
+    // /close — Close the current closeable tab
+    registry.register({
+        name: "close",
+        aliases: ["x"],
+        description: "Close the current tab",
+        usage: "/close",
+        handler: (_args, ctx) => {
+            ctx.tui.closeCurrentTab();
+        },
+    });
+    // /archive — Archive the current chat tab, then close it
+    registry.register({
+        name: "archive",
+        aliases: ["arc"],
+        description: "Archive the current chat tab and close it",
+        usage: "/archive",
+        handler: async (_args, ctx) => {
+            await ctx.tui.archiveCurrentTab();
+        },
+    });
     // /clear — Clear current view
     registry.register({
         name: "clear",

package/dist/tui/dashboard.d.ts

@@ -6,6 +6,9 @@
  */
 import { EventEmitter } from "node:events";
 import type { DashboardData } from "./layout.js";
+import type { AceRuntimeStatusPacket } from "../store/repositories/local-model-runtime-repository.js";
+export declare function isProcessAlive(pid: number): boolean;
+export declare function selectLiveRuntimeStatus(statuses: Array<Pick<AceRuntimeStatusPacket, "process_id"> & AceRuntimeStatusPacket>): AceRuntimeStatusPacket | undefined;
 export declare class DashboardState extends EventEmitter {
     private workspaceRoot;
     private readonly storePath;
@@ -14,10 +17,12 @@ export declare class DashboardState extends EventEmitter {
     private persistedEvents;
     private runtimeEvents;
     private phase;
+    private latestRuntimeStatus;
     constructor(workspaceRoot: string);
     startWatching(): void;
     stopWatching(): void;
     getData(provider: string, model: string, startTime: number, tokensIn: number, tokensOut: number, tokensPerSec: number, activeAgents: number, totalAgents: number): DashboardData;
+    getLatestRuntimeStatus(): AceRuntimeStatusPacket | undefined;
     addEvent(agent: string, message: string): void;
     private applySnapshot;
 }

package/dist/tui/dashboard.js

@@ -5,8 +5,8 @@
  * The TUI never tails compatibility files directly.
  */
 import { EventEmitter } from "node:events";
-import { resolve } from "node:path";
 import { pollStore } from "../store/state-reader.js";
+import { getWorkspaceStorePath } from "../store/store-snapshot.js";
 function dedupeEvents(events) {
     const seen = new Set();
     const ordered = [];
@@ -19,7 +19,37 @@ function dedupeEvents(events) {
     }
     return ordered.slice(-500);
 }
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function selectLiveRuntimeStatus(statuses) {
+    return statuses.find((status) => isProcessAlive(status.process_id));
+}
 function derivePhase(snapshot) {
+    const runtimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
+    if (runtimeStatus?.bridge_status === "blocked") {
+        return "Blocked";
+    }
+    if (runtimeStatus?.bridge_status === "approval_pending") {
+        return "Approval Pending";
+    }
+    if (runtimeStatus?.bridge_status === "needs_input") {
+        return "Needs Input";
+    }
+    if (runtimeStatus?.bridge_status === "retrying") {
+        return "Retrying";
+    }
+    if (runtimeStatus?.bridge_status === "running") {
+        return "Running";
+    }
     if (snapshot.jobs.some((job) => String(job.status ?? "") === "running")) {
         return "Running";
     }
@@ -42,10 +72,11 @@ export class DashboardState extends EventEmitter {
     persistedEvents = [];
     runtimeEvents = [];
     phase = "Initializing";
+    latestRuntimeStatus;
     constructor(workspaceRoot) {
         super();
         this.workspaceRoot = workspaceRoot;
-        this.storePath = resolve(workspaceRoot, ".agents", "ACE", "ace-state.ace");
+        this.storePath = getWorkspaceStorePath(workspaceRoot);
     }
     startWatching() {
         if (this.stopPolling)
@@ -74,10 +105,14 @@ export class DashboardState extends EventEmitter {
             tokensIn,
             tokensOut,
             tokensPerSec,
+            runtimeStatus: this.latestRuntimeStatus,
             tasks: this.tasks,
             events: dedupeEvents([...this.persistedEvents, ...this.runtimeEvents]).slice(-50),
         };
     }
+    getLatestRuntimeStatus() {
+        return this.latestRuntimeStatus;
+    }
     addEvent(agent, message) {
         this.runtimeEvents.push({
             timestamp: Date.now(),
@@ -105,6 +140,7 @@ export class DashboardState extends EventEmitter {
         }));
         this.persistedEvents = dedupeEvents([...trackerEvents, ...ledgerEvents]).slice(-300);
         this.phase = derivePhase(snapshot);
+        this.latestRuntimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
         // Surface discovered providers to the TUI controller so dashboard controls
         // reflect what's actually available in the store.
         if (snapshot.providers.length > 0) {

package/dist/tui/index.d.ts

@@ -30,6 +30,8 @@ export declare class AceTui implements TuiController {
     private messageQueue;
     private workspaceRoot;
     private providerBaseUrls;
+    private latestRuntimeStatus;
+    private pendingCloseTabId;
     constructor(options?: {
         provider?: string;
         model?: string;
@@ -64,6 +66,7 @@ export declare class AceTui implements TuiController {
     private syncTabState;
     /** 1-second tick for status bar, message expiry */
     private tick;
+    private getActiveRuntimeStatus;
     private normalizeProvider;
     static defaultSystemPrompt(): string;
     private ensureProvider;
@@ -92,9 +95,11 @@ export declare class AceTui implements TuiController {
     createChatTab(): void;
     createLogTab(): void;
     closeCurrentTab(): void;
+    archiveCurrentTab(): Promise<void>;
     showMessage(text: string, level?: "info" | "warn" | "error"): void;
     clearView(): void;
     refresh(): void;
+    setApprovalState(state: "not_required" | "pending" | "approved" | "rejected"): boolean;
     getStatus(): Record<string, unknown>;
     quit(): void;
     sendChatMessage(text: string): Promise<void>;