@gaunt-sloth/core 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/history/recordSession.d.ts

@@ -1,25 +1,20 @@
 /**
  * @packageDocumentation
- * GS2-7 (B20) — the opt-in bridge from a finished run to the {@link HistoryStore}.
+ * GS2-7 (B20) — the bridge from a finished run to the {@link HistoryStore}.
  *
- * {@link recordSessionSafe} is the ONE entry point the run path calls. It is a no-op unless
- * `history.enabled` is true, and it swallows every error, so:
- * - a **default run** (history absent/false) opens nothing, writes nothing, and behaves exactly
- *   as before — the stateless identity is preserved; and
- * - even with history **on**, a DB problem (locked/corrupt/read-only fs) can never abort or alter
+ * {@link recordSessionSafe} is the ONE entry point the run path calls. It writes unless
+ * `history.enabled` is `false`, and it swallows every error, so:
+ * - a **default run** records its turns locally, under the user's own `~/.gsloth` dir, and
+ *   `history.enabled: false` is the opt-out that restores the stateless identity; and
+ * - with history on, a DB problem (locked/corrupt/read-only fs) can never abort or alter
  *   the run: the worst case is that one session isn't recorded.
  */
-import type { ConversationMeta, SessionRecord } from '#src/history/historyStore.js';
-/** The subset of the resolved config the recorder reads (structural, to avoid a hard type dep). */
-export interface HistoryConfigView {
-    history?: {
-        enabled?: boolean;
-        dbPath?: string;
-    };
-}
+import type { ConversationMeta, ConversationSummary, SessionRecord } from '#src/history/historyStore.js';
+export type { HistoryConfigView } from '#src/history/historyEnabled.js';
+import type { HistoryConfigView } from '#src/history/historyEnabled.js';
 /**
- * Record one finished session IFF `history.enabled` is true. Returns the new row id, or `null`
- * when history is disabled or anything went wrong (both are non-events for the caller).
+ * Record one finished session unless `history.enabled` is `false`. Returns the new row id, or
+ * `null` when history is turned off or anything went wrong (both are non-events for the caller).
  *
  * Deliberately fully guarded: opening the store, ensuring the global dir, and the insert all run
  * behind a single try/catch, and the store itself is fail-soft. Callers put this in a `finally`
@@ -27,11 +22,78 @@ export interface HistoryConfigView {
  */
 export declare function recordSessionSafe(config: HistoryConfigView, record: SessionRecord): number | null;
 /**
- * GS2-19 — open one conversation for an interactive session IFF `history.enabled`, returning its id
- * (or `null` when disabled / anything failed). The session passes that id on every
- * {@link recordSessionSafe} so all its turns group under one conversation. Same guarantees as the
- * recorder: a no-op by default, fully fail-soft, never throws. When it returns `null` under an
- * enabled store (a rare open failure), turns simply fall back to per-turn 1-turn conversations —
- * grouping is lost but nothing is dropped or crashed.
+ * GS2-19 — open one conversation for an interactive session unless `history.enabled` is `false`,
+ * returning its id (or `null` when turned off / anything failed). The session passes that id on
+ * every {@link recordSessionSafe} so all its turns group under one conversation. Same guarantees as
+ * the recorder: fully fail-soft, never throws. When it returns `null` under an enabled store (a
+ * rare open failure), turns simply fall back to per-turn 1-turn conversations — grouping is lost
+ * but nothing is dropped or crashed.
+ *
+ * GS2-20 — `meta.threadId` is what makes the conversation resumable: it names the LangGraph thread
+ * whose durable checkpoint holds the session's graph state.
  */
 export declare function openConversationSafe(config: HistoryConfigView, meta: ConversationMeta): number | null;
+/**
+ * GS2-20 — record, ON DISK, that a conversation can no longer be resumed, by clearing its thread
+ * link. Called once per session, the first time a checkpoint write fails after the store opened.
+ *
+ * The session itself keeps running and the user is told; this is the half that has to outlive the
+ * process. A checkpoint chain that stopped growing mid-conversation is still a well-formed chain,
+ * so nothing a later `--resume` could inspect would reveal that it is truncated — the refusal has
+ * to be written down at the moment the writing broke.
+ *
+ * Fail-soft, like its neighbours: the session is already degraded, and a failure here must not turn
+ * that into a second error.
+ */
+export declare function markConversationUnresumableSafe(config: HistoryConfigView, conversationId: number): void;
+/**
+ * GS2-20 — the reverse trip: from a conversation id (what `gth history list` prints and a user
+ * types) to the LangGraph thread whose checkpoint holds its state, or `null` when there isn't one.
+ *
+ * `null` covers every way this can come up empty — history turned off, no store, an id that names
+ * nothing, or a conversation recorded without a checkpointer — and never a neighbouring
+ * conversation. A caller resuming on this must treat `null` as a refusal to resume and say so;
+ * quietly starting a fresh session, or picking the most recent conversation instead, would hand
+ * someone another conversation's state under the id they typed.
+ */
+export declare function lookupConversationThreadSafe(config: HistoryConfigView, conversationId: number): string | null;
+/** GS2-20 — what a resume needs to know about a stored conversation before re-entering it. */
+export interface StoredConversation {
+    /** The listing row: when it started, which command and model recorded it, its workspace. */
+    summary: ConversationSummary;
+    /** Its recorded turns, oldest first — what the surface replays as restored turns. */
+    turns: SessionRecord[];
+}
+/**
+ * GS2-20 — the conversation row and its recorded turns, or `null` when history is off, the store
+ * cannot be opened, or no conversation has that id.
+ *
+ * This is the *display and policy* half of a resume — the workspace the conversation belongs to,
+ * the command it was recorded under, the turns to show — and deliberately not the thread decision:
+ * whether the conversation can be re-entered is answered by {@link lookupConversationThreadSafe},
+ * whose exact-match-never-fallback contract is the one a resume rests on. Fail-soft, never throws.
+ */
+export declare function lookupConversationSafe(config: HistoryConfigView, conversationId: number): StoredConversation | null;
+/**
+ * GS2-20 — the conversations a `/resume` picker may offer: the most recent ones that carry a thread
+ * (so a resume could actually re-enter them), minus the one the session is already in. `[]` when
+ * history is off or the store cannot be opened, which the caller renders as "nothing to resume".
+ * Fail-soft, never throws.
+ */
+export declare function listResumableConversationsSafe(config: HistoryConfigView, options?: {
+    limit?: number;
+    exclude?: number;
+}): ConversationSummary[];
+/**
+ * GS2-20 — the stored approval-grants document of one conversation, as the opaque JSON string the
+ * approvals layer wrote (`core/approvals/conversationGrants.ts` owns the format), or `null` when
+ * there is none. Governed by the same switch as everything else here. Fail-soft, never throws.
+ */
+export declare function readConversationGrantsSafe(config: HistoryConfigView, conversationId: number): string | null;
+/**
+ * GS2-20 — replace one conversation's stored approval-grants document. Called whenever the session's
+ * grants change, so the row always holds the current set and a resume restores exactly what the
+ * conversation had. Returns whether the row was written. Fail-soft, never throws — a grant that
+ * could not be recorded costs one re-prompt after a resume, and must never cost the turn.
+ */
+export declare function writeConversationGrantsSafe(config: HistoryConfigView, conversationId: number, grantsJson: string | null): boolean;

package/dist/history/recordSession.js

@@ -1,7 +1,8 @@
 import { openHistoryStore, resolveHistoryDbPath } from '#src/history/historyStore.js';
+import { isHistoryEnabled } from '#src/history/historyEnabled.js';
 /**
- * Record one finished session IFF `history.enabled` is true. Returns the new row id, or `null`
- * when history is disabled or anything went wrong (both are non-events for the caller).
+ * Record one finished session unless `history.enabled` is `false`. Returns the new row id, or
+ * `null` when history is turned off or anything went wrong (both are non-events for the caller).
  *
  * Deliberately fully guarded: opening the store, ensuring the global dir, and the insert all run
  * behind a single try/catch, and the store itself is fail-soft. Callers put this in a `finally`
@@ -9,9 +10,9 @@ import { openHistoryStore, resolveHistoryDbPath } from '#src/history/historyStor
  */
 export function recordSessionSafe(config, record) {
     try {
-        if (!config?.history?.enabled)
+        if (!isHistoryEnabled(config))
             return null;
-        const dbPath = resolveHistoryDbPath(config.history.dbPath, /* ensureDir */ true);
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath, /* ensureDir */ true);
         const store = openHistoryStore(dbPath, { create: true });
         if (!store)
             return null;
@@ -27,18 +28,21 @@ export function recordSessionSafe(config, record) {
     }
 }
 /**
- * GS2-19 — open one conversation for an interactive session IFF `history.enabled`, returning its id
- * (or `null` when disabled / anything failed). The session passes that id on every
- * {@link recordSessionSafe} so all its turns group under one conversation. Same guarantees as the
- * recorder: a no-op by default, fully fail-soft, never throws. When it returns `null` under an
- * enabled store (a rare open failure), turns simply fall back to per-turn 1-turn conversations —
- * grouping is lost but nothing is dropped or crashed.
+ * GS2-19 — open one conversation for an interactive session unless `history.enabled` is `false`,
+ * returning its id (or `null` when turned off / anything failed). The session passes that id on
+ * every {@link recordSessionSafe} so all its turns group under one conversation. Same guarantees as
+ * the recorder: fully fail-soft, never throws. When it returns `null` under an enabled store (a
+ * rare open failure), turns simply fall back to per-turn 1-turn conversations — grouping is lost
+ * but nothing is dropped or crashed.
+ *
+ * GS2-20 — `meta.threadId` is what makes the conversation resumable: it names the LangGraph thread
+ * whose durable checkpoint holds the session's graph state.
  */
 export function openConversationSafe(config, meta) {
     try {
-        if (!config?.history?.enabled)
+        if (!isHistoryEnabled(config))
             return null;
-        const dbPath = resolveHistoryDbPath(config.history.dbPath, /* ensureDir */ true);
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath, /* ensureDir */ true);
         const store = openHistoryStore(dbPath, { create: true });
         if (!store)
             return null;
@@ -53,4 +57,175 @@ export function openConversationSafe(config, meta) {
         return null;
     }
 }
+/**
+ * GS2-20 — record, ON DISK, that a conversation can no longer be resumed, by clearing its thread
+ * link. Called once per session, the first time a checkpoint write fails after the store opened.
+ *
+ * The session itself keeps running and the user is told; this is the half that has to outlive the
+ * process. A checkpoint chain that stopped growing mid-conversation is still a well-formed chain,
+ * so nothing a later `--resume` could inspect would reveal that it is truncated — the refusal has
+ * to be written down at the moment the writing broke.
+ *
+ * Fail-soft, like its neighbours: the session is already degraded, and a failure here must not turn
+ * that into a second error.
+ */
+export function markConversationUnresumableSafe(config, conversationId) {
+    try {
+        if (!isHistoryEnabled(config))
+            return;
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return;
+        try {
+            store.clearConversationThread(conversationId);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * GS2-20 — the reverse trip: from a conversation id (what `gth history list` prints and a user
+ * types) to the LangGraph thread whose checkpoint holds its state, or `null` when there isn't one.
+ *
+ * `null` covers every way this can come up empty — history turned off, no store, an id that names
+ * nothing, or a conversation recorded without a checkpointer — and never a neighbouring
+ * conversation. A caller resuming on this must treat `null` as a refusal to resume and say so;
+ * quietly starting a fresh session, or picking the most recent conversation instead, would hand
+ * someone another conversation's state under the id they typed.
+ */
+export function lookupConversationThreadSafe(config, conversationId) {
+    try {
+        if (!isHistoryEnabled(config))
+            return null;
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return null;
+        try {
+            return store.getConversationThreadId(conversationId);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * GS2-20 — the conversation row and its recorded turns, or `null` when history is off, the store
+ * cannot be opened, or no conversation has that id.
+ *
+ * This is the *display and policy* half of a resume — the workspace the conversation belongs to,
+ * the command it was recorded under, the turns to show — and deliberately not the thread decision:
+ * whether the conversation can be re-entered is answered by {@link lookupConversationThreadSafe},
+ * whose exact-match-never-fallback contract is the one a resume rests on. Fail-soft, never throws.
+ */
+export function lookupConversationSafe(config, conversationId) {
+    try {
+        if (!isHistoryEnabled(config))
+            return null;
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return null;
+        try {
+            const summary = store.getConversation(conversationId);
+            if (!summary)
+                return null;
+            return { summary, turns: store.getConversationThread(conversationId) };
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * GS2-20 — the conversations a `/resume` picker may offer: the most recent ones that carry a thread
+ * (so a resume could actually re-enter them), minus the one the session is already in. `[]` when
+ * history is off or the store cannot be opened, which the caller renders as "nothing to resume".
+ * Fail-soft, never throws.
+ */
+export function listResumableConversationsSafe(config, options = {}) {
+    try {
+        if (!isHistoryEnabled(config))
+            return [];
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return [];
+        try {
+            // Over-fetch so the filter below still yields up to `limit` rows when recent conversations
+            // are single-shot runs (no thread) or the excluded one.
+            const limit = options.limit ?? 20;
+            return store
+                .listConversations(limit * 3)
+                .filter((c) => c.threadId !== undefined && c.id !== options.exclude)
+                .slice(0, limit);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * GS2-20 — the stored approval-grants document of one conversation, as the opaque JSON string the
+ * approvals layer wrote (`core/approvals/conversationGrants.ts` owns the format), or `null` when
+ * there is none. Governed by the same switch as everything else here. Fail-soft, never throws.
+ */
+export function readConversationGrantsSafe(config, conversationId) {
+    try {
+        if (!isHistoryEnabled(config))
+            return null;
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return null;
+        try {
+            return store.getConversationGrants(conversationId);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * GS2-20 — replace one conversation's stored approval-grants document. Called whenever the session's
+ * grants change, so the row always holds the current set and a resume restores exactly what the
+ * conversation had. Returns whether the row was written. Fail-soft, never throws — a grant that
+ * could not be recorded costs one re-prompt after a resume, and must never cost the turn.
+ */
+export function writeConversationGrantsSafe(config, conversationId, grantsJson) {
+    try {
+        if (!isHistoryEnabled(config))
+            return false;
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath);
+        const store = openHistoryStore(dbPath, { create: false });
+        if (!store)
+            return false;
+        try {
+            return store.setConversationGrants(conversationId, grantsJson);
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=recordSession.js.map

package/dist/history/recordSession.js.map

@@ -1 +1 @@
-{"version":3,"file":"recordSession.js","sourceRoot":"","sources":["../../src/history/recordSession.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAOtF;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAyB,EAAE,MAAqB;IAChF,IAAI,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO;YAAE,OAAO,IAAI,CAAC;QAC3C,MAAM,MAAM,GAAG,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;QACjF,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QACxB,IAAI,CAAC;YACH,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;gBAAS,CAAC;YACT,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAyB,EACzB,IAAsB;IAEtB,IAAI,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO;YAAE,OAAO,IAAI,CAAC;QAC3C,MAAM,MAAM,GAAG,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;QACjF,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QACxB,IAAI,CAAC;YACH,OAAO,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;gBAAS,CAAC;YACT,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}
+{"version":3,"file":"recordSession.js","sourceRoot":"","sources":["../../src/history/recordSession.ts"],"names":[],"mappings":"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"}

package/dist/history/sessionCheckpointer.d.ts

@@ -0,0 +1,48 @@
+import { BaseCheckpointSaver } from '@langchain/langgraph';
+import { type HistoryConfigView } from '#src/history/historyEnabled.js';
+/** The checkpointer a session drives, plus what the session needs to know about it. */
+export interface SessionCheckpointer {
+    /** The saver to hand to `GthAgentRunner.init` / `GthAgentInterface.init`. Never null. */
+    saver: BaseCheckpointSaver;
+    /**
+     * True when checkpoints are reaching disk — i.e. when this session can be resumed later. False
+     * for a `MemorySaver`, whether that is the deliberate opt-out or the fallback.
+     */
+    durable: boolean;
+    /**
+     * The LangGraph thread this session's state is stored under, minted here so the conversation row
+     * can record it BEFORE the runner is initialised — `init` can throw partway, and a conversation
+     * whose thread id was never written is a listing entry that can never be resumed.
+     */
+    threadId: string;
+    /**
+     * Name the conversation row this session's turns group under, so a later checkpoint-write failure
+     * can mark it unresumable ON DISK. Call once per conversation the session records under:
+     * immediately after `openConversationSafe`, and again when a mid-session `/resume` moves the
+     * session onto another conversation — the saver is the same, so the row it would mark has to
+     * follow the session. Passing `undefined` (history off, or the row could not be opened) is fine
+     * and simply leaves nothing to mark. Safe to call before or after a failure has already happened
+     * — a failure that arrives first is applied here instead, and a rebind after one marks the new
+     * row too, which is correct: a saver that has stopped writing is truncating whichever
+     * conversation it is now on. Never throws.
+     *
+     * **Optional on the interface, and called with `?.`**, because a dozen-odd specs stub
+     * `openSessionCheckpointerSafe` with a plain object literal to keep a session off the real
+     * database. Requiring it would break every one of them at runtime for no gain: a stub that omits
+     * it simply has no conversation to mark, which is the correct behaviour for a test that is not
+     * about this.
+     */
+    bindConversation?(conversationId: number | undefined): void;
+    /** Release the underlying connection (a no-op when the saver is in memory). Never throws. */
+    close(): void;
+}
+export interface OpenSessionCheckpointerOptions {
+    /** Drive a specific thread instead of a fresh one — how a resume re-enters a stored thread. */
+    threadId?: string;
+    /**
+     * Where the fallback notice goes. Defaults to {@link displayWarning}; injectable so a caller on a
+     * managed surface can route it, and so a test can read it without mocking the console.
+     */
+    notify?: (message: string) => void;
+}
+export declare function openSessionCheckpointerSafe(config: HistoryConfigView, options?: OpenSessionCheckpointerOptions): SessionCheckpointer;

package/dist/history/sessionCheckpointer.js

@@ -0,0 +1,200 @@
+/**
+ * @packageDocumentation
+ * GS2-20 — the bridge from a session's config to the checkpointer it drives, and the counterpart to
+ * the recorder bridge in `recordSession.ts`: one call, never throws, always returns a usable saver.
+ *
+ * **The fallback is a `MemorySaver`, never the absence of one.** With a tool-approval interrupt
+ * installed and no checkpointer at all, the first gated tool call throws a LangGraph-internal
+ * `MISSING_CHECKPOINTER` in the middle of a turn — a failure with no relationship to what the user
+ * was doing. So a database this session cannot open costs exactly one thing, resumability, and the
+ * user is told that plainly rather than discovering it later.
+ *
+ * **A write that fails later costs the same one thing.** This module owns the degrade policy the
+ * saver reports into: one notice per session, and — the part that has to outlive the process — the
+ * conversation's thread link cleared on disk, so a later resume refuses it. A checkpoint chain that
+ * stopped growing mid-conversation is still well-formed, so without that mark the next `--resume`
+ * would load a truncated conversation and present it as complete.
+ */
+import { randomUUID } from 'node:crypto';
+import { MemorySaver } from '@langchain/langgraph';
+import { openCheckpointSaver } from '#src/history/checkpointSaver.js';
+import { isHistoryEnabled } from '#src/history/historyEnabled.js';
+import { resolveHistoryDbPath } from '#src/history/historyStore.js';
+import { markConversationUnresumableSafe } from '#src/history/recordSession.js';
+import { displayWarning } from '#src/utils/consoleUtils.js';
+/**
+ * Open the session's checkpointer. Returns a durable, SQLite-backed saver when history is on and
+ * the database opens; a `MemorySaver` otherwise. Never throws.
+ *
+ * The `MemorySaver` case is two different situations that must not be conflated:
+ * - `history.enabled: false` — the user turned persistence off. Silent: they asked for this.
+ * - the database would not open — the user asked for persistence and did not get it, so
+ *   {@link OpenSessionCheckpointerOptions.notify} says so.
+ */
+/**
+ * Every durable checkpointer currently open in this process, as its own close function.
+ *
+ * A session normally closes its connection in a `finally`, but a process killed by a signal never
+ * reaches one: `systemUtils` answers `SIGINT`/`SIGTERM` with `process.exit(0)`, which unwinds no
+ * `try`/`finally` at all, and a `SIGHUP` — a user closing the terminal window — terminates without
+ * running anything. Leaving the database open until the OS tears the process down is harmless on
+ * POSIX and not on win32, where a live handle blocks the file from being deleted or replaced.
+ */
+const openSavers = new Set();
+/** Installed at most once per process, on the first durable checkpointer. */
+let terminationHooksInstalled = false;
+/**
+ * Close every open checkpointer on the way out of the process.
+ *
+ * `exit` rather than a `SIGINT`/`SIGTERM` handler of our own, deliberately: `systemUtils` registers
+ * its signal handlers when it is first imported, which is long before any session starts, and they
+ * call `process.exit(0)`. Node runs signal listeners in registration order, so a later listener of
+ * ours would never be reached — but `process.exit()` does run `exit` listeners, so that one hook
+ * covers `SIGINT`, `SIGTERM`, an explicit exit and a normal return alike. `SIGHUP` has no such
+ * handler anywhere and so needs its own.
+ */
+function ensureTerminationHooks() {
+    if (terminationHooksInstalled)
+        return;
+    terminationHooksInstalled = true;
+    const closeAll = () => {
+        for (const close of [...openSavers]) {
+            try {
+                close();
+            }
+            catch {
+                // Nothing useful can be done about a failed close while the process is already leaving.
+            }
+        }
+        openSavers.clear();
+    };
+    process.on('exit', closeAll);
+    const onHangup = () => {
+        // Remove ourselves first so the default disposition applies again and the process dies with the
+        // status it would have had. Swallowing a hangup would leave a session running invisibly.
+        process.off('SIGHUP', onHangup);
+        closeAll();
+        process.kill(process.pid, 'SIGHUP');
+    };
+    process.on('SIGHUP', onHangup);
+}
+export function openSessionCheckpointerSafe(config, options = {}) {
+    const threadId = options.threadId ?? randomUUID();
+    const notify = options.notify ?? displayWarning;
+    const inMemory = () => ({
+        saver: new MemorySaver(),
+        durable: false,
+        threadId,
+        bindConversation: () => { },
+        close: () => { },
+    });
+    // GS2-20 — the degrade path. A checkpoint write that fails mid-session drops the write and lets
+    // the turn continue; these two closures are the "loudly" half. They are declared before the saver
+    // because the saver is handed `degrade` at construction.
+    //
+    // The two facts are tracked separately on purpose. `degraded` is what happened; `conversationId`
+    // is where to write it down, and it is not known yet — the conversation row is opened by the
+    // caller AFTER this returns, because the row has to carry the thread id minted just above. So a
+    // failure can precede the binding, and `applyMark` is called from both sides to close that gap.
+    let degraded = false;
+    let conversationId;
+    const applyMark = () => {
+        if (!degraded || conversationId === undefined)
+            return;
+        markConversationUnresumableSafe(config, conversationId);
+    };
+    const degrade = () => {
+        // Once per session, not once per write: a full disk fails every super-step, and a notice per
+        // write would bury the turn the user is still having under its own error report.
+        if (degraded)
+            return;
+        degraded = true;
+        notify('Could not save this conversation to the conversation store, so it will not be resumable ' +
+            'later — the rest of this session is unaffected and your work is not lost. The usual cause ' +
+            'is a full or read-only disk. Set `history.enabled: false` in your config to stop trying.');
+        applyMark();
+    };
+    try {
+        if (!isHistoryEnabled(config))
+            return inMemory();
+        const dbPath = resolveHistoryDbPath(config.history?.dbPath, /* ensureDir */ true);
+        const saver = openCheckpointSaver(dbPath, { onWriteFailure: degrade });
+        if (!saver) {
+            notify(`Could not open the conversation store at ${dbPath}, so this session will not be ` +
+                'resumable later. It runs normally otherwise; set `history.enabled: false` in your ' +
+                'config to stop trying.');
+            return inMemory();
+        }
+        // GS2-20 — hold the connection open only as long as the session actually runs. `saver.close()`
+        // is itself fail-soft, so the guard is about not counting a closed saver as open rather than
+        // about a double close throwing.
+        let closed = false;
+        const closeOnce = () => {
+            if (closed)
+                return;
+            closed = true;
+            saver.close();
+        };
+        openSavers.add(closeOnce);
+        ensureTerminationHooks();
+        // GS2-107 — the automatic half of the retention policy runs HERE, on the orderly close of a
+        // session that actually ran, and nowhere else.
+        //
+        // **Why the close and not the open.** The connection is already there, so it adds no open of its
+        // own, and it lands after the person has stopped waiting on the tool rather than in front of
+        // their first prompt — a user with a large store must not pay for retention at startup.
+        //
+        // **Why not in `closeOnce`.** That closure is also what the process-exit and SIGHUP hooks call.
+        // A row delete while the process is already leaving is work nobody is waiting for and nothing
+        // can report, on a path that a signal can interrupt halfway.
+        //
+        // **Why the `bindConversation` gate.** Both surfaces bind straight after the resume checks pass,
+        // so a checkpointer closed before that point is one whose session never started — the
+        // `--resume` refusal path, which exits 1 promising that nothing was changed. Deleting rows there
+        // would make that sentence false.
+        //
+        // **What keeps this session's own thread safe.** Not the id minted above: the runner rotates
+        // threads and does not tell anyone — `resetThread()` on `/clear`, `resumeConversation` onto a
+        // stored thread — so after any rotation that id names a thread nobody wrote. The saver excludes
+        // the threads IT wrote instead, which is the same set by construction however often the session
+        // rotated, so nothing is passed here. What remains outside that set is a live session in
+        // ANOTHER process, and it is bounded only by the grace window; closing that gap needs shared
+        // cross-process session state, which this ticket does not add.
+        let served = false;
+        let reclaimed = false;
+        const reclaimOnClose = () => {
+            if (reclaimed || !served || closed)
+                return;
+            reclaimed = true;
+            try {
+                saver.reclaimUnresumableThreads();
+            }
+            catch {
+                /* retention is housekeeping: it must never be the reason a session fails to exit */
+            }
+        };
+        return {
+            saver,
+            durable: true,
+            threadId,
+            bindConversation: (id) => {
+                served = true;
+                conversationId = id;
+                applyMark();
+            },
+            close: () => {
+                reclaimOnClose();
+                openSavers.delete(closeOnce);
+                closeOnce();
+            },
+        };
+    }
+    catch {
+        // Reaching here means something outside the saver's own fail-soft open threw — resolving the
+        // path, or creating `~/.gsloth`. Same outcome, same sentence: the session runs, unresumable.
+        notify('Could not open the conversation store, so this session will not be resumable later. ' +
+            'It runs normally otherwise; set `history.enabled: false` in your config to stop trying.');
+        return inMemory();
+    }
+}
+//# sourceMappingURL=sessionCheckpointer.js.map

package/dist/history/sessionCheckpointer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionCheckpointer.js","sourceRoot":"","sources":["../../src/history/sessionCheckpointer.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,8 +1,14 @@
 export * from '#src/constants.js';
 export * from '#src/core/types.js';
 export { gthLeanAgentFactory } from '#src/core/gthLeanAgentFactory.js';
+export * from '#src/core/compaction.js';
+export { AutocompactController } from '#src/core/compactionThreshold.js';
+export type { AutocompactConfig, AutocompactControllerOptions, AutocompactStatus, AutocompactThresholdOrigin, ResolvedAutocompactConfig, } from '#src/core/compactionThreshold.js';
+export type { ContextWindowOrigin, ContextWindowReading, ContextWindowResolutionOptions, ContextWindowSource, OllamaLikeModel, ResolvedContextWindow, } from '#src/core/contextWindow.js';
 export * from '#src/config.js';
 export * from '#src/providers/modelDiscovery.js';
+export type { CatalogOptions, EnrichedModel, ModelCatalogEntry, ModelCost, ModelLimit, ModelModalities, ProviderCatalog, } from '#src/providers/modelCatalog.js';
 export * from '#src/history/historyStore.js';
 export * from '#src/history/recordSession.js';
 export * from '#src/history/historyFormat.js';
+export type { CheckpointStoreStats, PrunableConversation, ReclaimSummary, ThreadUsage, } from '#src/history/checkpointRetention.js';