@superblocksteam/vite-plugin-file-sync 1.99.99-next.3 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/ai-service/llm/context-v2/storage/event-store.d.ts

@@ -0,0 +1,83 @@
+/**
+ * EventStore interface for append-only event log storage.
+ *
+ * Defines the contract for persisting conversation events and
+ * reconstructing conversation history from the event log. The
+ * primary implementation is `JsonlEventStore`, which stores events
+ * as newline-delimited JSON in per-context `.jsonl` files.
+ */
+import type { ContextId, StoredMessage } from "../types.js";
+import type { EventLogEntry } from "./event-types.js";
+/**
+ * Append-only event log store for conversation history.
+ *
+ * Events are written one at a time via `appendEvent`. Message history
+ * is reconstructed via `loadMessages`, which scans backward for the
+ * last compaction event and reads forward from that point.
+ *
+ * All operations are keyed by {@link ContextId}. Log identity is
+ * `{appId, name}` — the reasoning context is app-scoped, so every editor
+ * of an application shares one log per context name. (The JSONL
+ * implementation derives only `name` from the id; app scoping comes from
+ * the store's per-app root directory.)
+ */
+export interface EventStore {
+    /**
+     * Append a single event to the log for the given context.
+     *
+     * Writes are atomic at the line level -- each call appends exactly
+     * one JSON line to the underlying storage.
+     *
+     * `opts.shouldAbort` is checked at the last possible moment before
+     * the file write -- after any directory-creation step but with no
+     * further `await` before the write itself. This lets a caller whose
+     * validity can be revoked mid-write (e.g. a shared context that gets
+     * disposed while this call is in flight) abort instead of writing
+     * into a log that a concurrent clear just emptied.
+     */
+    appendEvent(id: ContextId, event: EventLogEntry, opts?: {
+        shouldAbort?: () => boolean;
+    }): Promise<void>;
+    /**
+     * Load conversation messages by scanning backward for the last
+     * compaction event, then reading forward from that point.
+     *
+     * Returns `StoredMessage[]` (not raw events) because consumers need
+     * the AI SDK `ModelMessage` shape with `_superblocks` metadata. If
+     * no compaction event exists, all events are included. If the file
+     * does not exist or is empty, returns an empty array.
+     */
+    loadMessages(id: ContextId): Promise<StoredMessage[]>;
+    /**
+     * Check whether any events exist for the given context.
+     */
+    hasEvents(id: ContextId): Promise<boolean>;
+    /**
+     * Drop every event whose `timestamp` is strictly greater than
+     * `sinceTimestamp`, keeping the prefix of the append-only log that
+     * existed at or before that moment. Used by checkpoint restore to roll a
+     * conversation back to a commit's point in time from the local log alone,
+     * without trusting a remote archive that a later flush may have overwritten.
+     *
+     * Filters per-entry by the entry's own `timestamp` (not by file position),
+     * so an out-of-order or corrupted line cannot drag newer history back in.
+     * Unparseable lines are kept: their timestamp is unknown, and discarding
+     * one could remove a compaction anchor and unbound the loaded window.
+     *
+     * Returns the number of events dropped. Missing or empty logs return 0 and
+     * leave the file untouched.
+     */
+    truncateAfterTimestamp(id: ContextId, sinceTimestamp: number): Promise<number>;
+    /**
+     * Remove the event log for a single context. Idempotent: returns
+     * normally when no log exists.
+     */
+    deleteEvents(id: ContextId): Promise<void>;
+    /**
+     * Remove the entire event log tree on this store. Used by
+     * "new chat"/clear-all flows so prior conversations cannot be
+     * silently reloaded from disk.
+     */
+    deleteAllEvents(): Promise<void>;
+}
+//# sourceMappingURL=event-store.d.ts.map

package/dist/ai-service/llm/context-v2/storage/event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;OAYG;IACH,WAAW,CACT,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;;;;;;OAQG;IACH,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAEtD;;OAEG;IACH,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;OAcG;IACH,sBAAsB,CACpB,EAAE,EAAE,SAAS,EACb,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC,CAAC;IAEnB;;;OAGG;IACH,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;OAIG;IACH,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC"}

package/dist/ai-service/llm/context-v2/storage/event-store.js

@@ -0,0 +1,10 @@
+/**
+ * EventStore interface for append-only event log storage.
+ *
+ * Defines the contract for persisting conversation events and
+ * reconstructing conversation history from the event log. The
+ * primary implementation is `JsonlEventStore`, which stores events
+ * as newline-delimited JSON in per-context `.jsonl` files.
+ */
+export {};
+//# sourceMappingURL=event-store.js.map

package/dist/ai-service/llm/context-v2/storage/event-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/ai-service/llm/context-v2/storage/event-types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Event type definitions for the JSONL event log.
+ *
+ * Events are appended to per-app JSONL files as an append-only log.
+ * Each line represents a single event (prompt sent, response received,
+ * or compaction received). The event log replaces full-context JSON
+ * blob storage with an incremental, corruption-tolerant format.
+ */
+import type { SuperblocksMetadata } from "../types.js";
+/**
+ * Discriminator for event log entries.
+ *
+ * - `prompt_sent`: A user prompt was sent to the LLM.
+ * - `response_received`: An assistant response was received from the LLM.
+ * - `compaction_received`: A compaction replaced earlier history — either a
+ *   server-side compaction summary or the anchor marker written before a
+ *   client-side phase-1 compaction window.
+ */
+export type EventType = "prompt_sent" | "response_received" | "compaction_received";
+/**
+ * Content of the `compaction_received` marker written before a client-side
+ * phase-1 compaction window. The marker is the replay anchor that
+ * `JsonlEventStore.loadMessages` scans back to; phase-2 windows do not need
+ * it because their first message carries `isSummary`.
+ */
+export declare const CLIENT_COMPACTION_MARKER = "Client-side compaction applied";
+/**
+ * Message role aligned with AI SDK's `ModelMessage` role literals.
+ */
+export type MessageRole = "user" | "assistant" | "tool" | "system";
+/**
+ * A single entry in the JSONL event log.
+ *
+ * Each entry captures a conversation turn with enough metadata to
+ * reconstruct `StoredMessage[]` for the AI SDK. The `_superblocks`
+ * field preserves round-trip metadata (token counts, summary flags)
+ * through the storage layer.
+ */
+export interface EventLogEntry {
+    /** Event discriminator. */
+    readonly type: EventType;
+    /** Unix epoch milliseconds when this event occurred. */
+    readonly timestamp: number;
+    /** Message role matching AI SDK `ModelMessage` role literals. */
+    readonly role: MessageRole;
+    /** Message content -- string, array of content parts, or other AI SDK content shapes. */
+    readonly content: unknown;
+    /** Token usage for this turn (typically set on response_received events). */
+    readonly usage?: {
+        readonly input: number;
+        readonly output: number;
+        readonly cacheRead: number;
+    };
+    /** Provider-specific metadata passed through from the AI SDK. */
+    readonly providerMetadata?: Record<string, unknown>;
+    /** Superblocks metadata preserved through storage round-trip (isSummary, tokenCount, etc.). */
+    readonly _superblocks?: SuperblocksMetadata;
+}
+//# sourceMappingURL=event-types.d.ts.map

package/dist/ai-service/llm/context-v2/storage/event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB,aAAa,GACb,mBAAmB,GACnB,qBAAqB,CAAC;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,mCAAmC,CAAC;AAEzE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,iEAAiE;IACjE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpD,+FAA+F;IAC/F,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;CAC7C"}

package/dist/ai-service/llm/context-v2/storage/event-types.js

@@ -0,0 +1,16 @@
+/**
+ * Event type definitions for the JSONL event log.
+ *
+ * Events are appended to per-app JSONL files as an append-only log.
+ * Each line represents a single event (prompt sent, response received,
+ * or compaction received). The event log replaces full-context JSON
+ * blob storage with an incremental, corruption-tolerant format.
+ */
+/**
+ * Content of the `compaction_received` marker written before a client-side
+ * phase-1 compaction window. The marker is the replay anchor that
+ * `JsonlEventStore.loadMessages` scans back to; phase-2 windows do not need
+ * it because their first message carries `isSummary`.
+ */
+export const CLIENT_COMPACTION_MARKER = "Client-side compaction applied";
+//# sourceMappingURL=event-types.js.map

package/dist/ai-service/llm/context-v2/storage/event-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-types.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/event-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,gCAAgC,CAAC"}

package/dist/ai-service/llm/context-v2/storage/index.d.ts

@@ -0,0 +1,14 @@
+import type { ContextRecordV2 } from "../types.js";
+import type { ContextId } from "./types.js";
+export interface ContextStorageV2 {
+    saveContext(id: ContextId, context: ContextRecordV2): Promise<void>;
+    /**
+     * Load a context record from storage.
+     * Returns unknown because the stored format may be any version.
+     * The migration system handles version detection and migration.
+     */
+    loadContext(id: ContextId): Promise<unknown | null>;
+    deleteContext(id: ContextId): Promise<void>;
+    deleteAllContexts(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/ai-service/llm/context-v2/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IACpD,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC"}

package/dist/ai-service/llm/context-v2/storage/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/ai-service/llm/context-v2/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/index.ts"],"names":[],"mappings":""}

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.d.ts

@@ -0,0 +1,108 @@
+/**
+ * JSONL file-based EventStore implementation.
+ *
+ * Stores conversation events as newline-delimited JSON in per-context
+ * `.jsonl` files under
+ * `{rootDir}/.superblocks/events/shared/{name}.jsonl`.
+ *
+ * The path is rooted under the fixed `SHARED_CONTEXT_SEGMENT` (`shared`)
+ * segment: the reasoning context is intentionally shared by every editor
+ * of the app, not partitioned per user. Only the `name` segment is
+ * derived from the `ContextId`, and it is `encodeContextPathSegment`-encoded
+ * before being joined into the path via `safeJoinUnderRoot`, which guards
+ * against `..`, `/`, or other path-control characters escaping the
+ * `events/` root via path traversal.
+ *
+ * Writes are append-only (one `appendFile` call per event). Reads
+ * scan backward for the most recent compaction anchor, then return
+ * messages from that point forward. Corrupted lines (invalid JSON)
+ * are skipped with a warning log, making the format tolerant to
+ * partial writes or manual edits.
+ */
+import type { ContextId, StoredMessage } from "../types.js";
+import type { EventStore } from "./event-store.js";
+import type { EventLogEntry } from "./event-types.js";
+/**
+ * Append-only JSONL event store backed by the local filesystem.
+ *
+ * Each app's events are stored in a single `.jsonl` file. The file
+ * path mirrors the existing `.superblocks/` convention used by
+ * `LocalContextStorageV2` but under an `events/` subdirectory.
+ */
+export declare class JsonlEventStore implements EventStore {
+    private readonly rootDir;
+    private static readonly SUPERBLOCKS_SYSTEM_DIR;
+    private static readonly EVENTS_SUBDIR;
+    constructor(rootDir: string);
+    /**
+     * Append a single event to the log for the given context.
+     *
+     * Creates parent directories if they do not exist. Each call
+     * writes exactly one JSON line terminated by `\n`.
+     *
+     * `opts.shouldAbort` is re-checked here, between the `mkdir` and the
+     * `appendFile`, with no `await` in between: a concurrent clear can
+     * finish inside the gap opened by the `mkdir` await above, and this
+     * is the last point before the write where that can be caught. An
+     * empty recreated directory from the `mkdir` is harmless -- there is
+     * no file yet, so `loadMessages` on a missing file returns `[]` and
+     * no anchor exists.
+     */
+    appendEvent(id: ContextId, event: EventLogEntry, opts?: {
+        shouldAbort?: () => boolean;
+    }): Promise<void>;
+    /**
+     * Check whether any events exist for the given context.
+     */
+    hasEvents(id: ContextId): Promise<boolean>;
+    /**
+     * Remove the event log for a single context. Missing files are
+     * treated as success so callers can use this as a fire-and-forget
+     * cleanup step.
+     */
+    deleteEvents(id: ContextId): Promise<void>;
+    /**
+     * Drop every event newer than `sinceTimestamp`, keeping the prefix that
+     * existed at or before the checkpoint. See {@link EventStore.truncateAfterTimestamp}.
+     *
+     * Kept lines are written back verbatim (not re-serialized) so metadata this
+     * store does not model is never lost. The rewrite is atomic — a temp file in
+     * the same directory plus `rename` — so a process kill mid-write (an OOM/pod
+     * eviction on this live dev-server pod) can never leave the log empty or
+     * half-written and silently lose the whole conversation.
+     */
+    truncateAfterTimestamp(id: ContextId, sinceTimestamp: number): Promise<number>;
+    /**
+     * Remove the entire `.superblocks/events/` tree under `rootDir`.
+     *
+     * Used by clear-all flows so a subsequent `getOrCreateContext` does
+     * not silently restore a "deleted" conversation from disk.
+     */
+    deleteAllEvents(): Promise<void>;
+    /**
+     * Load conversation messages by scanning backward for the last
+     * compaction anchor, then reading forward from that point.
+     *
+     * A compaction anchor is either:
+     * - An event with `type === "compaction_received"`
+     * - An event with `_superblocks.isSummary === true` (migration seed)
+     *
+     * Each `EventLogEntry` is mapped to a `StoredMessage` so that
+     * consumers receive the AI SDK `ModelMessage` shape.
+     */
+    loadMessages(id: ContextId): Promise<StoredMessage[]>;
+    /**
+     * Map an EventLogEntry to a StoredMessage (AI SDK ModelMessage shape).
+     *
+     * The cast is required at this JSON deserialization boundary: `content`
+     * is stored as `unknown` because AI SDK content shapes are polymorphic
+     * (string, content part arrays, tool results). The role is type-safe
+     * via `MessageRole`, but TypeScript cannot narrow the discriminated
+     * union without runtime content validation — which would be fragile
+     * against SDK version changes.
+     */
+    private toStoredMessage;
+    private getEventsRoot;
+    private getFilePath;
+}
+//# sourceMappingURL=jsonl-event-store.d.ts.map

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-event-store.d.ts","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/jsonl-event-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,kBAAkB,CAAC;AAInE;;;;;;GAMG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAIpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAkB;IAChE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAY;gBAEpB,OAAO,EAAE,MAAM;IAE5C;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,EAAE,EAAE,SAAS,EACb,KAAK,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;KAAE,GACrC,OAAO,CAAC,IAAI,CAAC;IAOhB;;OAEG;IACG,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAYhD;;;;OAIG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD;;;;;;;;;OASG;IACG,sBAAsB,CAC1B,EAAE,EAAE,SAAS,EACb,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAmElB;;;;;OAKG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAItC;;;;;;;;;;OAUG;IACG,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAwE3D;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;IAcvB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,WAAW;CAQpB"}

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.js

@@ -0,0 +1,267 @@
+/**
+ * JSONL file-based EventStore implementation.
+ *
+ * Stores conversation events as newline-delimited JSON in per-context
+ * `.jsonl` files under
+ * `{rootDir}/.superblocks/events/shared/{name}.jsonl`.
+ *
+ * The path is rooted under the fixed `SHARED_CONTEXT_SEGMENT` (`shared`)
+ * segment: the reasoning context is intentionally shared by every editor
+ * of the app, not partitioned per user. Only the `name` segment is
+ * derived from the `ContextId`, and it is `encodeContextPathSegment`-encoded
+ * before being joined into the path via `safeJoinUnderRoot`, which guards
+ * against `..`, `/`, or other path-control characters escaping the
+ * `events/` root via path traversal.
+ *
+ * Writes are append-only (one `appendFile` call per event). Reads
+ * scan backward for the most recent compaction anchor, then return
+ * messages from that point forward. Corrupted lines (invalid JSON)
+ * are skipped with a warning log, making the format tolerant to
+ * partial writes or manual edits.
+ */
+import { readFile, appendFile, mkdir, rename, rm, writeFile, } from "node:fs/promises";
+import * as path from "node:path";
+import { getPrefixedLogger } from "../../../../util/logger.js";
+import { encodeContextPathSegment, safeJoinUnderRoot, SHARED_CONTEXT_SEGMENT, } from "../../../context-archive-paths.js";
+const logger = getPrefixedLogger("[jsonl-event-store]");
+/**
+ * Append-only JSONL event store backed by the local filesystem.
+ *
+ * Each app's events are stored in a single `.jsonl` file. The file
+ * path mirrors the existing `.superblocks/` convention used by
+ * `LocalContextStorageV2` but under an `events/` subdirectory.
+ */
+export class JsonlEventStore {
+    rootDir;
+    static SUPERBLOCKS_SYSTEM_DIR = ".superblocks";
+    static EVENTS_SUBDIR = "events";
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    /**
+     * Append a single event to the log for the given context.
+     *
+     * Creates parent directories if they do not exist. Each call
+     * writes exactly one JSON line terminated by `\n`.
+     *
+     * `opts.shouldAbort` is re-checked here, between the `mkdir` and the
+     * `appendFile`, with no `await` in between: a concurrent clear can
+     * finish inside the gap opened by the `mkdir` await above, and this
+     * is the last point before the write where that can be caught. An
+     * empty recreated directory from the `mkdir` is harmless -- there is
+     * no file yet, so `loadMessages` on a missing file returns `[]` and
+     * no anchor exists.
+     */
+    async appendEvent(id, event, opts) {
+        const filePath = this.getFilePath(id);
+        await mkdir(path.dirname(filePath), { recursive: true });
+        if (opts?.shouldAbort?.())
+            return;
+        await appendFile(filePath, JSON.stringify(event) + "\n");
+    }
+    /**
+     * Check whether any events exist for the given context.
+     */
+    async hasEvents(id) {
+        try {
+            const content = await readFile(this.getFilePath(id), "utf-8");
+            return content.trimEnd().length > 0;
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return false;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Remove the event log for a single context. Missing files are
+     * treated as success so callers can use this as a fire-and-forget
+     * cleanup step.
+     */
+    async deleteEvents(id) {
+        await rm(this.getFilePath(id), { force: true });
+    }
+    /**
+     * Drop every event newer than `sinceTimestamp`, keeping the prefix that
+     * existed at or before the checkpoint. See {@link EventStore.truncateAfterTimestamp}.
+     *
+     * Kept lines are written back verbatim (not re-serialized) so metadata this
+     * store does not model is never lost. The rewrite is atomic — a temp file in
+     * the same directory plus `rename` — so a process kill mid-write (an OOM/pod
+     * eviction on this live dev-server pod) can never leave the log empty or
+     * half-written and silently lose the whole conversation.
+     */
+    async truncateAfterTimestamp(id, sinceTimestamp) {
+        const filePath = this.getFilePath(id);
+        let raw;
+        try {
+            raw = await readFile(filePath, "utf-8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return 0;
+            }
+            throw err;
+        }
+        const contextLabel = `${id.appId}/${id.userId}/${id.name}`;
+        const lines = raw.split("\n").filter((line) => line.length > 0);
+        const kept = [];
+        let dropped = 0;
+        for (const line of lines) {
+            let timestamp;
+            try {
+                timestamp = JSON.parse(line).timestamp;
+            }
+            catch {
+                // Unparseable line: keep it (its timestamp is unknown, and dropping a
+                // line that might be a compaction anchor could unbound a later load).
+                // Mirror loadMessages' policy of warning on corruption without logging
+                // the raw payload, which can hold user prompts or tool results.
+                logger.warn(`Keeping a corrupted JSONL line during truncation for context '${contextLabel}' (length=${line.length}); its timestamp is unknown`);
+                kept.push(line);
+                continue;
+            }
+            if (typeof timestamp !== "number") {
+                // Parseable but no usable timestamp — cannot decide if it is newer than
+                // the checkpoint, so keep it. Warn: every appended EventLogEntry carries
+                // a numeric timestamp, so a missing one signals a malformed write.
+                logger.warn(`Keeping an event with no numeric timestamp during truncation for context '${contextLabel}'`);
+                kept.push(line);
+                continue;
+            }
+            if (timestamp > sinceTimestamp) {
+                dropped++;
+            }
+            else {
+                kept.push(line);
+            }
+        }
+        if (dropped === 0) {
+            return 0;
+        }
+        // Atomic rewrite: write the kept prefix to a sibling temp file, then rename
+        // over the original. rename(2) is atomic within a filesystem, so a crash
+        // leaves either the old file or the fully-written new one — never a partial.
+        const next = kept.length > 0 ? kept.join("\n") + "\n" : "";
+        const tmpPath = `${filePath}.tmp`;
+        await writeFile(tmpPath, next);
+        try {
+            await rename(tmpPath, filePath);
+        }
+        catch (err) {
+            await rm(tmpPath, { force: true }).catch(() => { });
+            throw err;
+        }
+        return dropped;
+    }
+    /**
+     * Remove the entire `.superblocks/events/` tree under `rootDir`.
+     *
+     * Used by clear-all flows so a subsequent `getOrCreateContext` does
+     * not silently restore a "deleted" conversation from disk.
+     */
+    async deleteAllEvents() {
+        await rm(this.getEventsRoot(), { recursive: true, force: true });
+    }
+    /**
+     * Load conversation messages by scanning backward for the last
+     * compaction anchor, then reading forward from that point.
+     *
+     * A compaction anchor is either:
+     * - An event with `type === "compaction_received"`
+     * - An event with `_superblocks.isSummary === true` (migration seed)
+     *
+     * Each `EventLogEntry` is mapped to a `StoredMessage` so that
+     * consumers receive the AI SDK `ModelMessage` shape.
+     */
+    async loadMessages(id) {
+        const filePath = this.getFilePath(id);
+        let raw;
+        try {
+            raw = await readFile(filePath, "utf-8");
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return [];
+            }
+            throw err;
+        }
+        const lines = raw.split("\n").filter((line) => line.length > 0);
+        if (lines.length === 0) {
+            return [];
+        }
+        // Parse each line, skipping corrupted entries. A corrupted line could
+        // be the compaction anchor itself; if that happens the backward scan
+        // below will overshoot and return more history than intended, so we
+        // log loudly enough that the discrepancy is investigable.
+        //
+        // The raw line payload is intentionally NOT logged: even a partial
+        // JSONL fragment can contain user prompts or tool results, and those
+        // would otherwise leak into log sinks that don't share the event
+        // store's privacy boundary. Length is enough to debug truncation
+        // patterns without spilling content.
+        const contextLabel = `${id.appId}/${id.name}`;
+        const events = [];
+        let corruptedCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                corruptedCount++;
+                logger.warn(`Skipping corrupted JSONL line ${i} for context '${contextLabel}' (length=${line.length})`);
+            }
+        }
+        if (corruptedCount > 0) {
+            logger.warn(`Encountered ${corruptedCount} corrupted line(s) in event log for context '${contextLabel}'; if any held a compaction anchor the loaded window may extend further back than expected.`);
+        }
+        // Backward scan: find the last compaction anchor
+        let anchorIndex = -1;
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            if (event.type === "compaction_received" ||
+                event._superblocks?.isSummary === true) {
+                anchorIndex = i;
+                break;
+            }
+        }
+        if (anchorIndex < 0 && corruptedCount > 0) {
+            logger.error(`No compaction anchor found for context '${contextLabel}' but ${corruptedCount} corrupted line(s) were skipped; the loaded conversation window may be unbounded.`);
+        }
+        const window = anchorIndex >= 0 ? events.slice(anchorIndex) : events;
+        return window.map((event) => this.toStoredMessage(event));
+    }
+    /**
+     * Map an EventLogEntry to a StoredMessage (AI SDK ModelMessage shape).
+     *
+     * The cast is required at this JSON deserialization boundary: `content`
+     * is stored as `unknown` because AI SDK content shapes are polymorphic
+     * (string, content part arrays, tool results). The role is type-safe
+     * via `MessageRole`, but TypeScript cannot narrow the discriminated
+     * union without runtime content validation — which would be fragile
+     * against SDK version changes.
+     */
+    toStoredMessage(event) {
+        return {
+            role: event.role,
+            content: event.content,
+            ...(event.providerMetadata && {
+                providerMetadata: event.providerMetadata,
+            }),
+            _superblocks: {
+                timestamp: event.timestamp,
+                ...event._superblocks,
+            },
+        };
+    }
+    getEventsRoot() {
+        return path.join(this.rootDir, JsonlEventStore.SUPERBLOCKS_SYSTEM_DIR, JsonlEventStore.EVENTS_SUBDIR);
+    }
+    getFilePath(id) {
+        const root = this.getEventsRoot();
+        return safeJoinUnderRoot(root, SHARED_CONTEXT_SEGMENT, `${encodeContextPathSegment(id.name, "name")}.jsonl`);
+    }
+}
+//# sourceMappingURL=jsonl-event-store.js.map

package/dist/ai-service/llm/context-v2/storage/jsonl-event-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-event-store.js","sourceRoot":"","sources":["../../../../../src/ai-service/llm/context-v2/storage/jsonl-event-store.ts"],"names":[],"mappings":"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"}

package/dist/ai-service/llm/context-v2/storage/legacy-context-adoption.d.ts

@@ -0,0 +1,46 @@
+/**
+ * One-time adoption of pre-app-scoping per-user ContextV2 directories.
+ *
+ * Before the app-scoped layout, each editor's context lived under
+ * `.superblocks/context/{userId}/` (event logs under
+ * `.superblocks/events/{userId}/`). Warm-pool S3 restore and PVC reuse can
+ * put those directories on disk under code that only reads the `shared/`
+ * segment, which would silently drop uncommitted conversations at the
+ * deploy boundary.
+ *
+ * Policy:
+ * - If `context/shared/` does not exist, move the most recently modified
+ *   per-user context dir (and that same user's event logs) into `shared/`.
+ * - If `context/shared/` already exists and no adoption pass is in flight
+ *   (no intent marker), adopt nothing from either tree — not even a
+ *   still-missing `events/shared/` — because the event log is replayed
+ *   before the context snapshot on load, and grafting a stale per-user
+ *   event log onto a live shared context would resurrect old conversation
+ *   content for every editor.
+ * - Delete every remaining per-user directory afterward. The deletion is
+ *   the tombstone: a re-fire after a New Chat clear would resurrect a
+ *   cleared conversation, and a rollback should read the committed remote
+ *   rather than stale local state.
+ * - Collapsing N per-user threads into one shared thread is lossy by
+ *   design: latest-modified wins, matching the app-scoped product model.
+ * - The winner is moved BEFORE losers are deleted, so a crash mid-pass
+ *   only leaves cleanup for the next run to finish.
+ *
+ * Crash safety: the picked winner is pinned in an intent marker
+ * (`INTENT_MARKER_FILE`, written directly under `context/`) BEFORE any
+ * rename. Each tree
+ * (context, events) is then adopted with a single whole-directory rename
+ * from the winner's per-user dir straight to its own `shared/` — no
+ * per-file loop, so `shared/` is never partially populated. The marker is
+ * removed only after both renames and the legacy-dir cleanup finished, and
+ * a pass that finds a marker resumes with the recorded winner instead of
+ * treating `context/shared/`'s existence as proof the pass completed. A
+ * crash between the two renames therefore can neither delete the winner's
+ * still-unadopted event log nor pair one user's snapshot with a different
+ * user's event log on the retry. A torn marker write can only happen
+ * before any rename ran, so an unreadable marker safely degrades to the
+ * fresh-pass logic. Without a marker, an existing `context/shared/` wins
+ * wholesale, whatever its age, and nothing is adopted.
+ */
+export declare function adoptLegacyPerUserContextDirs(rootDir: string): Promise<void>;
+//# sourceMappingURL=legacy-context-adoption.d.ts.map