laohuang 0.9.6 → 0.9.8

package/dist/bin.js

@@ -7628,21 +7628,10 @@ function parseSessionItem(value, expectedSessionId) {
         if (message["role"] !== "system" || !Array.isArray(message["toolDefinitions"]))
           throw new SessionSchemaError("invalid tool definitions message");
         for (const raw of message["toolDefinitions"]) {
-          const definition = objectOf(raw, "loaded tool");
-          requireString(definition, "version");
-          const spec2 = objectOf(definition["spec"], "tool spec");
-          requireString(spec2, "name");
-          if (typeof spec2["description"] !== "string" || !Array.isArray(spec2["promptGuidelines"]) || spec2["promptGuidelines"].some((value2) => typeof value2 !== "string"))
-            throw new SessionSchemaError("invalid tool spec");
-          objectOf(spec2["parameters"], "tool parameters");
-          if (spec2["catalog"] !== void 0) {
-            const catalog = objectOf(spec2["catalog"], "tool catalog metadata");
-            for (const key of ["source", "originalName", "binding"])
-              requireString(catalog, key);
-            if (catalog["exposure"] !== "direct" && catalog["exposure"] !== "deferred")
-              throw new SessionSchemaError("invalid exposure");
-          }
+          assertStoredTool(raw, true);
         }
+        if (message["toolsRemoved"] !== void 0)
+          assertToolReferences(message["toolsRemoved"]);
       } else {
         if (message["role"] !== "user")
           throw new SessionSchemaError("invalid catalog message role");
@@ -7654,6 +7643,9 @@ function parseSessionItem(value, expectedSessionId) {
             throw new SessionSchemaError("invalid tool version");
       }
     }
+    if (entryType === "compaction" && entryPayload["toolState"] !== void 0) {
+      assertToolSelectionSnapshot(entryPayload["toolState"]);
+    }
     return input;
   }
   if (kind === "record") {
@@ -7682,6 +7674,54 @@ function parseSessionItem(value, expectedSessionId) {
   }
   throw new SessionSchemaError("invalid session item kind");
 }
+function assertStoredTool(value, activationOptional) {
+  const definition = objectOf(value, "loaded tool");
+  requireString(definition, "version");
+  const activation = definition["activation"];
+  if ((!activationOptional || activation !== void 0) && activation !== "baseline" && activation !== "search") {
+    throw new SessionSchemaError("invalid tool activation");
+  }
+  const spec2 = objectOf(definition["spec"], "tool spec");
+  requireString(spec2, "name");
+  if (typeof spec2["description"] !== "string" || !Array.isArray(spec2["promptGuidelines"]) || spec2["promptGuidelines"].some((value2) => typeof value2 !== "string")) {
+    throw new SessionSchemaError("invalid tool spec");
+  }
+  objectOf(spec2["parameters"], "tool parameters");
+  if (spec2["catalog"] !== void 0) {
+    const catalog = objectOf(spec2["catalog"], "tool catalog metadata");
+    for (const key of ["source", "originalName", "binding"])
+      requireString(catalog, key);
+    if (catalog["exposure"] !== "direct" && catalog["exposure"] !== "deferred")
+      throw new SessionSchemaError("invalid exposure");
+  }
+}
+function assertToolReferences(value) {
+  if (!Array.isArray(value))
+    throw new SessionSchemaError("invalid removed tools");
+  for (const raw of value) {
+    const reference = objectOf(raw, "removed tool");
+    requireString(reference, "name");
+    if (reference["version"] !== void 0)
+      requireString(reference, "version");
+  }
+}
+function assertToolSelectionSnapshot(value) {
+  const snapshot = objectOf(value, "tool state");
+  const catalog = snapshot["catalog"];
+  if (catalog !== null) {
+    const state = objectOf(catalog, "tool state catalog");
+    if (state["mode"] !== "full" && state["mode"] !== "deferred")
+      throw new SessionSchemaError("invalid tool mode");
+    for (const version of Object.values(objectOf(state["tools"], "tool versions"))) {
+      if (typeof version !== "string")
+        throw new SessionSchemaError("invalid tool version");
+    }
+  }
+  if (!Array.isArray(snapshot["activeTools"]))
+    throw new SessionSchemaError("invalid active tools");
+  for (const tool of snapshot["activeTools"])
+    assertStoredTool(tool, false);
+}
 function contextResetBoundary(entries) {
   return entries.reduce((boundary, entry) => entry.entryType === "context_reset" ? Math.max(boundary, entry.payload.resetThroughSeq) : boundary, 0);
 }
@@ -8666,7 +8706,7 @@ var ConversationHistory = class _ConversationHistory {
       payload: input
     });
   }
-  appendToolDefinitions(input) {
+  appendToolState(input) {
     return this.append({ entryType: "tool_definitions", payload: input });
   }
   appendToolCatalog(input) {
@@ -9054,7 +9094,9 @@ function conversationTail(entries, activeCompaction) {
   return entries.filter((entry) => entry.seq >= boundary && entry.entryType !== "system_context" && entry.entryType !== "project_instructions" && entry.entryType !== "compaction");
 }
 function modelMessageForEntry(entry, currentProvider, currentModel) {
-  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
+  if (entry.entryType === "tool_definitions")
+    return null;
+  if (entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
     return entry.payload.message;
   if (entry.entryType === "user_message" || entry.entryType === "reminder") {
     return entry.payload.message;
@@ -9105,7 +9147,7 @@ function validateToolPairs(selected) {
 }
 
 // ../../packages/session/session-context/dist/summary-prompt.js
-var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
+var COMPACTION_SYSTEM_PROMPT = "Summarize the conversation for continuation. If the input contains <previous_summary>, merge and update it with the newer conversation instead of discarding it. Preserve user goals, explicit constraints, completed work, modified files, architectural decisions, tool outcomes, failures, current TODOs, and concrete state needed to continue. Do not include credentials. Do not invent results.";
 
 // ../../packages/session/session-context/dist/compaction.js
 function selectCompactionPlan(input) {
@@ -9151,8 +9193,6 @@ function serializeConversation(entries) {
       }
     } else if (entry.entryType === "tool_result") {
       lines2.push(`[tool-result ${entry.payload.message.toolCallId} ${entry.payload.message.toolName}] ${entry.payload.message.content}`);
-    } else if (entry.entryType === "tool_definitions") {
-      lines2.push(`[loaded tool definitions] ${(entry.payload.message.toolDefinitions ?? []).map((tool) => tool.spec.name).join(", ")}`);
     } else if (entry.entryType === "user_message" || entry.entryType === "skill_context" || entry.entryType === "reminder" || entry.entryType === "project_instructions") {
       lines2.push(`[${entry.payload.message.role}] ${entry.payload.message.content}`);
     }
@@ -9167,12 +9207,9 @@ function serializeConversation(entries) {
 }
 function semanticUnits(entries) {
   const units = [];
-  const groupedDefinitions = /* @__PURE__ */ new Set();
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
-    if (groupedDefinitions.has(entry.id))
-      continue;
-    if (entry.entryType === "context_reset" || entry.entryType === "image_offload" || entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
+    if (entry.entryType === "context_reset" || entry.entryType === "image_offload" || entry.entryType === "tool_definitions" || entry.entryType === "system_context" || entry.entryType === "project_instructions" || entry.entryType === "compaction") {
       continue;
     }
     if (entry.entryType === "assistant_message") {
@@ -9186,12 +9223,6 @@ function semanticUnits(entries) {
           }
           grouped.push(entries[resultIndex]);
         }
-        const lastResultIndex = entries.findIndex((candidate) => candidate.id === grouped.at(-1).id);
-        const definitions = entries[lastResultIndex + 1];
-        if (definitions?.entryType === "tool_definitions") {
-          grouped.push(definitions);
-          groupedDefinitions.add(definitions.id);
-        }
         units.push({ entries: grouped, messages: grouped.map(messageForEntry) });
         continue;
       }
@@ -9204,7 +9235,7 @@ function semanticUnits(entries) {
   return units;
 }
 function messageForEntry(entry) {
-  if (entry.entryType === "tool_definitions" || entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
+  if (entry.entryType === "tool_catalog" || entry.entryType === "skill_context")
     return entry.payload.message;
   if (entry.entryType === "assistant_message") {
     return entry.payload.message;
@@ -9225,6 +9256,8 @@ var ContextBudgetError = class extends Error {
     this.name = "ContextBudgetError";
   }
 };
+var NoCompactionAvailableError = class extends Error {
+};
 var ContextGovernor = class {
   #builder;
   #estimator;
@@ -9245,7 +9278,17 @@ var ContextGovernor = class {
         throw new ContextBudgetError("context exceeds hard input limit");
       return { built, messages: built.messages, compacted: false, tokens };
     }
-    const result = await this.compact({ ...input, trigger: "automatic" });
+    let result;
+    try {
+      result = await this.compact({ ...input, trigger: "automatic" });
+    } catch (error) {
+      if (!(error instanceof NoCompactionAvailableError))
+        throw error;
+      if (tokens > calculated.hardInputLimit) {
+        throw new ContextBudgetError("context exceeds hard input limit with no earlier messages to compact");
+      }
+      return { built, messages: built.messages, compacted: false, tokens };
+    }
     const entries = [...input.entries, result.entry];
     built = this.#builder.build({ ...input, entries });
     tokens = this.measure({ ...input, entries }, built);
@@ -9256,12 +9299,14 @@ var ContextGovernor = class {
   }
   async compact(input) {
     const calculated = calculateModelBudget({ budget: input.budget, policy: input.policy });
+    const built = this.#builder.build(input);
+    const activeCompaction = input.entries.find((entry) => entry.id === built.activeCompactionId && entry.entryType === "compaction");
+    const activeSourceEntryIds = new Set(built.sourceEntryIds);
+    const projectedEntries = activeCompaction === void 0 ? input.entries : input.entries.filter((entry) => entry.id !== activeCompaction.id && activeSourceEntryIds.has(entry.id));
     const plan = selectCompactionPlan({
       protectedFromSeq: input.protectedFromSeq,
-      entries: input.entries,
-      // A search preflight reserves the pending call/result/definition unit.
-      // Keep the latest completed unit and summarize older units to make room.
-      retainTokens: input.reserveTokens === void 0 ? calculated.retainTokens : 1,
+      entries: projectedEntries,
+      retainTokens: calculated.retainTokens,
       estimator: this.#estimator
     });
     if (plan.summarizedEntries.length === 0) {
@@ -9270,19 +9315,14 @@ var ContextGovernor = class {
       if (input.trigger === "provider_overflow") {
         throw new ContextBudgetError("No earlier messages to compact after provider overflow.");
       }
+      throw new NoCompactionAvailableError();
     }
-    const summarizedFromSeq = plan.summarizedEntries[0]?.seq ?? 1;
-    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? Math.max(0, summarizedFromSeq - 1);
-    const built = this.#builder.build(input);
-    const activeCompaction = input.entries.find((entry) => entry.id === built.activeCompactionId);
+    const summarizedFromSeq = activeCompaction?.payload.summarizedFromSeq ?? plan.summarizedEntries[0]?.seq ?? 1;
+    const summarizedThroughSeq = plan.summarizedEntries.at(-1)?.seq ?? activeCompaction?.payload.summarizedThroughSeq ?? Math.max(0, summarizedFromSeq - 1);
     const messagesBefore = built.messages;
     const tokensBefore = this.#estimator.estimateMessages(messagesBefore) + this.#estimator.estimateTools(input.projectTools?.(messagesBefore) ?? input.tools);
-    const summary = plan.summarizedEntries.length === 0 ? {
-      summary: "No prior conversation needed compaction.",
-      inputTokens: 0,
-      outputTokens: 0
-    } : await this.#summarize({
-      serialized: serializeConversation(plan.summarizedEntries),
+    const summary = await this.#summarize({
+      serialized: serializeCompactionInput(activeCompaction?.payload.summary, plan.summarizedEntries),
       maxSummaryTokens: input.policy.maxSummaryTokens
     });
     const payload = {
@@ -9297,7 +9337,8 @@ var ContextGovernor = class {
       summaryOutputTokens: summary.outputTokens,
       provider: input.currentProvider,
       model: input.currentModel,
-      trigger: input.trigger
+      trigger: input.trigger,
+      ...input.toolState === void 0 ? {} : { toolState: input.toolState }
     };
     return { entry: this.#appendCompaction(payload) };
   }
@@ -9329,9 +9370,18 @@ var ContextGovernor = class {
       systemFingerprint: fingerprintContextPart(built.messages.find((message) => message.role === "system") ?? null),
       projectInstructionsFingerprint: fingerprintContextPart(built.messages.filter((message, index) => index > 0 && message.role === "user")),
       toolsFingerprint: fingerprintContextPart(tools)
-    }).totalTokens + (input.reserveTokens ?? 0);
+    }).totalTokens;
   }
 };
+function serializeCompactionInput(previousSummary, entries) {
+  const conversation = serializeConversation(entries);
+  if (previousSummary === void 0)
+    return conversation;
+  return `<previous_summary>
+${previousSummary}
+</previous_summary>
+${conversation}`;
+}
 function calculateModelBudget(input) {
   const hardInputLimit = input.budget.contextWindow - input.budget.maxOutputTokens;
   const safetyTokens = Math.ceil(input.budget.contextWindow * input.policy.safetyRatio);
@@ -9340,6 +9390,52 @@ function calculateModelBudget(input) {
   return { hardInputLimit, safetyTokens, autoTrigger, retainTokens };
 }
 
+// ../../packages/session/session-context/dist/tool-state.js
+function projectToolSelectionState(entries) {
+  const sorted = [...entries].sort((left, right) => left.seq - right.seq);
+  const latestCompaction2 = [...sorted].reverse().find((entry) => entry.entryType === "compaction");
+  const checkpoint = latestCompaction2?.entryType === "compaction" && latestCompaction2.payload.toolState !== void 0 ? latestCompaction2 : void 0;
+  let catalog = checkpoint?.entryType === "compaction" ? copyCatalog(checkpoint.payload.toolState.catalog) : null;
+  const active = /* @__PURE__ */ new Map();
+  if (checkpoint?.entryType === "compaction") {
+    for (const tool of checkpoint.payload.toolState.activeTools) {
+      active.set(tool.spec.name, copyActiveTool(tool));
+    }
+  }
+  const afterSeq = checkpoint?.seq ?? 0;
+  for (const entry of sorted) {
+    if (entry.seq <= afterSeq)
+      continue;
+    if (entry.entryType === "tool_catalog") {
+      catalog = copyCatalog(entry.payload.message.toolCatalog ?? null);
+      continue;
+    }
+    if (entry.entryType !== "tool_definitions")
+      continue;
+    for (const removed of entry.payload.message.toolsRemoved ?? []) {
+      const current = active.get(removed.name);
+      if (current !== void 0 && (removed.version === void 0 || current.version === removed.version)) {
+        active.delete(removed.name);
+      }
+    }
+    for (const tool of entry.payload.message.toolDefinitions ?? []) {
+      const activeTool = normalizeActiveTool(tool);
+      active.set(activeTool.spec.name, activeTool);
+    }
+  }
+  return { catalog, activeTools: [...active.values()] };
+}
+function normalizeActiveTool(tool) {
+  const activation = "activation" in tool && (tool.activation === "baseline" || tool.activation === "search") ? tool.activation : "search";
+  return { version: tool.version, spec: tool.spec, activation };
+}
+function copyCatalog(catalog) {
+  return catalog === null ? null : { mode: catalog.mode, tools: { ...catalog.tools } };
+}
+function copyActiveTool(tool) {
+  return { version: tool.version, spec: tool.spec, activation: tool.activation };
+}
+
 // ../../packages/llm/llm-pi-ai/dist/adapter.js
 import { clampThinkingLevel, ModelsError } from "@earendil-works/pi-ai";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
@@ -9520,8 +9616,22 @@ function parseToolArguments(raw) {
       kind: "protocol"
     });
   }
+  if (!Object.values(parsed).every(isJsonValue)) {
+    throw new ModelError("tool-call arguments contain invalid JSON values", {
+      kind: "protocol"
+    });
+  }
   return parsed;
 }
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  if (Array.isArray(value))
+    return value.every(isJsonValue);
+  return isRecord(value) && Object.values(value).every(isJsonValue);
+}
 function zeroUsage() {
   return {
     input: 0,
@@ -9959,7 +10069,10 @@ var PiModelsStore = class {
       return void 0;
     }
     return {
-      models: entry.models.map((model2) => restoreModel(providerId, model2)),
+      models: entry.models.flatMap((model2) => {
+        const restored = restoreModel(providerId, model2);
+        return restored === void 0 ? [] : [restored];
+      }),
       ...entry.lastModified === void 0 ? {} : { lastModified: entry.lastModified },
       ...entry.checkedAt === void 0 ? {} : { checkedAt: entry.checkedAt },
       ...entry.etag === void 0 ? {} : { etag: entry.etag }
@@ -9978,12 +10091,15 @@ var PiModelsStore = class {
   }
 };
 function restoreModel(providerId, model2) {
+  const type = model2["type"] ?? "chat";
+  if (type !== "chat" && type !== "image" && type !== "classifier")
+    return void 0;
   const id = readString(model2, "id", providerId);
   const name = readString(model2, "name", providerId);
   const api2 = readString(model2, "api", providerId);
   const provider2 = readString(model2, "provider", providerId);
   const input = model2["input"];
-  if (!Array.isArray(input) || !input.every((item) => typeof item === "string")) {
+  if (!Array.isArray(input) || !input.every((item) => item === "text" || item === "image")) {
     throw new ModelError(`stored model for '${providerId}' has invalid input`, {
       kind: "protocol"
     });
@@ -9994,6 +10110,27 @@ function restoreModel(providerId, model2) {
       kind: "protocol"
     });
   }
+  const common = {
+    ...model2,
+    id,
+    name,
+    api: api2,
+    provider: provider2,
+    input,
+    cost: cost2,
+    baseUrl: readString(model2, "baseUrl", providerId)
+  };
+  if (type === "image") {
+    const output = model2["output"];
+    if (!Array.isArray(output) || !output.includes("image") || !output.every((item) => item === "text" || item === "image")) {
+      throw new ModelError(`stored model for '${providerId}' has invalid output`, { kind: "protocol" });
+    }
+    return { ...common, type, api: api2, output };
+  }
+  const contextWindow = readPositiveNumber(model2, "contextWindow", providerId);
+  if (type === "classifier") {
+    return { ...common, type, api: api2, contextWindow };
+  }
   const reasoning = model2["reasoning"];
   if (typeof reasoning !== "boolean") {
     throw new ModelError(`stored model for '${providerId}' has invalid reasoning`, {
@@ -10001,15 +10138,13 @@ function restoreModel(providerId, model2) {
     });
   }
   return {
-    ...model2,
-    id,
-    name,
+    ...common,
+    type,
     api: api2,
-    provider: provider2,
     reasoning,
     input,
     cost: cost2,
-    contextWindow: readPositiveNumber(model2, "contextWindow", providerId),
+    contextWindow,
     maxTokens: readPositiveNumber(model2, "maxTokens", providerId)
   };
 }
@@ -10043,11 +10178,11 @@ function isCost(value) {
 }
 
 // ../../packages/llm/llm-pi-ai/dist/platform.js
-import { defaultProviderAuthContext, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { defaultProviderAuthContext, getSupportedThinkingLevels, isModelType as isModelType2 } from "@earendil-works/pi-ai";
 import { builtinModels as builtinModels2 } from "@earendil-works/pi-ai/providers/all";
 
 // ../../packages/llm/llm-pi-ai/dist/custom-models.js
-import { createProvider, envApiKeyAuth } from "@earendil-works/pi-ai";
+import { createProvider, envApiKeyAuth, isModelType } from "@earendil-works/pi-ai";
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
@@ -17873,6 +18008,8 @@ var completionsCompat = partial(typebox_exports.Object({
   supportsOpenAIGrammarTools: typebox_exports.Boolean(),
   supportsStrictMode: typebox_exports.Boolean(),
   cacheControlFormat: typebox_exports.Literal("anthropic"),
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
+  supportsMidConvoToolAdditions: typebox_exports.Boolean(),
   sendSessionAffinityHeaders: typebox_exports.Boolean(),
   deferredToolsMode: typebox_exports.Literal("kimi"),
   sessionAffinityFormat: affinity,
@@ -17882,6 +18019,7 @@ var completionsCompat = partial(typebox_exports.Object({
 var responsesCompat = partial(typebox_exports.Object({
   supportsDeveloperRole: typebox_exports.Boolean(),
   sessionAffinityFormat: affinity,
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
   supportsLongCacheRetention: typebox_exports.Boolean(),
   supportsStrictMode: typebox_exports.Boolean(),
   supportsOpenAIGrammarTools: typebox_exports.Boolean(),
@@ -17901,6 +18039,9 @@ var anthropicCompat = partial(typebox_exports.Object({
   supportsStrictTools: typebox_exports.Boolean(),
   supportsMidConvoEffort: typebox_exports.Boolean(),
   supportsToolReferences: typebox_exports.Boolean(),
+  supportsMidConvoSystemMessages: typebox_exports.Boolean(),
+  supportsMidConvoToolChanges: typebox_exports.Boolean(),
+  sessionAffinityFormat: typebox_exports.Literal("openrouter"),
   allowedFallbackModels: typebox_exports.Array(typebox_exports.Object({ provider: text, model: text, cost }, { additionalProperties: false }))
 }, { additionalProperties: false }));
 var api = typebox_exports.Union([
@@ -18073,6 +18214,10 @@ function customProvider(id, config, base) {
     baseUrl: config.baseUrl ?? base?.baseUrl,
     headers: { ...base?.headers, ...config.headers },
     getModels,
+    getAllModels: () => [
+      ...getModels(),
+      ...(base?.getAllModels?.() ?? []).filter((model2) => !isModelType(model2, "chat"))
+    ],
     // Keep provider-owned refresh/cache logic; getModels reapplies user overrides afterwards.
     ...base?.filterModels === void 0 ? {} : {
       filterModels: (models, credential) => {
@@ -18080,6 +18225,12 @@ function customProvider(id, config, base) {
         return models.filter((model2) => available.has(model2.id) || additions.has(model2.id));
       }
     },
+    ...base?.filterAllModels === void 0 ? {} : {
+      filterAllModels: (models, credential) => {
+        const available = new Set(base.filterAllModels(models, credential).map((model2) => `${model2.type ?? "chat"}:${model2.id}`));
+        return models.filter((model2) => available.has(`${model2.type ?? "chat"}:${model2.id}`) || isModelType(model2, "chat") && additions.has(model2.id));
+      }
+    },
     stream: (model2, context, options) => dispatch(model2).stream(model2, context, options),
     streamSimple: (model2, context, options) => dispatch(model2).streamSimple(model2, context, options)
   };
@@ -18190,7 +18341,9 @@ var PiAiPlatform = class {
   }
 };
 function isEligibleProvider(provider2, excludedProviderIds) {
-  return provider2.auth.apiKey?.login !== void 0 && !excludedProviderIds.has(provider2.id);
+  const allModels = provider2.getAllModels?.() ?? provider2.getModels();
+  return provider2.auth.apiKey?.login !== void 0 && !excludedProviderIds.has(provider2.id) && // Empty dynamic catalogs remain eligible; operation-only catalogs do not.
+  (allModels.length === 0 || allModels.some((model2) => isModelType2(model2, "chat")));
 }
 var PiAiCatalog = class {
   models;
@@ -18381,6 +18534,33 @@ function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// ../../packages/llm/llm-pi-ai/dist/tool-validation.js
+import { validateToolArguments } from "@earendil-works/pi-ai";
+var validatePiToolArguments = (spec2, call, args) => {
+  const tool = {
+    name: spec2.name,
+    description: spec2.description,
+    parameters: spec2.parameters
+  };
+  const toolCall = {
+    type: "toolCall",
+    id: call.id,
+    name: call.name,
+    arguments: args
+  };
+  let validated;
+  try {
+    validated = validateToolArguments(tool, toolCall);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(message.split("\n\nReceived arguments:\n")[0]);
+  }
+  if (typeof validated !== "object" || validated === null || Array.isArray(validated)) {
+    throw new Error("Validated tool arguments must be a JSON object");
+  }
+  return validated;
+};
+
 // ../../packages/storage/local-config/dist/config.js
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
@@ -28760,8 +28940,13 @@ var StdTerminalDriver = class {
 var ToolRuntime = class {
   tools;
   createExecutionContext;
-  constructor(tools, options = {}) {
+  validateArguments;
+  constructor(tools, options) {
+    if (typeof options?.validateToolArguments !== "function") {
+      throw new Error("Tool argument validator is required");
+    }
     this.tools = tools;
+    this.validateArguments = options.validateToolArguments;
     this.createExecutionContext = options.createExecutionContext ?? ((_, cancelToken) => ({
       signal: cancelToken?.signal,
       isCancelled: () => isCancelled(cancelToken),
@@ -28772,6 +28957,7 @@ var ToolRuntime = class {
   }
   async execute(request) {
     const registry = request.registry ?? this.tools;
+    const definitions = new Map(registry.definitions.map((tool) => [tool.name, tool]));
     const results = new Array(request.toolCalls.length).fill(void 0);
     const prepared = [];
     for (let offset = 0; offset < request.toolCalls.length; offset += 1) {
@@ -28779,7 +28965,7 @@ var ToolRuntime = class {
       if (toolCall === void 0) {
         continue;
       }
-      let args;
+      let args = { _raw: toolCall.arguments };
       let result;
       try {
         const decoded = JSON.parse(toolCall.arguments);
@@ -28787,8 +28973,11 @@ var ToolRuntime = class {
           throw new Error("Tool arguments must be a JSON object");
         }
         args = decoded;
+        const tool = definitions.get(toolCall.name);
+        if (tool === void 0)
+          throw new Error(`Unknown tool: ${toolCall.name}`);
+        args = this.validateArguments(tool, toolCall, args);
       } catch (error) {
-        args = { _raw: toolCall.arguments };
         result = { ok: false, error: errorMessage7(error) };
       }
       const event = {
@@ -28961,23 +29150,92 @@ var TOOL_SEARCH_THRESHOLD = 20;
 var ToolSelection = class {
   indexKey = "";
   index;
-  prepare(registry, records, canLoad = () => true, retainedRecords) {
+  catalog = null;
+  active = /* @__PURE__ */ new Map();
+  apply(update) {
+    if (update.catalog !== void 0)
+      this.catalog = copyCatalog2(update.catalog);
+    for (const removed of update.toolsRemoved) {
+      const current = this.active.get(removed.name);
+      if (current !== void 0 && (removed.version === void 0 || current.version === removed.version)) {
+        this.active.delete(removed.name);
+      }
+    }
+    for (const tool of update.toolsAdded)
+      this.active.set(tool.spec.name, copyActiveTool2(tool));
+  }
+  restore(snapshot) {
+    this.catalog = snapshot.catalog === null ? null : copyCatalog2(snapshot.catalog);
+    this.active.clear();
+    for (const tool of snapshot.activeTools)
+      this.active.set(tool.spec.name, copyActiveTool2(tool));
+  }
+  snapshot() {
+    return {
+      catalog: this.catalog === null ? null : copyCatalog2(this.catalog),
+      activeTools: [...this.active.values()].map(copyActiveTool2)
+    };
+  }
+  prepare(registry) {
     const all = registry.definitions.filter((spec2) => spec2.name !== SEARCH_TOOL_NAME);
     const deferred = all.filter((spec2) => spec2.catalog?.exposure === "deferred");
     const mode = all.length >= TOOL_SEARCH_THRESHOLD ? "deferred" : "full";
-    const versions = new Map(deferred.map((spec2) => [spec2.name, toolVersion(spec2)]));
-    const catalog = { mode, tools: mode === "deferred" ? Object.fromEntries(versions) : {} };
-    let previous;
-    const loaded = loadedVersions(records, versions);
-    for (const record of records) {
-      if (record.toolCatalog) {
-        previous = record.toolCatalog;
+    const versions = new Map(all.map((spec2) => [spec2.name, toolVersion(spec2)]));
+    const catalog = {
+      mode,
+      tools: mode === "deferred" ? Object.fromEntries(deferred.map((spec2) => [spec2.name, versions.get(spec2.name)])) : {}
+    };
+    const current = new Map(all.map((spec2) => [spec2.name, spec2]));
+    const desired = /* @__PURE__ */ new Map();
+    const toolsAdded = [];
+    const toolsRemoved = [];
+    const missing = [];
+    for (const [name, active] of this.active) {
+      const spec2 = current.get(name);
+      if (spec2 === void 0) {
+        toolsRemoved.push({ name, version: active.version });
+        missing.push(name);
+        continue;
+      }
+      const baseline = mode === "full" || spec2.catalog?.exposure !== "deferred";
+      const version = versions.get(name);
+      if (version !== active.version) {
+        toolsRemoved.push({ name, version: active.version });
+        if (baseline || active.activation === "search") {
+          const updated = {
+            spec: spec2,
+            version,
+            activation: spec2.catalog?.exposure === "deferred" && active.activation === "search" ? "search" : "baseline"
+          };
+          desired.set(name, updated);
+          toolsAdded.push(updated);
+        }
+        continue;
+      }
+      if (baseline || active.activation === "search") {
+        desired.set(name, { spec: spec2, version, activation: active.activation });
+      } else {
+        toolsRemoved.push({ name, version: active.version });
       }
     }
-    const changed = canonicalToolJson(previous ?? { mode: "full", tools: {} }) !== canonicalToolJson(catalog);
+    for (const spec2 of all) {
+      const baseline = mode === "full" || spec2.catalog?.exposure !== "deferred";
+      if (!baseline || desired.has(spec2.name))
+        continue;
+      const added = { spec: spec2, version: versions.get(spec2.name), activation: "baseline" };
+      desired.set(spec2.name, added);
+      toolsAdded.push(added);
+    }
+    const catalogChanged = canonicalToolJson(this.catalog ?? { mode: "full", tools: {} }) !== canonicalToolJson(catalog);
+    const update = {
+      ...catalogChanged ? { catalog } : {},
+      toolsAdded,
+      toolsRemoved
+    };
+    const loaded = new Map([...desired].map(([name, tool]) => [name, tool.version]));
     let announcement;
-    if (changed) {
-      const before = previous?.mode === "deferred" && mode === "deferred" ? previous.tools : {};
+    if (catalogChanged) {
+      const before = this.catalog?.mode === "deferred" && mode === "deferred" ? this.catalog.tools : {};
       const added = Object.keys(catalog.tools).filter((name) => before[name] !== catalog.tools[name]);
       const removed = Object.keys(before).filter((name) => before[name] !== catalog.tools[name]);
       const sections = ["<system-reminder>", mode === "deferred" ? "Use tool_search to search and load tool definitions before calling deferred tools." : "All currently available tool definitions are now directly available."];
@@ -28996,8 +29254,10 @@ var ToolSelection = class {
       }
     }
     const pending = /* @__PURE__ */ new Map();
-    let resultBytes = 0;
-    const definitions = mode === "full" ? all : [...all.filter((spec2) => spec2.catalog?.exposure !== "deferred" || loaded.has(spec2.name)), SEARCH_TOOL_SPEC];
+    const definitions = [
+      ...all.filter((spec2) => desired.has(spec2.name)),
+      ...mode === "deferred" ? [SEARCH_TOOL_SPEC] : []
+    ];
     const visible = new Set(definitions.map((spec2) => spec2.name));
     const index = this.index;
     const view = {
@@ -29021,55 +29281,29 @@ var ToolSelection = class {
             name: name2,
             description: spec2.description.length > 1024 ? `${spec2.description.slice(0, 1024)}...[truncated]` : spec2.description,
             source: spec2.catalog?.source,
-            status: "not_loaded_budget"
+            status: "loaded"
           };
         });
-        resultBytes += Buffer.byteLength(JSON.stringify({ ok: true, matches }), "utf8");
-        const previouslyPending = new Set(pending.keys());
-        for (let pass = 0; pass < (retainedRecords ? 2 : 1); pass++) {
-          const retained = retainedRecords ? loadedVersions(retainedRecords(), versions) : loaded;
-          for (const match of matches) {
-            const { name: name2 } = match;
-            if (pending.has(name2)) {
-              match.status = previouslyPending.has(name2) ? "already_loaded" : "loaded";
-              continue;
-            }
-            if (retained.has(name2)) {
-              match.status = "already_loaded";
-              continue;
-            }
-            if (pass > 0 && match.status === "not_loaded_budget")
-              continue;
-            const spec2 = deferred.find((tool2) => tool2.name === name2);
-            const tool = { spec: spec2, version: versions.get(name2) };
-            if (await canLoad([...pending.values(), tool], resultBytes)) {
-              pending.set(name2, tool);
-              match.status = "loaded";
-            } else
-              match.status = "not_loaded_budget";
+        for (const match of matches) {
+          const { name: name2 } = match;
+          if (pending.has(name2) || loaded.has(name2)) {
+            match.status = "already_loaded";
+            continue;
           }
+          const spec2 = deferred.find((tool) => tool.name === name2);
+          pending.set(name2, { spec: spec2, version: versions.get(name2), activation: "search" });
         }
         return { ok: true, matches, ...matches.length ? {} : { content: "No matching tools. Try an exact name, source, or different keywords." } };
       }
     };
-    return { view, announcement, mode, pending: () => [...pending.values()] };
+    return { view, announcement, mode, update, missing, pending: () => [...pending.values()] };
   }
 };
-function loadedVersions(records, versions) {
-  const loaded = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    if (record.toolCatalog?.mode === "deferred") {
-      for (const [name, version] of loaded)
-        if (record.toolCatalog.tools[name] !== version)
-          loaded.delete(name);
-    }
-    for (const tool of record.toolDefinitions ?? [])
-      loaded.set(tool.spec.name, tool.version);
-  }
-  for (const [name, version] of loaded)
-    if (versions.get(name) !== version)
-      loaded.delete(name);
-  return loaded;
+function copyCatalog2(catalog) {
+  return { mode: catalog.mode, tools: { ...catalog.tools } };
+}
+function copyActiveTool2(tool) {
+  return { version: tool.version, spec: tool.spec, activation: tool.activation };
 }
 
 // ../../packages/core/tools/dist/index.js
@@ -32506,44 +32740,22 @@ var AgentStepRunner = class {
       this.options.onRequestId(requestId);
       const registry = this.options.getTools();
       const selection = this.options.selection ?? new ToolSelection();
-      let remainingTokens = Number.POSITIVE_INFINITY;
-      let preflightCompacted = false;
-      const select = (messages) => selection.prepare(registry, messages.map((message) => message.role === "system" || message.role === "user" ? message : {}), async (pending2, resultBytes) => {
-        const snapshot = history.snapshot();
-        const assistant = snapshot.at(-1);
-        const reserve = Math.ceil((resultBytes + Buffer.byteLength(JSON.stringify(assistant ?? {}), "utf8")) / 4);
-        const cost2 = reserve + pending2.reduce((sum, { spec: { name, description, parameters } }) => sum + Math.ceil(Buffer.byteLength(JSON.stringify({ name, description, parameters }), "utf8") / 4) + 8, 0);
-        if (cost2 <= remainingTokens)
-          return true;
-        if (preflightCompacted || !this.options.contextGovernor)
-          return false;
-        preflightCompacted = true;
-        if (assistant?.role !== "assistant")
-          return false;
-        try {
-          const projectTools = (retained) => selection.prepare(registry, [...retained.map((message) => message.role === "system" || message.role === "user" ? message : {}), { toolDefinitions: pending2 }]).view.definitions;
-          const compacted = await this.options.contextGovernor.prepare({
-            messages: snapshot.slice(0, -1),
-            tools: projectTools(snapshot),
-            projectTools,
-            provider: this.options.provider,
-            model: this.options.model,
-            pendingToolCall: true,
-            reserveTokens: reserve + 1024
-          });
-          history.retain([...compacted.messages, assistant]);
-          remainingTokens = compacted.hardInputLimit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, compacted.hardInputLimit - (compacted.contextTokens ?? 0)) + cost2;
-          return cost2 <= remainingTokens;
-        } catch (error) {
-          if (error instanceof Error && error.name === "ContextBudgetError")
-            return false;
-          throw error;
-        }
-      }, () => history.snapshot().map((message) => message.role === "system" || message.role === "user" ? message : {}));
+      const select = () => selection.prepare(registry);
+      const synchronizeSelection = () => {
+        const planned = select();
+        if (planned.update.toolsAdded.length > 0 || planned.update.toolsRemoved.length > 0) {
+          history.commitToolState(planned.update);
+        }
+        if (planned.announcement) {
+          history.commitToolCatalog({ role: "user", ...planned.announcement });
+        }
+        selection.apply(planned.update);
+        if (planned.missing.length > 0)
+          this.options.onToolStateWarning?.(planned.missing);
+        return select();
+      };
       const prepareRequest = async () => {
-        let selected2 = select(history.snapshot());
-        if (selected2.announcement)
-          history.commitToolContext({ role: "user", ...selected2.announcement });
+        let selected2 = synchronizeSelection();
         let prepared2 = { messages: history.snapshot() };
         for (let attempt = 0; attempt < 3; attempt++) {
           prepared2 = await this.options.contextGovernor?.prepare({
@@ -32551,23 +32763,23 @@ var AgentStepRunner = class {
             tools: selected2.view.definitions,
             provider: this.options.provider,
             model: this.options.model,
-            projectTools: (messages) => select(messages).view.definitions
+            projectTools: () => select().view.definitions
           }) ?? { messages: history.snapshot() };
           history.retain(prepared2.messages);
-          selected2 = select(prepared2.messages);
+          selected2 = select();
           const resources = await this.options.resources?.prepareContext(prepared2.messages, cancelToken?.signal) ?? [];
           if (!selected2.announcement && resources.length === 0)
             break;
           if (attempt === 2)
             throw this.options.createError("Resource catalog cannot fit the retained context.");
-          if (selected2.announcement)
-            history.commitToolContext({ role: "user", ...selected2.announcement });
+          if (selected2.announcement || selected2.update.toolsAdded.length > 0 || selected2.update.toolsRemoved.length > 0) {
+            selected2 = synchronizeSelection();
+          }
           for (const message of resources) {
             history.commitSkillContext(message);
             this.options.resources?.committed([message]);
           }
         }
-        remainingTokens = prepared2.hardInputLimit === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, prepared2.hardInputLimit - (prepared2.contextTokens ?? 0) - 1024);
         return { selected: selected2, prepared: prepared2 };
       };
       let { selected, prepared } = await prepareRequest();
@@ -32639,12 +32851,10 @@ var AgentStepRunner = class {
               tools: definitions,
               provider: this.options.provider,
               model: this.options.model,
-              projectTools: (messages) => select(messages).view.definitions
+              projectTools: () => select().view.definitions
             });
             this.raiseIfCancelled();
             history.retain(recovered.messages);
-            remainingTokens = Number.POSITIVE_INFINITY;
-            preflightCompacted = false;
             ({ selected, prepared } = await prepareRequest());
             this.raiseIfCancelled();
             tools = selected.view;
@@ -32728,13 +32938,16 @@ Authentication failed for ${this.options.provider}. Run /login ${this.options.pr
         onToolResult: (event) => this.completeToolEvent(event, modelRound)
       })).results;
       const repeated = repeatToolPolicy.record(toolCalls, toolResults);
+      const current = new Map(this.options.getTools().definitions.map((spec2) => [spec2.name, toolVersion(spec2)]));
+      const pending = selected.pending().filter((tool) => current.get(tool.spec.name) === tool.version);
+      if (pending.length) {
+        const update = { toolsAdded: pending, toolsRemoved: [] };
+        history.commitToolState(update);
+        selection.apply(update);
+      }
       history.commitToolResults(toolCalls, toolResults);
       this.options.resources?.committed(history.snapshot().slice(-toolResults.length));
       this.raiseIfCancelled();
-      const current = new Map(this.options.getTools().definitions.map((spec2) => [spec2.name, toolVersion(spec2)]));
-      const pending = selected.pending().filter((tool) => current.get(tool.spec.name) === tool.version);
-      if (pending.length)
-        history.commitToolContext({ role: "system", content: "", toolDefinitions: pending });
       const touchedPaths = [];
       for (const toolResult of toolResults) {
         const touched = touchedPathOf(toolResult);
@@ -32971,12 +33184,20 @@ var HistoryCommitter = class {
     this.conversationHistory?.appendSkillContext?.({ message });
     this.messages.push(message);
   }
-  commitToolContext(message) {
+  commitToolState(update) {
     this.raiseIfCancelled();
-    if (message.role === "system")
-      this.conversationHistory?.appendToolDefinitions?.({ message });
-    else
-      this.conversationHistory?.appendToolCatalog?.({ message });
+    this.conversationHistory?.appendToolState?.({
+      message: {
+        role: "system",
+        content: "",
+        toolDefinitions: update.toolsAdded,
+        toolsRemoved: update.toolsRemoved
+      }
+    });
+  }
+  commitToolCatalog(message) {
+    this.raiseIfCancelled();
+    this.conversationHistory?.appendToolCatalog?.({ message });
     this.messages.push(message);
   }
   /** Adopt the governor's retained context without rewriting the append-only journal. */
@@ -33045,7 +33266,7 @@ var CodingAgent = class {
   modelRuntime;
   reasoningEffort;
   toolRuntime;
-  selection = new ToolSelection();
+  selection;
   tools;
   repeatToolReminderThresholds;
   toolExecution;
@@ -33066,9 +33287,11 @@ var CodingAgent = class {
   contextGovernor;
   prepareTools;
   resources;
+  onToolStateWarning;
   constructor(options) {
     this.repeatToolReminderThresholds = normalizeReminderThresholds(options.repeatToolReminderThresholds ?? [3, 5, 8]);
     this.model = options.model;
+    this.selection = options.toolSelection ?? new ToolSelection();
     this.tools = options.tools;
     this.onToolEvent = options.onToolEvent ?? null;
     this.onAgentEvent = options.onAgentEvent ?? null;
@@ -33082,9 +33305,11 @@ var CodingAgent = class {
     this.contextGovernor = options.contextGovernor ?? null;
     this.prepareTools = options.prepareTools;
     this.resources = options.resources;
+    this.onToolStateWarning = options.onToolStateWarning;
     this.modelRuntime = new ModelRuntime(this.adapter);
     this.toolExecution = options.toolExecution ?? "parallel";
     this.toolRuntime = new ToolRuntime(this.tools, {
+      validateToolArguments: options.validateToolArguments,
       createExecutionContext: (toolCallId, cancelToken) => makeToolContext(this.activeContext, toolCallId, cancelToken)
     });
     this.instructionRoot = options.projectRoot == null ? null : realpathOrSelf(options.projectRoot);
@@ -33167,6 +33392,7 @@ var CodingAgent = class {
         onToolEvent: (name, args, result) => {
           this.onToolEvent?.(name, args, result);
         },
+        onToolStateWarning: this.onToolStateWarning,
         createError: (message, cause) => new AgentError(message, { cause }),
         createCancelled: (message, cause) => new AgentCancelled(message, { cause })
       });
@@ -33477,7 +33703,7 @@ function createSessionRuntime(options) {
   let releaseAttachments;
   const activeConversationHistory = {
     appendSkillContext: (input) => activeHistory(options.sessionController).appendSkillContext(input),
-    appendToolDefinitions: (input) => activeHistory(options.sessionController).appendToolDefinitions(input),
+    appendToolState: (input) => activeHistory(options.sessionController).appendToolState(input),
     appendToolCatalog: (input) => activeHistory(options.sessionController).appendToolCatalog(input),
     appendUser: (input) => activeHistory(options.sessionController).appendUser(input),
     appendAssistant: (input) => activeHistory(options.sessionController).appendAssistant(input),
@@ -33508,6 +33734,7 @@ function createSessionRuntime(options) {
       };
     }
   });
+  const toolSelection = new ToolSelection();
   const agent = new CodingAgent({
     resources: {
       prepareInput: async (input, signal, inputs) => {
@@ -33535,7 +33762,10 @@ function createSessionRuntime(options) {
     modelAdapter: adapter,
     model: route.model,
     tools: options.tools,
+    validateToolArguments: validatePiToolArguments,
     prepareTools: options.prepareTools,
+    toolSelection,
+    onToolStateWarning: (names) => options.presentation?.toolStateWarning?.(names),
     cliName: "laohuang",
     cliVersion: options.version,
     provider: route.provider,
@@ -33544,21 +33774,20 @@ function createSessionRuntime(options) {
     startupCwd: options.startupCwd,
     conversationHistory: activeConversationHistory,
     contextGovernor: {
-      prepare: async ({ tools, projectTools: projectTools2, reserveTokens, pendingToolCall }) => {
+      prepare: async ({ tools, projectTools: projectTools2 }) => {
         const history = options.sessionController.history;
         if (history === null) {
           return { messages: [], contextTokens: 0, contextWindow: 0, hardInputLimit: 0 };
         }
         const entries = history.entries();
-        const pendingAssistant = pendingToolCall ? [...entries].reverse().find((entry) => entry.entryType === "assistant_message") : void 0;
         const prepared = await createGovernor(history).prepare({
           protectedFromSeq: attachmentTurnStart,
-          entries: entries.filter((entry) => entry !== pendingAssistant),
+          entries,
           currentProvider: route.provider,
           currentModel: route.model,
           tools,
           projectTools: projectTools2,
-          reserveTokens,
+          toolState: toolSelection.snapshot(),
           budget: modelBudget(selectedModel),
           policy: defaultContextPolicy()
         });
@@ -33578,6 +33807,7 @@ function createSessionRuntime(options) {
           currentModel: route.model,
           tools,
           projectTools: projectTools2,
+          toolState: toolSelection.snapshot(),
           budget: modelBudget(selectedModel),
           policy: defaultContextPolicy()
         });
@@ -33603,10 +33833,7 @@ function createSessionRuntime(options) {
     eventBus: session.eventBus,
     journal: () => options.sessionController.currentJournal
   });
-  const projectTools = (messages) => new ToolSelection().prepare(
-    options.tools,
-    messages.map((message) => message.role === "system" || message.role === "user" ? message : {})
-  ).view.definitions;
+  const projectTools = (_messages) => toolSelection.prepare(options.tools).view.definitions;
   const refreshContextUsage = () => {
     const notify = options.presentation?.contextUsageChanged;
     if (notify === void 0) {
@@ -33632,6 +33859,7 @@ function createSessionRuntime(options) {
     options.skills?.selectSession(sessionId);
     options.presentation?.sessionChanged?.(sessionId);
     let entries = history.entries();
+    toolSelection.restore(projectToolSelectionState(entries));
     if (entries.length === 0) {
       const system = agent.messages.find(
         (message) => message.role === "system"
@@ -33661,6 +33889,7 @@ function createSessionRuntime(options) {
       currentModel: route.model,
       tools: options.tools.definitions,
       projectTools,
+      toolState: toolSelection.snapshot(),
       budget: modelBudget(selectedModel),
       policy: defaultContextPolicy(),
       trigger: "manual"
@@ -40082,17 +40311,22 @@ Submit an empty line to retry, or enter a replacement.`);
       projectRoot: instructionRoot,
       startupCwd: process.cwd(),
       version: VERSION,
-      presentation: terminalUi === null ? void 0 : {
-        sessionChanged: (sessionId) => terminalUi?.setSessionId(sessionId),
-        historyChanged: (entries) => {
-          const transcript = projectTranscript(entries);
-          if (transcript.length > 0) {
-            terminalUi?.replaceTranscript(transcript);
-          } else if (runtimeInitialized) {
-            resetEmptySessionTranscript(terminalUi);
-          }
-        },
-        contextUsageChanged: ({ contextTokens, contextWindow }) => terminalUi?.setContextUsage(contextTokens, contextWindow)
+      presentation: {
+        toolStateWarning: (names) => runtimeForCleanup?.publishNotice(
+          `Previously active tools are no longer available and were removed: ${names.join(", ")}`
+        ),
+        ...terminalUi === null ? {} : {
+          sessionChanged: (sessionId) => terminalUi?.setSessionId(sessionId),
+          historyChanged: (entries) => {
+            const transcript = projectTranscript(entries);
+            if (transcript.length > 0) {
+              terminalUi?.replaceTranscript(transcript);
+            } else if (runtimeInitialized) {
+              resetEmptySessionTranscript(terminalUi);
+            }
+          },
+          contextUsageChanged: ({ contextTokens, contextWindow }) => terminalUi?.setContextUsage(contextTokens, contextWindow)
+        }
       },
       commandDispatcher: (command) => commandDispatcher?.(command) ?? { status: "not_found", command }
     });