@selesai/code 0.13.3 → 0.13.5

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/cwd.test.ts

@@ -1,40 +1,40 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { normalizeCwd, sameCwd } from "./cwd.ts";
-
-test("sameCwd collapses a trailing slash", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
-});
-
-test("sameCwd collapses lexical '.' and '..' segments", () => {
-  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
-});
-
-test("sameCwd treats genuinely different directories as different", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
-});
-
-test("sameCwd collapses a symlink to its real target", () => {
-  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
-  try {
-    const real = join(base, "real");
-    const link = join(base, "link");
-    mkdirSync(real);
-    symlinkSync(real, link);
-    // Reached via the symlink vs its canonical path — must compare equal.
-    assert.equal(sameCwd(link, real), true);
-    // And normalizeCwd resolves the link to the real path.
-    assert.equal(normalizeCwd(link), realpathSync(real));
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
-  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
-  // lexical variants rather than throw.
-  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { normalizeCwd, sameCwd } from "./cwd.ts";
+
+test("sameCwd collapses a trailing slash", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
+});
+
+test("sameCwd collapses lexical '.' and '..' segments", () => {
+  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
+});
+
+test("sameCwd treats genuinely different directories as different", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
+});
+
+test("sameCwd collapses a symlink to its real target", () => {
+  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
+  try {
+    const real = join(base, "real");
+    const link = join(base, "link");
+    mkdirSync(real);
+    symlinkSync(real, link);
+    // Reached via the symlink vs its canonical path — must compare equal.
+    assert.equal(sameCwd(link, real), true);
+    // And normalizeCwd resolves the link to the real path.
+    assert.equal(normalizeCwd(link), realpathSync(real));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
+  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
+  // lexical variants rather than throw.
+  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
+});

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

@@ -1,31 +1,31 @@
-import { resolve } from "node:path";
-import { realpathSync } from "node:fs";
-
-// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
-// hides genuine same-directory peers when two cwd strings differ only by a
-// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
-// /private/tmp). resolve() collapses the lexical variants; realpathSync()
-// collapses symlinks (best-effort: falls back to the resolved path if the
-// directory no longer exists). Memoized — the set of distinct cwd strings is
-// small and stable, so repeat comparisons are free after warmup.
-const normalizeCache = new Map<string, string>();
-
-export function normalizeCwd(cwd: string): string {
-  const cached = normalizeCache.get(cwd);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const resolved = resolve(cwd);
-  let normalized: string;
-  try {
-    normalized = realpathSync(resolved);
-  } catch {
-    normalized = resolved;
-  }
-  normalizeCache.set(cwd, normalized);
-  return normalized;
-}
-
-export function sameCwd(a: string, b: string): boolean {
-  return normalizeCwd(a) === normalizeCwd(b);
-}
+import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+
+// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
+// hides genuine same-directory peers when two cwd strings differ only by a
+// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
+// /private/tmp). resolve() collapses the lexical variants; realpathSync()
+// collapses symlinks (best-effort: falls back to the resolved path if the
+// directory no longer exists). Memoized — the set of distinct cwd strings is
+// small and stable, so repeat comparisons are free after warmup.
+const normalizeCache = new Map<string, string>();
+
+export function normalizeCwd(cwd: string): string {
+  const cached = normalizeCache.get(cwd);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const resolved = resolve(cwd);
+  let normalized: string;
+  try {
+    normalized = realpathSync(resolved);
+  } catch {
+    normalized = resolved;
+  }
+  normalizeCache.set(cwd, normalized);
+  return normalized;
+}
+
+export function sameCwd(a: string, b: string): boolean {
+  return normalizeCwd(a) === normalizeCwd(b);
+}

package/dist/extensions/pi-intercom/format-context.test.ts

@@ -1,31 +1,31 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { formatTokenCount, formatContextUsage } from "./format-context.ts";
-import type { SessionInfo } from "./types.ts";
-
-const base: SessionInfo = { id: "s1", cwd: "/w", model: "m", pid: 1, startedAt: 0, lastActivity: 0 };
-
-test("formatTokenCount compacts thousands", () => {
-  assert.equal(formatTokenCount(0), "0");
-  assert.equal(formatTokenCount(999), "999");
-  assert.equal(formatTokenCount(1432), "1.4k");
-  assert.equal(formatTokenCount(144000), "144k");
-  assert.equal(formatTokenCount(200000), "200k");
-});
-
-test("formatContextUsage renders percent + token detail when all known", () => {
-  assert.equal(
-    formatContextUsage({ ...base, contextPct: 72, contextTokens: 144000, contextWindow: 200000 }),
-    " · 72% ctx (144k/200k)",
-  );
-});
-
-test("formatContextUsage shows percent only when token counts are absent", () => {
-  assert.equal(formatContextUsage({ ...base, contextPct: 30 }), " · 30% ctx");
-});
-
-test("formatContextUsage renders nothing when percent is unknown (never a stale %)", () => {
-  assert.equal(formatContextUsage(base), "");
-  // Tokens present but no percent (e.g. right after a compaction) still renders nothing.
-  assert.equal(formatContextUsage({ ...base, contextTokens: 100, contextWindow: 200 }), "");
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { formatTokenCount, formatContextUsage } from "./format-context.ts";
+import type { SessionInfo } from "./types.ts";
+
+const base: SessionInfo = { id: "s1", cwd: "/w", model: "m", pid: 1, startedAt: 0, lastActivity: 0 };
+
+test("formatTokenCount compacts thousands", () => {
+  assert.equal(formatTokenCount(0), "0");
+  assert.equal(formatTokenCount(999), "999");
+  assert.equal(formatTokenCount(1432), "1.4k");
+  assert.equal(formatTokenCount(144000), "144k");
+  assert.equal(formatTokenCount(200000), "200k");
+});
+
+test("formatContextUsage renders percent + token detail when all known", () => {
+  assert.equal(
+    formatContextUsage({ ...base, contextPct: 72, contextTokens: 144000, contextWindow: 200000 }),
+    " · 72% ctx (144k/200k)",
+  );
+});
+
+test("formatContextUsage shows percent only when token counts are absent", () => {
+  assert.equal(formatContextUsage({ ...base, contextPct: 30 }), " · 30% ctx");
+});
+
+test("formatContextUsage renders nothing when percent is unknown (never a stale %)", () => {
+  assert.equal(formatContextUsage(base), "");
+  // Tokens present but no percent (e.g. right after a compaction) still renders nothing.
+  assert.equal(formatContextUsage({ ...base, contextTokens: 100, contextWindow: 200 }), "");
+});

package/dist/extensions/pi-intercom/format-context.ts

@@ -1,32 +1,32 @@
-import type { SessionInfo } from "./types.ts";
-
-// Compact token count for display: 1432 -> "1.4k", 144000 -> "144k". Keeps list
-// rows short while staying legible.
-export function formatTokenCount(tokens: number): string {
-  if (tokens < 1000) {
-    return String(Math.max(0, Math.round(tokens)));
-  }
-  const k = tokens / 1000;
-  const value = k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, "");
-  return `${value}k`;
-}
-
-// Render a session's context-window usage to sit beside its model, e.g.
-// " · 72% ctx (144k/200k)". The token detail is appended only when both counts
-// are known. Unknown percent (e.g. right after a compaction, before the next
-// assistant response) renders nothing, so a frozen value is never shown as a
-// stale percentage.
-export function formatContextUsage(session: SessionInfo): string {
-  if (typeof session.contextPct !== "number") {
-    return "";
-  }
-  let out = ` · ${session.contextPct}% ctx`;
-  if (
-    typeof session.contextTokens === "number"
-    && typeof session.contextWindow === "number"
-    && session.contextWindow > 0
-  ) {
-    out += ` (${formatTokenCount(session.contextTokens)}/${formatTokenCount(session.contextWindow)})`;
-  }
-  return out;
-}
+import type { SessionInfo } from "./types.ts";
+
+// Compact token count for display: 1432 -> "1.4k", 144000 -> "144k". Keeps list
+// rows short while staying legible.
+export function formatTokenCount(tokens: number): string {
+  if (tokens < 1000) {
+    return String(Math.max(0, Math.round(tokens)));
+  }
+  const k = tokens / 1000;
+  const value = k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, "");
+  return `${value}k`;
+}
+
+// Render a session's context-window usage to sit beside its model, e.g.
+// " · 72% ctx (144k/200k)". The token detail is appended only when both counts
+// are known. Unknown percent (e.g. right after a compaction, before the next
+// assistant response) renders nothing, so a frozen value is never shown as a
+// stale percentage.
+export function formatContextUsage(session: SessionInfo): string {
+  if (typeof session.contextPct !== "number") {
+    return "";
+  }
+  let out = ` · ${session.contextPct}% ctx`;
+  if (
+    typeof session.contextTokens === "number"
+    && typeof session.contextWindow === "number"
+    && session.contextWindow > 0
+  ) {
+    out += ` (${formatTokenCount(session.contextTokens)}/${formatTokenCount(session.contextWindow)})`;
+  }
+  return out;
+}

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 },

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

@@ -1672,59 +1672,7 @@ test("intercom tool result hook marks failed details as errors", async () => {
   assert.deepEqual(okResults.filter(Boolean), []);
 });
 
-test("lazy tool visibility reveals intercom on bundled skill use only", { concurrency: false }, async () => {
-  const { default: piIntercomExtension } = await import("./index.ts");
-
-  await withIntercomConfig({ toolVisibility: "after-first-use" }, () => withChildOrchestratorEnv({
-    orchestratorTarget: "orchestrator",
-    runId: "78f659a3",
-    agent: "worker",
-    index: "0",
-  }, async () => {
-    const harness = createExtensionHarness("lazy-skill-worker", { activeTools: ["read", "bash"] });
-    piIntercomExtension(harness.pi as never);
-
-    try {
-      await harness.emitLifecycle("session_start");
-      assert.deepEqual(harness.getActiveTools(), ["read", "bash", "contact_supervisor"]);
-
-      harness.pi.events.emit("subagent:control-intercom", {
-        to: "session-child-test",
-        message: "Local relay traffic should not reveal the generic tool.",
-      });
-      assert.equal(harness.sentMessages.at(-1)?.activeTools.includes("intercom"), false);
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "README.md") },
-        isError: false,
-      });
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
-        isError: true,
-      });
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-
-      await harness.emitLifecycle("tool_result", {
-        toolName: "read",
-        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
-        isError: false,
-      });
-      assert.deepEqual(harness.getActiveTools(), ["read", "bash", "contact_supervisor", "intercom"]);
-
-      await harness.emitLifecycle("session_start");
-      assert.equal(harness.getActiveTools().includes("intercom"), false);
-      await harness.emitLifecycle("input", { text: "  /skill: pi-intercom", source: "user" });
-      assert.equal(harness.getActiveTools().includes("intercom"), true);
-    } finally {
-      await harness.emitLifecycle("session_shutdown");
-    }
-  }));
-});
-
-test("lazy tool visibility reveals intercom before broker injection and after an overlay send", { concurrency: false }, async () => {
+test("obsolete toolVisibility config never hides or reveals the intercom tool", { concurrency: false }, async () => {
   const { default: piIntercomExtension } = await import("./index.ts");
 
   await withIntercomConfig({ toolVisibility: "after-first-use" }, async () => {
@@ -1754,14 +1702,14 @@ test("lazy tool visibility reveals intercom before broker injection and after an
       piIntercomExtension(inboundHarness.pi as never);
       await overlayHarness.emitLifecycle("session_start");
       await inboundHarness.emitLifecycle("session_start");
-      assert.equal(overlayHarness.getActiveTools().includes("intercom"), false);
-      assert.equal(inboundHarness.getActiveTools().includes("intercom"), false);
+      assert.equal(overlayHarness.getActiveTools().includes("intercom"), true);
+      assert.equal(inboundHarness.getActiveTools().includes("intercom"), true);
 
       selectedSession = await waitForSessionByName(planner, "planner");
       const inboundSession = await waitForSessionByName(planner, "lazy-inbound-worker");
       const delivered = await planner.send(inboundSession.id, {
-        messageId: "lazy-inbound-message",
-        text: "Reveal intercom before injecting this message.",
+        messageId: "stable-inbound-message",
+        text: "Keep intercom active before injecting this message.",
       });
       assert.equal(delivered.delivered, true);
       const deadline = Date.now() + 1000;
@@ -1770,6 +1718,13 @@ test("lazy tool visibility reveals intercom before broker injection and after an
       }
       assert.equal(inboundHarness.sentMessages[0]?.activeTools.includes("intercom"), true);
 
+      await inboundHarness.emitLifecycle("tool_result", {
+        toolName: "read",
+        input: { path: path.join(repoDir, "skills", "pi-intercom", "SKILL.md") },
+        isError: false,
+      });
+      assert.equal(inboundHarness.getActiveTools().includes("intercom"), true);
+
       await overlayHarness.commands.get("intercom")!("", overlayHarness.ctx);
       assert.equal(overlayStep, 2);
       assert.equal(overlayHarness.getActiveTools().includes("intercom"), true);
@@ -3148,6 +3103,43 @@ test("intercom reply sends attachments", { concurrency: false }, async () => {
   }
 });
 
+test("intercom send refuses a different target during an active inbound ask turn", { concurrency: false }, async () => {
+  const { planner, orchestrator, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const harness = createExtensionHarness("cwd-reply-worker");
+
+  try {
+    piIntercomExtension(harness.pi as never);
+    await harness.emitLifecycle("session_start");
+    const worker = await waitForSessionByName(planner, "cwd-reply-worker");
+
+    assert.equal((await planner.send(worker.id, {
+      messageId: "cwd-hierarchy-ask",
+      text: "Please answer me, not the repo-root session.",
+      expectsReply: true,
+    })).delivered, true);
+    const deadline = Date.now() + 1000;
+    while (harness.sentMessages.length === 0 && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    await harness.emitLifecycle("turn_start");
+
+    const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+    const result = await intercomTool.execute("misdirected-send", {
+      action: "send",
+      to: "orchestrator",
+      message: "This was meant as the ask answer.",
+    }, new AbortController().signal, undefined, harness.ctx);
+
+    assert.equal(result.details?.error, true);
+    assert.equal(result.details?.replyTo, "cwd-hierarchy-ask");
+    assert.match(result.content[0]?.text ?? "", /Refusing non-reply send to "orchestrator"/);
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
 test("intercom reply targets one of multiple pending asks by short session ID", { concurrency: false }, async () => {
   const { planner, orchestrator, cleanup } = await setupClients();
   const { default: piIntercomExtension } = await import("./index.ts");

package/dist/extensions/pi-intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-intercom",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "license": "MIT",
   "type": "module",
   "main": "index.ts",

package/dist/extensions/pi-intercom/reply-tracker.test.ts

@@ -93,6 +93,26 @@ test("explicit to overrides the current turn context", () => {
   assert.throws(() => tracker.resolveReplyTarget({ to: "missing" }, 1003), /No pending ask from/);
 });
 
+test("active ask context flags non-reply sends to a different target", () => {
+  const tracker = new ReplyTracker();
+  const current = tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "Need a reply"), 1000);
+  tracker.queueTurnContext(current);
+  tracker.beginTurn(1001);
+
+  assert.equal(tracker.findActiveReplyTargetMismatch("planner-id", 1002), null);
+  assert.equal(tracker.findActiveReplyTargetMismatch("planner", 1002)?.message.id, "ask-1");
+  assert.equal(tracker.findActiveReplyTargetMismatch("repo-root", 1002)?.message.id, "ask-1");
+});
+
+test("active ask context does not trust sender names as destination identity", () => {
+  const tracker = new ReplyTracker();
+  const current = tracker.recordIncomingMessage(createSession("asker-session", "root-session"), createMessage("ask-1", "Need a reply"), 1000);
+  tracker.queueTurnContext(current);
+  tracker.beginTurn(1001);
+
+  assert.equal(tracker.findActiveReplyTargetMismatch("root-session", 1002)?.message.id, "ask-1");
+});
+
 test("replyTo resolves the exact pending ask", () => {
   const tracker = new ReplyTracker();
   tracker.recordIncomingMessage(createSession("planner-id", "planner"), createMessage("ask-1", "First"), 1000);

package/dist/extensions/pi-intercom/reply-tracker.ts

@@ -121,6 +121,14 @@ export class ReplyTracker {
     return candidates.length === 1 ? candidates[0]! : null;
   }
 
+  findActiveReplyTargetMismatch(to: string, now = Date.now()): IntercomContext | null {
+    this.pruneExpired(now);
+    if (!this.currentTurnContext?.message.expectsReply) {
+      return null;
+    }
+    return this.currentTurnContext.from.id === to ? null : this.currentTurnContext;
+  }
+
   markReplied(replyTo: string): void {
     this.dismissPendingAsk(replyTo);
   }