context-mode 1.0.104 → 1.0.106

package/build/session/db.d.ts

@@ -148,6 +148,29 @@ export declare class SessionDB extends SQLiteBase {
      * Mark the resume snapshot as consumed (already injected into conversation).
      */
     markResumeConsumed(sessionId: string): void;
+    /**
+     * Atomically claim the most recent unconsumed resume snapshot in this DB,
+     * EXCLUDING any row that belongs to `currentSessionId`.
+     *
+     * `SessionDB` is sharded per project (see `getSessionDBPath` — SHA-256 of
+     * project dir), so "this DB" already implies "this project". The atomic
+     * `UPDATE … RETURNING` ensures concurrent processes for the same project
+     * cannot both inject the same snapshot (Mickey / PR #376 race).
+     *
+     * The `currentSessionId` parameter prevents self-injection: when a session
+     * compacts mid-flight and produces its own row, that session's next chat
+     * turn must NOT claim that row back (wasted tokens AND it would consume
+     * the snapshot meant for the next fresh session).
+     *
+     * Pass an empty string to allow self-claim (legacy behaviour, only useful
+     * in tests or one-off harnesses).
+     *
+     * Returns null when no unconsumed snapshot exists for any other session.
+     */
+    claimLatestUnconsumedResume(currentSessionId: string): {
+        sessionId: string;
+        snapshot: string;
+    } | null;
     /**
      * Return the most recent session_id from session_meta, or null if none.
      * Used by the runtime to attach persistent counters to the right session

package/build/session/db.js

@@ -87,6 +87,7 @@ const S = {
     upsertResume: "upsertResume",
     getResume: "getResume",
     markResumeConsumed: "markResumeConsumed",
+    claimLatestUnconsumedResume: "claimLatestUnconsumedResume",
     deleteEvents: "deleteEvents",
     deleteMeta: "deleteMeta",
     deleteResume: "deleteResume",
@@ -251,6 +252,25 @@ export class SessionDB extends SQLiteBase {
          consumed = 0`);
         p(S.getResume, `SELECT snapshot, event_count, consumed FROM session_resume WHERE session_id = ?`);
         p(S.markResumeConsumed, `UPDATE session_resume SET consumed = 1 WHERE session_id = ?`);
+        // Atomic "pick newest unconsumed snapshot AND mark it consumed in one
+        // statement". Required for race-safe cross-session resume injection
+        // (Mickey / PR #376) — two parallel chat-turn hooks must not both read
+        // the same row before either one writes consumed=1.
+        //
+        // The `session_id != ?` clause prevents self-injection (v1.0.106): when
+        // Session B compacts mid-flight and produces its own row, B's next chat
+        // turn must NOT claim that row back into its own prompt — that's wasted
+        // tokens and steals the snapshot meant for the next fresh session.
+        p(S.claimLatestUnconsumedResume, `UPDATE session_resume
+       SET consumed = 1
+       WHERE id = (
+         SELECT id FROM session_resume
+         WHERE consumed = 0
+           AND session_id != ?
+         ORDER BY created_at DESC, id DESC
+         LIMIT 1
+       )
+       RETURNING session_id, snapshot`);
         // ── Delete ──
         p(S.deleteEvents, `DELETE FROM session_events WHERE session_id = ?`);
         p(S.deleteMeta, `DELETE FROM session_meta WHERE session_id = ?`);
@@ -478,6 +498,31 @@ export class SessionDB extends SQLiteBase {
     markResumeConsumed(sessionId) {
         this.stmt(S.markResumeConsumed).run(sessionId);
     }
+    /**
+     * Atomically claim the most recent unconsumed resume snapshot in this DB,
+     * EXCLUDING any row that belongs to `currentSessionId`.
+     *
+     * `SessionDB` is sharded per project (see `getSessionDBPath` — SHA-256 of
+     * project dir), so "this DB" already implies "this project". The atomic
+     * `UPDATE … RETURNING` ensures concurrent processes for the same project
+     * cannot both inject the same snapshot (Mickey / PR #376 race).
+     *
+     * The `currentSessionId` parameter prevents self-injection: when a session
+     * compacts mid-flight and produces its own row, that session's next chat
+     * turn must NOT claim that row back (wasted tokens AND it would consume
+     * the snapshot meant for the next fresh session).
+     *
+     * Pass an empty string to allow self-claim (legacy behaviour, only useful
+     * in tests or one-off harnesses).
+     *
+     * Returns null when no unconsumed snapshot exists for any other session.
+     */
+    claimLatestUnconsumedResume(currentSessionId) {
+        const row = this.stmt(S.claimLatestUnconsumedResume).get(currentSessionId);
+        if (!row)
+            return null;
+        return { sessionId: row.session_id, snapshot: row.snapshot };
+    }
     /**
      * Return the most recent session_id from session_meta, or null if none.
      * Used by the runtime to attach persistent counters to the right session