From ab0ef76069ce9cb599b6284ca93cc520600defc3 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Fri, 29 May 2026 17:02:51 +0100
Subject: [PATCH 1/8] fix: filter unregistered profile tools from active set
 and improve missing tool error

---
 .changeset/tool-websearch-not-found-filter.md |  6 ++
 packages/agent-core/src/agent/tool/index.ts   | 13 ++-
 packages/agent-core/src/agent/turn/index.ts   |  2 +-
 packages/agent-core/src/loop/tool-call.ts     |  5 +-
 .../agent-core/test/agent/compaction.test.ts  |  4 +-
 packages/agent-core/test/agent/tool.test.ts   | 82 +++++++++++++++++++
 6 files changed, 107 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/tool-websearch-not-found-filter.md

diff --git a/.changeset/tool-websearch-not-found-filter.md b/.changeset/tool-websearch-not-found-filter.md
new file mode 100644
index 00000000..7a9c1c2c
--- /dev/null
+++ b/.changeset/tool-websearch-not-found-filter.md
@@ -0,0 +1,6 @@
+---
+"@moonshot-ai/agent-core": patch
+"@moonshot-ai/kimi-code": patch
+---
+
+Filter unregistered profile tools from active set and warn when they require configuration.
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 550cfeba..b8ad0a93 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -297,7 +297,18 @@ export class ToolManager {
     });
     // MCP entries are glob patterns gated separately; the rest are exact
     // builtin/user tool names. The split keeps every caller on one string[].
-    this.enabledTools = new Set(names.filter((name) => !isMcpToolName(name)));
+    const nonMcpNames = names.filter((name) => !isMcpToolName(name));
+    const availableNames = nonMcpNames.filter(
+      (name) => this.builtinTools.has(name) || this.userTools.has(name),
+    );
+    const missingTools = nonMcpNames.filter((name) => !availableNames.includes(name));
+    if (missingTools.length > 0) {
+      this.agent.log.warn(
+        `The following tools listed in the active profile are not available and will be omitted: ${missingTools.join(', ')}. ` +
+          `They may require additional service configuration.`,
+      );
+    }
+    this.enabledTools = new Set(availableNames);
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
   }
 
diff --git a/packages/agent-core/src/agent/turn/index.ts b/packages/agent-core/src/agent/turn/index.ts
index 7ed428b8..3f7897af 100644
--- a/packages/agent-core/src/agent/turn/index.ts
+++ b/packages/agent-core/src/agent/turn/index.ts
@@ -816,7 +816,7 @@ function telemetryToolOutcome(result: ToolTelemetryResult): 'success' | 'error'
 
 function telemetryToolErrorType(result: ToolTelemetryResult): string {
   const text = toolResultText(result);
-  if (text.startsWith('Tool "') && text.includes('" not found')) return 'ToolNotFound';
+  if (text.startsWith('Tool "') && (text.includes('" not found') || text.includes('is not available'))) return 'ToolNotFound';
   if (text.startsWith('Invalid args for tool "')) return 'ToolInputError';
   if (text.includes('prepareToolExecution hook failed')) return 'HookError';
   if (text.includes('finalizeToolResult hook failed')) return 'HookError';
diff --git a/packages/agent-core/src/loop/tool-call.ts b/packages/agent-core/src/loop/tool-call.ts
index 2e9956ec..9072dbbc 100644
--- a/packages/agent-core/src/loop/tool-call.ts
+++ b/packages/agent-core/src/loop/tool-call.ts
@@ -181,7 +181,10 @@ function preflightToolCall(
       toolCall,
       toolName,
       args,
-      output: `Tool "${toolName}" not found`,
+      output:
+        `Tool "${toolName}" is not available. The tool was not found in the current session's tool list. ` +
+        `It may require configuration or have been removed from the active profile. ` +
+        `Use the available tools listed in your tool list instead.`,
     };
   }
   if (!parsedArgs.success) {
diff --git a/packages/agent-core/test/agent/compaction.test.ts b/packages/agent-core/test/agent/compaction.test.ts
index cbd9c437..9379e042 100644
--- a/packages/agent-core/test/agent/compaction.test.ts
+++ b/packages/agent-core/test/agent/compaction.test.ts
@@ -1499,8 +1499,8 @@ describe('Agent compaction', () => {
       [wire] context.append_loop_event   { "event": { "type": "content.part", "uuid": "<uuid-2>", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "part": { "type": "text", "text": "I need a tool." } }, "time": "<time>" }
       [wire] context.append_loop_event   { "event": { "type": "tool.call", "uuid": "call_missing", "turnId": "0", "step": 1, "stepUuid": "<uuid-1>", "toolCallId": "call_missing", "name": "MissingTool", "args": {} }, "time": "<time>" }
       [emit] tool.call.started           { "turnId": 0, "toolCallId": "call_missing", "name": "MissingTool", "args": {} }
-      [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "call_missing", "toolCallId": "call_missing", "result": { "output": "Tool \\"MissingTool\\" not found", "isError": true } }, "time": "<time>" }
-      [emit] tool.result                 { "turnId": 0, "toolCallId": "call_missing", "output": "Tool \\"MissingTool\\" not found", "isError": true }
+      [wire] context.append_loop_event   { "event": { "type": "tool.result", "parentUuid": "call_missing", "toolCallId": "call_missing", "result": { "output": "Tool \\"MissingTool\\" is not available. The tool was not found in the current session's tool list. It may require configuration or have been removed from the active profile. Use the available tools listed in your tool list instead.", "isError": true } }, "time": "<time>" }
+      [emit] tool.result                 { "turnId": 0, "toolCallId": "call_missing", "output": "Tool \\"MissingTool\\" is not available. The tool was not found in the current session's tool list. It may require configuration or have been removed from the active profile. Use the available tools listed in your tool list instead.", "isError": true }
       [wire] context.append_loop_event   { "event": { "type": "step.end", "uuid": "<uuid-1>", "turnId": "0", "step": 1, "usage": { "inputOther": 9, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use" }, "time": "<time>" }
       [emit] turn.step.completed         { "turnId": 0, "step": 1, "stepId": "<uuid-1>", "usage": { "inputOther": 9, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "finishReason": "tool_use" }
       [wire] usage.record                { "model": "mock-model", "usage": { "inputOther": 9, "output": 11, "inputCacheRead": 0, "inputCacheCreation": 0 }, "usageScope": "turn", "time": "<time>" }
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index 768caf6f..98855233 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -1,6 +1,7 @@
 import type { ToolCall } from '@moonshot-ai/kosong';
 import { describe, expect, it, vi } from 'vitest';
 
+import { ToolManager } from '../../src/agent/tool';
 import { HookEngine } from '../../src/session/hooks';
 import type { SessionSubagentHost } from '../../src/session/subagent-host';
 import { createFakeKaos } from '../tools/fixtures/fake-kaos';
@@ -9,6 +10,87 @@ import { executeTool } from '../tools/fixtures/execute-tool';
 
 const signal = new AbortController().signal;
 
+describe('ToolManager setActiveTools filtering', () => {
+  it('filters out unregistered profile tools from the active set', () => {
+    const warnings: string[] = [];
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: (msg: string) => { warnings.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    // Populate builtinTools map directly to simulate registered tools
+    (tm as any).builtinTools.set('Read', { name: 'Read', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Write', { name: 'Write', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Bash', { name: 'Bash', description: '', parameters: {}, resolveExecution: vi.fn() });
+
+    // Set active tools — WebSearch and NonExistentTool are not registered
+    tm.setActiveTools(['Read', 'Write', 'Bash', 'WebSearch', 'NonExistentTool']);
+
+    // Check active tools via toolInfos
+    const activeNames = [...tm.toolInfos()]
+      .filter((i) => i.active)
+      .map((i) => i.name)
+      .toSorted();
+    expect(activeNames).toEqual(['Bash', 'Read', 'Write']);
+
+    // Check warning was logged with missing tool names
+    expect(warnings.length).toBe(1);
+    expect(warnings[0]).toContain('are not available');
+    expect(warnings[0]).toContain('WebSearch');
+    expect(warnings[0]).toContain('NonExistentTool');
+    // Read should not be mentioned as missing
+    expect(warnings[0]).not.toContain('Read');
+  });
+
+  it('keeps all tools when all profile names are registered', () => {
+    const warnings: string[] = [];
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: (msg: string) => { warnings.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    (tm as any).builtinTools.set('Read', { name: 'Read', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Write', { name: 'Write', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Bash', { name: 'Bash', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Grep', { name: 'Grep', description: '', parameters: {}, resolveExecution: vi.fn() });
+    (tm as any).builtinTools.set('Glob', { name: 'Glob', description: '', parameters: {}, resolveExecution: vi.fn() });
+
+    tm.setActiveTools(['Read', 'Write', 'Bash', 'Grep', 'Glob']);
+
+    const activeNames = [...tm.toolInfos()]
+      .filter((i) => i.active)
+      .map((i) => i.name)
+      .toSorted();
+    expect(activeNames).toEqual(['Bash', 'Glob', 'Grep', 'Read', 'Write']);
+    expect(warnings.length).toBe(0);
+  });
+
+  it('does not warn when all tools are available', () => {
+    const warnings: string[] = [];
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: (msg: string) => { warnings.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    (tm as any).builtinTools.set('Read', { name: 'Read', description: '', parameters: {}, resolveExecution: vi.fn() });
+
+    tm.setActiveTools(['Read']);
+    expect(warnings.length).toBe(0);
+  });
+});
+
 describe('Agent tools', () => {
   it('blocks tools through PreToolUse before permission and emits PostToolUseFailure', async () => {
     const execWithEnv = vi.fn().mockRejectedValue(new Error('Bash should not execute'));

From b8dde92b37738fa815cfa232349a955c8142ec42 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Fri, 29 May 2026 17:47:41 +0100
Subject: [PATCH 2/8] fix: defer builtin tool filtering until builtins are
 initialized

When setActiveTools() is called before initializeBuiltinTools()
(e.g. profile applied before model config lands), every builtin name
was silently dropped because uiltinTools was empty.

- Save pending builtin names in pendingBuiltinToolNames instead of
  warning immediately when uiltinTools.size === 0
- Reapply pending names inside initializeBuiltinTools() after the
  builtins map is populated; warn only for tools still genuinely missing
- Reset pendingBuiltinToolNames when a subsequent setActiveTools
  call resolves all names
---
 packages/agent-core/src/agent/tool/index.ts | 45 +++++++++-
 packages/agent-core/test/agent/tool.test.ts | 91 +++++++++++++++++++++
 2 files changed, 132 insertions(+), 4 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index b8ad0a93..ffd3651a 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -38,6 +38,13 @@ export class ToolManager {
   protected enabledTools: Set<string> = new Set();
   /** Glob patterns (e.g. `mcp__*`, `mcp__github__*`) gating which MCP tools the profile exposes. */
   private mcpAccessPatterns: string[] = [];
+  /**
+   * Profile-requested builtin tool names that could not be resolved because
+   * `initializeBuiltinTools()` had not run yet.  Replayed once builtins are
+   * available so tools such as `WebSearch` — which require a service that may
+   * be present at init time — are not silently dropped on first profile apply.
+   */
+  private pendingBuiltinToolNames: string[] = [];
   protected readonly store: Partial<ToolStoreData> = {};
   private mcpToolStatusUnsubscribe: (() => void) | undefined;
 
@@ -303,10 +310,18 @@ export class ToolManager {
     );
     const missingTools = nonMcpNames.filter((name) => !availableNames.includes(name));
     if (missingTools.length > 0) {
-      this.agent.log.warn(
-        `The following tools listed in the active profile are not available and will be omitted: ${missingTools.join(', ')}. ` +
-          `They may require additional service configuration.`,
-      );
+      if (this.builtinTools.size > 0) {
+        // Builtins are fully initialized — missing tools are genuinely unavailable.
+        this.agent.log.warn(
+          `The following tools listed in the active profile are not available and will be omitted: ${missingTools.join(', ')}. ` +
+            `They may require additional service configuration.`,
+        );
+      }
+      // Save pending builtin names so they can be re-applied once builtins
+      // are initialized (e.g. when the model is configured after profile apply).
+      this.pendingBuiltinToolNames = missingTools;
+    } else {
+      this.pendingBuiltinToolNames = [];
     }
     this.enabledTools = new Set(availableNames);
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
@@ -410,6 +425,28 @@ export class ToolManager {
         .filter((tool) => !!tool)
         .map((tool) => [tool.name, tool] as const),
     );
+    // Re-apply pending profile tool names that were deferred because builtins
+    // had not been initialized when `setActiveTools` was first called.
+    if (this.pendingBuiltinToolNames.length > 0) {
+      const nowAvailable = this.pendingBuiltinToolNames.filter(
+        (name) => this.builtinTools.has(name) || this.userTools.has(name),
+      );
+      if (nowAvailable.length > 0) {
+        for (const name of nowAvailable) {
+          this.enabledTools.add(name);
+        }
+      }
+      const stillMissing = this.pendingBuiltinToolNames.filter(
+        (name) => !nowAvailable.includes(name),
+      );
+      if (stillMissing.length > 0) {
+        this.agent.log.warn(
+          `The following tools listed in the active profile are not available and will be omitted: ${stillMissing.join(', ')}. ` +
+            `They may require additional service configuration.`,
+        );
+      }
+      this.pendingBuiltinToolNames = [];
+    }
   }
 
   private createVideoUploader(provider: ChatProvider): b.VideoUploader | undefined {
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index 98855233..f1256855 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -89,6 +89,97 @@ describe('ToolManager setActiveTools filtering', () => {
     tm.setActiveTools(['Read']);
     expect(warnings.length).toBe(0);
   });
+
+  it('defers builtin tool names as pending when builtins not yet initialized', () => {
+    const warnings: string[] = [];
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: (msg: string) => { warnings.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    // builtinTools map is empty — simulate pre-initialization state
+
+    tm.setActiveTools(['Read', 'Write', 'Bash']);
+
+    // No warning because builtins are not yet initialized
+    expect(warnings.length).toBe(0);
+
+    // Active set is empty since no builtins are registered
+    const activeNames = [...tm.toolInfos()]
+      .filter((i) => i.active)
+      .map((i) => i.name);
+    expect(activeNames).toEqual([]);
+
+    // Names should be stored as pending
+    expect((tm as any).pendingBuiltinToolNames).toEqual(['Read', 'Write', 'Bash']);
+  });
+
+  it('resolves previously deferred tools when setActiveTools is recalled after builtin init', () => {
+    const makeTool = (name: string) => ({ name, description: '', parameters: {}, resolveExecution: vi.fn() });
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: vi.fn() },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    // builtinTools empty — pre-init state
+
+    // First call: builtins not initialized — names deferred
+    tm.setActiveTools(['Read', 'Write']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual(['Read', 'Write']);
+
+    // Builtins become available
+    (tm as any).builtinTools.set('Read', makeTool('Read'));
+    (tm as any).builtinTools.set('Write', makeTool('Write'));
+
+    // Second call: builtins populated — names resolve
+    tm.setActiveTools(['Read', 'Write']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([]);
+
+    const activeNames = [...tm.toolInfos()]
+      .filter((i) => i.active)
+      .map((i) => i.name)
+      .toSorted();
+    expect(activeNames).toEqual(['Read', 'Write']);
+    // No warning because all tools resolved
+    expect(agent.log.warn).not.toHaveBeenCalled();
+  });
+
+  it('warns about tools still missing when builtins were already initialized', () => {
+    const warnings: string[] = [];
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: (msg: string) => { warnings.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    // Populate builtins BEFORE setActiveTools (simulates initialized state)
+    (tm as any).builtinTools.set('Read', { name: 'Read', description: '', parameters: {}, resolveExecution: vi.fn() });
+
+    // Call setActiveTools with a genuinely missing tool
+    tm.setActiveTools(['Read', 'BogusTool']);
+
+    // Warning should fire immediately (builtins already initialized)
+    expect(warnings.length).toBe(1);
+    expect(warnings[0]).toContain('BogusTool');
+    expect(warnings[0]).toContain('not available');
+
+    // Read should be active, BogusTool should not
+    const activeNames = [...tm.toolInfos()]
+      .filter((i) => i.active)
+      .map((i) => i.name);
+    expect(activeNames).toEqual(['Read']);
+  });
 });
 
 describe('Agent tools', () => {

From a9cfb0f04c09f821ff5e2cecf7965099864bd776 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 06:32:36 +0100
Subject: [PATCH 3/8] fix: compute allowBackground from pending names before
 tool construction

---
 packages/agent-core/src/agent/tool/index.ts | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index ffd3651a..10f9b466 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -381,10 +381,15 @@ export class ToolManager {
       },
       this.agent.skills?.registry.getSkillRoots() ?? [],
     );
+    const pendingIncludesBackgroundTools =
+      this.pendingBuiltinToolNames.includes('TaskList') &&
+      this.pendingBuiltinToolNames.includes('TaskOutput') &&
+      this.pendingBuiltinToolNames.includes('TaskStop');
     const allowBackground =
-      this.enabledTools.has('TaskList') &&
-      this.enabledTools.has('TaskOutput') &&
-      this.enabledTools.has('TaskStop');
+      (this.enabledTools.has('TaskList') &&
+        this.enabledTools.has('TaskOutput') &&
+        this.enabledTools.has('TaskStop')) ||
+      pendingIncludesBackgroundTools;
     this.builtinTools = new Map(
       [
         new b.ReadTool(kaos, workspace),

From d846618ba5a26a335a8aef5471151a66bd6eff64 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 06:42:05 +0100
Subject: [PATCH 4/8] fix: address P2 issues from codex review

- Merge pendingBuiltinToolNames on repeated setActiveTools calls (P2)
  Prevents deferred names from being lost when an intermediate call
  (e.g. a user-tool-only activation) triggers the setActiveTools path.
- Log info when pending names are replayed at builtin init (P2)
- Change pendingBuiltinToolNames from private to protected (P2)
- Add test for background mode via pending task tools (P2)
- Add test for pending name merge across repeated calls (P2)
---
 packages/agent-core/src/agent/tool/index.ts | 20 ++++++--
 packages/agent-core/test/agent/tool.test.ts | 56 +++++++++++++++++++++
 2 files changed, 71 insertions(+), 5 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 10f9b466..026e489a 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -44,7 +44,7 @@ export class ToolManager {
    * available so tools such as `WebSearch` — which require a service that may
    * be present at init time — are not silently dropped on first profile apply.
    */
-  private pendingBuiltinToolNames: string[] = [];
+  protected pendingBuiltinToolNames: string[] = [];
   protected readonly store: Partial<ToolStoreData> = {};
   private mcpToolStatusUnsubscribe: (() => void) | undefined;
 
@@ -317,10 +317,17 @@ export class ToolManager {
             `They may require additional service configuration.`,
         );
       }
-      // Save pending builtin names so they can be re-applied once builtins
-      // are initialized (e.g. when the model is configured after profile apply).
-      this.pendingBuiltinToolNames = missingTools;
-    } else {
+      // Merge into pending so previously deferred names survive repeated
+      // calls (e.g. a user‑tool‑only setActiveTools between profile apply
+      // and provider init clears the state that initializeBuiltinTools
+      // needs for the allowBackground computation).
+      this.pendingBuiltinToolNames = [
+        ...new Set([...this.pendingBuiltinToolNames, ...missingTools]),
+      ];
+    } else if (this.builtinTools.size > 0) {
+      // Only clear pending when builtins are initialized so that deferred
+      // names are not lost by an intermediate setActiveTools call that
+      // happens to have no missing tools (e.g. a user‑tool‑only call).
       this.pendingBuiltinToolNames = [];
     }
     this.enabledTools = new Set(availableNames);
@@ -440,6 +447,9 @@ export class ToolManager {
         for (const name of nowAvailable) {
           this.enabledTools.add(name);
         }
+        this.agent.log.info(
+          `Re-applied pending tool names that are now available: ${nowAvailable.join(', ')}.`,
+        );
       }
       const stillMissing = this.pendingBuiltinToolNames.filter(
         (name) => !nowAvailable.includes(name),
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index f1256855..727e9e85 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -180,6 +180,62 @@ describe('ToolManager setActiveTools filtering', () => {
       .map((i) => i.name);
     expect(activeNames).toEqual(['Read']);
   });
+
+  it('merges pendingBuiltinToolNames across repeated setActiveTools calls before builtin init', () => {
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: { hasProvider: false },
+      log: { warn: vi.fn(), info: vi.fn() },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+    // builtins empty — pre-init state
+
+    // First call: task tools saved as pending
+    tm.setActiveTools(['Bash', 'TaskList', 'TaskOutput', 'TaskStop']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([
+      'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
+    ]);
+
+    // Second call: user-tool-only — all names available; pending must survive
+    // because builtins are not yet initialized.
+    const userTool = {
+      name: 'UserTool', description: '', parameters: {},
+      resolveExecution: vi.fn(),
+    };
+    (tm as any).userTools.set('UserTool', userTool);
+    tm.setActiveTools(['UserTool']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([
+      'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
+    ]);
+
+    // Third call with additional missing tool: merge, don't replace
+    tm.setActiveTools(['WebSearch']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([
+      'Bash', 'TaskList', 'TaskOutput', 'TaskStop', 'WebSearch',
+    ]);
+  });
+
+  it('enables Bash background mode when task tools arrive via pendingBuiltinToolNames', async () => {
+    const ctx = testAgent();
+    ctx.configure({ tools: ['Bash'] });
+
+    const tm = ctx.agent.tools;
+    // Simulate deferred profile: task tools are in pending, not in enabledTools
+    (tm as any).pendingBuiltinToolNames = [
+      'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
+    ];
+
+    // Re-initialize builtins — allowBackground computation should pick up
+    // pending task tools and construct Bash with run_in_background=true.
+    tm.initializeBuiltinTools();
+
+    const bashTool = tm.loopTools.find((t) => t.name === 'Bash');
+    expect(bashTool).toBeDefined();
+    expect(bashTool!.description).toContain('run_in_background=true');
+  });
 });
 
 describe('Agent tools', () => {

From 015fa22bcadc85e8dd40913d80c8f1ad4502bfc3 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 06:53:49 +0100
Subject: [PATCH 5/8] fix: address Codex P1 on stale pending merge

Replace merge with replace + builtins-not-init guard so that stale
pre-init tool selections are not re-enabled when an explicit
setActiveTools call replaces the tool set before provider init.
Pending names survive intermediate all-available calls but are
replaced (not merged) on the next call with missing tools.
---
 packages/agent-core/src/agent/tool/index.ts | 21 +++++++++++----------
 packages/agent-core/test/agent/tool.test.ts | 10 ++++------
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 026e489a..6fcec5fb 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -317,19 +317,20 @@ export class ToolManager {
             `They may require additional service configuration.`,
         );
       }
-      // Merge into pending so previously deferred names survive repeated
-      // calls (e.g. a user‑tool‑only setActiveTools between profile apply
-      // and provider init clears the state that initializeBuiltinTools
-      // needs for the allowBackground computation).
-      this.pendingBuiltinToolNames = [
-        ...new Set([...this.pendingBuiltinToolNames, ...missingTools]),
-      ];
+      // Replace pending with the current missing set.  The most recent
+      // pre-init call expressing intent about builtin tools wins, so stale
+      // names from an earlier profile are not re-enabled at init time.
+      this.pendingBuiltinToolNames = [...missingTools];
     } else if (this.builtinTools.size > 0) {
-      // Only clear pending when builtins are initialized so that deferred
-      // names are not lost by an intermediate setActiveTools call that
-      // happens to have no missing tools (e.g. a user‑tool‑only call).
+      // Builtins are initialized and all requested tools resolved — clear
+      // deferred state so a subsequent init does not re-apply old names.
       this.pendingBuiltinToolNames = [];
     }
+    // When builtins.size === 0 and missingTools.length === 0, the current
+    // call resolved all its names against user/MCP tools without touching
+    // builtins.  Keep the existing pending names alive so a previous
+    // deferral (e.g. a profile‑requested builtin tool before provider
+    // configuration) is not silently dropped.
     this.enabledTools = new Set(availableNames);
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
   }
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index 727e9e85..f530da69 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -181,7 +181,7 @@ describe('ToolManager setActiveTools filtering', () => {
     expect(activeNames).toEqual(['Read']);
   });
 
-  it('merges pendingBuiltinToolNames across repeated setActiveTools calls before builtin init', () => {
+  it('preserves pending builtin names across intermediate all‑available calls before builtin init', () => {
     const agent = {
       records: { logRecord: vi.fn() },
       config: { hasProvider: false },
@@ -200,7 +200,6 @@ describe('ToolManager setActiveTools filtering', () => {
     ]);
 
     // Second call: user-tool-only — all names available; pending must survive
-    // because builtins are not yet initialized.
     const userTool = {
       name: 'UserTool', description: '', parameters: {},
       resolveExecution: vi.fn(),
@@ -211,11 +210,10 @@ describe('ToolManager setActiveTools filtering', () => {
       'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
     ]);
 
-    // Third call with additional missing tool: merge, don't replace
+    // Third call replaces pending — no stale merge that could re-enable
+    // tools the intermediate call explicitly removed.
     tm.setActiveTools(['WebSearch']);
-    expect((tm as any).pendingBuiltinToolNames).toEqual([
-      'Bash', 'TaskList', 'TaskOutput', 'TaskStop', 'WebSearch',
-    ]);
+    expect((tm as any).pendingBuiltinToolNames).toEqual(['WebSearch']);
   });
 
   it('enables Bash background mode when task tools arrive via pendingBuiltinToolNames', async () => {

From f7972606b4bb9d76dc4ef9313f6c49faa2762148 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 07:05:34 +0100
Subject: [PATCH 6/8] fix: clear pending on empty/MCP-only setActiveTools
 before init
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When setActiveTools([]) or setActiveTools(['mcp__*']) is called before
provider init, nonMcpNames is empty — the call represents an explicit
replacement of the tool set.  Clear pendingBuiltinToolNames so the
next initializeBuiltinTools() does not re-enable tools the caller
explicitly removed.  User-tool-only calls (nonMcpNames.length > 0)
that resolve all their names still preserve pending for a previous
builtin deferral.
---
 packages/agent-core/src/agent/tool/index.ts | 14 +++++++++-----
 packages/agent-core/test/agent/tool.test.ts | 21 ++++++++++++++++-----
 2 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 6fcec5fb..382d70ba 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -325,12 +325,16 @@ export class ToolManager {
       // Builtins are initialized and all requested tools resolved — clear
       // deferred state so a subsequent init does not re-apply old names.
       this.pendingBuiltinToolNames = [];
+    } else if (nonMcpNames.length === 0) {
+      // Empty or MCP-only call before init — explicit replacement of the
+      // tool set.  Clear pending so initializeBuiltinTools does not
+      // re-enable tools the caller explicitly removed.
+      this.pendingBuiltinToolNames = [];
     }
-    // When builtins.size === 0 and missingTools.length === 0, the current
-    // call resolved all its names against user/MCP tools without touching
-    // builtins.  Keep the existing pending names alive so a previous
-    // deferral (e.g. a profile‑requested builtin tool before provider
-    // configuration) is not silently dropped.
+    // When builtins.size === 0, missingTools.length === 0, and
+    // nonMcpNames.length > 0, the call resolved all names against
+    // user tools without touching builtins.  Keep existing pending alive
+    // so a previous deferral is not silently dropped.
     this.enabledTools = new Set(availableNames);
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
   }
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index f530da69..1d87b3b7 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -181,7 +181,7 @@ describe('ToolManager setActiveTools filtering', () => {
     expect(activeNames).toEqual(['Read']);
   });
 
-  it('preserves pending builtin names across intermediate all‑available calls before builtin init', () => {
+  it('preserves pending builtin names across intermediate user‑tool‑only calls but clears on empty replacement', () => {
     const agent = {
       records: { logRecord: vi.fn() },
       config: { hasProvider: false },
@@ -200,6 +200,7 @@ describe('ToolManager setActiveTools filtering', () => {
     ]);
 
     // Second call: user-tool-only — all names available; pending must survive
+    // because this call doesn't express intent about builtin tools.
     const userTool = {
       name: 'UserTool', description: '', parameters: {},
       resolveExecution: vi.fn(),
@@ -210,10 +211,20 @@ describe('ToolManager setActiveTools filtering', () => {
       'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
     ]);
 
-    // Third call replaces pending — no stale merge that could re-enable
-    // tools the intermediate call explicitly removed.
-    tm.setActiveTools(['WebSearch']);
-    expect((tm as any).pendingBuiltinToolNames).toEqual(['WebSearch']);
+    // Third call: empty replacement — must clear pending since the caller
+    // explicitly removed all tools.
+    tm.setActiveTools([]);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([]);
+
+    // Fourth call: re-establish pending
+    tm.setActiveTools(['Bash', 'TaskList', 'TaskOutput', 'TaskStop']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([
+      'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
+    ]);
+
+    // Fifth call: MCP-only — no non-MCP names, acts like empty replacement
+    tm.setActiveTools(['mcp__*']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual([]);
   });
 
   it('enables Bash background mode when task tools arrive via pendingBuiltinToolNames', async () => {

From 22a417fd3871e8aebadb13c5ae0509f8978173fa Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 10:29:02 +0100
Subject: [PATCH 7/8] fix: retain capability-gated pending tool names across
 initializeBuiltinTools calls

When initializeBuiltinTools() runs and some pending tools are filtered
by model capabilities (e.g. ReadMediaFile without image_in), the
pending list was cleared entirely. On a later model swap that provides
the capability, nothing re-adds the tool to enabledTools.

Instead of clearing pending, retain the still-missing names so a
subsequent initializeBuiltinTools() call can re-check and re-enable
them when the capability becomes available.
---
 packages/agent-core/src/agent/tool/index.ts |  2 +-
 packages/agent-core/test/agent/tool.test.ts | 56 +++++++++++++++++++++
 2 files changed, 57 insertions(+), 1 deletion(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 382d70ba..6c741e01 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -465,7 +465,7 @@ export class ToolManager {
             `They may require additional service configuration.`,
         );
       }
-      this.pendingBuiltinToolNames = [];
+      this.pendingBuiltinToolNames = stillMissing;
     }
   }
 
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index 1d87b3b7..a766d622 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -245,6 +245,62 @@ describe('ToolManager setActiveTools filtering', () => {
     expect(bashTool).toBeDefined();
     expect(bashTool!.description).toContain('run_in_background=true');
   });
+
+  it('re-resolves deferred pending tool names when they become available in a later initializeBuiltinTools call', () => {
+    const makeTool = (name: string) => ({ name, description: '', parameters: {}, resolveExecution: vi.fn() });
+    const warnings: string[] = [];
+    const infos: string[] = [];
+
+    const agent = {
+      records: { logRecord: vi.fn() },
+      config: {
+        hasProvider: false,
+        cwd: '/workspace',
+        provider: {} as import('@moonshot-ai/kosong').ChatProvider,
+        modelCapabilities: {} as import('@moonshot-ai/kosong').ModelCapability,
+      },
+      log: { warn: (msg: string) => { warnings.push(msg); }, info: (msg: string) => { infos.push(msg); } },
+      mcp: undefined,
+      emitEvent: vi.fn(),
+      background: {} as unknown as import('../../src/agent').Agent['background'],
+      modelProvider: undefined,
+      cron: undefined,
+      skills: undefined,
+      subagentHost: undefined,
+      toolServices: undefined,
+      rpc: undefined,
+      kaos: createFakeKaos(),
+    } as unknown as import('../../src/agent').Agent;
+
+    const tm = new ToolManager(agent);
+
+    // Step 1: pre-init — setActiveTools defers names not in builtinTools
+    tm.setActiveTools(['Bash', 'ReadMediaFile']);
+    expect((tm as any).pendingBuiltinToolNames).toEqual(['Bash', 'ReadMediaFile']);
+    expect((tm as any).enabledTools.size).toBe(0);
+
+    // Step 2: first initializeBuiltinTools — ReadMediaFile NOT in builtinTools
+    tm.initializeBuiltinTools();
+    // ReadMediaFile stays in pending (not cleared)
+    expect((tm as any).pendingBuiltinToolNames).toEqual(['ReadMediaFile']);
+    // Warning fired
+    expect(warnings.length).toBe(1);
+    expect(warnings[0]).toContain('ReadMediaFile');
+    expect(warnings[0]).toContain('not available');
+
+    // Step 3: tool becomes available — model now supports image_in
+    agent.config.modelCapabilities = { image_in: true } as import('@moonshot-ai/kosong').ModelCapability;
+
+    // Step 4: second initializeBuiltinTools — ReadMediaFile now resolves
+    tm.initializeBuiltinTools();
+    expect((tm as any).pendingBuiltinToolNames).toEqual([]);
+    expect((tm as any).enabledTools.has('ReadMediaFile')).toBe(true);
+    // No second warning
+    expect(warnings.length).toBe(1);
+    // Info logged about re-application (Bash on first call, ReadMediaFile on second)
+    expect(infos.length).toBe(2);
+    expect(infos[1]).toContain('ReadMediaFile');
+  });
 });
 
 describe('Agent tools', () => {

From 2d201f1ad1e374cc904173e125397e4da65d5c58 Mon Sep 17 00:00:00 2001
From: LifeJiggy <Bloomtonjovish@gmail.com>
Date: Sat, 30 May 2026 10:41:20 +0100
Subject: [PATCH 8/8] fix: clear pendingBuiltinToolNames on any fully-resolved
 replacement set (Codex P2)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

setActiveTools is a replacement API — each call expresses the complete
desired tool set. The previous three-way guard kept old pending names
alive when the replacement resolved entirely against user tools (e.g.
switching from ['Bash', 'TaskList'] to ['UserTool'] before init). This
caused initializeBuiltinTools() to re-enable tools from the stale
profile.

Simplified the guard: pending is replaced when missingTools.length > 0
(profile requested unavailable tools), and cleared in all other cases
(replacement fully resolved, no stale names to carry forward).
---
 packages/agent-core/src/agent/tool/index.ts | 16 ++++------------
 packages/agent-core/test/agent/tool.test.ts | 21 ++++++++-------------
 2 files changed, 12 insertions(+), 25 deletions(-)

diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 6c741e01..57536cf3 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -321,20 +321,12 @@ export class ToolManager {
       // pre-init call expressing intent about builtin tools wins, so stale
       // names from an earlier profile are not re-enabled at init time.
       this.pendingBuiltinToolNames = [...missingTools];
-    } else if (this.builtinTools.size > 0) {
-      // Builtins are initialized and all requested tools resolved — clear
-      // deferred state so a subsequent init does not re-apply old names.
-      this.pendingBuiltinToolNames = [];
-    } else if (nonMcpNames.length === 0) {
-      // Empty or MCP-only call before init — explicit replacement of the
-      // tool set.  Clear pending so initializeBuiltinTools does not
-      // re-enable tools the caller explicitly removed.
+    } else {
+      // All requested tools resolved against known builtin/user tools.
+      // This is a replacement call: the new set explicitly replaces the
+      // previous one, so any prior deferred names are no longer relevant.
       this.pendingBuiltinToolNames = [];
     }
-    // When builtins.size === 0, missingTools.length === 0, and
-    // nonMcpNames.length > 0, the call resolved all names against
-    // user tools without touching builtins.  Keep existing pending alive
-    // so a previous deferral is not silently dropped.
     this.enabledTools = new Set(availableNames);
     this.mcpAccessPatterns = names.filter((name) => isMcpToolName(name));
   }
diff --git a/packages/agent-core/test/agent/tool.test.ts b/packages/agent-core/test/agent/tool.test.ts
index a766d622..ab7bca5d 100644
--- a/packages/agent-core/test/agent/tool.test.ts
+++ b/packages/agent-core/test/agent/tool.test.ts
@@ -181,7 +181,7 @@ describe('ToolManager setActiveTools filtering', () => {
     expect(activeNames).toEqual(['Read']);
   });
 
-  it('preserves pending builtin names across intermediate user‑tool‑only calls but clears on empty replacement', () => {
+  it('only keeps pending builtin names when the replacement set contains unresolved tools', () => {
     const agent = {
       records: { logRecord: vi.fn() },
       config: { hasProvider: false },
@@ -193,36 +193,31 @@ describe('ToolManager setActiveTools filtering', () => {
     const tm = new ToolManager(agent);
     // builtins empty — pre-init state
 
-    // First call: task tools saved as pending
+    // First call: task tools saved as pending (missing builtins)
     tm.setActiveTools(['Bash', 'TaskList', 'TaskOutput', 'TaskStop']);
     expect((tm as any).pendingBuiltinToolNames).toEqual([
       'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
     ]);
 
-    // Second call: user-tool-only — all names available; pending must survive
-    // because this call doesn't express intent about builtin tools.
+    // Second call: user-tool-only replacement — clears pending because
+    // this is a replacement, not an incremental addition. The new active
+    // set explicitly replaces the previous one.
     const userTool = {
       name: 'UserTool', description: '', parameters: {},
       resolveExecution: vi.fn(),
     };
     (tm as any).userTools.set('UserTool', userTool);
     tm.setActiveTools(['UserTool']);
-    expect((tm as any).pendingBuiltinToolNames).toEqual([
-      'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
-    ]);
-
-    // Third call: empty replacement — must clear pending since the caller
-    // explicitly removed all tools.
-    tm.setActiveTools([]);
     expect((tm as any).pendingBuiltinToolNames).toEqual([]);
+    expect([...tm.toolInfos()].filter((t) => t.active).map((t) => t.name)).toEqual(['UserTool']);
 
-    // Fourth call: re-establish pending
+    // Third call: re-establish pending
     tm.setActiveTools(['Bash', 'TaskList', 'TaskOutput', 'TaskStop']);
     expect((tm as any).pendingBuiltinToolNames).toEqual([
       'Bash', 'TaskList', 'TaskOutput', 'TaskStop',
     ]);
 
-    // Fifth call: MCP-only — no non-MCP names, acts like empty replacement
+    // Fourth call: MCP-only — no non-MCP names, acts like empty replacement
     tm.setActiveTools(['mcp__*']);
     expect((tm as any).pendingBuiltinToolNames).toEqual([]);
   });