@voybio/ace-swarm 0.2.0 → 0.2.2

package/dist/store/materializers/context-snapshot-materializer.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ContextSnapshotRepository } from "../repositories/context-snapshot-repository.js";
+function writeText(path, content) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, path);
+}
+export class ContextSnapshotMaterializer {
+    store;
+    workspaceRoot;
+    repo;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.repo = new ContextSnapshotRepository(store);
+    }
+    directoryPath() {
+        return join(this.workspaceRoot, ".agents", "ACE", "agent-state", "context-snapshots");
+    }
+    async materializeAll() {
+        const dir = this.directoryPath();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const snapshots = await this.repo.listSnapshots();
+        const retained = new Set(["index.json"]);
+        for (const snapshot of snapshots) {
+            retained.add(snapshot.file);
+            writeText(join(dir, snapshot.file), `${JSON.stringify(snapshot.record, null, 2)}\n`);
+        }
+        writeText(join(dir, "index.json"), `${JSON.stringify({
+            snapshots: snapshots.map(({ name, file, timestamp, summary }) => ({
+                name,
+                file,
+                timestamp,
+                summary,
+            })),
+        }, null, 2)}\n`);
+        for (const file of readdirSync(dir)) {
+            if (!file.endsWith(".json"))
+                continue;
+            if (retained.has(file))
+                continue;
+            rmSync(join(dir, file), { force: true });
+        }
+    }
+}
+//# sourceMappingURL=context-snapshot-materializer.js.map

package/dist/store/materializers/host-file-materializer.d.ts

@@ -32,6 +32,12 @@ export declare class HostFileMaterializer {
     private buildVsCodeMcpEntry;
     private buildAllProjectedEntries;
     seedStorePayload(): Promise<void>;
+    /**
+     * Materialize the full MCP client config bundle to `.mcp-config/` at the workspace root.
+     * Writes one config file per supported client plus hook files and a README.
+     * Called by `ace preconfig`.
+     */
+    materializeMcpBundle(): Promise<string[]>;
     materializeAll(opts?: HostMaterializeOptions): Promise<string[]>;
 }
 //# sourceMappingURL=host-file-materializer.d.ts.map

package/dist/store/materializers/host-file-materializer.js

@@ -249,6 +249,19 @@ export class HostFileMaterializer {
             await this.seedProjectedText(entry);
         }
     }
+    /**
+     * Materialize the full MCP client config bundle to `.mcp-config/` at the workspace root.
+     * Writes one config file per supported client plus hook files and a README.
+     * Called by `ace preconfig`.
+     */
+    async materializeMcpBundle() {
+        await this.seedStorePayload();
+        const paths = [];
+        for (const entry of [...this.buildMcpBundleEntries(), ...this.buildOptionalHookBundleEntries()]) {
+            paths.push(await this.materializeEntry(entry));
+        }
+        return paths;
+    }
     async materializeAll(opts = {}) {
         const paths = [];
         const includeMcpConfig = opts.includeMcpConfig ?? false;

package/dist/store/materializers/projection-manager.d.ts

@@ -0,0 +1,14 @@
+import { AcePackedStore } from "../ace-packed-store.js";
+export type RuntimeProjectionTarget = "context_snapshots" | "handoffs" | "ledger" | "scheduler" | "status_events" | "todo_state" | "vericify_posts" | "hook_context";
+export declare class ProjectionManager {
+    private store;
+    private workspaceRoot;
+    private vericify;
+    private todoSyncer;
+    private hookContext;
+    private contextSnapshots;
+    private scheduler;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    projectAfterCommit(targets: readonly RuntimeProjectionTarget[]): Promise<void>;
+}
+//# sourceMappingURL=projection-manager.d.ts.map

package/dist/store/materializers/projection-manager.js

@@ -0,0 +1,73 @@
+import { ContextSnapshotMaterializer } from "./context-snapshot-materializer.js";
+import { HookContextMaterializer } from "./hook-context-materializer.js";
+import { SchedulerProjectionMaterializer } from "./scheduler-projection-materializer.js";
+import { TodoSyncer } from "./todo-syncer.js";
+import { VericifyProjector } from "./vericify-projector.js";
+export class ProjectionManager {
+    store;
+    workspaceRoot;
+    vericify;
+    todoSyncer;
+    hookContext;
+    contextSnapshots;
+    scheduler;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.vericify = new VericifyProjector(store, workspaceRoot);
+        this.todoSyncer = new TodoSyncer(store, workspaceRoot);
+        this.hookContext = new HookContextMaterializer(store, workspaceRoot);
+        this.contextSnapshots = new ContextSnapshotMaterializer(store, workspaceRoot);
+        this.scheduler = new SchedulerProjectionMaterializer(store, workspaceRoot);
+    }
+    async projectAfterCommit(targets) {
+        const uniqueTargets = [...new Set(targets)];
+        let stagedStoreWrites = false;
+        let renderedScheduler;
+        for (const target of uniqueTargets) {
+            if (target === "handoffs") {
+                await this.vericify.projectHandoffs();
+                stagedStoreWrites = true;
+            }
+            else if (target === "ledger") {
+                await this.vericify.projectLedger();
+                stagedStoreWrites = true;
+            }
+            else if (target === "status_events") {
+                await this.vericify.projectStatusEvents();
+                stagedStoreWrites = true;
+            }
+            else if (target === "todo_state") {
+                await this.vericify.projectTodos();
+                stagedStoreWrites = true;
+            }
+            else if (target === "vericify_posts") {
+                await this.vericify.projectVericifyPosts();
+                stagedStoreWrites = true;
+            }
+            else if (target === "scheduler") {
+                renderedScheduler = await this.scheduler.render();
+                await this.scheduler.stageStoreProjections(renderedScheduler);
+                stagedStoreWrites = true;
+            }
+        }
+        if (stagedStoreWrites) {
+            await this.store.commit();
+        }
+        for (const target of uniqueTargets) {
+            if (target === "todo_state") {
+                await this.todoSyncer.writeToFile();
+            }
+            else if (target === "hook_context") {
+                await this.hookContext.materialize();
+            }
+            else if (target === "context_snapshots") {
+                await this.contextSnapshots.materializeAll();
+            }
+            else if (target === "scheduler") {
+                await this.scheduler.materializeFiles(renderedScheduler);
+            }
+        }
+    }
+}
+//# sourceMappingURL=projection-manager.js.map

package/dist/store/materializers/scheduler-projection-materializer.d.ts

@@ -0,0 +1,16 @@
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class SchedulerProjectionMaterializer {
+    private store;
+    private workspaceRoot;
+    private repo;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    private filePath;
+    render(): Promise<{
+        queue: string;
+        locks: string;
+        lease: string;
+    }>;
+    stageStoreProjections(rendered?: Awaited<ReturnType<SchedulerProjectionMaterializer["render"]>>): Promise<void>;
+    materializeFiles(rendered?: Awaited<ReturnType<SchedulerProjectionMaterializer["render"]>>): Promise<void>;
+}
+//# sourceMappingURL=scheduler-projection-materializer.d.ts.map

package/dist/store/materializers/scheduler-projection-materializer.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { operationalArtifactKey } from "../store-artifacts.js";
+import { SchedulerRepository } from "../repositories/scheduler-repository.js";
+function writeText(path, content) {
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, path);
+}
+export class SchedulerProjectionMaterializer {
+    store;
+    workspaceRoot;
+    repo;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.repo = new SchedulerRepository(store);
+    }
+    filePath(file) {
+        return join(this.workspaceRoot, ".agents", "ACE", "agent-state", file);
+    }
+    async render() {
+        const queue = await this.repo.readQueue();
+        const locks = await this.repo.readLockTable();
+        const lease = await this.repo.readLease();
+        return {
+            queue: `${JSON.stringify(queue, null, 2)}\n`,
+            locks: `${JSON.stringify(locks, null, 2)}\n`,
+            lease: `${JSON.stringify(lease ?? null, null, 2)}\n`,
+        };
+    }
+    async stageStoreProjections(rendered) {
+        const content = rendered ?? (await this.render());
+        await this.store.setBlob(operationalArtifactKey("agent-state/job-queue.json"), content.queue);
+        await this.store.setBlob(operationalArtifactKey("agent-state/job-locks.json"), content.locks);
+        await this.store.setBlob(operationalArtifactKey("agent-state/scheduler-lease.json"), content.lease);
+    }
+    async materializeFiles(rendered) {
+        const content = rendered ?? (await this.render());
+        writeText(this.filePath("job-queue.json"), content.queue);
+        writeText(this.filePath("job-locks.json"), content.locks);
+        writeText(this.filePath("scheduler-lease.json"), content.lease);
+    }
+}
+//# sourceMappingURL=scheduler-projection-materializer.js.map

package/dist/store/repositories/context-snapshot-repository.d.ts

@@ -0,0 +1,46 @@
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface ContextSnapshotRecord {
+    name: string;
+    timestamp: string;
+    summary: string;
+    decisions: string[];
+    open_questions: string[];
+    artifacts: string[];
+    metadata: Record<string, unknown>;
+}
+export interface ContextSnapshotIndexEntry {
+    name: string;
+    file: string;
+    timestamp: string;
+    summary: string;
+}
+export interface SaveContextSnapshotInput {
+    name: string;
+    summary: string;
+    decisions?: string[];
+    open_questions?: string[];
+    artifacts?: string[];
+    metadata?: Record<string, unknown>;
+    timestamp?: string;
+}
+export declare class ContextSnapshotRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private snapshotKey;
+    getIndex(): Promise<ContextSnapshotIndexEntry[]>;
+    getSnapshotByFile(file: string): Promise<ContextSnapshotRecord | undefined>;
+    getSnapshotByName(name: string): Promise<{
+        entry: ContextSnapshotIndexEntry;
+        record: ContextSnapshotRecord;
+    } | undefined>;
+    saveSnapshot(input: SaveContextSnapshotInput): Promise<{
+        entry: ContextSnapshotIndexEntry;
+        record: ContextSnapshotRecord;
+        file: string;
+    }>;
+    listSnapshots(): Promise<Array<ContextSnapshotIndexEntry & {
+        record: ContextSnapshotRecord;
+    }>>;
+    private allocateFilename;
+}
+//# sourceMappingURL=context-snapshot-repository.d.ts.map

package/dist/store/repositories/context-snapshot-repository.js

@@ -0,0 +1,105 @@
+import { ContentSource, EntityKind } from "../types.js";
+const INDEX_KEY = "state/memory/context_snapshots/index.json";
+const SNAPSHOT_PREFIX = "state/memory/context_snapshots/";
+function uniqueStrings(values) {
+    return Array.from(new Set((values ?? []).filter((value) => typeof value === "string" && value.trim().length > 0)));
+}
+function slugify(name) {
+    const base = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+    return base.length > 0 ? base : "snapshot";
+}
+export class ContextSnapshotRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    snapshotKey(file) {
+        return `${SNAPSHOT_PREFIX}${file}`;
+    }
+    async getIndex() {
+        const index = await this.store.getJSON(INDEX_KEY);
+        if (Array.isArray(index))
+            return index;
+        return Array.isArray(index?.snapshots) ? index.snapshots : [];
+    }
+    async getSnapshotByFile(file) {
+        return this.store.getJSON(this.snapshotKey(file));
+    }
+    async getSnapshotByName(name) {
+        const index = await this.getIndex();
+        const entry = index.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase());
+        if (!entry)
+            return undefined;
+        const record = await this.getSnapshotByFile(entry.file);
+        if (!record)
+            return undefined;
+        return { entry, record };
+    }
+    async saveSnapshot(input) {
+        const index = await this.getIndex();
+        const timestamp = input.timestamp ?? new Date().toISOString();
+        const existing = index.find((candidate) => candidate.name.toLowerCase() === input.name.toLowerCase());
+        const file = existing?.file ?? this.allocateFilename(index, input.name);
+        const record = {
+            name: input.name,
+            timestamp,
+            summary: input.summary,
+            decisions: uniqueStrings(input.decisions),
+            open_questions: uniqueStrings(input.open_questions),
+            artifacts: uniqueStrings(input.artifacts),
+            metadata: input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata)
+                ? input.metadata
+                : {},
+        };
+        await this.store.setJSON(this.snapshotKey(file), record);
+        await this.store.appendEntry({
+            kind: EntityKind.ContextSnapshot,
+            content_source: ContentSource.Runtime,
+            key: this.snapshotKey(file),
+            payload: {
+                name: record.name,
+                file,
+                timestamp: record.timestamp,
+                summary: record.summary,
+            },
+        });
+        const nextIndex = index.filter((candidate) => candidate.name.toLowerCase() !== input.name.toLowerCase());
+        const entry = {
+            name: record.name,
+            file,
+            timestamp: record.timestamp,
+            summary: record.summary,
+        };
+        nextIndex.push(entry);
+        nextIndex.sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+        await this.store.setJSON(INDEX_KEY, { snapshots: nextIndex });
+        return { entry, record, file };
+    }
+    async listSnapshots() {
+        const index = await this.getIndex();
+        const rows = [];
+        for (const entry of index) {
+            const record = await this.getSnapshotByFile(entry.file);
+            if (!record)
+                continue;
+            rows.push({ ...entry, record });
+        }
+        return rows;
+    }
+    allocateFilename(index, name) {
+        const base = slugify(name);
+        const used = new Set(index.map((entry) => entry.file));
+        if (!used.has(`${base}.json`))
+            return `${base}.json`;
+        let suffix = 2;
+        while (used.has(`${base}-${suffix}.json`))
+            suffix += 1;
+        return `${base}-${suffix}.json`;
+    }
+}
+//# sourceMappingURL=context-snapshot-repository.js.map

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

@@ -0,0 +1,98 @@
+import { type AcePackedStore } from "../ace-packed-store.js";
+export interface AceSessionActivationLedger {
+    session_id: string;
+    created_at: number;
+    updated_at: number;
+    prompt_count: number;
+    shown_nudges: string[];
+    accepted_nudges: string[];
+    activated_tools: string[];
+    activated_roles: string[];
+    last_recommended_action?: string;
+}
+export interface AceSessionContinuityRecord {
+    session_id: string;
+    created_at: number;
+    updated_at: number;
+    workspace_root: string;
+    state_resolution_mode: "top_level" | "nested_projection" | "store_projection" | "missing";
+    last_role?: string;
+    last_preflight_state?: "ready" | "attention_required" | "blocked";
+    last_bridge_status?: "running" | "needs_input" | "approval_pending" | "retrying" | "blocked" | "failed" | "done";
+    active_tool?: string;
+    blockers: string[];
+    recent_decisions: string[];
+    recommended_next_action?: string;
+    evidence_refs: string[];
+}
+export interface AceRuntimeStatusPacket {
+    session_id: string;
+    process_id: number;
+    turn_count: number;
+    role?: string;
+    bridge_status: "running" | "needs_input" | "approval_pending" | "retrying" | "blocked" | "failed" | "done";
+    preflight_state: "ready" | "attention_required" | "blocked";
+    approval_state?: "not_required" | "pending" | "approved" | "rejected";
+    retry_state?: {
+        attempt: number;
+        max_attempts?: number;
+        backoff_ms?: number;
+        reason?: string;
+    };
+    poll_state?: {
+        active: boolean;
+        interval_ms?: number;
+        waiting_on?: string;
+    };
+    current_task?: string;
+    active_tool?: string;
+    active_tool_role?: string;
+    recommended_next_action?: string;
+    blocked_reason?: string;
+    tokens_in?: number;
+    tokens_out?: number;
+    updated_at: number;
+}
+export interface AceArchivedChatRecord {
+    session_id: string;
+    tab_id: string;
+    label: string;
+    provider: string;
+    model: string;
+    created_at: number;
+    archived_at: number;
+    last_active_at: number;
+    transcript_excerpt?: string;
+    transcript_summary?: string;
+    ace_context: {
+        resolved_layout_mode: string;
+        role?: string;
+        bridge_status: string;
+        active_tool?: string;
+        blocked_reason?: string;
+        approval_state?: string;
+        retry_state?: Record<string, unknown>;
+        recommended_next_action?: string;
+    };
+}
+export declare class LocalModelRuntimeRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private activationKey;
+    private continuityKey;
+    private statusKey;
+    private archiveKey;
+    getActivationLedger(sessionId: string): Promise<AceSessionActivationLedger | undefined>;
+    upsertActivationLedger(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">): Promise<AceSessionActivationLedger>;
+    getContinuityRecord(sessionId: string): Promise<AceSessionContinuityRecord | undefined>;
+    upsertContinuityRecord(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>;
+    listRuntimeStatuses(): Promise<AceRuntimeStatusPacket[]>;
+    archiveChat(input: Omit<AceArchivedChatRecord, "archived_at"> & Partial<Pick<AceArchivedChatRecord, "archived_at">>): Promise<AceArchivedChatRecord>;
+    listArchivedChats(): Promise<AceArchivedChatRecord[]>;
+    private addToIndex;
+    private appendLifecycleEntry;
+}
+export declare function withLocalModelRuntimeRepository<T>(workspaceRoot: string, fn: (repo: LocalModelRuntimeRepository) => Promise<T>): Promise<T | undefined>;
+//# sourceMappingURL=local-model-runtime-repository.d.ts.map

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

@@ -0,0 +1,165 @@
+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";
+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";
+function uniqueStrings(values) {
+    return Array.from(new Set((values ?? []).filter((value) => typeof value === "string" && value.length > 0)));
+}
+export class LocalModelRuntimeRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    activationKey(sessionId) {
+        return `state/ui/session_activation/${sessionId}`;
+    }
+    continuityKey(sessionId) {
+        return `state/runtime/session_continuity/${sessionId}`;
+    }
+    statusKey(sessionId) {
+        return `state/runtime/ui_status/${sessionId}`;
+    }
+    archiveKey(sessionId) {
+        return `state/ui/chat_archives/${sessionId}`;
+    }
+    async getActivationLedger(sessionId) {
+        return this.store.getJSON(this.activationKey(sessionId));
+    }
+    async upsertActivationLedger(input) {
+        const current = await this.getActivationLedger(input.session_id);
+        const now = Date.now();
+        const record = {
+            session_id: input.session_id,
+            created_at: current?.created_at ?? now,
+            updated_at: now,
+            prompt_count: input.prompt_count ?? current?.prompt_count ?? 0,
+            shown_nudges: uniqueStrings(input.shown_nudges ?? current?.shown_nudges ?? []),
+            accepted_nudges: uniqueStrings(input.accepted_nudges ?? current?.accepted_nudges ?? []),
+            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,
+        };
+        await this.store.setJSON(this.activationKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.activationKey(record.session_id), {
+            op: current ? "activation_update" : "activation_create",
+            session_id: record.session_id,
+        });
+        await this.addToIndex(ACTIVATION_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async getContinuityRecord(sessionId) {
+        return this.store.getJSON(this.continuityKey(sessionId));
+    }
+    async upsertContinuityRecord(input) {
+        const current = await this.getContinuityRecord(input.session_id);
+        const now = Date.now();
+        const record = {
+            ...input,
+            created_at: current?.created_at ?? input.created_at ?? now,
+            updated_at: now,
+            blockers: uniqueStrings(input.blockers ?? current?.blockers ?? []),
+            recent_decisions: uniqueStrings(input.recent_decisions ?? current?.recent_decisions ?? []),
+            evidence_refs: uniqueStrings(input.evidence_refs ?? current?.evidence_refs ?? []),
+        };
+        await this.store.setJSON(this.continuityKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.continuityKey(record.session_id), {
+            op: current ? "continuity_update" : "continuity_create",
+            session_id: record.session_id,
+            bridge_status: record.last_bridge_status,
+        });
+        await this.addToIndex(CONTINUITY_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async getRuntimeStatus(sessionId) {
+        return this.store.getJSON(this.statusKey(sessionId));
+    }
+    async upsertRuntimeStatus(input) {
+        const record = {
+            ...input,
+            updated_at: Date.now(),
+        };
+        await this.store.setJSON(this.statusKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.statusKey(record.session_id), {
+            op: "runtime_status",
+            session_id: record.session_id,
+            bridge_status: record.bridge_status,
+            preflight_state: record.preflight_state,
+        });
+        await this.addToIndex(STATUS_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async listRuntimeStatuses() {
+        const index = await this.store.getJSON(STATUS_INDEX_KEY) ?? [];
+        const statuses = [];
+        for (const sessionId of index) {
+            const record = await this.getRuntimeStatus(sessionId);
+            if (record)
+                statuses.push(record);
+        }
+        return statuses.sort((left, right) => right.updated_at - left.updated_at);
+    }
+    async archiveChat(input) {
+        const record = {
+            ...input,
+            archived_at: input.archived_at ?? Date.now(),
+        };
+        await this.store.setJSON(this.archiveKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.archiveKey(record.session_id), {
+            op: "chat_archive",
+            session_id: record.session_id,
+            tab_id: record.tab_id,
+            label: record.label,
+        });
+        await this.addToIndex(ARCHIVE_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async listArchivedChats() {
+        const index = await this.store.getJSON(ARCHIVE_INDEX_KEY) ?? [];
+        const archives = [];
+        for (const sessionId of index) {
+            const record = await this.store.getJSON(this.archiveKey(sessionId));
+            if (record)
+                archives.push(record);
+        }
+        return archives.sort((left, right) => right.archived_at - left.archived_at);
+    }
+    async addToIndex(indexKey, id) {
+        const index = await this.store.getJSON(indexKey) ?? [];
+        if (!index.includes(id)) {
+            index.push(id);
+            await this.store.setJSON(indexKey, index);
+        }
+    }
+    async appendLifecycleEntry(key, payload) {
+        await this.store.appendEntry({
+            kind: EntityKind.SessionEvent,
+            content_source: ContentSource.Runtime,
+            key,
+            payload: {
+                ...payload,
+                id: randomUUID(),
+            },
+        });
+    }
+}
+export async function withLocalModelRuntimeRepository(workspaceRoot, fn) {
+    const storePath = getWorkspaceStorePath(workspaceRoot);
+    return withStoreWriteQueue(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            const repo = new LocalModelRuntimeRepository(store);
+            const result = await fn(repo);
+            await store.commit();
+            return result;
+        }
+        finally {
+            await store.close();
+        }
+    });
+}
+//# sourceMappingURL=local-model-runtime-repository.js.map