@theokit/sdk 4.0.1 → 4.1.0

package/dist/cron.d.cts

@@ -1,3 +1,3 @@
-export { N as Cron } from './cron-BfPhZjRJ.cjs';
+export { N as Cron } from './cron-BlAjYOew.cjs';
 import './run-BTvkk53K.cjs';
 import 'zod';

package/dist/cron.d.ts

@@ -1,3 +1,3 @@
-export { N as Cron } from './cron-L5QTlAtl.js';
+export { N as Cron } from './cron-AzT5D0VP.js';
 import './run-BTvkk53K.js';
 import 'zod';

package/dist/cron.js

@@ -3507,6 +3507,72 @@ var init_cloud_tool_parity = __esm({
     init_errors();
   }
 });
+
+// src/internal/persistence/file-lock.ts
+async function getProperLockfile() {
+  if (cached !== void 0) return cached;
+  try {
+    const mod = await import('proper-lockfile');
+    if (!validateLockModule(mod)) {
+      if (!warnedStructural) {
+        warnedStructural = true;
+        process.stderr.write(
+          "[theokit-sdk] proper-lockfile: imported module does NOT expose the expected `lock`/`unlock` API surface. This may indicate a supply-chain compromise or an incompatible major version. Falling back to in-process mutex (no cross-process safety). Reinstall with: pnpm add proper-lockfile@^11\n"
+        );
+      }
+      cached = null;
+      return cached;
+    }
+    cached = mod;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function validateLockModule(mod) {
+  if (mod === null || mod === void 0 || typeof mod !== "object") return false;
+  const m = mod;
+  return typeof m.lock === "function" && typeof m.unlock === "function";
+}
+async function withFileLock(path, fn, options) {
+  const lib = await getProperLockfile();
+  if (lib === null) {
+    if (!warnedMissing) {
+      warnedMissing = true;
+      process.stderr.write(
+        "[theokit-sdk] proper-lockfile not installed; cross-process file lock unavailable. Install with: pnpm add proper-lockfile\n"
+      );
+    }
+    return withCwdMutex(`file-lock:${path}`, fn);
+  }
+  return withCwdMutex(`file-lock:${path}`, async () => {
+    const release = await lib.lock(path, {
+      // EC-1: companion lockfile, target path may not exist yet.
+      lockfilePath: `${path}.lock`,
+      realpath: false,
+      stale: 3e4,
+      retries: {
+        retries: 5,
+        factor: 1.5,
+        minTimeout: 100,
+        maxTimeout: 5e3
+      }
+    });
+    try {
+      return await fn();
+    } finally {
+      await release();
+    }
+  });
+}
+var cached, warnedMissing, warnedStructural;
+var init_file_lock = __esm({
+  "src/internal/persistence/file-lock.ts"() {
+    init_cwd_mutex();
+    warnedMissing = false;
+    warnedStructural = false;
+  }
+});
 function encodeProjectDir(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
 }
@@ -3733,70 +3799,31 @@ var init_session_transcript = __esm({
     };
   }
 });
-
-// src/internal/persistence/file-lock.ts
-async function getProperLockfile() {
-  if (cached !== void 0) return cached;
-  try {
-    const mod = await import('proper-lockfile');
-    if (!validateLockModule(mod)) {
-      if (!warnedStructural) {
-        warnedStructural = true;
-        process.stderr.write(
-          "[theokit-sdk] proper-lockfile: imported module does NOT expose the expected `lock`/`unlock` API surface. This may indicate a supply-chain compromise or an incompatible major version. Falling back to in-process mutex (no cross-process safety). Reinstall with: pnpm add proper-lockfile@^11\n"
-        );
-      }
-      cached = null;
-      return cached;
-    }
-    cached = mod;
-  } catch {
-    cached = null;
-  }
-  return cached;
-}
-function validateLockModule(mod) {
-  if (mod === null || mod === void 0 || typeof mod !== "object") return false;
-  const m = mod;
-  return typeof m.lock === "function" && typeof m.unlock === "function";
-}
-async function withFileLock(path, fn, options) {
-  const lib = await getProperLockfile();
-  if (lib === null) {
-    if (!warnedMissing) {
-      warnedMissing = true;
-      process.stderr.write(
-        "[theokit-sdk] proper-lockfile not installed; cross-process file lock unavailable. Install with: pnpm add proper-lockfile\n"
-      );
-    }
-    return withCwdMutex(`file-lock:${path}`, fn);
-  }
-  return withCwdMutex(`file-lock:${path}`, async () => {
-    const release = await lib.lock(path, {
-      // EC-1: companion lockfile, target path may not exist yet.
-      lockfilePath: `${path}.lock`,
-      realpath: false,
-      stale: 3e4,
-      retries: {
-        retries: 5,
-        factor: 1.5,
-        minTimeout: 100,
-        maxTimeout: 5e3
+var FsSessionStore;
+var init_fs_session_store = __esm({
+  "src/internal/persistence/fs-session-store.ts"() {
+    init_file_lock();
+    init_session_transcript();
+    FsSessionStore = class {
+      #baseDir;
+      #cwd;
+      constructor(options) {
+        this.#baseDir = options.baseDir;
+        this.#cwd = options.cwd;
+      }
+      async readRecords(agentId) {
+        return readTranscript(transcriptPath(this.#baseDir, this.#cwd, agentId));
+      }
+      async appendRecords(agentId, records) {
+        if (records.length === 0) return;
+        const path = transcriptPath(this.#baseDir, this.#cwd, agentId);
+        await mkdir(dirname(path), { recursive: true });
+        await withFileLock(path, async () => {
+          const prior = await readTranscript(path);
+          await writeTranscript(path, [...prior, ...records]);
+        });
       }
-    });
-    try {
-      return await fn();
-    } finally {
-      await release();
-    }
-  });
-}
-var cached, warnedMissing, warnedStructural;
-var init_file_lock = __esm({
-  "src/internal/persistence/file-lock.ts"() {
-    init_cwd_mutex();
-    warnedMissing = false;
-    warnedStructural = false;
+    };
   }
 });
 function getTheokitHome(cwd) {
@@ -5128,6 +5155,8 @@ var init_memory_path_selector = __esm({
     PORT_MEMORY_PATH_ENV_VAR = "THEOKIT_PORT_MEMORY_PATH";
   }
 });
+
+// src/internal/runtime/session/agent-session-store.ts
 function seedTranscript(prior, opts) {
   return SessionTranscript.fromRecords(prior, opts);
 }
@@ -5165,8 +5194,8 @@ function appendConversation(transcript, conversation) {
     if (toolResults.length > 0) transcript.appendToolResults(toolResults);
   }
 }
-async function readSessionMessages(baseDir, cwd, agentId) {
-  const records = await readTranscript(transcriptPath(baseDir, cwd, agentId));
+async function readSessionMessages(store, agentId) {
+  const records = await store.readRecords(agentId);
   return reconstructMessages(records).map(narrowToSessionMessage);
 }
 function partToText(p) {
@@ -5183,37 +5212,31 @@ function narrowToSessionMessage(m) {
   const text = m.content.map(partToText).filter((s) => s.length > 0).join("\n");
   return { role, text };
 }
-async function persistTurn(loc, sessionId, turn) {
-  const path = transcriptPath(loc.baseDir, loc.cwd, loc.agentId);
-  await mkdir(dirname(path), { recursive: true });
-  await withFileLock(path, async () => {
-    const prior = await readTranscript(path);
-    const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });
-    transcript.appendUserTurn(turn.userText);
-    appendConversation(transcript, turn.conversation);
-    await writeTranscript(path, transcript.records());
-  });
+function deltaRecords(transcript, priorLength) {
+  return transcript.records().slice(priorLength);
 }
-async function appendCompactBoundaryRecord(loc, sessionId, meta) {
-  const path = transcriptPath(loc.baseDir, loc.cwd, loc.agentId);
-  await mkdir(dirname(path), { recursive: true });
-  await withFileLock(path, async () => {
-    const prior = await readTranscript(path);
-    const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });
-    transcript.appendCompactBoundary(meta);
-    await writeTranscript(path, transcript.records());
-  });
+async function persistTurn(store, loc, sessionId, turn) {
+  const prior = await store.readRecords(loc.agentId);
+  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });
+  transcript.appendUserTurn(turn.userText);
+  appendConversation(transcript, turn.conversation);
+  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));
+}
+async function appendCompactBoundaryRecord(store, loc, sessionId, meta) {
+  const prior = await store.readRecords(loc.agentId);
+  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });
+  transcript.appendCompactBoundary(meta);
+  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));
 }
 var init_agent_session_store = __esm({
   "src/internal/runtime/session/agent-session-store.ts"() {
-    init_file_lock();
     init_session_transcript();
   }
 });
 
 // src/internal/runtime/session/agent-session.ts
-function transcriptKey(baseDir, cwd, agentId) {
-  return `${baseDir}::${cwd}::${agentId}`;
+function transcriptKey(cwd, agentId) {
+  return `${cwd}::${agentId}`;
 }
 function appendSessionMessage(agentId, message) {
   const existing = sessions.get(agentId) ?? [];
@@ -5223,15 +5246,15 @@ function appendSessionMessage(agentId, message) {
 function getSessionMessages(agentId) {
   return sessions.get(agentId) ?? [];
 }
-function persistTurnToTranscript(loc, sessionId, turn, onCompact) {
-  const key = transcriptKey(loc.baseDir, loc.cwd, loc.agentId);
+function persistTurnToTranscript(store, loc, sessionId, turn, onCompact) {
+  const key = transcriptKey(loc.cwd, loc.agentId);
   const chained = (pendingWrites.get(key) ?? Promise.resolve()).then(async () => {
     try {
-      await persistTurn(loc, sessionId, turn);
+      await persistTurn(store, loc, sessionId, turn);
       const count = (recordCounts.get(key) ?? 0) + 1;
       recordCounts.set(key, count);
       if (count % COMPACTION_CHECK_INTERVAL === 0) {
-        await appendCompactBoundaryRecord(loc, sessionId, {
+        await appendCompactBoundaryRecord(store, loc, sessionId, {
           preTokens: 0,
           trigger: "auto"
         });
@@ -5254,10 +5277,10 @@ function persistTurnToTranscript(loc, sessionId, turn, onCompact) {
   );
 }
 async function hydrateSession(agentId, loc) {
-  const key = transcriptKey(loc.baseDir, loc.cwd, agentId);
+  const key = transcriptKey(loc.cwd, agentId);
   if (hydratedKeys.has(key)) return;
   hydratedKeys.add(key);
-  const persisted = await readSessionMessages(loc.baseDir, loc.cwd, agentId);
+  const persisted = await readSessionMessages(loc.store, agentId);
   if (persisted.length === 0) return;
   if (!sessions.has(agentId) || sessions.get(agentId)?.length === 0) {
     sessions.set(agentId, persisted);
@@ -5292,7 +5315,7 @@ async function runPostRunLifecycle(inputs) {
     userText,
     agentId,
     workspaceCwd,
-    baseDir,
+    sessionStore,
     model,
     onRunEvent,
     hooksExecutor,
@@ -5311,7 +5334,8 @@ async function runPostRunLifecycle(inputs) {
   }
   const conversation = await safeConversation(run);
   persistTurnToTranscript(
-    { baseDir, cwd: workspaceCwd, agentId, model },
+    sessionStore,
+    { cwd: workspaceCwd, agentId, model },
     agentId,
     { userText, conversation },
     onRunEvent !== void 0 ? () => emitRunEvent(onRunEvent, { type: "compact_boundary", trigger: "auto" }) : void 0
@@ -17918,6 +17942,7 @@ var init_local_agent = __esm({
     init_errors();
     init_ids();
     init_cwd_mutex();
+    init_fs_session_store();
     init_session_transcript();
     init_store();
     init_manager();
@@ -17961,6 +17986,12 @@ var init_local_agent = __esm({
        * `~/.theokit`; set `local.baseDir: "~/.claude"` for Claude Code CLI interop.
        */
       transcriptBaseDir;
+      /**
+       * SE41 — the session record store. Defaults to the FS transcript store (byte-
+       * identical to SE40); `local.sessionStore` injects an external store (Postgres /
+       * Redis / KV) so resume works on serverless (ephemeral FS) and multi-host.
+       */
+      sessionStore;
       /**
        * D319: lifecycle AbortController fired on `dispose()`. Composed with the
        * caller's `SendOptions.signal` via `anySignal` so the LLM `fetch()`
@@ -18003,6 +18034,7 @@ var init_local_agent = __esm({
         this.options = options;
         this.workspaceCwd = resolveCwd(options.local?.cwd);
         this.transcriptBaseDir = resolveBaseDir(options.local?.baseDir);
+        this.sessionStore = options.local?.sessionStore ?? new FsSessionStore({ baseDir: this.transcriptBaseDir, cwd: this.workspaceCwd });
         this.settingSourcesIncludeProject = includesSetting(options, "project");
         this.settingSourcesIncludePlugins = includesSetting(options, "plugins");
         const sub = bootstrapSubmanagers({
@@ -18050,7 +18082,7 @@ var init_local_agent = __esm({
           this.settingSourcesIncludeProject,
           this.options.agents
         );
-        await hydrateSession(this.agentId, { baseDir: this.transcriptBaseDir, cwd: this.workspaceCwd });
+        await hydrateSession(this.agentId, { store: this.sessionStore, cwd: this.workspaceCwd });
         await this.personalityStore.hydrate(this.agentId);
       }
       /** T4.2 — expose PluginManager so agent-loop can fire pre_tool_call hooks. @internal */
@@ -18106,7 +18138,7 @@ var init_local_agent = __esm({
             userText,
             agentId: this.agentId,
             workspaceCwd: this.workspaceCwd,
-            baseDir: this.transcriptBaseDir,
+            sessionStore: this.sessionStore,
             model: this.model?.id ?? "unknown",
             ...options.onRunEvent !== void 0 ? { onRunEvent: options.onRunEvent } : {},
             hooksExecutor: this.hooksExecutor,