@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/store/repositories/local-model-runtime-repository.d.ts

@@ -9,6 +9,9 @@ export interface AceSessionActivationLedger {
     activated_tools: string[];
     activated_roles: string[];
     last_recommended_action?: string;
+    auto_executed_nudges?: string[];
+    ignored_nudges?: string[];
+    last_transition_id?: string;
 }
 export interface AceSessionContinuityRecord {
     session_id: string;
@@ -24,6 +27,7 @@ export interface AceSessionContinuityRecord {
     recent_decisions: string[];
     recommended_next_action?: string;
     evidence_refs: string[];
+    last_transition_id?: string;
 }
 export interface AceRuntimeStatusPacket {
     session_id: string;
@@ -52,6 +56,25 @@ export interface AceRuntimeStatusPacket {
     tokens_in?: number;
     tokens_out?: number;
     updated_at: number;
+    surface_kind?: "tui_interactive" | "unattended_runtime" | "scheduled_job" | "bridge_resumed" | "supervised_step";
+    model_class?: "frontier" | "mid" | "small_local";
+    waiting_on?: string;
+    resume_condition?: string;
+    resume_after?: number;
+    sleep_state?: "awake" | "sleeping" | "approval_pending" | "dependency_wait" | "stalled";
+    escalation_policy?: {
+        silent_until?: string;
+        escalate_after_ms?: number;
+        route_to?: string[];
+    };
+    last_transition_id?: string;
+    last_progress_at?: number;
+    turn_budget_ms?: number;
+    stall_window_ms?: number;
+    stall_restart_count?: number;
+    active_workspace_path?: string;
+    active_workspace_session_id?: string;
+    workspace_hook_health?: "ok" | "degraded" | "failed";
 }
 export interface AceArchivedChatRecord {
     session_id: string;
@@ -75,19 +98,112 @@ export interface AceArchivedChatRecord {
         recommended_next_action?: string;
     };
 }
+export interface TransitionRecord {
+    transition_id: string;
+    session_id?: string;
+    subject_kind: "runtime_status" | "continuity" | "plan_step" | "plan_proposal" | "nudge" | "capability" | "workspace_session" | "turn" | "activation";
+    subject_id: string;
+    from?: string;
+    to: string;
+    reason: string;
+    reason_code?: string;
+    evidence_refs: string[];
+    at: number;
+}
+export interface TurnSnapshotRecord {
+    snapshot_id: string;
+    session_id: string;
+    turn_number: number;
+    captured_at: number;
+    preflight: Record<string, unknown>;
+    recall: Record<string, unknown> | null;
+    continuity: Record<string, unknown> | null;
+    capability_snapshot_id: string | null;
+    tool_choice_audit_id?: string | null;
+    surface_kind: AceRuntimeStatusPacket["surface_kind"];
+}
+export type ToolCostClass = "cheap" | "moderate" | "heavy";
+export interface ToolAvailabilityEntry {
+    name: string;
+    reason: string;
+    reason_code: "runtime_disabled" | "workspace_disabled" | "policy_disabled" | "missing_credentials" | "unhealthy";
+}
+export interface CapabilitySnapshotRecord {
+    snapshot_id: string;
+    session_id: string;
+    turn_number: number;
+    captured_at: number;
+    model_class: AceRuntimeStatusPacket["model_class"];
+    allowed_tools: string[];
+    unavailable_tools: ToolAvailabilityEntry[];
+    tool_cost_class: Record<string, ToolCostClass>;
+    tool_choice_audit_id?: string;
+}
+export interface ToolChoiceAuditRecord {
+    audit_id: string;
+    session_id: string;
+    turn_number: number;
+    captured_at: number;
+    model_class: AceRuntimeStatusPacket["model_class"];
+    priority_tools: string[];
+    demoted_tools: Array<{
+        name: string;
+        reason_code: "heavy_for_small_local" | "policy_disabled" | "workspace_disabled";
+    }>;
+    selected_budget: {
+        read_file_lines_max_lines: number | null;
+    };
+    capability_snapshot_id: string;
+}
+type TransitionMetadata = {
+    from?: string;
+    reason: string;
+    reason_code?: string;
+    evidence_refs?: string[];
+};
 export declare class LocalModelRuntimeRepository {
     private store;
     constructor(store: AcePackedStore);
+    private static normalizeTransitionMetadata;
     private activationKey;
     private continuityKey;
     private statusKey;
     private archiveKey;
     getActivationLedger(sessionId: string): Promise<AceSessionActivationLedger | undefined>;
-    upsertActivationLedger(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">): Promise<AceSessionActivationLedger>;
+    private writeActivationLedger;
+    upsertActivationLedger(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">, transition: TransitionMetadata): Promise<AceSessionActivationLedger>;
+    upsertActivationLedgerForTestSetup(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">): Promise<AceSessionActivationLedger>;
+    upsertActivationLedgerWithTransition(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">, transition: TransitionMetadata): Promise<AceSessionActivationLedger>;
     getContinuityRecord(sessionId: string): Promise<AceSessionContinuityRecord | undefined>;
-    upsertContinuityRecord(input: Omit<AceSessionContinuityRecord, "updated_at" | "created_at"> & Partial<Pick<AceSessionContinuityRecord, "created_at">>): Promise<AceSessionContinuityRecord>;
+    private writeContinuityRecord;
+    upsertContinuityRecord(input: Omit<AceSessionContinuityRecord, "updated_at" | "created_at"> & Partial<Pick<AceSessionContinuityRecord, "created_at">>, transition: TransitionMetadata): Promise<AceSessionContinuityRecord>;
+    upsertContinuityRecordWithTransition(input: Omit<AceSessionContinuityRecord, "updated_at" | "created_at"> & Partial<Pick<AceSessionContinuityRecord, "created_at">>, transition: TransitionMetadata): Promise<AceSessionContinuityRecord>;
+    upsertContinuityRecordForTestSetup(input: Omit<AceSessionContinuityRecord, "updated_at" | "created_at"> & Partial<Pick<AceSessionContinuityRecord, "created_at">>): Promise<AceSessionContinuityRecord>;
     getRuntimeStatus(sessionId: string): Promise<AceRuntimeStatusPacket | undefined>;
-    upsertRuntimeStatus(input: Omit<AceRuntimeStatusPacket, "updated_at">): Promise<AceRuntimeStatusPacket>;
+    private writeRuntimeStatus;
+    upsertRuntimeStatus(input: Omit<AceRuntimeStatusPacket, "updated_at">, transition: TransitionMetadata): Promise<AceRuntimeStatusPacket>;
+    upsertRuntimeStatusWithTransition(input: Omit<AceRuntimeStatusPacket, "updated_at">, transition: TransitionMetadata): Promise<AceRuntimeStatusPacket>;
+    upsertRuntimeStatusForTestSetup(input: Omit<AceRuntimeStatusPacket, "updated_at">): Promise<AceRuntimeStatusPacket>;
+    private transitionLogKey;
+    private transitionSessionIndexKey;
+    private deriveTransitionSessionId;
+    appendTransitionRecord(record: Omit<TransitionRecord, "transition_id" | "at"> & Partial<Pick<TransitionRecord, "transition_id" | "at" | "session_id">>): Promise<TransitionRecord>;
+    getTransitionLog(subjectKind: TransitionRecord["subject_kind"], subjectId: string): Promise<TransitionRecord[]>;
+    getTransitionLog(sessionId: string, limit: number): Promise<TransitionRecord[]>;
+    private turnSnapshotKey;
+    saveTurnSnapshot(snapshot: TurnSnapshotRecord): Promise<void>;
+    getTurnSnapshot(sessionId: string, turnNumber: number): Promise<TurnSnapshotRecord | undefined>;
+    private capabilitySnapshotKey;
+    private capabilitySnapshotIdKey;
+    private toolChoiceAuditKey;
+    private toolChoiceAuditIdKey;
+    saveCapabilitySnapshot(snapshot: CapabilitySnapshotRecord): Promise<void>;
+    getCapabilitySnapshot(sessionId: string, turnNumber: number): Promise<CapabilitySnapshotRecord | undefined>;
+    getCapabilitySnapshotById(sessionId: string, snapshotId: string): Promise<CapabilitySnapshotRecord | undefined>;
+    getTurnCapabilitySnapshot(sessionId: string, turnNumber: number): Promise<CapabilitySnapshotRecord | undefined>;
+    saveToolChoiceAudit(audit: ToolChoiceAuditRecord): Promise<ToolChoiceAuditRecord>;
+    getToolChoiceAudit(sessionId: string, turnNumber: number): Promise<ToolChoiceAuditRecord | undefined>;
+    getToolChoiceAuditById(sessionId: string, auditId: string): Promise<ToolChoiceAuditRecord | undefined>;
     listRuntimeStatuses(): Promise<AceRuntimeStatusPacket[]>;
     archiveChat(input: Omit<AceArchivedChatRecord, "archived_at"> & Partial<Pick<AceArchivedChatRecord, "archived_at">>): Promise<AceArchivedChatRecord>;
     listArchivedChats(): Promise<AceArchivedChatRecord[]>;
@@ -95,4 +211,5 @@ export declare class LocalModelRuntimeRepository {
     private appendLifecycleEntry;
 }
 export declare function withLocalModelRuntimeRepository<T>(workspaceRoot: string, fn: (repo: LocalModelRuntimeRepository) => Promise<T>): Promise<T | undefined>;
+export {};
 //# sourceMappingURL=local-model-runtime-repository.d.ts.map

package/dist/store/repositories/local-model-runtime-repository.js

@@ -2,19 +2,52 @@ import { randomUUID } from "node:crypto";
 import { openStore } from "../ace-packed-store.js";
 import { ContentSource, EntityKind } from "../types.js";
 import { getWorkspaceStorePath } from "../store-snapshot.js";
-import { withStoreWriteQueue } from "../write-queue.js";
+import { withStoreWriteCoordinator } from "../write-coordinator.js";
 const ACTIVATION_INDEX_KEY = "state/ui/session_activation/index";
 const CONTINUITY_INDEX_KEY = "state/runtime/session_continuity/index";
 const STATUS_INDEX_KEY = "state/runtime/ui_status/index";
 const ARCHIVE_INDEX_KEY = "state/ui/chat_archives/index";
+const TRANSITION_LOG_PREFIX = "state/runtime/transitions";
+const TRANSITION_SESSION_INDEX_PREFIX = "state/runtime/transitions/by_session";
+const TURN_SNAPSHOT_PREFIX = "state/runtime/turn_snapshots";
+const CAPABILITY_SNAPSHOT_PREFIX = "state/runtime/capability_snapshots";
+const TOOL_CHOICE_AUDIT_PREFIX = "state/runtime/tool_choice_audits";
 function uniqueStrings(values) {
     return Array.from(new Set((values ?? []).filter((value) => typeof value === "string" && value.length > 0)));
 }
+function normalizeTransitionField(name, value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "(unspecified)" || trimmed === "placeholder" || trimmed === "(placeholder)") {
+        throw new Error(`Transition metadata requires a non-placeholder ${name}.`);
+    }
+    return trimmed;
+}
 export class LocalModelRuntimeRepository {
     store;
     constructor(store) {
         this.store = store;
     }
+    static normalizeTransitionMetadata(transition) {
+        const reason = normalizeTransitionField("reason", transition.reason);
+        if (!reason) {
+            throw new Error("Transition metadata requires a non-placeholder reason.");
+        }
+        const from = normalizeTransitionField("from", transition.from);
+        const reasonCode = normalizeTransitionField("reason_code", transition.reason_code);
+        const evidenceRefs = uniqueStrings(transition.evidence_refs ?? []);
+        if (evidenceRefs.some((entry) => entry === "placeholder" || entry === "(placeholder)")) {
+            throw new Error("Transition metadata evidence_refs cannot use placeholder values.");
+        }
+        return {
+            ...transition,
+            ...(from ? { from } : {}),
+            reason,
+            ...(reasonCode ? { reason_code: reasonCode } : {}),
+            evidence_refs: evidenceRefs,
+        };
+    }
     activationKey(sessionId) {
         return `state/ui/session_activation/${sessionId}`;
     }
@@ -30,7 +63,7 @@ export class LocalModelRuntimeRepository {
     async getActivationLedger(sessionId) {
         return this.store.getJSON(this.activationKey(sessionId));
     }
-    async upsertActivationLedger(input) {
+    async writeActivationLedger(input, transition) {
         const current = await this.getActivationLedger(input.session_id);
         const now = Date.now();
         const record = {
@@ -43,7 +76,27 @@ export class LocalModelRuntimeRepository {
             activated_tools: uniqueStrings(input.activated_tools ?? current?.activated_tools ?? []),
             activated_roles: uniqueStrings(input.activated_roles ?? current?.activated_roles ?? []),
             last_recommended_action: input.last_recommended_action ?? current?.last_recommended_action,
+            auto_executed_nudges: input.auto_executed_nudges != null
+                ? uniqueStrings(input.auto_executed_nudges)
+                : current?.auto_executed_nudges,
+            ignored_nudges: input.ignored_nudges != null
+                ? uniqueStrings(input.ignored_nudges)
+                : current?.ignored_nudges,
         };
+        if (transition) {
+            const normalizedTransition = LocalModelRuntimeRepository.normalizeTransitionMetadata(transition);
+            const tr = await this.appendTransitionRecord({
+                session_id: input.session_id,
+                subject_kind: "activation",
+                subject_id: input.session_id,
+                from: normalizedTransition.from ?? (current ? "updated" : "created"),
+                to: "updated",
+                reason: normalizedTransition.reason,
+                reason_code: normalizedTransition.reason_code,
+                evidence_refs: normalizedTransition.evidence_refs ?? [],
+            });
+            record.last_transition_id = tr.transition_id;
+        }
         await this.store.setJSON(this.activationKey(record.session_id), record);
         await this.appendLifecycleEntry(this.activationKey(record.session_id), {
             op: current ? "activation_update" : "activation_create",
@@ -52,10 +105,22 @@ export class LocalModelRuntimeRepository {
         await this.addToIndex(ACTIVATION_INDEX_KEY, record.session_id);
         return record;
     }
+    async upsertActivationLedger(input, transition) {
+        if (!transition) {
+            throw new Error("upsertActivationLedger requires transition metadata. Use upsertActivationLedgerForTestSetup for seeding.");
+        }
+        return this.writeActivationLedger(input, transition);
+    }
+    async upsertActivationLedgerForTestSetup(input) {
+        return this.writeActivationLedger(input);
+    }
+    async upsertActivationLedgerWithTransition(input, transition) {
+        return this.upsertActivationLedger(input, transition);
+    }
     async getContinuityRecord(sessionId) {
         return this.store.getJSON(this.continuityKey(sessionId));
     }
-    async upsertContinuityRecord(input) {
+    async writeContinuityRecord(input, transition) {
         const current = await this.getContinuityRecord(input.session_id);
         const now = Date.now();
         const record = {
@@ -66,6 +131,20 @@ export class LocalModelRuntimeRepository {
             recent_decisions: uniqueStrings(input.recent_decisions ?? current?.recent_decisions ?? []),
             evidence_refs: uniqueStrings(input.evidence_refs ?? current?.evidence_refs ?? []),
         };
+        if (transition) {
+            const normalizedTransition = LocalModelRuntimeRepository.normalizeTransitionMetadata(transition);
+            const tr = await this.appendTransitionRecord({
+                session_id: input.session_id,
+                subject_kind: "continuity",
+                subject_id: input.session_id,
+                from: normalizedTransition.from ?? current?.last_bridge_status,
+                to: input.last_bridge_status ?? "running",
+                reason: normalizedTransition.reason,
+                reason_code: normalizedTransition.reason_code,
+                evidence_refs: normalizedTransition.evidence_refs ?? [],
+            });
+            record.last_transition_id = tr.transition_id;
+        }
         await this.store.setJSON(this.continuityKey(record.session_id), record);
         await this.appendLifecycleEntry(this.continuityKey(record.session_id), {
             op: current ? "continuity_update" : "continuity_create",
@@ -75,14 +154,42 @@ export class LocalModelRuntimeRepository {
         await this.addToIndex(CONTINUITY_INDEX_KEY, record.session_id);
         return record;
     }
+    async upsertContinuityRecord(input, transition) {
+        if (!transition) {
+            throw new Error("upsertContinuityRecord requires transition metadata. Use upsertContinuityRecordForTestSetup for seeding.");
+        }
+        return this.writeContinuityRecord(input, transition);
+    }
+    async upsertContinuityRecordWithTransition(input, transition) {
+        return this.upsertContinuityRecord(input, transition);
+    }
+    async upsertContinuityRecordForTestSetup(input) {
+        return this.writeContinuityRecord(input);
+    }
     async getRuntimeStatus(sessionId) {
         return this.store.getJSON(this.statusKey(sessionId));
     }
-    async upsertRuntimeStatus(input) {
+    async writeRuntimeStatus(input, transition) {
+        const current = await this.getRuntimeStatus(input.session_id);
         const record = {
             ...input,
             updated_at: Date.now(),
         };
+        if (transition) {
+            const normalizedTransition = LocalModelRuntimeRepository.normalizeTransitionMetadata(transition);
+            const tr = await this.appendTransitionRecord({
+                session_id: input.session_id,
+                subject_kind: "runtime_status",
+                subject_id: input.session_id,
+                from: normalizedTransition.from ?? current?.bridge_status,
+                to: input.bridge_status,
+                reason: normalizedTransition.reason,
+                reason_code: normalizedTransition.reason_code,
+                evidence_refs: normalizedTransition.evidence_refs ?? [],
+            });
+            record.last_transition_id = tr.transition_id;
+            record.last_progress_at = tr.at;
+        }
         await this.store.setJSON(this.statusKey(record.session_id), record);
         await this.appendLifecycleEntry(this.statusKey(record.session_id), {
             op: "runtime_status",
@@ -93,6 +200,135 @@ export class LocalModelRuntimeRepository {
         await this.addToIndex(STATUS_INDEX_KEY, record.session_id);
         return record;
     }
+    async upsertRuntimeStatus(input, transition) {
+        if (!transition) {
+            throw new Error("upsertRuntimeStatus requires transition metadata. Use upsertRuntimeStatusForTestSetup for seeding.");
+        }
+        return this.writeRuntimeStatus(input, transition);
+    }
+    async upsertRuntimeStatusWithTransition(input, transition) {
+        return this.upsertRuntimeStatus(input, transition);
+    }
+    async upsertRuntimeStatusForTestSetup(input) {
+        return this.writeRuntimeStatus(input);
+    }
+    transitionLogKey(subjectKind, subjectId) {
+        return `${TRANSITION_LOG_PREFIX}/${subjectKind}/${subjectId}`;
+    }
+    transitionSessionIndexKey(sessionId) {
+        return `${TRANSITION_SESSION_INDEX_PREFIX}/${sessionId}`;
+    }
+    deriveTransitionSessionId(record) {
+        if (typeof record.session_id === "string" && record.session_id.trim().length > 0) {
+            return record.session_id.trim();
+        }
+        const [ownerId] = record.subject_id.split("/", 1);
+        return ownerId?.trim() || record.subject_id;
+    }
+    async appendTransitionRecord(record) {
+        const normalizedTransition = LocalModelRuntimeRepository.normalizeTransitionMetadata(record);
+        const sessionId = this.deriveTransitionSessionId(record);
+        const full = {
+            ...record,
+            session_id: sessionId,
+            reason: normalizedTransition.reason,
+            evidence_refs: normalizedTransition.evidence_refs ?? [],
+            transition_id: record.transition_id ?? randomUUID(),
+            at: record.at ?? Date.now(),
+        };
+        const key = this.transitionLogKey(full.subject_kind, full.subject_id);
+        const existing = await this.store.getJSON(key) ?? [];
+        existing.push(full);
+        await this.store.setJSON(key, existing);
+        const sessionIndexKey = this.transitionSessionIndexKey(sessionId);
+        const sessionIndex = await this.store.getJSON(sessionIndexKey) ?? [];
+        sessionIndex.push(full);
+        await this.store.setJSON(sessionIndexKey, sessionIndex);
+        return full;
+    }
+    async getTransitionLog(subjectKindOrSessionId, subjectIdOrLimit) {
+        if (typeof subjectIdOrLimit === "number") {
+            const sessionId = subjectKindOrSessionId;
+            const deduped = new Map();
+            const indexed = await this.store.getJSON(this.transitionSessionIndexKey(sessionId)) ?? [];
+            for (const record of indexed) {
+                deduped.set(record.transition_id, record);
+            }
+            const kinds = [
+                "runtime_status", "continuity", "turn", "plan_step", "plan_proposal", "capability", "workspace_session", "nudge", "activation",
+            ];
+            for (const kind of kinds) {
+                const records = await this.store.getJSON(this.transitionLogKey(kind, sessionId)) ?? [];
+                for (const record of records) {
+                    deduped.set(record.transition_id, record);
+                }
+            }
+            return Array.from(deduped.values()).sort((a, b) => b.at - a.at).slice(0, subjectIdOrLimit);
+        }
+        const key = this.transitionLogKey(subjectKindOrSessionId, subjectIdOrLimit);
+        return await this.store.getJSON(key) ?? [];
+    }
+    turnSnapshotKey(sessionId, turnNumber) {
+        return `${TURN_SNAPSHOT_PREFIX}/${sessionId}/${turnNumber}`;
+    }
+    async saveTurnSnapshot(snapshot) {
+        await this.store.setJSON(this.turnSnapshotKey(snapshot.session_id, snapshot.turn_number), snapshot);
+    }
+    async getTurnSnapshot(sessionId, turnNumber) {
+        return this.store.getJSON(this.turnSnapshotKey(sessionId, turnNumber));
+    }
+    capabilitySnapshotKey(sessionId, turnNumber) {
+        return `${CAPABILITY_SNAPSHOT_PREFIX}/${sessionId}/${turnNumber}`;
+    }
+    capabilitySnapshotIdKey(sessionId, snapshotId) {
+        return `${CAPABILITY_SNAPSHOT_PREFIX}/by_id/${sessionId}/${snapshotId}`;
+    }
+    toolChoiceAuditKey(sessionId, turnNumber) {
+        return `${TOOL_CHOICE_AUDIT_PREFIX}/${sessionId}/${turnNumber}`;
+    }
+    toolChoiceAuditIdKey(sessionId, auditId) {
+        return `${TOOL_CHOICE_AUDIT_PREFIX}/by_id/${sessionId}/${auditId}`;
+    }
+    async saveCapabilitySnapshot(snapshot) {
+        await this.store.setJSON(this.capabilitySnapshotKey(snapshot.session_id, snapshot.turn_number), snapshot);
+        await this.store.setJSON(this.capabilitySnapshotIdKey(snapshot.session_id, snapshot.snapshot_id), {
+            turn_number: snapshot.turn_number,
+        });
+    }
+    async getCapabilitySnapshot(sessionId, turnNumber) {
+        return this.store.getJSON(this.capabilitySnapshotKey(sessionId, turnNumber));
+    }
+    async getCapabilitySnapshotById(sessionId, snapshotId) {
+        const pointer = await this.store.getJSON(this.capabilitySnapshotIdKey(sessionId, snapshotId));
+        if (!pointer)
+            return undefined;
+        return this.getCapabilitySnapshot(sessionId, pointer.turn_number);
+    }
+    async getTurnCapabilitySnapshot(sessionId, turnNumber) {
+        const turnSnapshot = await this.getTurnSnapshot(sessionId, turnNumber);
+        if (!turnSnapshot)
+            return undefined;
+        if (!turnSnapshot.capability_snapshot_id) {
+            return this.getCapabilitySnapshot(sessionId, turnNumber);
+        }
+        return this.getCapabilitySnapshotById(sessionId, turnSnapshot.capability_snapshot_id);
+    }
+    async saveToolChoiceAudit(audit) {
+        await this.store.setJSON(this.toolChoiceAuditKey(audit.session_id, audit.turn_number), audit);
+        await this.store.setJSON(this.toolChoiceAuditIdKey(audit.session_id, audit.audit_id), {
+            turn_number: audit.turn_number,
+        });
+        return audit;
+    }
+    async getToolChoiceAudit(sessionId, turnNumber) {
+        return this.store.getJSON(this.toolChoiceAuditKey(sessionId, turnNumber));
+    }
+    async getToolChoiceAuditById(sessionId, auditId) {
+        const pointer = await this.store.getJSON(this.toolChoiceAuditIdKey(sessionId, auditId));
+        if (!pointer)
+            return undefined;
+        return this.getToolChoiceAudit(sessionId, pointer.turn_number);
+    }
     async listRuntimeStatuses() {
         const index = await this.store.getJSON(STATUS_INDEX_KEY) ?? [];
         const statuses = [];
@@ -149,7 +385,7 @@ export class LocalModelRuntimeRepository {
 }
 export async function withLocalModelRuntimeRepository(workspaceRoot, fn) {
     const storePath = getWorkspaceStorePath(workspaceRoot);
-    return withStoreWriteQueue(storePath, async () => {
+    return withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const repo = new LocalModelRuntimeRepository(store);
@@ -160,6 +396,6 @@ export async function withLocalModelRuntimeRepository(workspaceRoot, fn) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "withLocalModelRuntimeRepository" });
 }
 //# sourceMappingURL=local-model-runtime-repository.js.map

package/dist/store/repositories/vericify-repository.d.ts

@@ -9,7 +9,7 @@ export interface VericifyPost {
     id: string;
     run_id: string;
     agent_id: string;
-    kind: "intent" | "progress" | "completion" | "blocker" | "handoff_note" | "stale_ack";
+    kind: "intent" | "progress" | "completion" | "blocker" | "handoff_note" | "stale_ack" | "plan_proposal" | "plan_quality_assessment";
     summary: string;
     ts: number;
     metadata?: Record<string, unknown>;

package/dist/store/skills-install.d.ts

@@ -20,6 +20,10 @@ export interface InstallResult {
 export declare function installSkillPack(workspaceRoot: string, skillName: string): Promise<InstallResult>;
 export declare function installAllSkills(workspaceRoot: string): Promise<InstallResult[]>;
 export declare function listInstalledSkills(workspaceRoot: string): Promise<string[]>;
+export declare function listInstalledSkillsDetailed(workspaceRoot: string): Promise<{
+    skills: string[];
+    warnings: string[];
+}>;
 export declare function listAvailableSkillPacks(workspaceRoot: string): Promise<{
     installed: string[];
     available: string[];

package/dist/store/skills-install.js

@@ -13,10 +13,11 @@
  *   4. Compact if the install materially expands the store (>50% dead space)
  */
 import { existsSync } from "fs";
-import { join, dirname, resolve } from "path";
+import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 import { openStore } from "./ace-packed-store.js";
 import { bakeSkillPack, listAvailableSkills } from "./knowledge-bake.js";
+import { ensureCanonicalWorkspaceStore, resolveWorkspaceStorePath, } from "./workspace-store-paths.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getAssetsRoot() {
     const candidate = resolve(__dirname, "..", "..", "assets");
@@ -25,26 +26,29 @@ function getAssetsRoot() {
     return resolve(__dirname, "..", "..", "..", "assets");
 }
 export async function installSkillPack(workspaceRoot, skillName) {
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
-    if (!existsSync(storePath)) {
-        throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
+    const resolved = await ensureCanonicalWorkspaceStore(workspaceRoot, {
+        operationLabel: "installSkillPack",
+    });
+    if (resolved.mode === "missing") {
+        throw new Error(`No ACE store found at ${resolved.canonicalPath} or ${resolved.legacyPath}. Run 'ace init' first.`);
+    }
+    for (const w of resolved.warnings) {
+        console.warn(`[skills-install] ${w}`);
     }
     const assetsRoot = getAssetsRoot();
     const available = await listAvailableSkills(assetsRoot);
     if (!available.includes(skillName)) {
         throw new Error(`Skill pack '${skillName}' not found. Available: ${available.join(", ")}`);
     }
-    const store = await openStore(storePath);
+    const store = await openStore(resolved.storePath);
     let compacted = false;
     try {
-        // Check if already installed
         const existing = await store.listSkills();
         if (existing.includes(skillName)) {
             console.log(`[skills-install] '${skillName}' already installed — reinstalling`);
         }
         const files = await bakeSkillPack(store, assetsRoot, skillName);
         await store.commit();
-        // Compact if dead space > 50%
         if (store.deadSpaceRatio > 0.5) {
             await store.compact();
             compacted = true;
@@ -65,12 +69,17 @@ export async function installAllSkills(workspaceRoot) {
     return results;
 }
 export async function listInstalledSkills(workspaceRoot) {
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
-    if (!existsSync(storePath))
-        return [];
-    const store = await openStore(storePath);
+    const { skills } = await listInstalledSkillsDetailed(workspaceRoot);
+    return skills;
+}
+export async function listInstalledSkillsDetailed(workspaceRoot) {
+    const resolution = resolveWorkspaceStorePath(workspaceRoot);
+    if (resolution.mode === "missing")
+        return { skills: [], warnings: [] };
+    const store = await openStore(resolution.storePath);
     try {
-        return await store.listSkills();
+        const skills = await store.listSkills();
+        return { skills, warnings: resolution.warnings };
     }
     finally {
         await store.close();

package/dist/store/state-reader.d.ts

@@ -15,6 +15,7 @@ import { TrackerRepository } from "./repositories/tracker-repository.js";
 import { DiscoveryRepository } from "./repositories/discovery-repository.js";
 import { VericifyRepository } from "./repositories/vericify-repository.js";
 import { LocalModelRuntimeRepository } from "./repositories/local-model-runtime-repository.js";
+import type { TransitionRecord } from "./repositories/local-model-runtime-repository.js";
 export interface DashboardSnapshot {
     handoffs: Awaited<ReturnType<HandoffRepository["list"]>>;
     todos: Awaited<ReturnType<TodoRepository["getAll"]>>;
@@ -27,6 +28,7 @@ export interface DashboardSnapshot {
     providers: Awaited<ReturnType<DiscoveryRepository["listAll"]>>;
     runtimeStatuses: Awaited<ReturnType<LocalModelRuntimeRepository["listRuntimeStatuses"]>>;
     posts: Awaited<ReturnType<VericifyRepository["list"]>>;
+    recentTransitions: TransitionRecord[];
     snapped_at: number;
 }
 export declare class StoreStateReader {

package/dist/store/state-reader.js

@@ -58,6 +58,25 @@ export class StoreStateReader {
             r.localModelRuntime.listRuntimeStatuses(),
             r.vericify.list(),
         ]);
+        // Phase 2: fetch transition log for the live session (needs runtimeStatuses from phase 1)
+        const liveStatus = runtimeStatuses.find((s) => {
+            try {
+                process.kill(s.process_id, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        let recentTransitions = [];
+        if (liveStatus?.session_id) {
+            try {
+                recentTransitions = await r.localModelRuntime.getTransitionLog(liveStatus.session_id, 15);
+            }
+            catch {
+                recentTransitions = [];
+            }
+        }
         return {
             handoffs,
             todos,
@@ -70,6 +89,7 @@ export class StoreStateReader {
             providers,
             runtimeStatuses,
             posts,
+            recentTransitions,
             snapped_at: Date.now(),
         };
     }

package/dist/store/store-artifacts.d.ts

@@ -1,3 +1,4 @@
+import { type StoreWriteCoordinatorOptions } from "./write-coordinator.js";
 export declare const OPERATIONAL_ARTIFACT_REL_PATHS: Set<string>;
 export declare function operationalArtifactKey(relPath: string): string;
 export declare function isOperationalArtifactPath(relPath: string): boolean;
@@ -9,4 +10,10 @@ export declare function writeStoreBlobsSync(workspaceRoot: string, blobs: Readon
 }>): string[];
 export declare function writeStoreBlobSync(workspaceRoot: string, key: string, content: string): string;
 export declare function writeOperationalArtifactSync(workspaceRoot: string, relPath: string, content: string): string;
+export declare function writeStoreBlobsQueued(workspaceRoot: string, blobs: ReadonlyArray<{
+    key: string;
+    content: string;
+}>, options?: StoreWriteCoordinatorOptions): Promise<string[]>;
+export declare function writeStoreBlobQueued(workspaceRoot: string, key: string, content: string, options?: StoreWriteCoordinatorOptions): Promise<string>;
+export declare function writeOperationalArtifactQueued(workspaceRoot: string, relPath: string, content: string, options?: StoreWriteCoordinatorOptions): Promise<string>;
 //# sourceMappingURL=store-artifacts.d.ts.map