@theokit/sdk 4.37.1 → 4.38.0

package/dist/{inject-session-DM4SKTZO.cjs → inject-session-25EC74WV.cjs}

@@ -1,16 +1,16 @@
 'use strict';
 
-var chunkH5YVJB4K_cjs = require('./chunk-H5YVJB4K.cjs');
-var chunkIT3PWBW4_cjs = require('./chunk-IT3PWBW4.cjs');
-var chunkIEUDKUPM_cjs = require('./chunk-IEUDKUPM.cjs');
-require('./chunk-ICYBIC6N.cjs');
-require('./chunk-LTCOPATU.cjs');
+var chunk6ZGD7R27_cjs = require('./chunk-6ZGD7R27.cjs');
+var chunkBURYFNOM_cjs = require('./chunk-BURYFNOM.cjs');
+var chunk6OKPJZMX_cjs = require('./chunk-6OKPJZMX.cjs');
+require('./chunk-YVI4YPUP.cjs');
+require('./chunk-BE3W4HYV.cjs');
 
 // src/internal/session/inject-session.ts
 async function injectSessionTurn(opts) {
-  await chunkH5YVJB4K_cjs.enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
+  await chunk6ZGD7R27_cjs.enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
     const prior = await opts.store.readRecords(opts.loc.agentId);
-    const transcript = chunkIEUDKUPM_cjs.SessionTranscript.fromRecords(prior, {
+    const transcript = chunk6OKPJZMX_cjs.SessionTranscript.fromRecords(prior, {
       cwd: opts.loc.cwd,
       sessionId: opts.sessionId,
       model: opts.loc.model ?? "unknown"
@@ -18,10 +18,10 @@ async function injectSessionTurn(opts) {
     transcript.appendUserTurn(opts.userText);
     transcript.appendAssistantTurn({ text: opts.assistantText });
     await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));
-    chunkIT3PWBW4_cjs.invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);
+    chunkBURYFNOM_cjs.invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);
   });
 }
 
 exports.injectSessionTurn = injectSessionTurn;
-//# sourceMappingURL=inject-session-DM4SKTZO.cjs.map
-//# sourceMappingURL=inject-session-DM4SKTZO.cjs.map
+//# sourceMappingURL=inject-session-25EC74WV.cjs.map
+//# sourceMappingURL=inject-session-25EC74WV.cjs.map

package/dist/{inject-session-DM4SKTZO.cjs.map → inject-session-25EC74WV.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":["enqueueSessionWrite","SessionTranscript","invalidateSessionCache"],"mappings":";;;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAMA,sCAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAaC,mCAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAAC,wCAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-DM4SKTZO.cjs","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":["enqueueSessionWrite","SessionTranscript","invalidateSessionCache"],"mappings":";;;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAMA,sCAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAaC,mCAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAAC,wCAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-25EC74WV.cjs","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/{inject-session-UXNJQTZ6.js → inject-session-RKNLUE72.js}

@@ -1,8 +1,8 @@
-import { enqueueSessionWrite } from './chunk-5SB4V74H.js';
-import { invalidateSessionCache } from './chunk-EEZ7CFMM.js';
-import { SessionTranscript } from './chunk-XAEAMI5H.js';
-import './chunk-56OXYUZE.js';
-import './chunk-TAPQWDW2.js';
+import { enqueueSessionWrite } from './chunk-A4XXV2C6.js';
+import { invalidateSessionCache } from './chunk-5KOW3GLE.js';
+import { SessionTranscript } from './chunk-AOZYORH7.js';
+import './chunk-LGCEYEU2.js';
+import './chunk-KCZW75PI.js';
 
 // src/internal/session/inject-session.ts
 async function injectSessionTurn(opts) {
@@ -21,5 +21,5 @@ async function injectSessionTurn(opts) {
 }
 
 export { injectSessionTurn };
-//# sourceMappingURL=inject-session-UXNJQTZ6.js.map
-//# sourceMappingURL=inject-session-UXNJQTZ6.js.map
+//# sourceMappingURL=inject-session-RKNLUE72.js.map
+//# sourceMappingURL=inject-session-RKNLUE72.js.map

package/dist/{inject-session-UXNJQTZ6.js.map → inject-session-RKNLUE72.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":[],"mappings":";;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAM,oBAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAA,sBAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-UXNJQTZ6.js","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":[],"mappings":";;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAM,oBAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAA,sBAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-RKNLUE72.js","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/internal/agent-loop/live-events.d.ts

@@ -0,0 +1,46 @@
+import type { SDKMessage } from "../../types/messages.js";
+/**
+ * theokit#140 — the loop's event log, reporting each event AS IT HAPPENS.
+ *
+ * ## The defect this closes
+ *
+ * `runAgentLoop` collected events into a plain array and returned it, so nothing reached the run
+ * until the loop had finished. `RealLocalRun.applyAgentLoopOutput` then copied the whole batch in
+ * one pass. Meanwhile `SendOptions.onDelta` fired live from inside that same loop.
+ *
+ * Two clocks, one of which does not start until the other has stopped. A consumer that wanted tool
+ * calls interleaved with tokens in true order had to fuse both surfaces itself — which is exactly
+ * what `@theokit/agents` was doing, and the documented root of its ordering bug (theokit#47), its
+ * namespace-dedup bug (theokit#138) and its missing terminal frame (theokit#142).
+ *
+ * ## Why a subclass, and not a callback threaded through nine call sites
+ *
+ * The events are appended from nine places across `loop.ts`, `loop-llm-stream.ts` and
+ * `tool-dispatch.ts`. Threading an `onEvent` parameter to each would touch every one of them and,
+ * worse, would leave the NEXT `events.push(...)` silently un-notified — a defect that reintroduces
+ * itself by omission, which is the failure mode this whole issue is about.
+ *
+ * Extending `Array` moves the decision to the single place the log is CREATED. Every existing push
+ * becomes live with no call-site change, and any push added later is live for free.
+ *
+ * It stays a real `Array`: `AgentLoopOutput.events` is still `SDKMessage[]`, `instanceof Array`
+ * still holds, and every downstream consumer — including the batch copy in `applyAgentLoopOutput` —
+ * is unchanged. This is additive; nothing that worked before observes a difference.
+ *
+ * `push` is the only override, deliberately. The loop only ever appends; overriding the rest of the
+ * mutation surface would be guarding against callers that do not exist (YAGNI), and a subscriber
+ * that must reason about splices is a worse contract than one that receives appends.
+ */
+export declare class LiveEventLog extends Array<SDKMessage> {
+    #private;
+    /** Attach the live subscriber. One sink: the run that owns this loop. */
+    subscribe(sink: (event: SDKMessage) => void): void;
+    push(...events: SDKMessage[]): number;
+}
+/**
+ * Build the loop's event log, seeded with the events that exist before the loop starts.
+ *
+ * `LiveEventLog.from` rather than `new LiveEventLog(...seed)`: the `Array` constructor treats a
+ * single numeric argument as a length, and a seed is a list of events, never a count.
+ */
+export declare function createEventLog(seed: readonly SDKMessage[]): LiveEventLog;

package/dist/internal/budget/compute-cost.d.ts

@@ -10,7 +10,7 @@
  *   - "subscription_included" routes (Codex CLI, future Claude Pro) →
  *     return $0 with status="included".
  *   - Provider unknown / pricing missing → status="unknown" with
- *     undefined amountUsd (NÃO retorna 0 falso).
+ *     undefined amountUsd (does NOT return a false 0).
  *
  * @internal
  */

package/dist/internal/diagnostics.d.ts

@@ -1,54 +1,56 @@
 /**
- * Canal único de diagnóstico da biblioteca — silencioso por padrão (#147).
+ * The library's single diagnostics channel — silent by default (#147).
  *
  * ## O problema
  *
- * O SDK escrevia diagnósticos direto em `process.stderr` a partir de caminhos quentes —
- * 92 sítios em 51 arquivos sob `internal/`. Numa host de TUI (Ink, alternate screen), essas
- * escritas se intercalam com o render e **corrompem o frame**. E o host não tinha como
- * interceptá-las: não havia logger injetável. Um consumidor chegou a instalar
- * `proper-lockfile` só para calar UMA delas.
+ * The SDK wrote diagnostics straight to `process.stderr` from hot paths — 92 sites across 51
+ * files under `internal/`. In a TUI host (Ink, alternate screen), those writes interleave with the
+ * render and **corrupt the frame**. And the host had no way to intercept them: there was no
+ * injectable logger. One consumer went as far as installing `proper-lockfile` just to silence ONE
+ * of them.
  *
- * Uma biblioteca não pode assumir que `stdout`/`stderr` são sinks livres. Quem é dono do
- * terminal é a aplicação, não a dependência.
+ * A library cannot assume `stdout`/`stderr` are free sinks. The application owns the terminal, not
+ * the dependency.
  *
  * ## O contrato
  *
- * - **`setDiagnosticsSink(fn)`** entrega as mensagens à aplicação, que decide onde colocá-las
- *   (uma linha de status, um arquivo, um painel). É o que faltava para uma TUI conviver com o SDK.
- * - **Sem sink, vai para o `stderr`** — exatamente como antes desta mudança.
+ * - **`setDiagnosticsSink(fn)`** hands the messages to the application, which decides where to put
+ *   them (a status line, a file, a panel). It is what was missing for a TUI to coexist with the SDK.
+ * - **With no sink, it goes to `stderr`** — exactly as before this change.
  *
- * ## Por que o padrão NÃO mudou (ainda), e isso é deliberado
+ * ## Why the default did NOT change (yet), and why that is deliberate
  *
- * A #147 pede silêncio por padrão, e é o alvo certo. Mas **58 arquivos de teste** asseram hoje
- * que estes diagnósticos chegam ao `stderr` — eles codificam o contrato "o aviso É emitido", que
- * continua valendo e não deve ser perdido. Virar o padrão sem migrá-los reprovaria ~53 testes, e
- * migrá-los às pressas, em quatro formas diferentes de espionar o `stderr`, é a receita para
- * enfraquecer 58 suítes de uma vez.
+ * #147 asks for silence by default, and that is the right target. But **58 test files** currently
+ * assert these diagnostics reach `stderr` — they encode the contract "the warning IS emitted",
+ * which still holds and must not be lost. Flipping the default without migrating them would fail
+ * ~53 tests, and migrating them in a hurry, across four different ways of spying on `stderr`, is
+ * the recipe for weakening 58 suites at once.
  *
- * Então esta mudança entrega a metade que DESTRAVA o consumidor — o host de TUI agora consegue
+ * So this change delivers the half that UNBLOCKS the consumer — a TUI host can now
  * interceptar, que era o bloqueio relatado ("no way to intercept these; no injectable logger") — e
- * deixa a virada do padrão como migração própria, com custo medido. Um host que quer silêncio
+ * and leaves flipping the default as its own migration, with a measured cost. A host that wants silence
  * hoje instala `setDiagnosticsSink(() => {})`.
  *
- * ## O que isto NÃO é
+ * ## What this is NOT
  *
- * Não é um logger com níveis, formatação ou destinos múltiplos. É o mínimo que resolve o
- * bloqueio relatado; um logger completo aqui seria inventar requisito que ninguém pediu.
+ * It is not a logger with levels, formatting or multiple destinations. It is the minimum that
+ * resolves the reported blocker; a full logger here would be inventing a requirement nobody asked
+ * for.
  */
-/** Recebe cada mensagem de diagnóstico já formatada, com o `\n` final. */
+/** Receives each diagnostic message already formatted, with the trailing `\n`. */
 export type DiagnosticsSink = (message: string) => void;
 /**
- * Instala (ou remove, passando `undefined`) o destino dos diagnósticos.
+ * Installs (or removes, by passing `undefined`) the diagnostics destination.
  *
- * Quando há sink, ele é o ÚNICO destino — o `stderr` não recebe cópia. Duplicar destinos
- * devolveria o problema à TUI que instalou o sink justamente para tirar as mensagens do terminal.
+ * When a sink is present it is the ONLY destination — `stderr` gets no copy. Duplicating
+ * destinations would hand the problem back to the TUI that installed the sink precisely to get the
+ * messages out of the terminal.
  */
 export declare function setDiagnosticsSink(next: DiagnosticsSink | undefined): void;
 /**
- * Emite uma mensagem de diagnóstico da biblioteca.
+ * Emits a library diagnostic message.
  *
- * Substitui `process.stderr.write` nos caminhos internos. Nunca lança: um sink defeituoso não
- * pode derrubar o run que ele apenas observa.
+ * Replaces `process.stderr.write` on internal paths. Never throws: a faulty sink must not
+ * must not take down the run it merely observes.
  */
 export declare function diag(message: string): void;

package/dist/internal/error-mappers/anthropic.d.ts

@@ -12,7 +12,7 @@
  *                                       `"content_filtered"` for policy.)
  *   408     → `NetworkError`          (`code: "timeout"`)
  *   5xx     → `NetworkError`          (`code: "server_error"` — covers 529
- *                                       overloaded_error common em horário
+ *                                       overloaded_error common at peak
  *                                       de pico)
  *   other   → `UnknownAgentError`     (`code: "unknown"`)
  *

package/dist/internal/global-singleton.d.ts

@@ -1,13 +1,13 @@
 /**
  * Singleton por realm, chaveado por `Symbol.for`.
  *
- * Existe porque um pacote pode ser carregado mais de uma vez no mesmo processo (duas cópias em
- * `node_modules`, ESM e CJS lado a lado, monorepo com versões distintas) — e aí `const x = new Map()`
- * a nível de módulo produz DUAS caches que não se enxergam. `Symbol.for` usa o registro global de
- * símbolos, que é do realm e não do módulo, então todas as cópias convergem para a mesma instância.
+ * It exists because a package can be loaded more than once in the same process (two copies in
+ * `node_modules`, ESM and CJS side by side, a monorepo with distinct versions) — and then a module-level
+ * `const x = new Map()` produces TWO caches that cannot see each other. `Symbol.for` uses the global
+ * symbol registry, which belongs to the realm and not the module, so every copy converges on one instance.
  *
- * Estava copiado verbatim em `providers/discovery.ts` e `providers/catalog-loader.ts`. Isso é
- * duplicação de CONHECIMENTO, não coincidência de forma: as duas cópias precisam concordar sobre o
- * mecanismo, e uma corrigida sem a outra produz exatamente o bug que a função existe para evitar.
+ * It was copied verbatim into `providers/discovery.ts` and `providers/catalog-loader.ts`. That is
+ * duplicated KNOWLEDGE, not a coincidence of shape: the two copies have to agree on the
+ * mechanism, and one fixed without the other produces exactly the bug the function exists to avoid.
  */
 export declare function globalSingleton<T>(key: string, create: () => T): T;

package/dist/internal/judge/judge-call.d.ts

@@ -8,32 +8,32 @@ export interface JudgeContext {
 /** Caller-supplied tuning knobs for the judge call. */
 export interface JudgeOptions {
     /**
-     * Judge model identifier. Quando ausente, DERIVA de {@link agentModel} — e só cai no literal
-     * `"openai/gpt-4o-mini"` se nem esse for informado.
+     * Judge model identifier. When absent, it DERIVES from {@link agentModel} — and only falls back to the literal
+     * `"openai/gpt-4o-mini"` when neither is provided.
      *
-     * M80 — o default fixo era provider-cego: ele só resolve em OpenRouter. Com chave Anthropic dá
-     * 404, com bearer OAuth dá 401, e em ambos o goal queimava 3 turnos inteiros antes de falhar com
-     * razão enganosa. O agent-builder já contornava isso derivando por conta própria; o conhecimento
-     * pertence aqui.
+     * M80 — the fixed default was provider-blind: it only resolves on OpenRouter. With an Anthropic key it gives
+     * 404, with an OAuth bearer it gives 401, and in both the goal burned 3 whole turns before failing with
+     * a misleading reason. The agent-builder already worked around this by deriving on its own; the knowledge
+     * belongs here.
      */
     judgeModel?: string;
     /**
-     * M80 — o modelo do agente CONDUZIDO. É a base da derivação: um judge que roda no mesmo modelo do
-     * chat funciona onde o chat funciona.
+     * M80 — the DRIVEN agent's model. It is the basis of the derivation: a judge running on the same model as the
+     * chat works wherever chat works.
      */
     agentModel?: string;
     /** Override env. Default `process.env.OPENROUTER_API_KEY` (EC-A). */
     apiKey?: string;
 }
 /**
- * M80 — a credencial ou o modelo do judge não servem: 401/404.
+ * M80 — the judge's credential or model does not work: 401/404.
  *
- * Falha RÁPIDA por design. `rules/error-handling.md § 2` separa recuperável de irrecuperável, e um
- * modelo inexistente não passa a existir no retry — dobrar isso em `{parseFailed: true}` fazia o loop
- * tentar três vezes e reportar "failed" por limite de falhas consecutivas, escondendo que a causa era
- * credencial. Falha lenta e opaca trocada por rápida e clara.
+ * Fails FAST by design. `rules/error-handling.md` § 2 separates recoverable from unrecoverable, and a
+ * nonexistent model does not start existing on retry — folding that into `{parseFailed: true}` made the loop
+ * try three times and report "failed" on a consecutive-failure limit, hiding that the cause was the
+ * credential. A slow, opaque failure traded for a fast, clear one.
  *
- * Falha de PARSE e erro de rede continuam dobrados: são recuperáveis, e o loop já decide por falhas
+ * PARSE failures and network errors stay folded: they are recoverable, and the loop already decides on
  * consecutivas.
  */
 export declare class JudgeCredentialError extends TheokitAgentError {

package/dist/internal/llm/retrying-client.d.ts

@@ -1,40 +1,40 @@
 import type { LlmClient, LlmEvent, LlmFinish, LlmRequest } from "./types.js";
-/** Teto de tentativas. Fixo em 3 — o DoD do M93 nomeia o número. */
-export declare const MAX_TENTATIVAS = 3;
+/** Attempt ceiling. Fixed at 3 — M93's DoD names the number. */
+export declare const MAX_ATTEMPTS = 3;
 /**
- * O erro é transitório, isto é: reexecutar pode mudar o resultado?
+ * Is the error transient — that is, can retrying change the outcome?
  *
- * ## Delega para `isTransientError`, e diz o que subtrai
+ * ## Delegates to `isTransientError`, and states what it subtracts
  *
- * O SDK **já** publica `isTransientError` — documentado como "a single source of truth rather than
- * a re-derivation", e com o aviso explícito de que "It never inspects `err.message`". A primeira
- * versão desta função ignorou as duas coisas: derivou de novo, por regex sobre a mensagem
- * (`/\b4\d\d\b/`). A revisão adversarial mediu o custo — `connect ECONNREFUSED 127.0.0.1:443`
- * era classificado como NÃO transitório, porque a **porta** casa a regex. Os erros de rede para os
- * quais o retry existe eram exatamente os excluídos.
+ * The SDK **already** publishes `isTransientError` — documented as "a single source of truth rather
+ * than a re-derivation", with the explicit warning that "It never inspects `err.message`". The first
+ * version of this function ignored both: it re-derived, by regex over the message (`/\b4\d\d\b/`).
+ * Adversarial review measured the cost — `connect ECONNREFUSED 127.0.0.1:443` was classified as NOT
+ * transient, because the **port** matches the regex. The network errors retry exists for were
+ * exactly the ones excluded.
  *
- * Reinventar aqui foi violação da rung 4 da parcimônia com a peça pronta à mão. O que sobra desta
- * função são **três subtrações** do veredito do dono, cada uma com razão:
+ * Reinventing here violated parsimony rung 4 with the part already at hand. What remains of this
+ * function are **three subtractions** from the owner's verdict, each with a reason:
  *
- * | Subtração | Por quê |
+ * | Subtraction | Why |
  * |---|---|
- * | `CredentialPoolExhaustedError` | o pool já gastou o próprio orçamento de tentativas e rotação; o `nextRetryAt` está em dezenas de segundos. Reexecutar multiplicaria a espera por `MAX_TENTATIVAS` sem chance de sucesso. |
- * | `code === "circuit_open"` | o breaker existe **para** falhar rápido; envolvê-lo num retry desfaz de fora a decisão que ele acabou de tomar. |
- * | `RateLimitError` com 402 | cota de faturamento não se resolve em milissegundos — é por isso que o `classifyAndDecide` do pool rotaciona em vez de esperar. |
+ * | `CredentialPoolExhaustedError` | the pool already spent its own attempt and rotation budget; `nextRetryAt` is tens of seconds out. Retrying would multiply the wait by `MAX_ATTEMPTS` with no chance of success. |
+ * | `code === "circuit_open"` | the breaker exists **in order to** fail fast; wrapping it in a retry undoes from outside the decision it just made. |
+ * | `RateLimitError` with 402 | a billing quota does not resolve in milliseconds — which is why the pool's `classifyAndDecide` rotates instead of waiting. |
  *
- * As duas primeiras vieram da medição da revisão: com elas transitórias, o pool inteiro era
- * reexecutado 3×, e uma espera de 30 s virava ~90 s.
+ * The first two came out of the review's measurements: with them treated as transient, the entire
+ * pool was retried 3x, and a 30 s wait became ~90 s.
  */
-export declare function ehTransitorio(err: unknown): boolean;
+export declare function isRetriableError(err: unknown): boolean;
 /**
- * ## Por que NÃO há circuit breaker aqui
+ * ## Why there is NO circuit breaker here
  *
- * O `CircuitBreaker` do pacote é **chaveado por credencial** (`recordSuccess(key)` /
- * `recordTimeout(key)`): existe para o pool marcar uma chave como insalubre e **pular** para outra. Com
- * uma chave só não há para onde pular, então um breaker aqui registraria estado que ninguém consulta.
+ * The package's `CircuitBreaker` is **keyed by credential** (`recordSuccess(key)` /
+ * `recordTimeout(key)`): it exists so the pool can mark a key unhealthy and **skip** to another.
+ * With a single key there is nowhere to skip to, so a breaker here would record state nobody reads.
  *
- * Rung 1 da parcimônia — "isto precisa existir?". Não: seria cerimônia com nome de resiliência. O que
- * protege o caminho de chave única é o teto de tentativas e o backoff, e os dois estão abaixo.
+ * Parsimony rung 1 — "does this need to exist?". No: it would be ceremony with resilience's name on
+ * it. What protects the single-key path is the attempt ceiling and the backoff, and both are below.
  */
 export declare class RetryingLlmClient implements LlmClient {
     #private;
@@ -42,10 +42,10 @@ export declare class RetryingLlmClient implements LlmClient {
         rng?: () => number;
     });
     /**
-     * O cliente decorado. Público pela mesma convenção de `FaultInjectingLlmClient.inner`: os testes
-     * de fiação do router afirmam `instanceof PoolAwareLlmClient` e precisam enxergar através dos
-     * decorators. Sem isto, adicionar um decorator quebra testes cuja intenção continua válida — que
-     * foi exatamente o que o M93 fez com 4 testes pré-existentes.
+     * The decorated client. Public by the same convention as `FaultInjectingLlmClient.inner`: the
+     * router's wiring tests assert `instanceof PoolAwareLlmClient` and need to see through the
+     * decorators. Without this, adding a decorator breaks tests whose intent is still valid — which is
+     * exactly what M93 did to 4 pre-existing tests.
      */
     get inner(): LlmClient;
     get name(): string;

package/dist/internal/llm/transport-error.d.ts

@@ -1,7 +1,7 @@
 /**
- * Envolve uma falha de socket num {@link NetworkError}, preservando a causa.
+ * Wraps a socket failure in a {@link NetworkError}, preserving the cause.
  *
- * Devolve o erro original — sem envolver — quando ele é um abort ou já é um erro do SDK.
+ * Returns the original error — unwrapped — when it is an abort or already an SDK error.
  */
 export declare function wrapTransportError(err: unknown, ctx: {
     providerId: string;

package/dist/internal/persistence/exclusive-create.d.cts

@@ -11,8 +11,8 @@
  * readable 0o644 under typical umask 022. Callers writing non-sensitive
  * files can pass `mode: 0o644` explicitly.
  *
- * NFS sem honor de O_EXCL é documentado (D61 — mesma postura do
- * `withFileLock`); SDK target é ext4/APFS/NTFS.
+ * NFS not honoring O_EXCL is documented (D61 — same stance as
+ * `withFileLock`); the SDK target is ext4/APFS/NTFS.
  *
  * @internal
  */

package/dist/internal/persistence/exclusive-create.d.ts

@@ -11,8 +11,8 @@
  * readable 0o644 under typical umask 022. Callers writing non-sensitive
  * files can pass `mode: 0o644` explicitly.
  *
- * NFS sem honor de O_EXCL é documentado (D61 — mesma postura do
- * `withFileLock`); SDK target é ext4/APFS/NTFS.
+ * NFS not honoring O_EXCL is documented (D61 — same stance as
+ * `withFileLock`); the SDK target is ext4/APFS/NTFS.
  *
  * @internal
  */

package/dist/internal/persistence/fs-session-store.d.cts

@@ -32,34 +32,34 @@ export declare class FsSessionStore implements SessionStore {
     readRecords(agentId: string): Promise<SessionRecord[]>;
     appendRecords(agentId: string, records: readonly SessionRecord[]): Promise<void>;
     /**
-     * Toma o lease de escritor da sessão. Lança `SessionBusyError` quando outro processo a detém.
+     * Takes the session's writer lease. Throws `SessionBusyError` when another process holds it.
      *
-     * **Explícito, e NÃO no `appendRecords`** — a revisão adversarial do M95 mediu por que isso
-     * importa: o contrato de `SessionStore` diz que "an `appendRecords` rejection is logged to
-     * stderr, NOT thrown to the caller (best-effort write)". Adquirir ali fazia o `SessionBusyError`
-     * ser **engolido**, e o resultado era pior que o problema original: em vez de dois escritores
-     * intercalarem linhas, o perdedor **perdia o turno em silêncio** — nada em disco, um aviso em
-     * stderr invisível sob a TUI, e o chamador sem como reagir.
+     * **Explicit, and NOT inside `appendRecords`** — M95's adversarial review measured why that
+     * matters: the `SessionStore` contract states that "an `appendRecords` rejection is logged to
+     * stderr, NOT thrown to the caller (best-effort write)". Acquiring there made the
+     * `SessionBusyError` get **swallowed**, and the result was worse than the original problem:
+     * instead of two writers interleaving lines, the loser **lost the turn silently** — nothing on
+     * disk, a stderr warning invisible under the TUI, and no way for the caller to react.
      *
-     * No init o erro chega a quem pode agir: o `exec` forka para um id novo, que é o que a própria
-     * mensagem do erro prescreve. É a diferença entre falhar onde dá para decidir e falhar onde só
-     * dá para perder.
+     * At init the error reaches someone who can act: `exec` forks to a new id, which is exactly what
+     * the error message itself prescribes. It is the difference between failing where a decision is
+     * possible and failing where only loss is.
      */
     acquire(agentId: string): Promise<void>;
     /**
-     * Solta o lease de UM agente.
+     * Releases ONE agent's lease.
      *
-     * Existe porque `dispose()` solta **todos** os leases do store, e um store injetado pelo
-     * consumidor pode servir vários agentes: um init que falha para o agente B não pode liberar o
-     * lease do agente A, que segue vivo e escrevendo.
+     * It exists because `dispose()` releases **every** lease the store holds, and a store injected by
+     * the consumer may serve several agents: an init that fails for agent B must not free agent A's
+     * lease, which is still live and writing.
      */
     release(agentId: string): Promise<void>;
     /**
-     * Solta todo lease que este store detém.
+     * Releases every lease this store holds.
      *
-     * 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.
+     * Without it the `.writer.lock` outlives the process and the next open would have to wait out the
+     * heartbeat window — recoverable, but 30 s of waiting after a CLEAN shutdown would be an avoidable
+     * defect. Idempotent: calling it twice is not an error.
      */
     dispose(): Promise<void>;
 }

package/dist/internal/persistence/fs-session-store.d.ts

@@ -32,34 +32,34 @@ export declare class FsSessionStore implements SessionStore {
     readRecords(agentId: string): Promise<SessionRecord[]>;
     appendRecords(agentId: string, records: readonly SessionRecord[]): Promise<void>;
     /**
-     * Toma o lease de escritor da sessão. Lança `SessionBusyError` quando outro processo a detém.
+     * Takes the session's writer lease. Throws `SessionBusyError` when another process holds it.
      *
-     * **Explícito, e NÃO no `appendRecords`** — a revisão adversarial do M95 mediu por que isso
-     * importa: o contrato de `SessionStore` diz que "an `appendRecords` rejection is logged to
-     * stderr, NOT thrown to the caller (best-effort write)". Adquirir ali fazia o `SessionBusyError`
-     * ser **engolido**, e o resultado era pior que o problema original: em vez de dois escritores
-     * intercalarem linhas, o perdedor **perdia o turno em silêncio** — nada em disco, um aviso em
-     * stderr invisível sob a TUI, e o chamador sem como reagir.
+     * **Explicit, and NOT inside `appendRecords`** — M95's adversarial review measured why that
+     * matters: the `SessionStore` contract states that "an `appendRecords` rejection is logged to
+     * stderr, NOT thrown to the caller (best-effort write)". Acquiring there made the
+     * `SessionBusyError` get **swallowed**, and the result was worse than the original problem:
+     * instead of two writers interleaving lines, the loser **lost the turn silently** — nothing on
+     * disk, a stderr warning invisible under the TUI, and no way for the caller to react.
      *
-     * No init o erro chega a quem pode agir: o `exec` forka para um id novo, que é o que a própria
-     * mensagem do erro prescreve. É a diferença entre falhar onde dá para decidir e falhar onde só
-     * dá para perder.
+     * At init the error reaches someone who can act: `exec` forks to a new id, which is exactly what
+     * the error message itself prescribes. It is the difference between failing where a decision is
+     * possible and failing where only loss is.
      */
     acquire(agentId: string): Promise<void>;
     /**
-     * Solta o lease de UM agente.
+     * Releases ONE agent's lease.
      *
-     * Existe porque `dispose()` solta **todos** os leases do store, e um store injetado pelo
-     * consumidor pode servir vários agentes: um init que falha para o agente B não pode liberar o
-     * lease do agente A, que segue vivo e escrevendo.
+     * It exists because `dispose()` releases **every** lease the store holds, and a store injected by
+     * the consumer may serve several agents: an init that fails for agent B must not free agent A's
+     * lease, which is still live and writing.
      */
     release(agentId: string): Promise<void>;
     /**
-     * Solta todo lease que este store detém.
+     * Releases every lease this store holds.
      *
-     * 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.
+     * Without it the `.writer.lock` outlives the process and the next open would have to wait out the
+     * heartbeat window — recoverable, but 30 s of waiting after a CLEAN shutdown would be an avoidable
+     * defect. Idempotent: calling it twice is not an error.
      */
     dispose(): Promise<void>;
 }