@theokit/sdk 4.31.1 → 4.33.0

package/dist/chunk-E33A7YIR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/session/agent-session-store.ts","../src/internal/session/agent-session.ts"],"names":["SessionTranscript","reconstructMessages","sessions","hydratedKeys","transcriptKey"],"mappings":"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","file":"chunk-E33A7YIR.cjs","sourcesContent":["/**\n * SE40 — native session store over the Claude-shaped `.jsonl` transcript.\n *\n * The theokit session format IS the Claude Code record shape (see\n * `../../persistence/session-transcript.ts`). This module owns the FS lifecycle:\n * read existing records, seed a {@link SessionTranscript}'s parent chain, append\n * the new turn (user + assistant/tool blocks), and write append-only. Compaction\n * appends a `compact_boundary` record (a new root) — it NEVER shrinks the line\n * set (that would break the DAG). Reads reconstruct `LlmMessage[]` via\n * {@link reconstructMessages}, narrowed to the in-memory {@link SessionMessage}.\n *\n * @internal\n */\n\nimport type { ConversationStep, ConversationTurn } from \"../../types/conversation.js\";\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport {\n  type AssistantTurn,\n  reconstructMessages,\n  type SessionRecord,\n  SessionTranscript,\n} from \"../persistence/session-transcript.js\";\nimport type { SessionMessage } from \"./session-types.js\";\n\n/**\n * Seed a {@link SessionTranscript} from the already-on-disk records so a new\n * append parents correctly on the existing DAG leaf. The transcript re-emits the\n * seeded records verbatim before the new turn, so the whole file rewrites atomically\n * as one append-only line set. Returns the transcript primed with the prior records.\n */\nfunction seedTranscript(\n  prior: readonly SessionRecord[],\n  opts: { cwd: string; sessionId: string; model: string },\n): SessionTranscript {\n  return SessionTranscript.fromRecords(prior, opts);\n}\n\n/** The turn to persist: the user's text plus the rich per-turn conversation view. */\nexport interface PersistTurnInput {\n  userText: string;\n  conversation: readonly ConversationTurn[];\n  /**\n   * M50 — when supplied, size-driven auto-compaction runs in the SAME write chain after the turn\n   * persists (usage real vs the model's context window; summarizer injected by the caller).\n   */\n  autoCompact?: {\n    usageTotal?: number | undefined;\n    contextWindow?: number | undefined;\n    summarize: (\n      messages: readonly import(\"../../compaction.js\").CompressibleMessage[],\n    ) => Promise<string>;\n  };\n}\n\ninterface MappedTurn {\n  assistant: AssistantTurn;\n  toolResults: Array<{ toolUseId: string; content: string; isError?: boolean }>;\n}\n\n/** Fold one agent turn's steps into an assistant record + paired tool results. */\nfunction mapAgentTurn(steps: readonly ConversationStep[]): MappedTurn {\n  const assistant: AssistantTurn = {};\n  const toolResults: MappedTurn[\"toolResults\"] = [];\n  const toolCalls: NonNullable<AssistantTurn[\"toolCalls\"]> = [];\n  for (const step of steps) {\n    if (step.type === \"thinkingMessage\") assistant.thinking = step.message.text;\n    else if (step.type === \"assistantMessage\") assistant.text = step.message.text;\n    else if (step.type === \"toolCall\")\n      toolCalls.push({\n        id: step.message.callId,\n        name: step.message.name,\n        input: (step.message.args as Record<string, unknown> | undefined) ?? {},\n      });\n    else\n      toolResults.push({\n        toolUseId: step.message.callId,\n        content: step.message.result,\n        isError: step.message.isError,\n      });\n  }\n  if (toolCalls.length > 0) assistant.toolCalls = toolCalls;\n  return { assistant, toolResults };\n}\n\n/** True when the assistant record carries any content worth emitting. */\nfunction hasAssistantContent(a: AssistantTurn): boolean {\n  return a.text !== undefined || a.thinking !== undefined || (a.toolCalls?.length ?? 0) > 0;\n}\n\n/**\n * Map the rich `ConversationTurn[]` (from `run.conversation()`) into the native\n * assistant/tool records. One transcript turn is: an `assistant` record carrying\n * thinking + text + tool_use blocks, then (when present) a `user` record carrying\n * the paired tool_result blocks. Tool results pair with tool_use by `callId`.\n */\nfunction appendConversation(\n  transcript: SessionTranscript,\n  conversation: readonly ConversationTurn[],\n): void {\n  for (const ct of conversation) {\n    if (ct.type !== \"agentConversationTurn\") continue;\n    const { assistant, toolResults } = mapAgentTurn(ct.turn.steps);\n    if (hasAssistantContent(assistant)) transcript.appendAssistantTurn(assistant);\n    if (toolResults.length > 0) transcript.appendToolResults(toolResults);\n  }\n}\n\n/**\n * The per-agent transcript metadata used to seed a {@link SessionTranscript}. The\n * actual record I/O goes through the injected {@link SessionStore} (SE41), so this\n * no longer carries a `baseDir` — the store is already bound to its location.\n */\nexport interface TranscriptLocation {\n  cwd: string;\n  agentId: string;\n  model: string;\n}\n\n/**\n * Read the session's records via the {@link SessionStore} and reconstruct the\n * resumable history, narrowed to the in-memory {@link SessionMessage} shape\n * (user/assistant text). Tool turns fold into assistant-role context so resume\n * keeps tool history. Works identically for the FS default and an external store.\n */\nexport async function readSessionMessages(\n  store: SessionStore,\n  agentId: string,\n): Promise<SessionMessage[]> {\n  const records = await store.readRecords(agentId);\n  return reconstructMessages(records).map(narrowToSessionMessage);\n}\n\ntype NarrowPart = { type: string; text?: string; content?: unknown; name?: string };\n\n/** Render one reconstructed content part as folded session text. */\nfunction partToText(p: NarrowPart): string {\n  if (p.type === \"text\") return p.text ?? \"\";\n  if (p.type === \"tool_use\") return `[tool call] ${p.name ?? \"\"}`;\n  if (p.type === \"tool_result\") {\n    const body = typeof p.content === \"string\" ? p.content : JSON.stringify(p.content);\n    return `[tool result] ${body}`;\n  }\n  return \"\";\n}\n\n/** Flatten a reconstructed `LlmMessage` to the narrowed in-memory `SessionMessage`. */\nfunction narrowToSessionMessage(m: {\n  role: \"system\" | \"user\" | \"assistant\";\n  content: NarrowPart[];\n}): SessionMessage {\n  const role = m.role === \"user\" ? \"user\" : \"assistant\";\n  const text = m.content\n    .map(partToText)\n    .filter((s) => s.length > 0)\n    .join(\"\\n\");\n  return { role, text };\n}\n\n/** The records appended by the last turn (the delta beyond the seeded prior). */\nfunction deltaRecords(\n  transcript: SessionTranscript,\n  priorLength: number,\n): readonly SessionRecord[] {\n  return transcript.records().slice(priorLength);\n}\n\n/**\n * Persist one conversation turn (user + assistant/tool records) to the session\n * store, append-only. Reads the prior records to seed the parent chain, folds the\n * new turn, and appends ONLY the delta via {@link SessionStore.appendRecords}\n * (the store owns the append atomicity — the FS default serializes under a file\n * lock). Within one process, turns for an agent are already chained upstream, so\n * the read→append is ordered; cross-host ordering is the external store's contract.\n */\nexport async function persistTurn(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  turn: PersistTurnInput,\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendUserTurn(turn.userText);\n  appendConversation(transcript, turn.conversation);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n\n/**\n * Append-only compaction: add a `compact_boundary` system record (a new root) so\n * resume replays only the post-boundary continuation. Appends only the boundary\n * record via the store — NEVER rewrites or shrinks the prior records.\n */\nexport async function appendCompactBoundaryRecord(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  meta: { preTokens: number; trigger: string },\n): Promise<void> {\n  const prior = await store.readRecords(loc.agentId);\n  const transcript = seedTranscript(prior, { cwd: loc.cwd, sessionId, model: loc.model });\n  transcript.appendCompactBoundary(meta);\n  await store.appendRecords(loc.agentId, deltaRecords(transcript, prior.length));\n}\n","import type { SessionStore } from \"../../types/session-store.js\";\nimport {\n  type PersistTurnInput,\n  persistTurn,\n  readSessionMessages,\n  type TranscriptLocation,\n} from \"./agent-session-store.js\";\n\n/**\n * Per-agent conversation history kept across runs (and across `Agent.resume()`\n * within the same process). Lets the fixture responder recall prior facts when\n * the user asks a follow-up question.\n *\n * SE40 — disk persistence IS the native Claude-shaped `.jsonl` transcript. The\n * in-memory cache holds the narrowed `SessionMessage[]` (user/assistant text) so\n * a send can read `priorMessages` synchronously; the whole rich turn (user +\n * assistant + tool blocks) lands on disk once per send via {@link persistTurnToTranscript}\n * (fed by `run.conversation()`). Hydration on resume reconstructs the session by\n * walking the transcript DAG (`readSessionMessages`).\n *\n * @internal\n */\n\n// `SessionMessage` lives in `./session-types.ts` (leaf types file). Re-exported\n// for back-compat with downstream importers that pulled it from here.\nexport type { SessionMessage } from \"./session-types.js\";\n\nimport type { SessionMessage } from \"./session-types.js\";\n\n// M75 — o cache mora numa folha; ver session-cache.ts para a razao (quebra de ciclo por extracao).\nexport {\n  hydratedKeys,\n  invalidateSessionCache,\n  sessions,\n  transcriptKey,\n} from \"./session-cache.js\";\n\nimport { hydratedKeys, sessions, transcriptKey } from \"./session-cache.js\";\n\nconst pendingWrites = new Map<string, Promise<void>>();\nconst recordCounts = new Map<string, number>();\n\n/**\n * Append a session message to the in-memory cache only. Disk persistence for the\n * whole turn happens once per send via {@link persistTurnToTranscript}; the cache\n * feeds `priorMessages` / `onBeforeSend.previousMessageCount` synchronously.\n *\n * @internal\n */\nexport function appendSessionMessage(agentId: string, message: SessionMessage): void {\n  const existing = sessions.get(agentId) ?? [];\n  existing.push(message);\n  // `delete` + `set` reinsere no FIM: `Map` do JS preserva ordem de inserção, então a primeira\n  // chave é sempre a menos recentemente tocada. É o LRU inteiro, sem estrutura nova (rung 2/5 da\n  // parcimônia — a ordenação que precisamos já é garantia da linguagem).\n  sessions.delete(agentId);\n  sessions.set(agentId, existing);\n  aplicarTeto();\n}\n\n/**\n * Teto de sessões mantidas em memória.\n *\n * O runtime só lê a sessão **ativa**; o resto é cache puro, reconstruível do transcript em disco.\n * 32 é folgado de propósito — o caminho primário de remoção é o `descartarSessao()` explícito no\n * fim da vida do agente, e este teto é rede de segurança contra um processo de vida longa que roda\n * centenas de sessões (risco #2 do plano: um teto apertado poderia evictar sessão ainda referenciada\n * por um fluxo assíncrono em voo).\n */\nexport const TETO_DE_SESSOES_EM_CACHE = 32;\n\nfunction aplicarTeto(): void {\n  while (sessions.size > TETO_DE_SESSOES_EM_CACHE) {\n    const maisAntiga = sessions.keys().next().value;\n    if (maisAntiga === undefined) return;\n    sessions.delete(maisAntiga);\n    hydratedKeys.delete(maisAntiga);\n    pendingWrites.delete(maisAntiga);\n    recordCounts.delete(maisAntiga);\n  }\n}\n\n/**\n * Apaga a escrituração de módulo do agente e devolve quantas entradas saíram.\n *\n * M95 — `invalidateSessionCache` limpava **dois** dos quatro mapas (`sessions`, `hydratedKeys`);\n * `pendingWrites` e `recordCounts` nunca eram tocados por id, então cresciam pela vida do processo.\n * Nenhum dos dois é grande por entrada — o vazamento é de contagem, não de volume — mas cache sem\n * dono da remoção é cache que só cresce.\n *\n * Devolve a contagem para que o chamador possa provar a remoção; um segundo descarte devolve 0,\n * que é o que torna o teste de idempotência possível sem expor os mapas.\n */\nexport function descartarSessao(cwd: string, agentId: string): number {\n  const chave = transcriptKey(cwd, agentId);\n  let removidas = 0;\n  // `sessions` NÃO é apagado aqui — e a distinção é medida, não estética. Ele é a conversa\n  // legível, e há leitor legítimo DEPOIS do dispose: o golden `two-concurrent-sends-serialize`\n  // chama `getSessionMessages(agentId)` após `agent.dispose()`. Apagá-lo aqui devolvia lista vazia\n  // e quebrava dois goldens. Quem o limita é o teto LRU acima; os três abaixo são escrituração\n  // pura, sem leitor pós-dispose.\n  if (hydratedKeys.delete(chave)) removidas++;\n  if (pendingWrites.delete(agentId)) removidas++;\n  if (recordCounts.delete(agentId)) removidas++;\n  return removidas;\n}\n\nexport function getSessionMessages(agentId: string): SessionMessage[] {\n  return sessions.get(agentId) ?? [];\n}\n\n/**\n * Persist a full conversation turn (user + assistant + tool blocks) to the native\n * transcript. Chained per-(agent, transcript) so on-disk order matches send order,\n * and fire-and-forget so `send()` is not blocked by disk I/O. Every\n * M50 — when the caller supplies `turn.autoCompact`, size-driven auto-compaction (usage real vs\n * the model's context window) runs in this same chain, surfaced via the optional `onCompact` observer.\n *\n * @internal\n */\nexport function persistTurnToTranscript(\n  store: SessionStore,\n  loc: TranscriptLocation,\n  sessionId: string,\n  turn: PersistTurnInput,\n  onCompact?: () => void,\n): void {\n  const key = transcriptKey(loc.cwd, loc.agentId);\n  // Divida PRE-EXISTENTE, exposta quando o M75 consertou a config Biome que abortava antes\n  // de varrer estes arquivos (raiz aninhada em refactor/). Nao e codigo novo e nao foi tocado\n  // pelo M75; refatorar internals do SDK sem revisao trocaria um problema visivel por um diff\n  // arriscado. Rastreado em usetheodev/theokit-sdk#151.\n  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: ver a razao logo acima\n  const chained = (pendingWrites.get(key) ?? Promise.resolve()).then(async () => {\n    try {\n      await persistTurn(store, loc, sessionId, turn);\n      const count = (recordCounts.get(key) ?? 0) + 1;\n      recordCounts.set(key, count);\n      // M50 — the 50-turn no-summary boundary stub is GONE (it silently amnesia'd the session).\n      // Auto-compaction is now size-driven with a real summary: see `maybeAutoCompact` below,\n      // invoked in this same write chain by the post-run lifecycle when usage is known.\n      if (turn.autoCompact !== undefined) {\n        const { autoCompactIfNeeded } = await import(\"./compact-session.js\");\n        const fired = await autoCompactIfNeeded({\n          store,\n          loc,\n          sessionId,\n          usageTotal: turn.autoCompact.usageTotal,\n          contextWindow: turn.autoCompact.contextWindow,\n          turnCount: count,\n          summarize: turn.autoCompact.summarize,\n        });\n        if (fired) onCompact?.();\n      }\n    } catch (cause) {\n      const msg = cause instanceof Error ? cause.message : String(cause);\n      process.stderr.write(\n        `[theokit-sdk] session transcript write failed (${loc.agentId}): ${msg}\\n`,\n      );\n    }\n  });\n  pendingWrites.set(\n    key,\n    chained.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n}\n\n/**\n * Load the persisted transcript into the in-memory cache. Idempotent per\n * (baseDir, cwd, agentId). Call once per agent lifecycle before the first read.\n *\n * @internal\n */\nexport async function hydrateSession(\n  agentId: string,\n  loc: { store: SessionStore; cwd: string },\n): Promise<void> {\n  const key = transcriptKey(loc.cwd, agentId);\n  if (hydratedKeys.has(key)) return;\n  hydratedKeys.add(key);\n\n  const persisted = await readSessionMessages(loc.store, agentId);\n  if (persisted.length === 0) return;\n  // M51 review F4 — the DISK is the source of truth at hydration time: after an invalidation\n  // (compact/inject), an in-flight turn may have repopulated the cache with a SINGLE message before\n  // this hydrate ran; the old \"skip when non-empty\" guard then pinned the parent to a 1-message\n  // context (history + injected pair lost until restart). The persist chain serializes writes, so\n  // the disk already contains that in-flight turn — replacing is always correct.\n  sessions.set(agentId, persisted);\n}\n\n/**\n * Wait for all pending transcript writes to settle. Used by tests and by the\n * agent dispose path so on-disk state matches in-memory before the caller proceeds.\n *\n * @internal\n */\nexport async function flushSessionWrites(): Promise<void> {\n  while (pendingWrites.size > 0) {\n    const all = Array.from(pendingWrites.values());\n    pendingWrites.clear();\n    await Promise.all(all);\n  }\n}\n\nexport function clearSession(agentId: string): void {\n  sessions.delete(agentId);\n}\n\n/**\n * M50 review F1 — drop BOTH the message cache and the hydration marker so the NEXT send re-hydrates\n * from disk. Without this, a compaction only helps after a process restart: the live process keeps\n * sending the full pre-compact history (the cache is read synchronously by every send).\n */\n/**\n * M50 review F5 — run `fn` serialized on the SAME per-(cwd,agentId) write chain the per-turn\n * persistence uses, so a manual `Agent.compact` can never interleave with an in-flight turn's\n * writes (boundary landing mid-turn would orphan the turn from the replay).\n */\nexport function enqueueSessionWrite<T>(\n  cwd: string,\n  agentId: string,\n  fn: () => Promise<T>,\n): Promise<T> {\n  const key = transcriptKey(cwd, agentId);\n  const prior = pendingWrites.get(key) ?? Promise.resolve();\n  const result = prior.then(fn);\n  pendingWrites.set(\n    key,\n    result.then(\n      () => undefined,\n      () => undefined,\n    ),\n  );\n  return result;\n}\n\n/** Test-only: drop every cached session and hydration marker. @internal */\nexport function clearAllSessions(): void {\n  sessions.clear();\n  hydratedKeys.clear();\n  recordCounts.clear();\n  // M50 review F11 — the auto-compact attempt marks live on globalThis; tests reset them here.\n  const g = globalThis as unknown as Record<symbol, Map<string, number>>;\n  const sym = Symbol.for(\"theokit-sdk.session.auto-compact-attempts\");\n  g[sym]?.clear();\n}\n"]}

package/dist/chunk-FER7UMIC.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunkLDDUIXWS_cjs = require('./chunk-LDDUIXWS.cjs');
+var chunkCJVMDRQB_cjs = require('./chunk-CJVMDRQB.cjs');
+var chunk2DYI7MIF_cjs = require('./chunk-2DYI7MIF.cjs');
+var promises = require('fs/promises');
+var path = require('path');
+
+var compartilhados = /* @__PURE__ */ new Map();
+async function adquirirCompartilhado(path) {
+  const existente = compartilhados.get(path);
+  if (existente !== void 0) {
+    existente.refs++;
+    return criarProxy(path);
+  }
+  const lease = await chunkLDDUIXWS_cjs.acquireSessionWriter(path);
+  compartilhados.set(path, { lease, refs: 1 });
+  return criarProxy(path);
+}
+function criarProxy(path) {
+  let solto = false;
+  return {
+    sessionPath: path,
+    release: async () => {
+      if (solto) return;
+      solto = true;
+      const entrada = compartilhados.get(path);
+      if (entrada === void 0) return;
+      entrada.refs--;
+      if (entrada.refs > 0) return;
+      compartilhados.delete(path);
+      await entrada.lease.release();
+    }
+  };
+}
+var FsSessionStore = class {
+  #baseDir;
+  #cwd;
+  /** Um lease por `agentId` — um store serve mais de uma sessão ao longo da vida do processo. */
+  #leases = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#baseDir = options.baseDir;
+    this.#cwd = options.cwd;
+  }
+  async readRecords(agentId) {
+    return chunk2DYI7MIF_cjs.readTranscript(chunk2DYI7MIF_cjs.transcriptPath(this.#baseDir, this.#cwd, agentId));
+  }
+  async appendRecords(agentId, records) {
+    if (records.length === 0) return;
+    const path$1 = chunk2DYI7MIF_cjs.transcriptPath(this.#baseDir, this.#cwd, agentId);
+    await promises.mkdir(path.dirname(path$1), { recursive: true });
+    if (!this.#leases.has(agentId)) {
+      this.#leases.set(agentId, await adquirirCompartilhado(path$1));
+    }
+    await chunkCJVMDRQB_cjs.withFileLock(path$1, async () => {
+      for (const record of records) chunkCJVMDRQB_cjs.appendJsonl(path$1, record);
+    });
+  }
+  /**
+   * Solta todo lease que este store detém.
+   *
+   * Sem isto o `.writer.lock` sobrevive ao processo e a próxima abertura teria de esperar a janela
+   * de heartbeat — recuperável, mas 30 s de espera para um encerramento LIMPO seria um defeito
+   * evitável. Idempotente: chamar duas vezes não é erro.
+   */
+  async dispose() {
+    const leases = [...this.#leases.values()];
+    this.#leases.clear();
+    for (const lease of leases) await lease.release();
+  }
+};
+
+exports.FsSessionStore = FsSessionStore;
+//# sourceMappingURL=chunk-FER7UMIC.cjs.map
+//# sourceMappingURL=chunk-FER7UMIC.cjs.map

package/dist/chunk-FER7UMIC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/persistence/fs-session-store.ts"],"names":["acquireSessionWriter","readTranscript","transcriptPath","path","mkdir","dirname","withFileLock","appendJsonl"],"mappings":";;;;;;;;AAyDA,IAAM,cAAA,uBAAqB,GAAA,EAAyD;AAEpF,eAAe,sBAAsB,IAAA,EAA2C;AAC9E,EAAA,MAAM,SAAA,GAAY,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AACzC,EAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,IAAA,SAAA,CAAU,IAAA,EAAA;AACV,IAAA,OAAO,WAAW,IAAI,CAAA;AAAA,EACxB;AACA,EAAA,MAAM,KAAA,GAAQ,MAAMA,sCAAA,CAAqB,IAAI,CAAA;AAC7C,EAAA,cAAA,CAAe,IAAI,IAAA,EAAM,EAAE,KAAA,EAAO,IAAA,EAAM,GAAG,CAAA;AAC3C,EAAA,OAAO,WAAW,IAAI,CAAA;AACxB;AAGA,SAAS,WAAW,IAAA,EAAkC;AACpD,EAAA,IAAI,KAAA,GAAQ,KAAA;AACZ,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,IAAA;AAAA,IACb,SAAS,YAA2B;AAClC,MAAA,IAAI,KAAA,EAAO;AACX,MAAA,KAAA,GAAQ,IAAA;AACR,MAAA,MAAM,OAAA,GAAU,cAAA,CAAe,GAAA,CAAI,IAAI,CAAA;AACvC,MAAA,IAAI,YAAY,MAAA,EAAW;AAC3B,MAAA,OAAA,CAAQ,IAAA,EAAA;AACR,MAAA,IAAI,OAAA,CAAQ,OAAO,CAAA,EAAG;AACtB,MAAA,cAAA,CAAe,OAAO,IAAI,CAAA;AAC1B,MAAA,MAAM,OAAA,CAAQ,MAAM,OAAA,EAAQ;AAAA,IAC9B;AAAA,GACF;AACF;AAEO,IAAM,iBAAN,MAA6C;AAAA,EACzC,QAAA;AAAA,EACA,IAAA;AAAA;AAAA,EAEA,OAAA,uBAAc,GAAA,EAAgC;AAAA,EAEvD,YAAY,OAAA,EAAgC;AAC1C,IAAA,IAAA,CAAK,WAAW,OAAA,CAAQ,OAAA;AACxB,IAAA,IAAA,CAAK,OAAO,OAAA,CAAQ,GAAA;AAAA,EACtB;AAAA,EAEA,MAAM,YAAY,OAAA,EAA2C;AAC3D,IAAA,OAAOC,iCAAeC,gCAAA,CAAe,IAAA,CAAK,UAAU,IAAA,CAAK,IAAA,EAAM,OAAO,CAAC,CAAA;AAAA,EACzE;AAAA,EAEA,MAAM,aAAA,CAAc,OAAA,EAAiB,OAAA,EAAkD;AAErF,IAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AAC1B,IAAA,MAAMC,SAAOD,gCAAA,CAAe,IAAA,CAAK,QAAA,EAAU,IAAA,CAAK,MAAM,OAAO,CAAA;AAE7D,IAAA,MAAME,eAAMC,YAAA,CAAQF,MAAI,GAAG,EAAE,SAAA,EAAW,MAAM,CAAA;AAK9C,IAAA,IAAI,CAAC,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,OAAO,CAAA,EAAG;AAC9B,MAAA,IAAA,CAAK,QAAQ,GAAA,CAAI,OAAA,EAAS,MAAM,qBAAA,CAAsBA,MAAI,CAAC,CAAA;AAAA,IAC7D;AACA,IAAA,MAAMG,8BAAA,CAAaH,QAAM,YAAY;AAyBnC,MAAA,KAAA,MAAW,MAAA,IAAU,OAAA,EAASI,6BAAA,CAAYJ,MAAA,EAAM,MAAM,CAAA;AAAA,IACxD,CAAC,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAM,OAAA,GAAyB;AAC7B,IAAA,MAAM,SAAS,CAAC,GAAG,IAAA,CAAK,OAAA,CAAQ,QAAQ,CAAA;AACxC,IAAA,IAAA,CAAK,QAAQ,KAAA,EAAM;AACnB,IAAA,KAAA,MAAW,KAAA,IAAS,MAAA,EAAQ,MAAM,KAAA,CAAM,OAAA,EAAQ;AAAA,EAClD;AACF","file":"chunk-FER7UMIC.cjs","sourcesContent":["/**\n * SE41 — `FsSessionStore`, the DEFAULT reference implementation of the pluggable\n * {@link SessionStore} seam. It reads and append-writes the native Claude-shaped\n * `.jsonl` transcript at `<baseDir>/projects/<encoded-cwd>/<agentId>.jsonl` — the\n * exact on-disk format SE40 introduced (the file the Claude Code CLI can\n * `--continue`). Omitting `local.sessionStore` resolves to this store, so the\n * default persistence path is byte-identical to SE40 behavior.\n *\n * `readRecords` is `readTranscript(transcriptPath(...))` (a missing session →\n * `[]`, not an error — a fresh agent has no history). `appendRecords` is a TRUE\n * append: it reads the prior records, concatenates the new-turn delta, and\n * rewrites the whole line set atomically under the SE40 cross-process file lock\n * (`writeTranscript` never shrinks — the native format is an append-only\n * `parentUuid` DAG). The parent dir is created BEFORE acquiring the lock because\n * the lock's companion `<path>.lock` file needs an existing parent dir (the SE40\n * `mkdir(dirname)`-before-lock fix).\n *\n * @internal\n */\n\nimport { mkdir } from \"node:fs/promises\";\nimport { dirname } from \"node:path\";\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { withFileLock } from \"./file-lock.js\";\nimport { appendJsonl } from \"./jsonl.js\";\nimport { readTranscript, type SessionRecord, transcriptPath } from \"./session-transcript.js\";\nimport { acquireSessionWriter, type SessionWriterLease } from \"./session-writer.js\";\n\n/** Options identifying the on-disk transcript location for the FS default store. */\nexport interface FsSessionStoreOptions {\n  /** Transcript base dir (`~/.theokit` default, `~/.claude` for CLI interop) — already `~`-expanded. */\n  baseDir: string;\n  /** The workspace cwd whose encoded form is the transcript project dir. */\n  cwd: string;\n}\n\n/**\n * The default `SessionStore` — reads/append-writes the native `.jsonl` transcript.\n *\n * @internal\n */\n/**\n * Leases compartilhados por caminho, com contagem de referências.\n *\n * `acquireSessionWriter` é ESTRITO de propósito: duas aquisições concorrentes do mesmo caminho, e\n * exatamente uma vence — \"um lease que deixasse as duas passarem seria decorativo\" (o teste do M81\n * diz isso com todas as letras, e está certo). Esse é o contrato do primitivo, e ele não muda.\n *\n * Mas dentro de UM processo é normal existir mais de um store sobre a mesma sessão: os testes\n * golden de compactação e de sends concorrentes fazem exatamente isso, e são registro de\n * comportamento real do runtime. Aplicar o primitivo cru ali transformaria um padrão legítimo em\n * `SessionBusyError`.\n *\n * A conciliação é aqui, no consumidor do primitivo: o processo tira UM lease por caminho e conta\n * quantos stores o usam. O último a soltar libera de fato. Cross-process continua estrito — que é o\n * problema que o M81 enuncia (\"`exec resume --last` pode escrever na sessão viva da TUI\").\n */\nconst compartilhados = new Map<string, { lease: SessionWriterLease; refs: number }>();\n\nasync function adquirirCompartilhado(path: string): Promise<SessionWriterLease> {\n  const existente = compartilhados.get(path);\n  if (existente !== undefined) {\n    existente.refs++;\n    return criarProxy(path);\n  }\n  const lease = await acquireSessionWriter(path);\n  compartilhados.set(path, { lease, refs: 1 });\n  return criarProxy(path);\n}\n\n/** Um handle que decrementa a contagem; o último a soltar libera o lease de verdade. */\nfunction criarProxy(path: string): SessionWriterLease {\n  let solto = false;\n  return {\n    sessionPath: path,\n    release: async (): Promise<void> => {\n      if (solto) return;\n      solto = true;\n      const entrada = compartilhados.get(path);\n      if (entrada === undefined) return;\n      entrada.refs--;\n      if (entrada.refs > 0) return;\n      compartilhados.delete(path);\n      await entrada.lease.release();\n    },\n  };\n}\n\nexport class FsSessionStore implements SessionStore {\n  readonly #baseDir: string;\n  readonly #cwd: string;\n  /** Um lease por `agentId` — um store serve mais de uma sessão ao longo da vida do processo. */\n  readonly #leases = new Map<string, SessionWriterLease>();\n\n  constructor(options: FsSessionStoreOptions) {\n    this.#baseDir = options.baseDir;\n    this.#cwd = options.cwd;\n  }\n\n  async readRecords(agentId: string): Promise<SessionRecord[]> {\n    return readTranscript(transcriptPath(this.#baseDir, this.#cwd, agentId));\n  }\n\n  async appendRecords(agentId: string, records: readonly SessionRecord[]): Promise<void> {\n    // Empty delta → nothing to persist (avoids an unnecessary lock + rewrite).\n    if (records.length === 0) return;\n    const path = transcriptPath(this.#baseDir, this.#cwd, agentId);\n    // mkdir BEFORE the lock: withFileLock's companion `<path>.lock` needs the parent dir.\n    await mkdir(dirname(path), { recursive: true });\n    // M95 — a garantia de escritor único do M81 finalmente LIGADA. Ela existia como\n    // `acquireSessionWriter` e tinha ZERO chamadores de produção desde o dia em que foi escrita;\n    // o roadmap a registrava como entregue. Adquirido no primeiro append (leitura segue livre) e\n    // solto em `dispose()`.\n    if (!this.#leases.has(agentId)) {\n      this.#leases.set(agentId, await adquirirCompartilhado(path));\n    }\n    await withFileLock(path, async () => {\n      // M93 — acrescenta o DELTA em vez de reescrever o arquivo inteiro.\n      //\n      // Antes: `readTranscript` + `writeTranscript` de tudo, por turno. O(n) de I/O **e** de parse a\n      // cada turno, O(n²) por sessão — a nota do consumidor em `agents/lib/session/backtrack.ts`\n      // registra 1,4 MB / 3000 linhas em 200 turnos.\n      //\n      // Correto porque o formato **já é append-only**: o DAG de `parentUuid` não depende da ordem de\n      // linha, e cada registro carrega o próprio pai. `appendJsonl` **já existia no pacote** e tinha um\n      // único chamador (`eval/runner.ts`) — a primitiva estava lá, o store é que a ignorava (rung 4).\n      //\n      // O `withFileLock` permanece — mas a afirmação anterior de que \"ele é o que serializa dois\n      // `appendRecords` concorrentes\" era forte demais, e a revisão adversarial do M93 mediu isso:\n      // removê-lo não reprova nenhum teste. A razão é o próprio parágrafo acima — o DAG de\n      // `parentUuid` não depende da ordem de linha, então dois lotes intercalados reconstroem igual.\n      // O trabalho que o lock fazia (proteger um read-modify-write) sumiu junto com o rewrite.\n      //\n      // O que ele ainda cobre é a janela TOCTOU de `precisaDeQuebraAntes` (ler o último byte, depois\n      // escrever): sem ele, dois processos podem ambos concluir \"falta \\n\" e produzir uma linha em\n      // branco — que o leitor descarta, isto é, benigno. Fica como **defesa declarada, não\n      // mecanizada** (a disciplina de `error-handling.md § 4`: enumerar o resíduo em vez de deixar a\n      // ausência de teste passar por cobertura).\n      //\n      // `writeTranscript` continua existindo para **compactação**, a única operação que legitimamente\n      // reescreve o arquivo.\n      for (const record of records) appendJsonl(path, record);\n    });\n  }\n\n  /**\n   * Solta todo lease que este store detém.\n   *\n   * Sem isto o `.writer.lock` sobrevive ao processo e a próxima abertura teria de esperar a janela\n   * de heartbeat — recuperável, mas 30 s de espera para um encerramento LIMPO seria um defeito\n   * evitável. Idempotente: chamar duas vezes não é erro.\n   */\n  async dispose(): Promise<void> {\n    const leases = [...this.#leases.values()];\n    this.#leases.clear();\n    for (const lease of leases) await lease.release();\n  }\n}\n"]}

package/dist/{chunk-NZCFLEHO.cjs → chunk-FTRNHGAD.cjs}

@@ -3,8 +3,8 @@
 var chunkLUSXDZPV_cjs = require('./chunk-LUSXDZPV.cjs');
 var chunkIT3PWBW4_cjs = require('./chunk-IT3PWBW4.cjs');
 var chunk6JSIEDKL_cjs = require('./chunk-6JSIEDKL.cjs');
-var chunkU2FO3MRG_cjs = require('./chunk-U2FO3MRG.cjs');
-var chunkEVADEGM7_cjs = require('./chunk-EVADEGM7.cjs');
+var chunk2DYI7MIF_cjs = require('./chunk-2DYI7MIF.cjs');
+var chunkFX2DAR5R_cjs = require('./chunk-FX2DAR5R.cjs');
 var chunkD42XHI4O_cjs = require('./chunk-D42XHI4O.cjs');
 var chunkA44COQJJ_cjs = require('./chunk-A44COQJJ.cjs');
 var chunkBEURCLDV_cjs = require('./chunk-BEURCLDV.cjs');
@@ -726,7 +726,7 @@ async function resolveBedrockToken(region) {
     return cachedToken.value;
   }
   try {
-    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-NZCFLEHO.cjs', document.baseURI).href)));
+    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-FTRNHGAD.cjs', document.baseURI).href)));
     const gen = r("@aws/bedrock-token-generator");
     if (typeof gen.getToken !== "function") return void 0;
     const providers = r("@aws-sdk/credential-providers");
@@ -2309,7 +2309,7 @@ async function resolveVertexAccessToken() {
 async function getAuthClientOrThrow() {
   let mod;
   try {
-    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-NZCFLEHO.cjs', document.baseURI).href)));
+    const r = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-FTRNHGAD.cjs', document.baseURI).href)));
     mod = r("google-auth-library");
   } catch (err) {
     const isModuleMissing = err instanceof Error && (err.message.includes("Cannot find module") || err.code === "MODULE_NOT_FOUND");
@@ -2820,7 +2820,7 @@ function plainText(content) {
 }
 async function compactSessionTranscript(opts) {
   const prior = await opts.store.readRecords(opts.loc.agentId);
-  const history = chunkU2FO3MRG_cjs.reconstructMessages(prior);
+  const history = chunk2DYI7MIF_cjs.reconstructMessages(prior);
   const compressible = [];
   for (const m of history) {
     const text = plainText(m.content);
@@ -2828,14 +2828,14 @@ async function compactSessionTranscript(opts) {
       compressible.push({ role: m.role, content: text });
     }
   }
-  const preTokens = chunkEVADEGM7_cjs.estimateTokens(compressible.map((m) => m.content).join("\n"));
+  const preTokens = chunkFX2DAR5R_cjs.estimateTokens(compressible.map((m) => m.content).join("\n"));
   const summaryBody = await opts.summarize(compressible);
   const preserved = [];
   let budget = 0;
   for (let i = compressible.length - 1; i >= 0; i--) {
     const m = compressible[i];
     if (m === void 0 || m.role !== "user" || isCompactSummary(m.content)) continue;
-    const cost = chunkEVADEGM7_cjs.estimateTokens(m.content);
+    const cost = chunkFX2DAR5R_cjs.estimateTokens(m.content);
     if (budget + cost > COMPACT_USER_MESSAGE_MAX_TOKENS) {
       const remaining = COMPACT_USER_MESSAGE_MAX_TOKENS - budget;
       if (remaining > 50) {
@@ -2849,7 +2849,7 @@ async function compactSessionTranscript(opts) {
   }
   const summary = `${COMPACT_SUMMARY_MARKER}
 ${summaryBody}`;
-  const transcript = chunkU2FO3MRG_cjs.SessionTranscript.fromRecords(prior, {
+  const transcript = chunk2DYI7MIF_cjs.SessionTranscript.fromRecords(prior, {
     cwd: opts.loc.cwd,
     sessionId: opts.sessionId,
     model: opts.loc.model ?? "unknown"
@@ -2860,7 +2860,7 @@ ${summaryBody}`;
   const delta = transcript.records().slice(prior.length);
   await opts.store.appendRecords(opts.loc.agentId, delta);
   chunkIT3PWBW4_cjs.invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);
-  const postTokens = chunkEVADEGM7_cjs.estimateTokens([...preserved, summary].join("\n"));
+  const postTokens = chunkFX2DAR5R_cjs.estimateTokens([...preserved, summary].join("\n"));
   return { preTokens, postTokens };
 }
 function resolveSummarizerRoute(opts) {
@@ -2970,5 +2970,5 @@ exports.resolveProviderChain = resolveProviderChain;
 exports.resolveSummarizerRoute = resolveSummarizerRoute;
 exports.shouldAutoCompact = shouldAutoCompact;
 exports.tryFirstEvent = tryFirstEvent;
-//# sourceMappingURL=chunk-NZCFLEHO.cjs.map
-//# sourceMappingURL=chunk-NZCFLEHO.cjs.map
+//# sourceMappingURL=chunk-FTRNHGAD.cjs.map
+//# sourceMappingURL=chunk-FTRNHGAD.cjs.map