@selesai/code 0.13.3 → 0.13.5

package/dist/extensions/pi-intercom/broker/framing.test.ts

@@ -1,114 +1,114 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createMessageReader, writeMessage } from "./framing.ts";
-
-function framePayload(payload: Buffer): Buffer {
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(payload.length, 0);
-  return Buffer.concat([header, payload]);
-}
-
-test("createMessageReader handles normal fragmented frames", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    64,
-  );
-  const frameA = framePayload(Buffer.from(JSON.stringify({ type: "one" }), "utf-8"));
-  const frameB = framePayload(Buffer.from(JSON.stringify({ type: "two" }), "utf-8"));
-  const combined = Buffer.concat([frameA, frameB]);
-
-  reader(combined.subarray(0, 2));
-  reader(combined.subarray(2, 7));
-  reader(combined.subarray(7));
-
-  assert.deepEqual(messages, [{ type: "one" }, { type: "two" }]);
-  assert.deepEqual(errors, []);
-});
-
-test("createMessageReader reassembles a fragmented frame after a header-boundary fast-path frame", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    64,
-  );
-  const frameA = framePayload(Buffer.from(JSON.stringify({ a: 1 }), "utf-8"));
-  const frameB = framePayload(Buffer.from(JSON.stringify({ bb: "1234567890" }), "utf-8"));
-
-  reader(frameA.subarray(0, 4)); // chunk ends exactly at the end of frame A's header
-  reader(frameA.subarray(4)); // frame A's payload arrives whole (zero-copy fast path)
-  reader(frameB.subarray(0, 6)); // frame B header + partial payload (buffered path)
-  reader(frameB.subarray(6));
-
-  assert.deepEqual(messages, [{ a: 1 }, { bb: "1234567890" }]);
-  assert.deepEqual(errors, []);
-});
-
-test("createMessageReader rejects an oversized declared frame", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const oversizedFrame = framePayload(Buffer.from(JSON.stringify({ text: "too large" }), "utf-8"));
-
-  reader(oversizedFrame);
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.match(errors[0].message, /Intercom frame length \d+ exceeds maximum 8 bytes/);
-});
-
-test("createMessageReader rejects an oversized frame before retaining same-chunk payload bytes", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(9, 0);
-
-  reader(Buffer.concat([header, Buffer.alloc(1024 * 1024)]));
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
-});
-
-test("createMessageReader rejects a partial oversized frame before buffering the payload", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(9, 0);
-
-  reader(header);
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
-});
-
-test("writeMessage emits frames accepted by createMessageReader", () => {
-  const chunks: Buffer[] = [];
-  const socket = { write: (chunk: Buffer) => chunks.push(chunk) };
-  const messages: unknown[] = [];
-  const reader = createMessageReader((message) => messages.push(message), assert.fail, 64);
-
-  writeMessage(socket as never, { ok: true });
-  reader(Buffer.concat(chunks));
-
-  assert.deepEqual(messages, [{ ok: true }]);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createMessageReader, writeMessage } from "./framing.ts";
+
+function framePayload(payload: Buffer): Buffer {
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0);
+  return Buffer.concat([header, payload]);
+}
+
+test("createMessageReader handles normal fragmented frames", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    64,
+  );
+  const frameA = framePayload(Buffer.from(JSON.stringify({ type: "one" }), "utf-8"));
+  const frameB = framePayload(Buffer.from(JSON.stringify({ type: "two" }), "utf-8"));
+  const combined = Buffer.concat([frameA, frameB]);
+
+  reader(combined.subarray(0, 2));
+  reader(combined.subarray(2, 7));
+  reader(combined.subarray(7));
+
+  assert.deepEqual(messages, [{ type: "one" }, { type: "two" }]);
+  assert.deepEqual(errors, []);
+});
+
+test("createMessageReader reassembles a fragmented frame after a header-boundary fast-path frame", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    64,
+  );
+  const frameA = framePayload(Buffer.from(JSON.stringify({ a: 1 }), "utf-8"));
+  const frameB = framePayload(Buffer.from(JSON.stringify({ bb: "1234567890" }), "utf-8"));
+
+  reader(frameA.subarray(0, 4)); // chunk ends exactly at the end of frame A's header
+  reader(frameA.subarray(4)); // frame A's payload arrives whole (zero-copy fast path)
+  reader(frameB.subarray(0, 6)); // frame B header + partial payload (buffered path)
+  reader(frameB.subarray(6));
+
+  assert.deepEqual(messages, [{ a: 1 }, { bb: "1234567890" }]);
+  assert.deepEqual(errors, []);
+});
+
+test("createMessageReader rejects an oversized declared frame", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const oversizedFrame = framePayload(Buffer.from(JSON.stringify({ text: "too large" }), "utf-8"));
+
+  reader(oversizedFrame);
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.match(errors[0].message, /Intercom frame length \d+ exceeds maximum 8 bytes/);
+});
+
+test("createMessageReader rejects an oversized frame before retaining same-chunk payload bytes", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(9, 0);
+
+  reader(Buffer.concat([header, Buffer.alloc(1024 * 1024)]));
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
+});
+
+test("createMessageReader rejects a partial oversized frame before buffering the payload", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(9, 0);
+
+  reader(header);
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
+});
+
+test("writeMessage emits frames accepted by createMessageReader", () => {
+  const chunks: Buffer[] = [];
+  const socket = { write: (chunk: Buffer) => chunks.push(chunk) };
+  const messages: unknown[] = [];
+  const reader = createMessageReader((message) => messages.push(message), assert.fail, 64);
+
+  writeMessage(socket as never, { ok: true });
+  reader(Buffer.concat(chunks));
+
+  assert.deepEqual(messages, [{ ok: true }]);
+});

package/dist/extensions/pi-intercom/broker/paths.ts

@@ -1,134 +1,134 @@
-import { chmodSync, mkdirSync, readFileSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
-import { getAgentDir } from "@selesai/code";
-
-export const INTERCOM_DIR_MODE = 0o700;
-export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
-export const INTERCOM_TCP_HOST = "127.0.0.1";
-export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
-export const INTERCOM_PROTOCOL_VERSION = 1;
-
-export interface BrokerTcpEndpoint {
-  transport: "tcp";
-  host: string;
-  port: number;
-  stateId?: string;
-}
-
-export type BrokerConnectTarget = string | BrokerTcpEndpoint;
-
-function sanitizePipeSegment(value: string): string {
-  return value
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .toLowerCase() || "default";
-}
-
-export function getAgentDirPath(
-  env: NodeJS.ProcessEnv = process.env,
-  cwd: string = process.cwd(),
-): string {
-  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
-  if (!configured) {
-    return getAgentDir();
-  }
-
-  return isAbsolute(configured) ? configured : resolve(cwd, configured);
-}
-
-export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
-  return join(agentDir, "intercom");
-}
-
-export function shouldUseWindowsTcpTransport(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  if (platform !== "win32") {
-    return false;
-  }
-
-  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
-  if (transport === "tcp") {
-    return true;
-  }
-
-  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
-  return legacyOptIn === "1" || legacyOptIn === "true";
-}
-
-export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
-  return join(intercomDir, "broker.port.json");
-}
-
-export function getBrokerSocketPath(
-  platform: NodeJS.Platform = process.platform,
-  agentDir: string = getAgentDirPath(),
-): string {
-  if (platform === "win32") {
-    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
-  }
-
-  return join(getIntercomDirPath(agentDir), "broker.sock");
-}
-
-export function getBrokerConnectTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    const endpointFile = getBrokerPortFilePath(intercomDir);
-    const raw = readFileSync(endpointFile, "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
-    }
-    const endpoint = parsed as Record<string, unknown>;
-    if (
-      endpoint.transport !== "tcp"
-      || endpoint.host !== INTERCOM_TCP_HOST
-      || typeof endpoint.port !== "number"
-      || !Number.isSafeInteger(endpoint.port)
-      || endpoint.port <= 0
-      || endpoint.port > 65535
-      || typeof endpoint.stateId !== "string"
-      || endpoint.stateId.length === 0
-    ) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
-    }
-    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function getBrokerListenTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function ensureIntercomRuntimeDir(
-  intercomDir: string = getIntercomDirPath(),
-  platform: NodeJS.Platform = process.platform,
-): void {
-  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
-  if (platform !== "win32") {
-    chmodSync(intercomDir, INTERCOM_DIR_MODE);
-  }
-}
-
-export function restrictIntercomRuntimeFile(
-  filePath: string,
-  platform: NodeJS.Platform = process.platform,
-): void {
-  if (platform !== "win32") {
-    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
-  }
-}
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { getAgentDir } from "@selesai/code";
+
+export const INTERCOM_DIR_MODE = 0o700;
+export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
+export const INTERCOM_TCP_HOST = "127.0.0.1";
+export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
+export const INTERCOM_PROTOCOL_VERSION = 1;
+
+export interface BrokerTcpEndpoint {
+  transport: "tcp";
+  host: string;
+  port: number;
+  stateId?: string;
+}
+
+export type BrokerConnectTarget = string | BrokerTcpEndpoint;
+
+function sanitizePipeSegment(value: string): string {
+  return value
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "default";
+}
+
+export function getAgentDirPath(
+  env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd(),
+): string {
+  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return getAgentDir();
+  }
+
+  return isAbsolute(configured) ? configured : resolve(cwd, configured);
+}
+
+export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
+  return join(agentDir, "intercom");
+}
+
+export function shouldUseWindowsTcpTransport(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (platform !== "win32") {
+    return false;
+  }
+
+  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
+  if (transport === "tcp") {
+    return true;
+  }
+
+  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
+  return legacyOptIn === "1" || legacyOptIn === "true";
+}
+
+export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
+  return join(intercomDir, "broker.port.json");
+}
+
+export function getBrokerSocketPath(
+  platform: NodeJS.Platform = process.platform,
+  agentDir: string = getAgentDirPath(),
+): string {
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
+  }
+
+  return join(getIntercomDirPath(agentDir), "broker.sock");
+}
+
+export function getBrokerConnectTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    const endpointFile = getBrokerPortFilePath(intercomDir);
+    const raw = readFileSync(endpointFile, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
+    }
+    const endpoint = parsed as Record<string, unknown>;
+    if (
+      endpoint.transport !== "tcp"
+      || endpoint.host !== INTERCOM_TCP_HOST
+      || typeof endpoint.port !== "number"
+      || !Number.isSafeInteger(endpoint.port)
+      || endpoint.port <= 0
+      || endpoint.port > 65535
+      || typeof endpoint.stateId !== "string"
+      || endpoint.stateId.length === 0
+    ) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
+    }
+    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function getBrokerListenTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function ensureIntercomRuntimeDir(
+  intercomDir: string = getIntercomDirPath(),
+  platform: NodeJS.Platform = process.platform,
+): void {
+  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (platform !== "win32") {
+    chmodSync(intercomDir, INTERCOM_DIR_MODE);
+  }
+}
+
+export function restrictIntercomRuntimeFile(
+  filePath: string,
+  platform: NodeJS.Platform = process.platform,
+): void {
+  if (platform !== "win32") {
+    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
+  }
+}

package/dist/extensions/pi-intercom/broker/runtime-claim.test.ts

@@ -1,34 +1,34 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { assertNoLiveBroker } from "./runtime-claim.ts";
-
-test("broker startup refuses to replace a live broker PID", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    writeFileSync(pidPath, `${process.pid}\n`);
-    assert.throws(
-      () => assertNoLiveBroker(pidPath),
-      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
-    );
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test("broker startup tolerates absent, invalid, and stale PID files", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "invalid\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "2147483647\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { assertNoLiveBroker } from "./runtime-claim.ts";
+
+test("broker startup refuses to replace a live broker PID", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    writeFileSync(pidPath, `${process.pid}\n`);
+    assert.throws(
+      () => assertNoLiveBroker(pidPath),
+      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("broker startup tolerates absent, invalid, and stale PID files", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "invalid\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "2147483647\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/dist/extensions/pi-intercom/broker/runtime-claim.ts

@@ -1,21 +1,21 @@
-import { existsSync, readFileSync } from "node:fs";
-
-export function assertNoLiveBroker(pidPath: string): void {
-  if (!existsSync(pidPath)) return;
-
-  let pid: number;
-  try {
-    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
-  } catch {
-    return;
-  }
-  if (!Number.isSafeInteger(pid) || pid <= 0) return;
-
-  try {
-    process.kill(pid, 0);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
-    throw error;
-  }
-  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
-}
+import { existsSync, readFileSync } from "node:fs";
+
+export function assertNoLiveBroker(pidPath: string): void {
+  if (!existsSync(pidPath)) return;
+
+  let pid: number;
+  try {
+    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+  } catch {
+    return;
+  }
+  if (!Number.isSafeInteger(pid) || pid <= 0) return;
+
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
+    throw error;
+  }
+  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
+}

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 {