laohuang 0.9.7 → 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;
@@ -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;
@@ -9275,9 +9306,7 @@ var ContextGovernor = class {
     const plan = selectCompactionPlan({
       protectedFromSeq: input.protectedFromSeq,
       entries: projectedEntries,
-      // 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,
+      retainTokens: calculated.retainTokens,
       estimator: this.#estimator
     });
     if (plan.summarizedEntries.length === 0) {
@@ -9308,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) };
   }
@@ -9340,7 +9370,7 @@ 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) {
@@ -9360,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";
@@ -18458,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";
@@ -28837,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),
@@ -28849,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) {
@@ -28856,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);
@@ -28864,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 = {
@@ -29038,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."];
@@ -29073,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 = {
@@ -29098,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
@@ -32583,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({
@@ -32628,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();
@@ -32716,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;
@@ -32805,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);
@@ -33048,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. */
@@ -33122,7 +33266,7 @@ var CodingAgent = class {
   modelRuntime;
   reasoningEffort;
   toolRuntime;
-  selection = new ToolSelection();
+  selection;
   tools;
   repeatToolReminderThresholds;
   toolExecution;
@@ -33143,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;
@@ -33159,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);
@@ -33244,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 })
       });
@@ -33554,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),
@@ -33585,6 +33734,7 @@ function createSessionRuntime(options) {
       };
     }
   });
+  const toolSelection = new ToolSelection();
   const agent = new CodingAgent({
     resources: {
       prepareInput: async (input, signal, inputs) => {
@@ -33612,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,
@@ -33621,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()
         });
@@ -33655,6 +33807,7 @@ function createSessionRuntime(options) {
           currentModel: route.model,
           tools,
           projectTools: projectTools2,
+          toolState: toolSelection.snapshot(),
           budget: modelBudget(selectedModel),
           policy: defaultContextPolicy()
         });
@@ -33680,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) {
@@ -33709,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"
@@ -33738,6 +33889,7 @@ function createSessionRuntime(options) {
       currentModel: route.model,
       tools: options.tools.definitions,
       projectTools,
+      toolState: toolSelection.snapshot(),
       budget: modelBudget(selectedModel),
       policy: defaultContextPolicy(),
       trigger: "manual"
@@ -40159,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 }
     });