@voybio/ace-swarm 0.1.0 → 0.2.1

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

@@ -5,7 +5,7 @@
  *
  * Replaces the old copyTree()-based bootstrap with:
  *   1. Create minimal directories
- *   2. Initialize AcePackedStore at .agents/ACE/ace-state.zarr
+ *   2. Initialize AcePackedStore at .agents/ACE/ace-state.ace
  *   3. Bake core knowledge (agents, modules, kernel)
  *   4. Write topology records
  *   5. Write initial runtime state seeds

package/dist/store/bootstrap-store.js

@@ -5,7 +5,7 @@
  *
  * Replaces the old copyTree()-based bootstrap with:
  *   1. Create minimal directories
- *   2. Initialize AcePackedStore at .agents/ACE/ace-state.zarr
+ *   2. Initialize AcePackedStore at .agents/ACE/ace-state.ace
  *   3. Bake core knowledge (agents, modules, kernel)
  *   4. Write topology records
  *   5. Write initial runtime state seeds
@@ -22,8 +22,8 @@ import { openStore } from "./ace-packed-store.js";
 import { bakeAllCoreKnowledge } from "./knowledge-bake.js";
 import { bakeTopology } from "./topology-bake.js";
 import { buildCatalog } from "./catalog-builder.js";
-import { HookContextMaterializer } from "./materializers/hook-context-materializer.js";
 import { HostFileMaterializer } from "./materializers/host-file-materializer.js";
+import { ProjectionManager } from "./materializers/projection-manager.js";
 import { TodoSyncer } from "./materializers/todo-syncer.js";
 import { OPERATIONAL_ARTIFACT_REL_PATHS, operationalArtifactKey, } from "./store-artifacts.js";
 import { STORE_VERSION } from "./types.js";
@@ -99,21 +99,31 @@ async function materializeStoreSurfaces(store, workspaceRoot, opts) {
             includeClientConfigBundle: opts.includeClientConfigBundle ?? false,
         })));
     }
-    const hookCtx = new HookContextMaterializer(store, workspaceRoot);
-    await hookCtx.materialize();
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "ace-hook-context.json"));
     const todoSyncer = new TodoSyncer(store, workspaceRoot);
     await todoSyncer.initStarter();
-    materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
     await store.commit();
+    const projections = new ProjectionManager(store, workspaceRoot);
+    await projections.projectAfterCommit(["hook_context", "todo_state", "scheduler", "context_snapshots"]);
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "ace-hook-context.json"));
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "tasks", "todo.md"));
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "job-queue.json"));
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "job-locks.json"));
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "scheduler-lease.json"));
+    materialized.push(join(workspaceRoot, ".agents", "ACE", "agent-state", "context-snapshots", "index.json"));
     return [...new Set(materialized)];
 }
+// Artifacts that receive live timestamp substitution on first seed.
+const TIMESTAMPED_ARTIFACT_RELS = new Set(["agent-state/STATUS.md", "agent-state/EVIDENCE_LOG.md"]);
 async function seedOperationalArtifacts(store) {
+    const bootstrapTs = new Date().toISOString();
     for (const relPath of OPERATIONAL_ARTIFACT_REL_PATHS) {
         const knowledgeKey = `knowledge/agent-state/${relPath.replace(/^agent-state\//, "")}`;
-        const content = relPath.endsWith("-archive.ndjson")
+        let content = relPath.endsWith("-archive.ndjson")
             ? ""
             : (await store.getBlob(knowledgeKey)) ?? "";
+        if (TIMESTAMPED_ARTIFACT_RELS.has(relPath) && content.includes("{{BOOTSTRAP_TIMESTAMP}}")) {
+            content = content.replaceAll("{{BOOTSTRAP_TIMESTAMP}}", bootstrapTs);
+        }
         await store.setBlob(operationalArtifactKey(relPath), content);
     }
 }
@@ -121,7 +131,7 @@ export async function bootstrapStoreWorkspace(opts) {
     const { workspaceRoot, force = false } = opts;
     const warnings = [];
     const materialized = [];
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
     if (existsSync(storePath) && !force) {
         if (!(opts.includeMcpConfig ?? false) && !(opts.includeClientConfigBundle ?? false) && !opts.llm) {
             warnings.push(`Store already exists at ${storePath}. Use --force to reinitialize, or run 'ace migrate' to import existing state.`);
@@ -168,6 +178,8 @@ export async function bootstrapStoreWorkspace(opts) {
         await store.setJSON("state/ledger/seq", 0);
         await store.setJSON("state/scheduler/queue", []);
         await store.setJSON("state/scheduler/locks", []);
+        await store.setJSON("state/scheduler/lease", null);
+        await store.setJSON("state/memory/context_snapshots/index.json", { snapshots: [] });
         await store.setJSON("state/runtime/sessions/index", []);
         await store.setJSON("state/discovery/index", []);
         await store.setJSON("state/vericify/posts/index", []);
@@ -194,7 +206,7 @@ export async function bootstrapStoreWorkspace(opts) {
 }
 // ── ace repair ────────────────────────────────────────────────────────────────
 export async function repairWorkspace(workspaceRoot) {
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
     if (!existsSync(storePath)) {
         return [`No store found at ${storePath}. Run 'ace init' first.`];
     }
@@ -208,10 +220,9 @@ export async function repairWorkspace(workspaceRoot) {
             includeMcpConfig: hostPolicy.include_mcp_config ?? false,
             includeClientConfigBundle: hostPolicy.include_client_config_bundle ?? false,
         });
-        // Re-materialize hook context
-        const hookCtx = new HookContextMaterializer(store, workspaceRoot);
-        await hookCtx.materialize();
         await store.commit();
+        const projections = new ProjectionManager(store, workspaceRoot);
+        await projections.projectAfterCommit(["hook_context", "todo_state", "scheduler", "context_snapshots"]);
     }
     catch (e) {
         warnings.push(`repair error: ${e.message}`);
@@ -223,7 +234,7 @@ export async function repairWorkspace(workspaceRoot) {
 }
 // ── ace compact ───────────────────────────────────────────────────────────────
 export async function compactWorkspace(workspaceRoot) {
-    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
     if (!existsSync(storePath)) {
         throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
     }

package/dist/store/catalog-builder.js

@@ -44,10 +44,10 @@ export async function buildCatalog(store) {
     return catalog;
 }
 function collectKeysByPrefix(store, prefix) {
-    // Access internal index synchronously — only call after store is opened
     const keys = [];
-    // @ts-ignore — accessing private index for catalog building
-    for (const key of store["index"].keys()) {
+    // @ts-ignore — accessing private kvIndex for synchronous catalog building
+    const kvIndex = store["kvIndex"];
+    for (const key of kvIndex.keys()) {
         if (key.startsWith(prefix))
             keys.push(key);
     }

package/dist/store/importer.d.ts

@@ -2,10 +2,10 @@
  * Importer — Phase 7
  *
  * Reads all current files from an existing ACE workspace and creates a new
- * ace-state.zarr with all content properly categorized.
+ * ace-state.ace with all content properly categorized.
  *
  * Used by `ace migrate` CLI command for one-time migration from file-backed
- * workspaces to the Zarrita-backed store.
+ * workspaces to the ACEPACK store.
  */
 export interface ImportResult {
     handoffs: number;

package/dist/store/importer.js

@@ -2,10 +2,10 @@
  * Importer — Phase 7
  *
  * Reads all current files from an existing ACE workspace and creates a new
- * ace-state.zarr with all content properly categorized.
+ * ace-state.ace with all content properly categorized.
  *
  * Used by `ace migrate` CLI command for one-time migration from file-backed
- * workspaces to the Zarrita-backed store.
+ * workspaces to the ACEPACK store.
  */
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";

package/dist/store/materializers/context-snapshot-materializer.d.ts

@@ -0,0 +1,10 @@
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class ContextSnapshotMaterializer {
+    private store;
+    private workspaceRoot;
+    private repo;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    private directoryPath;
+    materializeAll(): Promise<void>;
+}
+//# sourceMappingURL=context-snapshot-materializer.d.ts.map

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/hook-context-materializer.d.ts

@@ -5,7 +5,7 @@
  * Called at every session start, prompt submit, and tool gating change.
  *
  * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
- * It never touches the .zarr store directly.
+ * It never touches the .ace store directly.
  */
 import { AcePackedStore } from "../ace-packed-store.js";
 export declare class HookContextMaterializer {

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

@@ -5,7 +5,7 @@
  * Called at every session start, prompt submit, and tool gating change.
  *
  * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
- * It never touches the .zarr store directly.
+ * It never touches the .ace store directly.
  */
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { join, dirname } from "path";

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

@@ -216,7 +216,7 @@ export class HostFileMaterializer {
             fallbackContent: [
                 "# ACE MCP Client Config Bundle",
                 "",
-                `Generated for ${this.packageName}. Prefer global or user-level MCP installs; this bundle is stored in ace-state.zarr for export and repair.`,
+                `Generated for ${this.packageName}. Prefer global or user-level MCP installs; this bundle is stored in ace-state.ace for export and repair.`,
                 "",
                 "## Files",
                 ...ALL_MCP_CLIENTS.map((client) => `- ${client}: ${fileNames[client]}`),
@@ -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