@theokit/sdk 4.37.1 → 4.38.0

package/dist/{chunk-XJLGRJ7K.js → chunk-VUDH4D2M.js}

@@ -1,32 +1,32 @@
 import { extractCodePlugins } from './chunk-2SFBB54R.js';
-import { submit, emitRunEvent } from './chunk-HEN5WXXI.js';
-import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, descartarSessao, clearSession } from './chunk-5SB4V74H.js';
-import { FsSessionStore } from './chunk-YVTNFKZO.js';
-import { discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, shouldUseRealLocalRuntime, CircuitBreaker, buildDefaultSummarizer, parseSseStream, resolveProviderChain, inferProviderFromApiKey, detectPrimaryProvider, tryFirstEvent, relayStream, mapOpenAICompatibleError, renderToolResultContentText } from './chunk-GL7CFBVC.js';
-import { IndexManager, writeSessionSummary, memoryDir, globalEmbeddingCache, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-DCJ5MCJ3.js';
-import { loadHookConfig, warnOnce, currentPersonalityContext, warnPersonalitySwitchInsideFork } from './chunk-F6Y4IEQM.js';
+import { submit, emitRunEvent } from './chunk-7QDTZJRV.js';
+import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, discardSession, clearSession } from './chunk-A4XXV2C6.js';
+import { FsSessionStore } from './chunk-4NVV3GRU.js';
+import { discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, shouldUseRealLocalRuntime, CircuitBreaker, buildDefaultSummarizer, parseSseStream, resolveProviderChain, inferProviderFromApiKey, detectPrimaryProvider, tryFirstEvent, relayStream, mapOpenAICompatibleError, renderToolResultContentText } from './chunk-HI6G3SNY.js';
+import { IndexManager, writeSessionSummary, memoryDir, globalEmbeddingCache, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-4APWS2YF.js';
+import { loadHookConfig, warnOnce, currentPersonalityContext, warnPersonalitySwitchInsideFork } from './chunk-M6UUTNDT.js';
 import { resolveChildEnv } from './chunk-7GFX45DD.js';
-import { readVersionedJson, getTheokitHome, writeVersionedJson } from './chunk-ZW345YOI.js';
+import { readVersionedJson, getTheokitHome, writeVersionedJson } from './chunk-UD2T7ISG.js';
 import { sanitizeToolInput } from './chunk-U54XCYG3.js';
 import { subAgentToolsFromDefinitions, inheritSubAgentCredentials } from './chunk-FV3YEMQ7.js';
 import { setAgentFacade } from './chunk-6X6ID4MO.js';
 import { findGitRoot, DEFAULT_DISCOVERY_SPECS, walkUpForFile, walkUpForGlob } from './chunk-UJ7IQJAG.js';
 import { withToolWhitelist, checkToolWhitelist } from './chunk-7AD3ZTZL.js';
-import { mapWithConcurrency } from './chunk-QGDKZDPN.js';
-import { withFileLock } from './chunk-YHZXBDAW.js';
+import { mapWithConcurrency } from './chunk-4WIJSKFA.js';
+import { withFileLock } from './chunk-XJ5TMOGA.js';
 import { withCwdMutex } from './chunk-2XLKLVVR.js';
-import { defaultBaseDir, expandTilde } from './chunk-XAEAMI5H.js';
+import { defaultBaseDir, expandTilde } from './chunk-AOZYORH7.js';
 import { toJsonSchema } from './chunk-4VPXM6UU.js';
-import { atomicWriteJson } from './chunk-56OXYUZE.js';
-import { loadSubagents } from './chunk-YCXMSDSP.js';
-import { resolveEffectiveContextWindow, CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN } from './chunk-6VP3XGEK.js';
+import { atomicWriteJson } from './chunk-LGCEYEU2.js';
+import { loadSubagents } from './chunk-HHUDNTZC.js';
+import { resolveEffectiveContextWindow, CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN } from './chunk-A6GXYF2Q.js';
 import { parseModelId } from './chunk-X2FR4OIT.js';
-import { getCatalogModelInfo, registerBuiltins, getProviderProfile, registerProvider, isPatchedModelKey } from './chunk-77WHPVXE.js';
-import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-2WFB5ZOX.js';
-import { validateArtifactPath, PathTraversalError, safePathJoin } from './chunk-WDGCZDRG.js';
-import { readWorkspaceDir, parseSimpleYaml } from './chunk-UQPDFW4E.js';
-import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, UnsupportedRunOperationError, AgentDisposedError, NetworkError, TheokitAgentError } from './chunk-CD73YHEH.js';
-import { diag, redactSecrets } from './chunk-TAPQWDW2.js';
+import { getCatalogModelInfo, registerBuiltins, getProviderProfile, registerProvider, isPatchedModelKey } from './chunk-3XKVRLR2.js';
+import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-KWXC6ERT.js';
+import { validateArtifactPath, PathTraversalError, safePathJoin } from './chunk-JCXIDFRI.js';
+import { readWorkspaceDir, parseSimpleYaml } from './chunk-QFWQLXCL.js';
+import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, UnsupportedRunOperationError, AgentDisposedError, NetworkError, TheokitAgentError } from './chunk-ZYOHF37V.js';
+import { diag, redactSecrets } from './chunk-KCZW75PI.js';
 import { stat, mkdir, readFile, readdir, access, unlink } from 'fs/promises';
 import { randomUUID, createHash } from 'crypto';
 import { join, dirname, resolve, relative, isAbsolute } from 'path';
@@ -221,7 +221,7 @@ async function agentGenerate(agent, agentModel, agentApiKey, agentLocal, input,
   const { output, maxRetries, errorStrategy, ...sendOptions } = options;
   const run = await agent.send(input, sendOptions);
   const result = await run.wait();
-  const { generateObjectImpl, GenerateObjectError } = await import('./generate-object-I7UD4NWN.js');
+  const { generateObjectImpl, GenerateObjectError } = await import('./generate-object-LPSO6GVW.js');
   const answer = structurableAnswerOrThrow(result, GenerateObjectError);
   const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
   const facade = getAgentFacade();
@@ -1320,6 +1320,16 @@ var FixtureRunBase = class {
   resolveTermination;
   terminated = false;
   eventNotifier;
+  /**
+   * theokit#140 - the run's single ordered timeline: structural events and live token/tool deltas,
+   * in the order they actually occurred.
+   *
+   * Kept alongside `script.events` rather than replacing it. `stream()` is the SDKMessage view and
+   * stays byte-identical for every existing consumer; this is the complete view, and a consumer
+   * picks one. Merging them would have changed `stream()`'s element type - a breaking change for
+   * an additive feature.
+   */
+  timeline = [];
   constructor(options) {
     this.id = options.id;
     this.agentId = options.agentId;
@@ -1343,6 +1353,46 @@ var FixtureRunBase = class {
     this.eventNotifier = makeNotifier();
     current.resolve();
   }
+  /**
+   * theokit#140 - every event of this run, in true order, from ONE source.
+   *
+   * ## The defect this replaces
+   *
+   * A consumer that needed tool calls interleaved with tokens had to fuse two surfaces by hand:
+   * `stream()`, which was batched and post-completion, and `SendOptions.onDelta`, which was live.
+   * Neither was complete alone - `onDelta` has no `run_started`/`system`, and `stream()` had no
+   * token granularity - so the entire reconciliation, including its dedup, lived in the consumer.
+   * `@theokit/agents` carried ~200 lines of exactly that, and it is the documented root of its
+   * ordering bug (theokit#47), its namespace-dedup bug (#138) and its missing terminal frame (#142).
+   *
+   * The ordering is not reconstructed here. Both kinds are appended by the loop AS THEY HAPPEN, so
+   * arrival order IS model order - there is nothing to sort, and no timestamp heuristic to get
+   * wrong.
+   *
+   * `callId` is whatever the SDK's own `tool_call` events carry, so a consumer no longer holds two
+   * id namespaces and no longer has to correlate them.
+   */
+  async *events() {
+    let index = 0;
+    while (!this.terminated) {
+      while (index < this.timeline.length) {
+        yield this.timeline[index++];
+      }
+      if (this.terminated) break;
+      await Promise.race([this.eventNotifier.promise, this.terminationPromise]);
+    }
+    while (index < this.timeline.length) {
+      yield this.timeline[index++];
+    }
+    for await (const message of this.terminalErrorEvent()) {
+      yield { kind: "message", message };
+    }
+  }
+  /** theokit#140 - append to the timeline and wake `events()`. */
+  pushTimeline(event) {
+    this.timeline.push(event);
+    this.notifyNewEvents();
+  }
   async *stream() {
     let index = 0;
     while (!this.terminated) {
@@ -1358,22 +1408,22 @@ var FixtureRunBase = class {
     yield* this.terminalErrorEvent();
   }
   /**
-   * theokit#101 — quando o run termina em erro, `stream()` tem de DIZER.
+   * theokit#101 — when the run ends in error, `stream()` has to SAY SO.
    *
-   * O erro sempre existiu: o loop o registra em `ctx.error` e `wait()` devolve
-   * `status: 'error'` com a mensagem. Só o `stream()` não o mencionava — ele drena
-   * `script.events` e para. Uma falha de provider (404 "No endpoints found", auth, timeout)
-   * produzia um turno que parecia bem-sucedido e vazio, em TODA superfície que consome o
+   * The error always existed: the loop records it in `ctx.error` and `wait()` returns
+   * `status: 'error'` with the message. Only `stream()` failed to mention it — it drains
+   * `script.events` and stops. A provider failure (404 "No endpoints found", auth, timeout)
+   * produced a turn that looked successful and empty, on EVERY surface consuming the
    * stream: HTTP web, MCP, stdio, TUI in-process.
    *
-   * Erro silencioso é o pior tipo (Regra Inquebrável 8). E a assimetria era o que o tornava
-   * difícil de diagnosticar: quem depurasse por `wait()` via o erro e não reproduziria o
-   * relato de quem depurava pelo stream.
+   * A silent error is the worst kind (Unbreakable Rule 8). And the asymmetry was what made it
+   * hard to diagnose: anyone debugging via `wait()` saw the error and would not reproduce the
+   * report of anyone debugging via the stream.
    *
-   * Emite `SDKStatusMessage` com `status: "ERROR"` — o tipo JÁ EXISTE na união `SDKMessage`
-   * e já é esperado por quem consome. Um tipo novo seria breaking para todo consumidor que
-   * faz switch exaustivo; este é aditivo, e um consumidor que ignore `status` simplesmente
-   * segue como antes — nunca pior que hoje.
+   * It emits `SDKStatusMessage` with `status: "ERROR"` — the type ALREADY EXISTS in the `SDKMessage` union
+   * and is already expected by consumers. A new type would be breaking for every consumer doing
+   * an exhaustive switch; this one is additive, and a consumer ignoring `status` simply
+   * behaves as before — never worse than today.
    */
   *terminalErrorEvent() {
     if (this.status !== "error") return;
@@ -1383,7 +1433,7 @@ var FixtureRunBase = class {
       agent_id: this.agentId,
       run_id: this.id,
       status: "ERROR",
-      // Sem mensagem, o consumidor sabe QUE falhou e não O QUÊ — que é metade do defeito.
+      // Without a message, the consumer knows THAT it failed and not WHAT — which is half the defect.
       ...detail?.message !== void 0 ? { message: detail.message } : {}
     };
   }
@@ -2643,7 +2693,7 @@ async function runPostRunLifecycle(inputs) {
   }
   const conversation = await safeConversation(run);
   const resolvedWindow = resolveWindowForRun(model, contextWindow);
-  const janelaEfetiva = resolvedWindow.window;
+  const effectiveWindow = resolvedWindow.window;
   const budgetEvent = buildContextBudgetEvent(model, resolvedWindow);
   if (budgetEvent !== void 0 && onRunEvent !== void 0) {
     emitRunEvent(onRunEvent, budgetEvent);
@@ -2659,9 +2709,9 @@ async function runPostRunLifecycle(inputs) {
       conversation,
       autoCompact: {
         usageTotal: usageForTrigger,
-        // A janela EFETIVA (após override, clamp e margem) — não a declarada. Trocar por
-        // `contextWindow` aqui orçaria contra um número que o clamp já rejeitou.
-        contextWindow: janelaEfetiva,
+        // The EFFECTIVE window (after override, clamp and margin) — not the declared one. Swapping for
+        // `contextWindow` here would budget against a number the clamp already rejected.
+        contextWindow: effectiveWindow,
         summarize: buildDefaultSummarizer({
           agentModel: model,
           ...inputs.apiKey !== void 0 ? { apiKey: inputs.apiKey } : {}
@@ -4985,6 +5035,35 @@ function buildAssistantTurn(text, toolCalls) {
   return { role: "assistant", content };
 }
 
+// src/internal/agent-loop/live-events.ts
+var LiveEventLog = class extends Array {
+  /**
+   * Not readonly, and not a constructor parameter — `Array` subclasses are re-instantiated by
+   * `map`/`filter`/`slice` with a length argument, so a constructor with a different signature
+   * breaks those. The sink is attached after construction instead.
+   */
+  #sink;
+  /** Attach the live subscriber. One sink: the run that owns this loop. */
+  subscribe(sink) {
+    this.#sink = sink;
+  }
+  push(...events) {
+    const length = super.push(...events);
+    for (const event of events) {
+      try {
+        this.#sink?.(event);
+      } catch {
+      }
+    }
+    return length;
+  }
+};
+function createEventLog(seed) {
+  const log = new LiveEventLog();
+  log.push(...seed);
+  return log;
+}
+
 // src/internal/agent-loop/loop-context-init.ts
 function buildUserContent(text, images) {
   const content = [{ type: "text", text }];
@@ -5048,13 +5127,14 @@ async function initLoopContext(inputs) {
       });
     }
   }
-  const events = [
+  const events = createEventLog([
     buildSystemEvent(
       inputs,
       tools.map((t) => t.name)
     ),
     buildUserEvent(inputs)
-  ];
+  ]);
+  if (inputs.onLoopEvent !== void 0) events.subscribe(inputs.onLoopEvent);
   const priorMessages = (inputs.priorMessages ?? []).map((msg) => ({
     role: msg.role,
     content: [{ type: "text", text: msg.text }]
@@ -6901,6 +6981,31 @@ var HttpMcpClient = class extends BaseMcpClient {
    * Never overwritten by a later one: a server that re-issues mid-session would otherwise split
    * the session in two, and the second half would not see the first half's state.
    */
+  /**
+   * Read one JSON-RPC response, in either encoding the server may choose.
+   *
+   * Streamable HTTP lets the server answer a POST with `application/json` OR `text/event-stream`,
+   * and the client advertises both. Reading the body with `response.json()` unconditionally is what
+   * turned a working server into `Unexpected token 'e', "event: mes"... is not valid JSON` the
+   * moment the Accept header started asking for SSE — measured against a real server, not imagined.
+   *
+   * Only the `data:` payload is JSON; `event:` / `id:` / `retry:` lines and comments are framing.
+   * A single JSON-RPC reply arrives as one event, so the FIRST parseable `data:` is the answer.
+   */
+  async readBody(response) {
+    const tipo = response.headers.get("content-type") ?? "";
+    if (!tipo.includes("text/event-stream")) return await response.json();
+    const text = await response.text();
+    for (const line of text.split(/\r?\n/)) {
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (payload === "") continue;
+      return JSON.parse(payload);
+    }
+    throw new NetworkError(`MCP ${this.name} returned an event stream with no data payload`, {
+      code: "mcp_http_error"
+    });
+  }
   captureSession(response) {
     if (this.sessionId !== void 0) return;
     const issued = response.headers.get("mcp-session-id");
@@ -6931,7 +7036,7 @@ var HttpMcpClient = class extends BaseMcpClient {
     }
     this.captureSession(response);
     try {
-      return await response.json();
+      return await this.readBody(response);
     } catch (cause) {
       if (isAbortLike(cause)) throw mcpTimeoutError(this.name, timeoutMs);
       throw cause;
@@ -7326,7 +7431,26 @@ var RealLocalRun = class extends FixtureRunBase {
       }
     }
   }
+  /**
+   * theokit#140 - events already handed to stream() by the live subscriber.
+   *
+   * The loop still RETURNS its full event list, and that batch path is deliberately kept: it is the
+   * fallback if a live event is ever lost, and removing it would make the live channel a single
+   * point of failure for the whole transcript.
+   */
+  liveDelivered = /* @__PURE__ */ new Set();
   async executeAgentLoop(inputs) {
+    inputs.onLoopEvent = (event) => {
+      this.liveDelivered.add(event);
+      this.script.events.push(event);
+      this.pushTimeline({ kind: "message", message: event });
+      this.notifyNewEvents();
+    };
+    const callerOnDelta = inputs.onDelta;
+    inputs.onDelta = (delta) => {
+      callerOnDelta?.(delta);
+      this.pushTimeline({ kind: "delta", update: delta.update });
+    };
     try {
       const output = inputs.activeTools !== void 0 ? await withToolWhitelist(new Set(inputs.activeTools), () => runAgentLoop(inputs)) : await runAgentLoop(inputs);
       this.applyAgentLoopOutput(output);
@@ -7349,10 +7473,7 @@ var RealLocalRun = class extends FixtureRunBase {
    * Finding-B fix (sdk-error-packaging v1.1): set-once errorDetail copy.
    */
   applyAgentLoopOutput(output) {
-    for (const event of output.events) {
-      this.script.events.push(event);
-      this.notifyNewEvents();
-    }
+    this.deliverUndeliveredEvents(output.events);
     this.script.conversation.push(...output.conversation);
     if (output.result.length > 0) this.script.result = output.result;
     if (output.usage !== void 0) this.script.usage = output.usage;
@@ -7367,6 +7488,25 @@ var RealLocalRun = class extends FixtureRunBase {
       };
     }
   }
+  /**
+   * theokit#140 - deliver only what the live subscriber has NOT already handed to `stream()`.
+   *
+   * The loop now reports each event as it happens, so this batch is the SAME list, replayed.
+   * Without the guard every event would reach `stream()` twice: once live, once here.
+   *
+   * Identity, not deep equality: these are the very objects the live sink saw, and two genuinely
+   * distinct events can be structurally identical (the same tool called twice with the same args
+   * is not a duplicate).
+   *
+   * Extracted because the guard pushed `applyAgentLoopOutput` past the cognitive-complexity cap.
+   */
+  deliverUndeliveredEvents(events) {
+    for (const event of events) {
+      if (this.liveDelivered.has(event)) continue;
+      this.script.events.push(event);
+      this.notifyNewEvents();
+    }
+  }
   emitErrorEvent(cause, fallback, prefix = "", code) {
     if (this.script.errorDetail === void 0) {
       const message = cause instanceof Error ? cause.message : String(cause);
@@ -7652,7 +7792,7 @@ var LiveAgentRegistry = class {
 var liveAgentRegistry = new LiveAgentRegistry();
 
 // src/internal/local-agent/local-agent-lifecycle.ts
-async function adquirirLeaseSePossivel(store, agentId) {
+async function acquireLeaseIfPossible(store, agentId) {
   const a = store.acquire;
   if (typeof a !== "function") return;
   try {
@@ -7665,7 +7805,7 @@ async function adquirirLeaseSePossivel(store, agentId) {
     );
   }
 }
-async function soltarLeaseSePossivel(store, agentId) {
+async function releaseLeaseIfPossible(store, agentId) {
   const r = store.release;
   if (typeof r === "function") await r.call(store, agentId);
 }
@@ -7681,7 +7821,7 @@ async function disposeLocalAgentSession(agent) {
   await flushSessionWrites();
   await flushRegistrySaves(agent.workspaceCwd);
   await disposeSessionStore(agent.sessionStore);
-  descartarSessao(agent.workspaceCwd, agent.agentId);
+  discardSession(agent.workspaceCwd, agent.agentId);
 }
 async function reloadLocalAgent(agent) {
   if (agent.context !== void 0) await agent.context.refresh();
@@ -9022,9 +9162,9 @@ async function localAgentUsePersonality(args) {
 // src/internal/local-agent/local-agent-runtime-extensions.ts
 function localAgentRunUntil(agent, goal, options) {
   async function* wrap() {
-    const { runUntilImpl } = await import('./run-until-YZ2ODWOF.js');
+    const { runUntilImpl } = await import('./run-until-BK56WG4P.js');
     const buildDeps = async () => {
-      const { judgeCallImpl } = await import('./judge-call-TAEIXMYG.js');
+      const { judgeCallImpl } = await import('./judge-call-3S3T6O2Z.js');
       const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
       const create = getAgentFacade().create;
       return {
@@ -9057,7 +9197,7 @@ async function* localAgentStreamToCompletion(agent, message, options) {
 async function localAgentFork(parent, options) {
   const { forkAgentImpl } = await import('./fork-agent-RSV4E3EA.js');
   const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
-  const { withPersonalityContext } = await import('./context-VAYLPT4O.js');
+  const { withPersonalityContext } = await import('./context-ZDBBPIHY.js');
   const create = getAgentFacade().create;
   return withPersonalityContext(
     { slug: parent.personalitySlugSnapshot, isFork: true },
@@ -9213,6 +9353,9 @@ var SUPPORTED = /* @__PURE__ */ new Set([
   "cancel",
   "conversation"
 ]);
+function emptyTimeline() {
+  return emptyStream();
+}
 function emptyStream() {
   return {
     next: () => Promise.resolve({ done: true, value: void 0 }),
@@ -9237,6 +9380,9 @@ function createTripwireRun(args) {
     status: "cancelled",
     ...args.model !== void 0 ? { model: args.model } : {},
     stream: () => emptyStream(),
+    // theokit#140 - a tripwire run never executed, so its timeline is empty by construction, the
+    // same reason `stream()` is. Both are empty for the same fact, not by coincidence.
+    events: () => emptyTimeline(),
     wait: () => Promise.resolve(result),
     cancel: () => Promise.resolve(),
     conversation: () => Promise.resolve([]),
@@ -9432,7 +9578,7 @@ async function executeSendLocked(inputs, message, options) {
 function buildCompletionCheckDeps() {
   return {
     judge: async (ctx, opts) => {
-      const { judgeCallImpl } = await import('./judge-call-TAEIXMYG.js');
+      const { judgeCallImpl } = await import('./judge-call-3S3T6O2Z.js');
       const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
       return judgeCallImpl(ctx, opts, { create: getAgentFacade().create });
     }
@@ -9584,12 +9730,12 @@ var LocalAgent = class {
       this.settingSourcesIncludeProject,
       this.options.agents
     );
-    await adquirirLeaseSePossivel(this.sessionStore, this.agentId);
+    await acquireLeaseIfPossible(this.sessionStore, this.agentId);
     try {
       await hydrateSession(this.agentId, { store: this.sessionStore, cwd: this.workspaceCwd });
       await this.personalityStore.hydrate(this.agentId);
     } catch (err) {
-      await soltarLeaseSePossivel(this.sessionStore, this.agentId);
+      await releaseLeaseIfPossible(this.sessionStore, this.agentId);
       throw err;
     }
   }
@@ -9622,16 +9768,16 @@ var LocalAgent = class {
     });
   }
   /**
-   * A janela de contexto declarada na seleção de modelo, no formato de spread condicional.
+   * The context window declared on the model selection, in conditional-spread form.
    *
-   * M94 — sem isto, o `override` de `resolveEffectiveContextWindow` existia desde o M77 e nenhum
-   * call site de produção o passava: um modelo de 400k sem entrada de catálogo era orçado contra o
-   * piso de 128k. Método próprio porque o spread inline empurrava `runLockedSendCycle` para além do
-   * teto de complexidade cognitiva do projeto.
+   * M94 — without this, `resolveEffectiveContextWindow`'s `override` had existed since M77 and no
+   * production call site passed it: a 400k model with no catalog entry was budgeted against the
+   * 128k floor. Its own method because the inline spread pushed `runLockedSendCycle` past the
+   * project's cognitive-complexity ceiling.
    */
-  #janelaDeclarada() {
-    const declarada = this.model?.contextWindow;
-    return declarada !== void 0 ? { contextWindow: declarada } : {};
+  #declaredWindow() {
+    const declared = this.model?.contextWindow;
+    return declared !== void 0 ? { contextWindow: declared } : {};
   }
   async runLockedSendCycle(message, options, sendSpan, resolve, reject) {
     const userText = typeof message === "string" ? message : message.text;
@@ -9660,7 +9806,7 @@ var LocalAgent = class {
         workspaceCwd: this.workspaceCwd,
         sessionStore: this.sessionStore,
         model: this.model?.id ?? "unknown",
-        ...this.#janelaDeclarada(),
+        ...this.#declaredWindow(),
         // M50 — the auto-compaction summarizer resolves credentials like the run itself.
         ...this.options.apiKey !== void 0 ? { apiKey: this.options.apiKey } : {},
         ...options.onRunEvent !== void 0 ? { onRunEvent: options.onRunEvent } : {},
@@ -10190,7 +10336,7 @@ var Agent = class _Agent {
    * @public
    */
   static async generateObject(options) {
-    const { generateObjectImpl } = await import('./generate-object-I7UD4NWN.js');
+    const { generateObjectImpl } = await import('./generate-object-LPSO6GVW.js');
     return generateObjectImpl(options, {
       create: (opts) => _Agent.create(opts),
       delete: (agentId) => _Agent.delete(agentId)
@@ -10214,7 +10360,7 @@ var Agent = class _Agent {
       delete: (agentId) => _Agent.delete(agentId)
     };
     async function* wrapper() {
-      streamObjectImport ??= import('./stream-object-OFM66VUT.js');
+      streamObjectImport ??= import('./stream-object-AFERZU63.js');
       const { streamObjectImpl } = await streamObjectImport;
       yield* streamObjectImpl(options, deps);
     }
@@ -10238,7 +10384,7 @@ var Agent = class _Agent {
    * @public
    */
   static async batch(prompts, options) {
-    const { batchImpl } = await import('./batch-SY5GZLFD.js');
+    const { batchImpl } = await import('./batch-LXSALQC3.js');
     return batchImpl(prompts, options, { create: (opts) => _Agent.create(opts) });
   }
   /**
@@ -10262,7 +10408,7 @@ var Agent = class _Agent {
    *
    *   This bullet used to say the opposite ("Disposed agents are NOT auto-deleted...
    *   call `Agent.delete(agentId)` first"). It was measured false in M91:
-   *   `tests/m91-getorcreate-apos-dispose.test.ts` builds an agent, disposes it, and
+   *   `tests/m91-getorcreate-after-dispose.test.ts` builds an agent, disposes it, and
    *   gets a different instance back. The claim was about the PERSISTENT registry and
    *   read as being about the live cache — and consumers built around the wrong half.
    *   The agent-builder's M85 interrupt rotates the session id to work around a
@@ -10376,8 +10522,8 @@ var Agent = class _Agent {
         `No local agent "${agentId}" registered \u2014 compact targets local sessions.`
       );
     }
-    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-WNKKIIDW.js');
-    const { cwd, model, store } = await abrirStoreLocal(reg);
+    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-RR3ILTES.js');
+    const { cwd, model, store } = await openLocalStore(reg);
     return enqueueSessionWrite(
       cwd,
       agentId,
@@ -10412,8 +10558,8 @@ var Agent = class _Agent {
         `No local agent "${agentId}" registered \u2014 injectSessionTurn targets local sessions.`
       );
     }
-    const { injectSessionTurn } = await import('./inject-session-UXNJQTZ6.js');
-    const { cwd, model, store } = await abrirStoreLocal(reg);
+    const { injectSessionTurn } = await import('./inject-session-RKNLUE72.js');
+    const { cwd, model, store } = await openLocalStore(reg);
     await injectSessionTurn({
       store,
       loc: { cwd, agentId, model },
@@ -10455,16 +10601,16 @@ setAgentFacade({
   resume: (agentId, options) => Agent.resume(agentId, options),
   batch: (prompts, options) => Agent.batch(prompts, options)
 });
-async function abrirStoreLocal(reg) {
+async function openLocalStore(reg) {
   const cwd = reg.cwd ?? process.cwd();
   const optModel = reg.options.model;
   const model = reg.model?.id ?? (typeof optModel === "string" ? optModel : optModel?.id) ?? "unknown";
-  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-6MY7PNI2.js');
-  const { defaultBaseDir: defaultBaseDir2, expandTilde: expandTilde2 } = await import('./session-transcript-6WKLYIN4.js');
+  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-K5QUPNJZ.js');
+  const { defaultBaseDir: defaultBaseDir2, expandTilde: expandTilde2 } = await import('./session-transcript-MMPWCESR.js');
   const baseDir = reg.options.local?.baseDir !== void 0 ? expandTilde2(reg.options.local.baseDir) : defaultBaseDir2();
   return { cwd, model, store: new FsSessionStore2({ baseDir, cwd }) };
 }
 
 export { Agent, AgentBuilder, DEFAULT_AGENTIC_MODEL_ID, MEMORY_EMBEDDING_ADAPTERS, Tool, ToolError, UsageAccumulator, computeCost, generateCronId, getPricingEntry, openRouterMemoryEmbeddingProviderAdapter, resolveApiKey };
-//# sourceMappingURL=chunk-XJLGRJ7K.js.map
-//# sourceMappingURL=chunk-XJLGRJ7K.js.map
+//# sourceMappingURL=chunk-VUDH4D2M.js.map
+//# sourceMappingURL=chunk-VUDH4D2M.js.map