@voybio/ace-swarm 0.2.5 → 2.4.0

package/dist/tracker-adapters.js

@@ -1,11 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { existsSync, readFileSync, } from "node:fs";
+import { resolve } from "node:path";
 import { DEFAULTS_ROOT, resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, resolveWorkspaceRoot, } from "./helpers.js";
 import { validateTrackerSnapshotPayload } from "./schemas.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { readRuntimeProfile } from "./runtime-profile.js";
+import { safeWriteAsync } from "./helpers.js";
 export const TRACKER_SNAPSHOT_REL_PATH = "agent-state/tracker-snapshot.json";
 export const TRACKER_SNAPSHOT_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/TRACKER_SNAPSHOT.schema.json";
 export const TRACKER_SNAPSHOT_SCHEMA_NAME = "tracker-snapshot@1.0.0";
@@ -40,14 +41,6 @@ function resolveTrackerSnapshotTarget(explicitPath) {
 function resolveWorkspaceArtifactPath(filePath) {
     return resolveWorkspaceArtifactPathHelper(filePath, "write");
 }
-function safeWriteWorkspaceFile(filePath, content) {
-    const abs = resolveWorkspaceArtifactPath(filePath);
-    mkdirSync(dirname(abs), { recursive: true });
-    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, content, "utf-8");
-    renameSync(tmpPath, abs);
-    return abs;
-}
 function normalizeTrackerItem(item) {
     return {
         ...item,
@@ -150,12 +143,14 @@ function filterTrackerItems(items, filter) {
 }
 function emitTrackerEvent(eventType, summary, payload) {
     try {
-        appendStatusEvent({
+        void appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: eventType,
             status: eventType === "TRACKER_SNAPSHOT_REFRESH_FAILED" ? "fail" : "done",
             summary,
             payload,
+        }).catch(() => {
+            // Tracker operations must not fail because event logging failed.
         });
     }
     catch {
@@ -455,7 +450,7 @@ async function githubCreateComment(itemId, body) {
             }),
         ];
         nextSnapshot.updated_at = now;
-        writeTrackerSnapshot(nextSnapshot);
+        await writeTrackerSnapshot(nextSnapshot);
         emitTrackerEvent("TRACKER_COMMENT_CREATED", `Tracker comment created for ${issue.item_id}.`, {
             adapter_kind: "external",
             provider: "github",
@@ -502,7 +497,7 @@ async function githubUpdateItemState(itemId, state) {
     try {
         const issue = (await githubGetIssuesById([itemId]))[0];
         const snapshot = upsertTrackerItem(readOrBuildExternalSnapshot(), issue);
-        writeTrackerSnapshot(snapshot);
+        await writeTrackerSnapshot(snapshot);
         emitTrackerEvent("TRACKER_ITEM_STATE_UPDATED", `Tracker item ${issue.item_id} moved to ${issue.state}.`, {
             adapter_kind: "external",
             provider: "github",
@@ -569,13 +564,13 @@ export function readTrackerSnapshot() {
 export function getTrackerSnapshotPath() {
     return resolveTrackerSnapshotTarget().path;
 }
-export function writeTrackerSnapshot(snapshot) {
+export async function writeTrackerSnapshot(snapshot) {
     const normalized = normalizeTrackerSnapshot(snapshot);
     const validation = validateTrackerSnapshotPayload(normalized);
     if (!validation.ok) {
         throw new Error(`Tracker snapshot failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
     }
-    return safeWriteWorkspaceFile(TRACKER_SNAPSHOT_REL_PATH, JSON.stringify(normalized, null, 2));
+    return safeWriteAsync(TRACKER_SNAPSHOT_REL_PATH, JSON.stringify(normalized, null, 2));
 }
 const noneTrackerAdapter = {
     kind: "none",
@@ -700,7 +695,7 @@ const memoryTrackerAdapter = {
                 updated_at: now,
                 comments: [...snapshot.comments, comment],
             };
-            writeTrackerSnapshot(nextSnapshot);
+            await writeTrackerSnapshot(nextSnapshot);
             emitTrackerEvent("TRACKER_COMMENT_CREATED", `Tracker comment created for ${comment.item_id}.`, {
                 adapter_kind: "memory",
                 item_id: comment.item_id,
@@ -743,7 +738,7 @@ const memoryTrackerAdapter = {
                 updated_at: now,
                 items,
             };
-            writeTrackerSnapshot(nextSnapshot);
+            await writeTrackerSnapshot(nextSnapshot);
             emitTrackerEvent("TRACKER_ITEM_STATE_UPDATED", `Tracker item ${items[itemIndex].item_id} moved to ${nextState}.`, {
                 adapter_kind: "memory",
                 item_id: items[itemIndex].item_id,

package/dist/tracker-sync.js

@@ -2,15 +2,17 @@ import { resolve } from "node:path";
 import { resolveWorkspaceRoot } from "./helpers.js";
 import { readRuntimeProfile } from "./runtime-profile.js";
 import { buildDefaultTrackerSnapshot, getTrackerAdapter, writeTrackerSnapshot, readTrackerSnapshot, TRACKER_SNAPSHOT_REL_PATH, } from "./tracker-adapters.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 function emitTrackerSyncEvent(eventType, summary, payload) {
     try {
-        appendStatusEvent({
+        void appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: eventType,
             status: eventType === "TRACKER_SNAPSHOT_REFRESH_FAILED" ? "fail" : "done",
             summary,
             payload,
+        }).catch(() => {
+            // Snapshot refresh must not fail because observability logging failed.
         });
     }
     catch {
@@ -52,7 +54,7 @@ export async function refreshTrackerSnapshot(kind) {
                 items,
             };
         }
-        const writtenPath = writeTrackerSnapshot(snapshot);
+        const writtenPath = await writeTrackerSnapshot(snapshot);
         emitTrackerSyncEvent("TRACKER_SNAPSHOT_REFRESHED", `Tracker snapshot refreshed using ${snapshot.adapter_kind}.`, {
             adapter_kind: snapshot.adapter_kind,
             snapshot_path: writtenPath,

package/dist/tui/agent-runner.js

@@ -17,7 +17,9 @@ import { readAgentInstructions } from "../helpers.js";
 export class AgentRunner extends EventEmitter {
     agents = new Map();
     workspaceRoot;
-    startupTimeoutMs = 5000;
+    // Full-suite test runs can heavily contend CPU/IO while workers bootstrap.
+    // Keep startup resilient to transient contention before declaring failure.
+    startupTimeoutMs = 12000;
     constructor(workspaceRoot) {
         super();
         this.workspaceRoot = workspaceRoot;

package/dist/tui/chat.js

@@ -380,7 +380,11 @@ export class ChatSession extends EventEmitter {
             return;
         const { updated_at: _updatedAt, ...record } = status;
         void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
-            await repo.upsertRuntimeStatus(record);
+            await repo.upsertRuntimeStatusWithTransition(record, {
+                from: this.currentRuntimeStatus?.bridge_status,
+                reason: "Interactive runtime status updated after provider/tool progress.",
+                evidence_refs: [this.sessionId],
+            });
         }).catch((error) => {
             this.emit("error", `Runtime status persistence failed: ${formatErrorMessage(error)}`);
         });
@@ -390,14 +394,26 @@ export class ChatSession extends EventEmitter {
             return;
         void withLocalModelRuntimeRepository(this.workspaceRoot, async (repo) => {
             if (input.activationLedger) {
-                await repo.upsertActivationLedger(input.activationLedger);
+                await repo.upsertActivationLedgerWithTransition(input.activationLedger, {
+                    from: this.activationLedger ? "updated" : "created",
+                    reason: "Interactive activation ledger updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
             if (input.runtimeStatus) {
                 const { updated_at: _updatedAt, ...statusRecord } = input.runtimeStatus;
-                await repo.upsertRuntimeStatus(statusRecord);
+                await repo.upsertRuntimeStatusWithTransition(statusRecord, {
+                    from: this.currentRuntimeStatus?.bridge_status,
+                    reason: "Interactive runtime status updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
             if (input.continuity) {
-                await repo.upsertContinuityRecord(input.continuity);
+                await repo.upsertContinuityRecordWithTransition(input.continuity, {
+                    from: this.currentRuntimeStatus?.bridge_status,
+                    reason: "Interactive continuity record updated after ACE session progress.",
+                    evidence_refs: [this.sessionId],
+                });
             }
         }).catch((error) => {
             this.emit("error", `ACE runtime persistence failed: ${formatErrorMessage(error)}`);
@@ -416,15 +432,79 @@ export class ChatSession extends EventEmitter {
             preferredRole: this.aceRole,
         });
         const executionRole = preflight.recommended_role ?? this.aceRole;
+        const prevLedger = this.activationLedger;
         let activationLedger = nextActivationLedger(this.sessionId, this.activationLedger ?? undefined, preflight.recommended_next_action);
-        const startupNudge = buildStartupNudge(preflight, activationLedger);
+        // Detect previously shown but unaccepted/unauto-executed nudges as ignored
+        if (prevLedger) {
+            const autoExecuted = prevLedger.auto_executed_nudges ?? [];
+            const accepted = prevLedger.accepted_nudges;
+            const alreadyIgnored = prevLedger.ignored_nudges ?? [];
+            const ignoredNow = prevLedger.shown_nudges.filter((id) => !accepted.includes(id) && !autoExecuted.includes(id) && !alreadyIgnored.includes(id));
+            if (ignoredNow.length > 0) {
+                activationLedger = {
+                    ...activationLedger,
+                    ignored_nudges: uniqueStrings([...(activationLedger.ignored_nudges ?? []), ...ignoredNow]),
+                };
+                if (this.workspaceRoot) {
+                    const wsr = this.workspaceRoot;
+                    for (const nudgeId of ignoredNow) {
+                        void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                            await repo.appendTransitionRecord({
+                                session_id: this.sessionId,
+                                subject_kind: "nudge",
+                                subject_id: nudgeId,
+                                from: "shown",
+                                to: "ignored",
+                                reason: `Nudge ${nudgeId} ignored: user sent new message without accepting`,
+                                evidence_refs: [],
+                            });
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+        const startupNudge = buildStartupNudge(preflight, activationLedger, this.currentRuntimeStatus);
         if (startupNudge) {
             activationLedger = {
                 ...activationLedger,
                 shown_nudges: uniqueStrings([...activationLedger.shown_nudges, startupNudge.id]),
+                ...(startupNudge.auto_executable
+                    ? {
+                        auto_executed_nudges: uniqueStrings([
+                            ...(activationLedger.auto_executed_nudges ?? []),
+                            startupNudge.id,
+                        ]),
+                    }
+                    : {}),
             };
             this.pushSystemMessage(`Hint: ${startupNudge.text}`);
             this.emit("startup_nudge", startupNudge);
+            if (this.workspaceRoot) {
+                const wsr = this.workspaceRoot;
+                const nudge = startupNudge;
+                void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                    await repo.appendTransitionRecord({
+                        session_id: this.sessionId,
+                        subject_kind: "nudge",
+                        subject_id: nudge.id,
+                        from: "new",
+                        to: "shown",
+                        reason: `Startup nudge shown for action: ${nudge.recommended_action}`,
+                        evidence_refs: [],
+                    });
+                    if (nudge.auto_executable) {
+                        await repo.appendTransitionRecord({
+                            session_id: this.sessionId,
+                            subject_kind: "nudge",
+                            subject_id: nudge.id,
+                            from: "shown",
+                            to: "auto_executed",
+                            reason: `Auto-executed safe action: ${nudge.recommended_action}`,
+                            evidence_refs: [],
+                        });
+                    }
+                }).catch(() => { });
+            }
         }
         let runtimeStatus = this.buildRuntimeStatusPacket({
             role: executionRole,
@@ -488,15 +568,31 @@ export class ChatSession extends EventEmitter {
             },
             onToolCall: (tool, args) => {
                 toolNames.push(tool);
+                const nudgeToAccept = tool === startupNudge?.recommended_action ? startupNudge : undefined;
                 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])
+                    accepted_nudges: nudgeToAccept
+                        ? uniqueStrings([...activationLedger.accepted_nudges, nudgeToAccept.id])
                         : activationLedger.accepted_nudges,
                 };
+                if (nudgeToAccept && this.workspaceRoot) {
+                    const wsr = this.workspaceRoot;
+                    const nudge = nudgeToAccept;
+                    void withLocalModelRuntimeRepository(wsr, async (repo) => {
+                        await repo.appendTransitionRecord({
+                            session_id: this.sessionId,
+                            subject_kind: "nudge",
+                            subject_id: nudge.id,
+                            from: "shown",
+                            to: "manually_accepted",
+                            reason: `Nudge accepted via tool call: ${tool}`,
+                            evidence_refs: [],
+                        });
+                    }).catch(() => { });
+                }
                 runtimeStatus = {
                     ...runtimeStatus,
                     bridge_status: "running",

package/dist/tui/dashboard.d.ts

@@ -18,6 +18,7 @@ export declare class DashboardState extends EventEmitter {
     private runtimeEvents;
     private phase;
     private latestRuntimeStatus;
+    private latestTransitions;
     constructor(workspaceRoot: string);
     startWatching(): void;
     stopWatching(): void;

package/dist/tui/dashboard.js

@@ -7,6 +7,7 @@
 import { EventEmitter } from "node:events";
 import { pollStore } from "../store/state-reader.js";
 import { getWorkspaceStorePath } from "../store/store-snapshot.js";
+import { getLivenessDefaults } from "../runtime-profile.js";
 function dedupeEvents(events) {
     const seen = new Set();
     const ordered = [];
@@ -35,6 +36,18 @@ export function selectLiveRuntimeStatus(statuses) {
 }
 function derivePhase(snapshot) {
     const runtimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
+    if (runtimeStatus?.sleep_state === "stalled") {
+        return "Stalled";
+    }
+    if (runtimeStatus?.sleep_state === "sleeping") {
+        return "Sleeping";
+    }
+    if (runtimeStatus?.sleep_state === "approval_pending") {
+        return "Approval Pending";
+    }
+    if (runtimeStatus?.sleep_state === "dependency_wait") {
+        return runtimeStatus.waiting_on ? `Waiting: ${runtimeStatus.waiting_on}` : "Waiting";
+    }
     if (runtimeStatus?.bridge_status === "blocked") {
         return "Blocked";
     }
@@ -48,6 +61,15 @@ function derivePhase(snapshot) {
         return "Retrying";
     }
     if (runtimeStatus?.bridge_status === "running") {
+        const kind = runtimeStatus.surface_kind;
+        if (kind === "unattended_runtime")
+            return "Running (Unattended)";
+        if (kind === "scheduled_job")
+            return "Running (Scheduled)";
+        if (kind === "bridge_resumed")
+            return "Running (Resumed)";
+        if (kind === "supervised_step")
+            return "Running (Supervised)";
         return "Running";
     }
     if (snapshot.jobs.some((job) => String(job.status ?? "") === "running")) {
@@ -73,6 +95,7 @@ export class DashboardState extends EventEmitter {
     runtimeEvents = [];
     phase = "Initializing";
     latestRuntimeStatus;
+    latestTransitions = [];
     constructor(workspaceRoot) {
         super();
         this.workspaceRoot = workspaceRoot;
@@ -108,6 +131,7 @@ export class DashboardState extends EventEmitter {
             runtimeStatus: this.latestRuntimeStatus,
             tasks: this.tasks,
             events: dedupeEvents([...this.persistedEvents, ...this.runtimeEvents]).slice(-50),
+            recentTransitions: this.latestTransitions,
         };
     }
     getLatestRuntimeStatus() {
@@ -141,6 +165,25 @@ export class DashboardState extends EventEmitter {
         this.persistedEvents = dedupeEvents([...trackerEvents, ...ledgerEvents]).slice(-300);
         this.phase = derivePhase(snapshot);
         this.latestRuntimeStatus = selectLiveRuntimeStatus(snapshot.runtimeStatuses);
+        // Compute read-only staleness projection — no watcher, computed on each snapshot
+        if (this.latestRuntimeStatus?.last_progress_at) {
+            const livenessDefaults = getLivenessDefaults(this.latestRuntimeStatus.model_class);
+            const effectiveStallWindowMs = this.latestRuntimeStatus.stall_window_ms ?? livenessDefaults.stall_window_ms;
+            const stalenessSec = (Date.now() - this.latestRuntimeStatus.last_progress_at) / 1000;
+            const stallWindowSec = effectiveStallWindowMs / 1000;
+            this.latestRuntimeStatus["staleness_seconds"] = stalenessSec;
+            this.latestRuntimeStatus["stall_window_seconds"] = stallWindowSec;
+            this.latestRuntimeStatus["is_stale"] = stalenessSec >= stallWindowSec;
+        }
+        this.latestTransitions = (snapshot.recentTransitions ?? []).map((t) => ({
+            subject_kind: t.subject_kind,
+            subject_id: t.subject_id,
+            from: t.from,
+            to: t.to,
+            reason: t.reason,
+            evidence_refs: t.evidence_refs,
+            at: t.at,
+        }));
         // 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/layout.d.ts

@@ -60,11 +60,20 @@ interface RuntimeStatusSummary {
     bridge_status: string;
     preflight_state: string;
     role?: string;
+    model_class?: "frontier" | "mid" | "small_local";
     approval_state?: string;
     active_tool?: string;
     active_tool_role?: string;
     recommended_next_action?: string;
     blocked_reason?: string;
+    active_workspace_path?: string;
+    workspace_hook_health?: "ok" | "degraded" | "failed";
+    staleness_seconds?: number;
+    stall_window_seconds?: number;
+    is_stale?: boolean;
+    stall_restart_count?: number;
+    current_task?: string;
+    surface_kind?: string;
 }
 export declare class LayoutManager {
     private zones;
@@ -88,6 +97,7 @@ export declare class LayoutManager {
     renderStatusBar(state: StatusBarState): void;
     renderInputLine(buffer: string, cursorPos: number, mode: string, prompt?: string): void;
     renderDashboard(data: DashboardData, controls?: DashboardControlState): void;
+    private renderTransitionsPanel;
     private renderStatusPanel;
     private renderControlStrip;
     private renderTasksPanel;
@@ -119,11 +129,21 @@ export interface DashboardData {
     runtimeStatus?: RuntimeStatusSummary;
     tasks: TaskItem[];
     events: ActivityEvent[];
+    recentTransitions?: Array<{
+        subject_kind: string;
+        subject_id: string;
+        from?: string;
+        to: string;
+        reason: string;
+        evidence_refs?: string[];
+        at: number;
+    }>;
 }
 export interface TaskItem {
     title: string;
     done: boolean;
     priority?: string;
+    upstream_annotation?: string;
 }
 export interface ActivityEvent {
     timestamp: number;

package/dist/tui/layout.js

@@ -250,6 +250,18 @@ export class LayoutManager {
         drawBox(content.x, actY, content.width, actH, { title: "Agent Activity", titleColor: fg.brightGreen, borderColor: fg.gray, rounded: true });
         this.renderActivityLog(content.x + 2, actY + 1, content.width - 4, actH - 2, data.events);
     }
+    renderTransitionsPanel(x, y, w, data) {
+        const transitions = data.recentTransitions?.slice(-3) ?? [];
+        if (transitions.length === 0)
+            return;
+        writeAt(x, y, `${fg.gray}─── Recent Transitions ───`);
+        for (let i = 0; i < transitions.length; i++) {
+            const t = transitions[i];
+            const age = Math.round((Date.now() - t.at) / 1000);
+            const line = `${fg.gray}${age}s ago ${fg.cyan}${t.subject_kind}${fg.gray}:${fg.white}${t.to}${fg.gray} — ${truncate(t.reason, 28)}`;
+            writeAt(x, y + 1 + i, truncate(line + style.reset, w));
+        }
+    }
     renderStatusPanel(x, y, w, h, data) {
         const lines = [
             `${fg.gray}Phase:   ${fg.brightWhite}${data.phase}`,
@@ -266,12 +278,29 @@ export class LayoutManager {
             data.runtimeStatus?.role
                 ? `${fg.gray}Role:    ${fg.brightCyan}${data.runtimeStatus.role}`
                 : undefined,
+            data.runtimeStatus?.model_class
+                ? `${fg.gray}Model:   ${fg.brightCyan}${data.runtimeStatus.model_class}`
+                : 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,
+            data.runtimeStatus?.active_workspace_path
+                ? `${fg.gray}Wrkspace:${fg.cyan} ${truncate(data.runtimeStatus.active_workspace_path, 32)} ${fg.gray}[hook: ${data.runtimeStatus.workspace_hook_health ?? "?"}]`
+                : undefined,
+            data.runtimeStatus?.stall_restart_count
+                ? `${fg.gray}Stalls:  ${fg.yellow}${data.runtimeStatus.stall_restart_count} restart(s)`
+                : undefined,
+            data.runtimeStatus?.is_stale
+                ? `${fg.brightRed}⚠ STALE  ${fg.gray}${(data.runtimeStatus.staleness_seconds ?? 0).toFixed(0)}s since last progress (window: ${(data.runtimeStatus.stall_window_seconds ?? 0).toFixed(0)}s)`
+                : data.runtimeStatus?.staleness_seconds !== undefined
+                    ? `${fg.gray}Progress:${fg.brightGreen} ${(data.runtimeStatus.staleness_seconds).toFixed(0)}s ago`
+                    : undefined,
+            data.runtimeStatus?.current_task
+                ? `${fg.gray}Task:    ${fg.white}${truncate(data.runtimeStatus.current_task, 40)}`
+                : 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`,
@@ -304,7 +333,8 @@ export class LayoutManager {
             const t = tasks[i];
             const icon = t.done ? `${fg.green}${symbols.check}` : `${fg.gray}${symbols.hollowBullet}`;
             const priority = t.priority ? `${fg.gray}[${t.priority}]` : "";
-            const line = `${icon} ${fg.white}${t.title} ${priority}${style.reset}`;
+            const upstream = t.upstream_annotation ? ` ${fg.gray}← ${t.upstream_annotation}` : "";
+            const line = `${icon} ${fg.white}${t.title} ${priority}${upstream}${style.reset}`;
             writeAt(x, y + i, truncate(line, w));
         }
         if (tasks.length === 0) {

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

@@ -15,11 +15,14 @@ export interface AcePreflightPacket {
     recall_summary?: string;
     should_synthesize_plan: boolean;
 }
-export interface StartupNudge {
+export interface AceStartupNudge {
     id: string;
     text: string;
     recommended_action: string;
+    auto_executable: boolean;
 }
+/** @deprecated Use AceStartupNudge */
+export type StartupNudge = AceStartupNudge;
 export declare function shouldSynthesizeShortPlan(task: string): boolean;
 export declare function buildAcePreflightPacket(input: {
     sessionId: string;
@@ -28,7 +31,8 @@ export declare function buildAcePreflightPacket(input: {
     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 shouldAutoExecuteNudge(action: string, surfaceKind: AceRuntimeStatusPacket["surface_kind"] | undefined): boolean;
+export declare function buildStartupNudge(preflight: AcePreflightPacket, ledger: AceSessionActivationLedger, statusPacket?: AceRuntimeStatusPacket | null): AceStartupNudge | undefined;
 export declare function buildBridgeTaskInput(conversation: string, preflight: AcePreflightPacket): string;
 export declare function mapBridgeResultToRuntimeStatus(input: {
     current: AceRuntimeStatusPacket;

package/dist/tui/local-model-contract.js

@@ -122,10 +122,18 @@ export function nextActivationLedger(sessionId, current, recommendedAction) {
         accepted_nudges: [...(current?.accepted_nudges ?? [])],
         activated_tools: [...(current?.activated_tools ?? [])],
         activated_roles: [...(current?.activated_roles ?? [])],
-        last_recommended_action: recommendedAction ?? current?.last_recommended_action,
+        auto_executed_nudges: current?.auto_executed_nudges ? [...current.auto_executed_nudges] : undefined,
+        ignored_nudges: current?.ignored_nudges ? [...current.ignored_nudges] : undefined,
     };
 }
-export function buildStartupNudge(preflight, ledger) {
+export function shouldAutoExecuteNudge(action, surfaceKind) {
+    const SAFE_TRIO = new Set(["validate_framework", "recall_context", "run_orchestrator"]);
+    return (SAFE_TRIO.has(action) &&
+        (surfaceKind === "unattended_runtime" ||
+            surfaceKind === "scheduled_job" ||
+            surfaceKind === "supervised_step"));
+}
+export function buildStartupNudge(preflight, ledger, statusPacket) {
     const action = preflight.recommended_next_action;
     if (!action)
         return undefined;
@@ -140,7 +148,12 @@ export function buildStartupNudge(preflight, ledger) {
             : action === "route_task"
                 ? "Role selection is still ambiguous. Route the task before deeper work."
                 : "Load ACE context first with recall_context before deeper work.";
-    return { id: nudgeId, text, recommended_action: action };
+    return {
+        id: nudgeId,
+        text,
+        recommended_action: action,
+        auto_executable: shouldAutoExecuteNudge(action, statusPacket?.surface_kind),
+    };
 }
 function compactTrapPack() {
     return [

package/dist/vericify-bridge.d.ts

@@ -71,6 +71,11 @@ export interface VericifyBridgeSnapshot {
         process_posts: VericifyBridgeSourceState;
     };
     active_run_refs: VericifyBridgeActiveRunRef[];
+    ace_runtime_enrichment?: {
+        live_session_id?: string;
+        last_turn_outcome?: string;
+        last_turn_outcome_reason?: string;
+    };
 }
 export interface VericifyBridgeSnapshotResult {
     ok: boolean;

package/dist/vericify-bridge.js

@@ -9,7 +9,7 @@ import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { VericifyRepository } from "./store/repositories/vericify-repository.js";
 import { getWorkspaceStorePath, storeExistsSync } from "./store/store-snapshot.js";
 import { isOperationalArtifactPath, operationalArtifactVirtualPath } from "./store/store-artifacts.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 export const VERICIFY_PROCESS_POST_LOG_REL_PATH = "agent-state/vericify/process-posts.json";
 export const VERICIFY_PROCESS_POST_LOG_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/VERICIFY_PROCESS_POST_LOG.schema.json";
 export const VERICIFY_PROCESS_POST_LOG_SCHEMA_NAME = "vericify-process-post-log@1.0.0";
@@ -363,7 +363,7 @@ export async function appendVericifyProcessPost(input) {
         const path = await withFileLock(VERICIFY_PROCESS_POST_LOG_REL_PATH, async () => {
             const root = workspaceRoot();
             const storePath = getWorkspaceStorePath(root);
-            return withStoreWriteQueue(storePath, async () => {
+            return withStoreWriteCoordinator(storePath, async () => {
                 const store = await openStore(storePath);
                 try {
                     const repo = new VericifyRepository(store);
@@ -390,7 +390,7 @@ export async function appendVericifyProcessPost(input) {
                     await store.close();
                 }
                 return processPostLogPath();
-            });
+            }, { operation_label: "appendVericifyProcessPost" });
         });
         return {
             path,
@@ -544,6 +544,30 @@ export function buildVericifyBridgeSnapshot() {
             }),
         },
         active_run_refs: buildActiveRunRefs(),
+        ace_runtime_enrichment: (() => {
+            const rawSessions = safeRead(runtimeExecutorPath);
+            if (!rawSessions)
+                return undefined;
+            try {
+                const parsed = JSON.parse(rawSessions);
+                const runningSession = Array.isArray(parsed.sessions)
+                    ? parsed.sessions.find((s) => s.status === "running")
+                    : undefined;
+                if (!runningSession)
+                    return undefined;
+                const lastTurn = Array.isArray(runningSession.turns) && runningSession.turns.length > 0
+                    ? runningSession.turns[runningSession.turns.length - 1]
+                    : undefined;
+                return {
+                    live_session_id: runningSession.session_id,
+                    last_turn_outcome: lastTurn?.turn_outcome,
+                    last_turn_outcome_reason: lastTurn?.outcome_reason,
+                };
+            }
+            catch {
+                return undefined;
+            }
+        })(),
     };
 }
 export function refreshVericifyBridgeSnapshot() {