@selesai/code 0.13.2 → 0.13.4

package/dist/extensions/cost-reconcile.ts

@@ -9,19 +9,19 @@
  *
  * Extensions cannot hook the response body through the event API
  * (`after_provider_response` exposes only status/headers), but provider SDKs
- * fall back to `globalThis.fetch`. This extension installs a tee-wrapping
- * fetch once per process: LLM API responses are scanned for a
- * provider-reported cost (LiteLLM `x-litellm-response-cost` header,
- * OpenRouter `usage.cost`, `total_cost`, plus object-shaped `cost.total`)
- * and its response id, then recorded as a custom session entry on
- * `message_end`.
+ * fall back to `globalThis.fetch`. This extension installs a stream-wrapping
+ * fetch once per process: LLM API responses are scanned for a provider-reported
+ * cost (LiteLLM `x-litellm-response-cost` header, OpenRouter `usage.cost`,
+ * `total_cost`, plus object-shaped `cost.total`) and response id. The wrapper
+ * finishes capture before the provider SDK finalizes its assistant message, so
+ * `message_end` can replace `usage.cost.total` before session persistence.
  *
- * Providers whose payloads carry no cost (first-party OpenAI/Anthropic due to
- * their usage APIs) simply record nothing — their rate-card estimate matches
- * their bill anyway when catalog prices are configured.
- *
- * The zentui footer prefers reconciled entries over the rate-card total when
- * both exist for the same response id.
+ * Streamed bodies repeat the response id across chunks and also carry
+ * tool-call ids (`call_*`), so the billed cost is keyed by every id found and
+ * `message_end` consumes only the one matching the finalized message's
+ * `responseId`. Providers whose payloads carry no cost retain their rate-card
+ * estimate. Reconciled entries remain persisted for zentui and existing-session
+ * compatibility.
  */
 
 import type { ExtensionAPI } from "@selesai/code";
@@ -31,11 +31,10 @@ const ENTRY_VERSION = 1 as const;
 
 // Guard against pathological bodies; real usage chunks arrive well under 1MB.
 const MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
-// Only LLM API paths are tee'd and scanned; unrelated fetches (web fetch tool,
-// model catalog refreshes) pass through untouched.
+// Only LLM API paths are scanned; unrelated fetches (web fetch tool, model
+// catalog refreshes) pass through untouched.
 const LLM_PATH_RE = /(\/chat\/completions|\/responses|\/messages\b|:streamGenerateContent)/;
 const MAX_CAPTURED_IDS = 50;
-const MAX_PENDING_LOOKUPS = 200;
 const MAX_SESSION_ENTRIES = 2_000;
 
 type ReconcileEntry = {
@@ -49,46 +48,34 @@ type ReconcileEntry = {
 	source: "payload";
 };
 
-/**
- * Scan a captured SSE/JSON body for provider-reported cost and response ids.
- * Exported for tests.
- *
- * In streams, usage lands in the final chunk, so the LAST cost match wins.
- */
 type MessageInfo = {
 	provider: string;
 	model: string;
 	responseId: string;
 };
 
-// Process-wide capture state. The fetch patch is installed once per process
-// and must not capture session-bound `pi`; per-session message_end handlers
-// read these maps and write entries through their own session's appendEntry.
-const processCaptured = new Map<string, number>();
-const processWaiting = new Map<
-	string,
-	{ info: MessageInfo; write: (info: MessageInfo, cost: number) => void }
->();
+// Process-wide capture state. The fetch patch is installed once per process;
+// per-session message_end handlers consume the matching response id. A duplicate
+// capture for the same id is marked ambiguous rather than assigning either bill.
+const processCaptured = new Map<string, number | null>();
 
-/**
- * Scan a captured SSE/JSON body for provider-reported cost and response ids.
- * Pure function; exported for tests.
- *
- * In streams, usage lands in the final chunk, so the LAST cost match wins.
- */
 /**
  * Parse a LiteLLM `x-litellm-response-cost` header value (a USD float,
  * possibly in scientific notation). Exported for tests.
  */
 export function parseCostHeader(value: string | null): number | undefined {
-	if (value === null) return undefined;
-	const cost = Number(value);
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	const cost = Number(trimmed);
 	return Number.isFinite(cost) && cost >= 0 ? cost : undefined;
 }
 
-export function extractCosts(
-	text: string,
-): { ids: string[]; cost?: number } {
+/**
+ * Scan a captured SSE/JSON body for provider-reported cost and response ids.
+ * Exported for tests. In streams, usage lands in the final chunk, so the LAST
+ * valid cost match wins.
+ */
+export function extractCosts(text: string): { ids: string[]; cost?: number } {
 	const ids = new Set<string>();
 	for (const match of text.matchAll(/"id"\s*:\s*"([^"]{1,200})"/g)) {
 		ids.add(match[1]);
@@ -151,25 +138,25 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 		try {
 			pi.appendEntry(ENTRY_TYPE, entry);
 		} catch {
-			// transcript persistence failure must not break the session
+			// Transcript persistence failure must not break the session.
 		}
 	};
 
 	const finishCapture = (rawBody: string, headerCost?: number): void => {
-		// ponytail: one naive regex pass over the whole body; a streaming
-		// parser only matters if bodies grow past the 4MB cap.
+		// Ponytail: one naive regex pass over the whole body; a streaming parser
+		// only matters if bodies grow past the 4MB cap.
 		const { ids, cost } = extractCosts(rawBody);
-		// LiteLLM's header is the amount the gateway billed; prefer it over
-		// any cost the upstream payload reports.
+		// LiteLLM's header is the amount the gateway billed; prefer it over any
+		// cost the upstream payload reports.
 		const effectiveCost = headerCost ?? cost;
-		if (effectiveCost === undefined) return;
+		if (effectiveCost === undefined || ids.length === 0) return;
+		// A streamed response repeats its own id across chunks while tool-call
+		// ids (`call_*`) appear once, so a body legitimately carries several ids.
+		// Key the billed cost by every id; message_end consumes only the one
+		// matching the finalized message's responseId. A duplicate capture of the
+		// same id (retry) is marked ambiguous rather than assigning either bill.
 		for (const responseId of ids) {
-			processCaptured.set(responseId, effectiveCost);
-			const waiting = processWaiting.get(responseId);
-			if (waiting) {
-				processWaiting.delete(responseId);
-				waiting.write(waiting.info, effectiveCost);
-			}
+			processCaptured.set(responseId, processCaptured.has(responseId) ? null : effectiveCost);
 		}
 		if (processCaptured.size > 500) {
 			for (const key of [...processCaptured.keys()].slice(0, processCaptured.size - 500))
@@ -191,7 +178,7 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 				if (typeof responseId === "string") seen.add(responseId);
 			}
 		} catch {
-			// best effort only
+			// Best effort only.
 		}
 
 		const globalFetch = globalThis as typeof globalThis & { [FETCH_PATCHED]?: boolean };
@@ -205,26 +192,36 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 				const contentType = response.headers.get("content-type") ?? "";
 				if (!contentType.includes("json") && !contentType.includes("event-stream")) return response;
 				if (!response.body) return response;
+
 				const headerCost = parseCostHeader(response.headers.get("x-litellm-response-cost"));
-				const [main, tee] = response.body.tee();
-				void (async () => {
-					let raw = "";
-					try {
-						const reader = tee.getReader();
-						const decoder = new TextDecoder();
-						for (;;) {
-							const { done, value } = await reader.read();
-							if (done) break;
-							raw += decoder.decode(value, { stream: true });
-							if (raw.length > MAX_CAPTURE_BYTES) break;
+				let raw = "";
+				let captureFailed = false;
+				const decoder = new TextDecoder();
+				const capture = new TransformStream<Uint8Array, Uint8Array>({
+					transform(chunk, controller) {
+						controller.enqueue(chunk);
+						if (captureFailed) return;
+						try {
+							raw += decoder.decode(chunk, { stream: true });
+							if (raw.length > MAX_CAPTURE_BYTES) captureFailed = true;
+						} catch {
+							captureFailed = true;
 						}
-					} catch {
-						// capture is best-effort; the main branch is unaffected
-					}
-					finishCapture(raw, headerCost);
-				})();
-				// Preserve response identity as seen by the SDK: body swapped, rest identical.
-				return new Response(main, {
+					},
+					flush() {
+						if (captureFailed) return;
+						try {
+							raw += decoder.decode();
+							finishCapture(raw, headerCost);
+						} catch {
+							// Capture is best-effort; the response stream is unaffected.
+						}
+					},
+				});
+				// flush() runs before the SDK observes EOF, so message_end can safely
+				// replace the finalized message usage without waiting on another fetch.
+				const body = response.body.pipeThrough(capture);
+				return new Response(body, {
 					status: response.status,
 					statusText: response.statusText,
 					headers: response.headers,
@@ -236,43 +233,32 @@ export default function costReconcileExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("message_end", (event) => {
-		const message = event.message as
-			| {
-					role?: string;
-					provider?: string;
-					model?: string;
-					responseId?: string;
-					stopReason?: string;
-				}
-			| undefined;
-		if (!message || message.role !== "assistant") return;
+		const message = event.message;
+		if (message.role !== "assistant") return;
 		if (message.stopReason === "error" || message.stopReason === "aborted") return;
 		const responseId = message.responseId;
 		if (typeof responseId !== "string" || responseId.length === 0) return;
 
-		const info: MessageInfo = {
-			provider: message.provider ?? "",
-			model: message.responseModel ?? message.model ?? "",
-			responseId,
-		};
 		const cost = processCaptured.get(responseId);
-		if (cost !== undefined) {
-			writeEntry(info, cost);
+		if (cost === undefined || cost === null || !message.usage?.cost) {
+			processCaptured.delete(responseId);
 			return;
 		}
-		// The tee branch may finish after message_end; remember the message so
-		// the capture can match it on completion and write via this session.
-		if (!seen.has(responseId) && !processWaiting.has(responseId)) {
-			waitingLimitGuard();
-			processWaiting.set(responseId, { info, write: writeEntry });
-		}
+		processCaptured.delete(responseId);
+
+		writeEntry(
+			{
+				provider: message.provider ?? "",
+				model: message.responseModel ?? message.model ?? "",
+				responseId,
+			},
+			cost,
+		);
+		return {
+			message: {
+				...message,
+				usage: { ...message.usage, cost: { ...message.usage.cost, total: cost } },
+			},
+		};
 	});
 }
-
-// Trim oldest waiting entries so unclaimed captures cannot grow unbounded.
-function waitingLimitGuard(): void {
-	if (processWaiting.size >= MAX_PENDING_LOOKUPS) {
-		for (const key of [...processWaiting.keys()].slice(0, processWaiting.size - MAX_PENDING_LOOKUPS + 1))
-			processWaiting.delete(key);
-	}
-}

package/dist/extensions/pi-intercom/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.12.1] - 2026-08-29
+
+### Highlights
+- Replies to inbound asks are now harder to send to the wrong local session by mistake.
+- The `intercom` tool now stays in the active tool set, which avoids a late-session prompt-cache reset when intercom first becomes useful.
+- Existing configs that still mention `toolVisibility` keep loading; the old setting is simply ignored.
+
+### Fixed
+- Refuse non-reply `send` calls to a different target during a turn triggered by an inbound ask, preventing CWD hierarchy or roster guesses from misdirecting replies. Thanks to [@yceachan](https://github.com/yceachan) for issue #117.
+
+### Removed
+- Removed `toolVisibility` and the `after-first-use` reveal path. The generic `intercom` schema and prompt snippet now stay stable for provider prompt caches, and existing `toolVisibility` config keys are ignored. Thanks to [@XWIlluDelu](https://github.com/XWIlluDelu) for issue #118.
+
 ## [0.12.0] - 2026-08-22
 
 ### Highlights

package/dist/extensions/pi-intercom/README.md

@@ -218,7 +218,7 @@ This matters because the agent receiving the message doesn't need to reconstruct
 
 ### `send` vs `ask`
 
-`send` is fire-and-forget — the tool returns immediately after delivery. When the destination has exactly one pending inbound ask, `send` infers that it is the answer, attaches the ask's `replyTo`, and reports `Reply sent to <target> (inferred from pending ask)`. With zero or multiple matching asks, it remains an ordinary unthreaded send. An inferred answer still uses the `confirmSend` dialog when configured; only a caller-supplied `replyTo` skips confirmation.
+`send` is fire-and-forget — the tool returns immediately after delivery. When the destination has exactly one pending inbound ask, `send` infers that it is the answer, attaches the ask's `replyTo`, and reports `Reply sent to <target> (inferred from pending ask)`. During a turn triggered by an inbound ask, `send` refuses a different non-reply target instead of treating CWD, roster position, or project hierarchy as reply authority. With zero or multiple matching asks, it remains an ordinary unthreaded send. An inferred answer still uses the `confirmSend` dialog when configured; only a caller-supplied `replyTo` skips confirmation.
 
 `ask` requires a currently connected recipient, then blocks until it responds (10-minute timeout by default; set `PI_INTERCOM_ASK_TIMEOUT_MS` to a positive millisecond value to change it). If the target is disconnected, `ask` fails immediately; use `send` when queued, non-blocking mailbox delivery is appropriate. The reply comes back as the tool result, so the agent continues in the same turn with full context. No confirmation dialog — if you're asking and waiting, the intent is clear.
 
@@ -366,7 +366,7 @@ Only registered in sessions where `pi-subagents` supplied the required child bri
 
 **`list`** — Returns the current session plus other active intercom-connected sessions with name, short ID, working directory, model, and live status. Status is derived automatically from Selesai lifecycle events: `idle`, `thinking`, or `tool:<name>`.
 
-**`send`** — Sends a message to the specified session and returns immediately after delivery. If the destination has exactly one pending inbound ask, `send` infers the message is its answer and returns `Reply sent to <target> (inferred from pending ask)`; zero or multiple matches remain unthreaded sends. Set `confirmSend: true` to confirm ordinary and inferred sends. A caller-supplied `replyTo` skips confirmation. `to` alone resolves globally across all live sessions. `cwd` alone targets the sole live peer in that directory. `to` plus `cwd` requires that peer to be in the directory. With `openProjectPaneIfMissing: true`, pi-intercom opens a visible Herdr project pane, starts Selesai there, waits for that session to register, then delivers the message through normal intercom routing.
+**`send`** — Sends a message to the specified session and returns immediately after delivery. If the destination has exactly one pending inbound ask, `send` infers the message is its answer and returns `Reply sent to <target> (inferred from pending ask)`. During a turn triggered by an inbound ask, a non-reply `send` to a different target is rejected so a guessed parent/root CWD cannot receive an accidental reply. Zero or multiple pending-ask matches remain unthreaded sends outside the active ask turn. Set `confirmSend: true` to confirm ordinary and inferred sends. A caller-supplied `replyTo` skips confirmation. `to` alone resolves globally across all live sessions. `cwd` alone targets the sole live peer in that directory. `to` plus `cwd` requires that peer to be in the directory. With `openProjectPaneIfMissing: true`, pi-intercom opens a visible Herdr project pane, starts Selesai there, waits for that session to register, then delivers the message through normal intercom routing.
 
 **`ask`** — Requires a currently connected recipient, sends a message, and waits for the recipient to reply (10-minute timeout by default; configurable with `PI_INTERCOM_ASK_TIMEOUT_MS`). A disconnected target fails immediately rather than queueing a blocking request. The reply is returned as the tool result. No confirmation dialog. Only one pending `ask` is allowed per session at a time. Use this when the agent needs the answer to continue working. The same `to`, `cwd`, and `openProjectPaneIfMissing` targeting rules apply.
 
@@ -397,7 +397,6 @@ Create `~/.selesai/agent/intercom/config.json`:
   "brokerArgs": ["--no-install", "tsx"],
   "confirmSend": false,
   "inboundTrigger": "always",
-  "toolVisibility": "always",
   "enabled": true,
   "replyHint": true,
   "status": "researching"
@@ -410,12 +409,12 @@ Create `~/.selesai/agent/intercom/config.json`:
 | `brokerArgs` | `["--no-install", "tsx"]` | Advanced trusted arguments passed to custom `brokerCommand` before the broker script path |
 | `confirmSend` | false | Show a confirmation dialog before ordinary or inferred sends from an interactive session with UI; caller-supplied `replyTo` skips it |
 | `inboundTrigger` | `"always"` | Auto-trigger policy for inbound broker messages: `"always"`, `"replies"`, or `"never"`. Local in-process subagent relay events still trigger the addressed session. |
-| `toolVisibility` | `"always"` | When the generic `intercom` tool enters the active model tool set: `"always"` or `"after-first-use"`. Lazy visibility reveals it after an inbound broker message, a successful overlay send, or loading the bundled skill. It does not hide the child-only `contact_supervisor` tool. |
 | `enabled` | true | Enable/disable intercom entirely |
 | `replyHint` | true | Include reply instruction in incoming messages |
 | `status` | — | Optional custom status suffix shown after the automatic lifecycle status, for example `thinking · researching` |
 
 If `config.json` cannot be parsed or contains an invalid value, pi-intercom logs the error and fails closed for inbound broker auto-triggering by using `inboundTrigger: "never"` until the config is fixed.
+Obsolete `toolVisibility` values are ignored; the generic `intercom` tool remains stable in the active tool set for prompt-cache friendliness.
 
 Custom broker commands are trusted local configuration: anyone who can edit this config can choose the executable used for future broker auto-spawns. For example, if you have Bun installed and want it to start the broker directly, use:
 
@@ -542,7 +541,7 @@ Runtime files live at `~/.selesai/agent/intercom/` by default, or `$SELESAI_CODI
 - `broker.port.json` — Dynamic localhost TCP endpoint, only when Windows TCP transport is explicitly enabled
 - `config.json` — User configuration
 
-Supported `config.json` keys include `stableId` for restart-stable addressing, `status` for a custom status suffix, `inboundTrigger` (`always`, `replies`, or `never`), `toolVisibility` (`always` or `after-first-use`), `replyHint`, `confirmSend`, and advanced broker launch overrides.
+Supported `config.json` keys include `stableId` for restart-stable addressing, `status` for a custom status suffix, `inboundTrigger` (`always`, `replies`, or `never`), `replyHint`, `confirmSend`, and advanced broker launch overrides.
 
 ## Design Decisions
 

package/dist/extensions/pi-intercom/config.test.ts

@@ -60,24 +60,13 @@ test("loadConfig accepts inboundTrigger replies policy", async () => {
   }
 });
 
-test("loadConfig defaults intercom tool visibility to always", async () => {
-  const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
-  try {
-    await withAgentDir(root, () => {
-      assert.equal(loadConfig().toolVisibility, "always");
-    });
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test("loadConfig accepts lazy intercom tool visibility", async () => {
+test("loadConfig ignores obsolete toolVisibility values", async () => {
   const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
   try {
     mkdirSync(join(root, "intercom"), { recursive: true });
-    writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ toolVisibility: "after-first-use" }));
+    writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ toolVisibility: "lazy", replyHint: false }));
     await withAgentDir(root, () => {
-      assert.equal(loadConfig().toolVisibility, "after-first-use");
+      assert.equal(loadConfig().replyHint, false);
     });
   } finally {
     rmSync(root, { recursive: true, force: true });
@@ -97,23 +86,6 @@ test("loadConfig accepts a restart-stable intercom id", async () => {
   }
 });
 
-test("loadConfig rejects invalid toolVisibility values", async () => {
-  const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
-  try {
-    mkdirSync(join(root, "intercom"), { recursive: true });
-    writeFileSync(join(root, "intercom", "config.json"), JSON.stringify({ toolVisibility: "lazy" }));
-
-    await withAgentDir(root, () => {
-      assert.throws(
-        () => loadConfig(),
-        /Failed to load intercom config.*"toolVisibility" must be "always" or "after-first-use"/,
-      );
-    });
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
 test("loadConfig rejects invalid inboundTrigger values", async () => {
   const root = mkdtempSync(join(tmpdir(), "pi-intercom-config-"));
   try {

package/dist/extensions/pi-intercom/config.ts

@@ -24,7 +24,6 @@ export function getIntercomScopeId(env: NodeJS.ProcessEnv = process.env): string
 }
 
 export type InboundTriggerPolicy = "always" | "replies" | "never";
-export type IntercomToolVisibility = "always" | "after-first-use";
 
 export interface IntercomConfig {
   /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
@@ -39,9 +38,6 @@ export interface IntercomConfig {
   /** Controls whether inbound broker messages may automatically trigger a model turn */
   inboundTrigger: InboundTriggerPolicy;
 
-  /** Controls when the intercom tool enters the active model tool set */
-  toolVisibility: IntercomToolVisibility;
-
   /** Optional custom status suffix shown after automatic lifecycle status */
   status?: string;
 
@@ -64,7 +60,6 @@ const defaults: IntercomConfig = {
   brokerArgs: ["--no-install", "tsx"],
   confirmSend: false,
   inboundTrigger: "always",
-  toolVisibility: "always",
   enabled: true,
   replyHint: true,
 };
@@ -135,16 +130,6 @@ export function loadConfig(): IntercomConfig {
       config.inboundTrigger = parsedConfig.inboundTrigger;
     }
 
-    if (Object.hasOwn(parsedConfig, "toolVisibility")) {
-      if (
-        parsedConfig.toolVisibility !== "always"
-        && parsedConfig.toolVisibility !== "after-first-use"
-      ) {
-        throw new Error(`"toolVisibility" must be "always" or "after-first-use"`);
-      }
-      config.toolVisibility = parsedConfig.toolVisibility;
-    }
-
     if (Object.hasOwn(parsedConfig, "replyHint")) {
       if (typeof parsedConfig.replyHint !== "boolean") {
         throw new Error(`"replyHint" must be a boolean`);

package/dist/extensions/pi-intercom/index.ts

@@ -27,15 +27,12 @@ import {
   type IntercomOutboxResultV1,
 } from "./extension-api.ts";
 import { ReplyTracker } from "./reply-tracker.ts";
-import { realpathSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
-import { fileURLToPath } from "node:url";
 import { sameCwd } from "./cwd.ts";
 import { formatContextUsage } from "./format-context.ts";
 import { openProjectPane, resolveTargetInCwd, waitForProjectSession, type ProjectPaneLaunch } from "./project-agent.ts";
 
 const INTERCOM_TOOL_NAME = "intercom";
-const INTERCOM_SKILL_PATH = realpathSync(fileURLToPath(new URL("./skills/pi-intercom/SKILL.md", import.meta.url)));
 const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
@@ -116,18 +113,6 @@ function getErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function isIntercomSkillRead(input: unknown, cwd: string): boolean {
-  if (!input || typeof input !== "object") return false;
-  const inputPath = Reflect.get(input, "path");
-  if (typeof inputPath !== "string") return false;
-  const normalizedPath = inputPath.startsWith("@") ? inputPath.slice(1) : inputPath;
-  try {
-    return realpathSync(resolvePath(cwd, normalizedPath)) === INTERCOM_SKILL_PATH;
-  } catch {
-    return false;
-  }
-}
-
 function deliveryDetails(result: SendResult): Record<string, unknown> {
   return {
     messageId: result.id,
@@ -622,23 +607,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   let runtimeGeneration = 0;
   let agentRunning = false;
   const activeTools = new Map<string, string>();
-  let intercomToolHiddenByPolicy = false;
   const replyTracker = new ReplyTracker();
-  function hideIntercomTool(): void {
-    if (config.toolVisibility !== "after-first-use") return;
-    const activeToolNames = pi.getActiveTools();
-    if (!activeToolNames.includes(INTERCOM_TOOL_NAME)) return;
-    pi.setActiveTools(activeToolNames.filter((name) => name !== INTERCOM_TOOL_NAME));
-    intercomToolHiddenByPolicy = true;
-  }
-  function activateIntercomTool(): void {
-    if (!intercomToolHiddenByPolicy) return;
-    const activeToolNames = pi.getActiveTools();
-    if (!activeToolNames.includes(INTERCOM_TOOL_NAME)) {
-      pi.setActiveTools([...activeToolNames, INTERCOM_TOOL_NAME]);
-    }
-    intercomToolHiddenByPolicy = false;
-  }
 
   const seenInboundMessages = new Map<string, number>();
   const latestOutboundReceipts = new Map<string, { status: MessageReceiptStatus; timestamp: number; detail?: string }>();
@@ -1221,7 +1190,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     );
   }
   function sendIncomingBrokerMessage(entry: InboundMessageEntry, delivery: "trigger" | "steer", generation = runtimeGeneration): void {
-    activateIntercomTool();
     sendIncomingMessage(entry, delivery, generation);
   }
   function handleIncomingMessage(ctx: ExtensionContext, from: SessionInfo, message: Message): void {
@@ -1572,7 +1540,6 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     });
   }
   function startSessionRuntime(ctx: ExtensionContext): void {
-    hideIntercomTool();
     const previousClient = client;
     failPendingOutboxRequests(runtimeGeneration, "session_ended", "Session replaced");
     shuttingDown = false;
@@ -1819,17 +1786,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     return new InlineMessageComponent(details.from, details.message, theme, details.replyCommand, details.bodyText, !options.expanded);
   });
 
-  pi.on("input", (event) => {
-    if (/^\/skill: pi-intercom(?:\s|$)/u.test(event.text.trimStart())) {
-      activateIntercomTool();
-    }
-  });
-
-  pi.on("tool_result", (event, ctx) => {
-    if (event.toolName === "read" && event.isError !== true && isIntercomSkillRead(event.input, ctx.cwd)) {
-      activateIntercomTool();
-      return;
-    }
+  pi.on("tool_result", (event) => {
     if (event.toolName !== "intercom" && event.toolName !== "contact_supervisor") {
       return;
     }
@@ -2181,7 +2138,6 @@ Usage:
     }),
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      activateIntercomTool();
       let connectedClient: IntercomClient;
       try {
         connectedClient = await ensureConnected("tool");
@@ -2350,6 +2306,14 @@ Usage:
                 details: { error: true },
               };
             }
+            const activeReplyMismatch = replyTo ? null : replyTracker.findActiveReplyTargetMismatch(sendTo);
+            if (activeReplyMismatch) {
+              const senderLabel = activeReplyMismatch.from.name || activeReplyMismatch.from.id;
+              return {
+                content: [{ type: "text", text: `This turn is responding to an intercom ask from "${senderLabel}". Use intercom({ action: "reply", message: "..." }) or set replyTo: "${activeReplyMismatch.message.id}". Refusing non-reply send to "${targetDisplay}" to avoid a misdirected reply.` }],
+                details: { error: true, replyTo: activeReplyMismatch.message.id },
+              };
+            }
             const inferredAsk = replyTo ? null : replyTracker.findUniquePendingAskFrom(sendTo);
             const effectiveReplyTo = replyTo ?? inferredAsk?.message.id;
             if (confirmSend && !(cwd && openProjectPaneIfMissing)) {
@@ -2761,7 +2725,6 @@ Usage:
     ).catch(() => undefined);
 
     if (result?.sent && result.messageId && result.text && getLiveContext(ctx, overlayGeneration)) {
-      activateIntercomTool();
       pi.appendEntry("intercom_sent", {
         to: selectedSession.name || selectedSession.id,
         message: { text: result.text },