@ctliz/agent-intercom-claude 0.12.0-connect.3

package/dist/worker-daemon.mjs

@@ -0,0 +1,2797 @@
+#!/usr/bin/env node
+
+// claude/worker-daemon.ts
+import { once } from "node:events";
+import { realpathSync as realpathSync2 } from "node:fs";
+import { basename } from "node:path";
+
+// claude/cli-runner.ts
+import { spawn } from "node:child_process";
+
+// claude/permission-policy.ts
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  realpathSync
+} from "node:fs";
+import { dirname, isAbsolute, join, parse, relative, sep } from "node:path";
+var CLAUDE_PERMISSION_MODES = [
+  "acceptEdits",
+  "auto",
+  "bypassPermissions",
+  "manual",
+  "dontAsk",
+  "plan"
+];
+function validateClaudePermissionMode(value, field = "permissionMode") {
+  if (typeof value !== "string" || !CLAUDE_PERMISSION_MODES.includes(value)) {
+    throw new Error(`${field} must be one of: ${CLAUDE_PERMISSION_MODES.join(", ")}`);
+  }
+  return value;
+}
+function resolveClaudePermissionPolicy(input) {
+  const ceiling = input.ceiling ?? "standard";
+  if (ceiling !== "standard" && ceiling !== "read-only") {
+    throw new Error("permission ceiling must be standard or read-only");
+  }
+  if (input.dangerouslySkipPermissions !== void 0 && typeof input.dangerouslySkipPermissions !== "boolean") {
+    throw new Error("dangerouslySkipPermissions must be a boolean");
+  }
+  const dangerouslySkipPermissions = input.dangerouslySkipPermissions === true;
+  const requestedMode = input.permissionMode === void 0 ? void 0 : validateClaudePermissionMode(input.permissionMode);
+  if (ceiling === "read-only") {
+    if (dangerouslySkipPermissions) {
+      throw new Error("read-only Claude roles cannot skip permission checks");
+    }
+    if (requestedMode !== void 0 && requestedMode !== "plan") {
+      throw new Error("read-only Claude roles require permission mode plan");
+    }
+    return { permissionMode: "plan", dangerouslySkipPermissions: false, ceiling };
+  }
+  if (dangerouslySkipPermissions) {
+    return { dangerouslySkipPermissions: true, ceiling };
+  }
+  return {
+    permissionMode: requestedMode ?? "manual",
+    dangerouslySkipPermissions: false,
+    ceiling
+  };
+}
+var PERMISSION_OVERRIDE_OPTIONS = /* @__PURE__ */ new Set([
+  "--allow-dangerously-skip-permissions",
+  "--dangerously-skip-permissions",
+  "--permission-mode"
+]);
+var CLAUDE_2_1_220_HARDENED_CAPABILITY_OPTIONS = [
+  "--add-dir",
+  "--agent",
+  "--agents",
+  "--allowed-tools",
+  "--allowedTools",
+  "--mcp-config",
+  "--plugin-dir",
+  "--plugin-dir-no-mcp",
+  "--plugin-url",
+  "--setting-sources",
+  "--settings",
+  "--tools",
+  "--worktree",
+  "-w"
+];
+var HARDENED_PERMISSION_CAPABILITY_OPTIONS = new Set(
+  CLAUDE_2_1_220_HARDENED_CAPABILITY_OPTIONS
+);
+function permissionCapabilityOption(arg) {
+  const equalsIndex = arg.indexOf("=");
+  const option = equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
+  if (HARDENED_PERMISSION_CAPABILITY_OPTIONS.has(option)) return option;
+  if (arg.length > 1 && arg.startsWith("-") && !arg.startsWith("--")) return arg;
+  return void 0;
+}
+function isContainedPath(root, candidate) {
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !isAbsolute(pathFromRoot) && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`);
+}
+function sameFile(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function pathError(field, detail, cause) {
+  return cause === void 0 ? new Error(`${field} ${detail}`) : new Error(`${field} ${detail}`, { cause });
+}
+function inspectExistingRealDirectory(input, base, field) {
+  if (input.length === 0) {
+    throw pathError(field, "must name an existing real directory");
+  }
+  const rawAbsolute = isAbsolute(input) ? input : `${base.endsWith(sep) ? base : `${base}${sep}`}${input}`;
+  const root = parse(rawAbsolute).root;
+  let cursor = root;
+  const inspect = (path) => {
+    let descriptor2;
+    try {
+      descriptor2 = lstatSync(path, { bigint: true });
+    } catch (cause) {
+      throw pathError(field, "must name an existing real directory", cause);
+    }
+    if (descriptor2.isSymbolicLink()) {
+      throw pathError(field, "must not contain a symbolic-link component");
+    }
+    if (!descriptor2.isDirectory()) {
+      throw pathError(field, "must contain only existing directories");
+    }
+    return descriptor2;
+  };
+  let descriptor = inspect(cursor);
+  for (const component of rawAbsolute.slice(root.length).split(sep)) {
+    if (component === "" || component === ".") continue;
+    cursor = component === ".." ? dirname(cursor) : join(cursor, component);
+    descriptor = inspect(cursor);
+  }
+  let canonicalPath;
+  try {
+    canonicalPath = realpathSync(cursor);
+  } catch (cause) {
+    throw pathError(field, "cannot be bound to a canonical real directory", cause);
+  }
+  return { canonicalPath, descriptor };
+}
+function openBoundDirectory(input, base, field) {
+  if (typeof constants.O_DIRECTORY !== "number" || typeof constants.O_NOFOLLOW !== "number") {
+    throw pathError(field, "cannot be securely bound on this platform");
+  }
+  const first = inspectExistingRealDirectory(input, base, field);
+  let fd;
+  try {
+    fd = openSync(first.canonicalPath, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  } catch (cause) {
+    throw pathError(field, "cannot be bound to an open real directory", cause);
+  }
+  try {
+    const opened = fstatSync(fd, { bigint: true });
+    if (!opened.isDirectory() || !sameFile(opened, first.descriptor)) {
+      throw pathError(field, "changed while its real directory was being bound");
+    }
+    const second = inspectExistingRealDirectory(input, base, field);
+    if (second.canonicalPath !== first.canonicalPath || !sameFile(opened, second.descriptor)) {
+      throw pathError(field, "changed while its real directory was being bound");
+    }
+    return { path: first.canonicalPath, fd };
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+function bindHardenedClaudePaths(cwd, addDirs, field = "hardened Claude paths") {
+  const descriptors = [];
+  try {
+    const cwdBinding = openBoundDirectory(cwd, process.cwd(), `${field}.cwd`);
+    descriptors.push(cwdBinding.fd);
+    const canonicalAddDirs = addDirs.map((addDir, index) => {
+      const binding = openBoundDirectory(addDir, cwdBinding.path, `${field}.addDirs[${index}]`);
+      descriptors.push(binding.fd);
+      if (!isContainedPath(cwdBinding.path, binding.path)) {
+        throw pathError(`${field}.addDirs[${index}]`, "must stay within the assigned workspace root");
+      }
+      return binding.path;
+    });
+    let released = false;
+    return {
+      cwd: cwdBinding.path,
+      addDirs: canonicalAddDirs,
+      release() {
+        if (released) return;
+        released = true;
+        for (const fd of descriptors.splice(0)) closeSync(fd);
+      }
+    };
+  } catch (error) {
+    for (const fd of descriptors) closeSync(fd);
+    throw error;
+  }
+}
+function assertNoPermissionOverrides(args, field = "claudeArgs", ceiling = "standard") {
+  if (ceiling !== "read-only") return;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const option = arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg;
+    if (PERMISSION_OVERRIDE_OPTIONS.has(option)) {
+      throw new Error(`${field}[${index}] cannot override the validated Claude permission policy`);
+    }
+    if (ceiling === "read-only" && permissionCapabilityOption(arg) !== void 0) {
+      throw new Error(`${field}[${index}] cannot add a permission capability to a hardened Claude role`);
+    }
+  }
+}
+
+// claude/cli-runner.ts
+function prepareClaudeLaunch(options) {
+  const args = ["-p", "--output-format", "json"];
+  const permission = resolveClaudePermissionPolicy({
+    permissionMode: options.permissionMode,
+    dangerouslySkipPermissions: options.dangerouslySkipPermissions,
+    ceiling: options.permissionCeiling
+  });
+  assertNoPermissionOverrides(options.extraArgs ?? [], "extraArgs", permission.ceiling);
+  let cwd = options.cwd;
+  let addDirs = options.addDirs ?? [];
+  let release = () => {
+  };
+  if (permission.ceiling === "read-only") {
+    if (options.mcpConfig !== void 0) {
+      throw new Error("mcpConfig cannot add an arbitrary MCP capability to a hardened Claude role");
+    }
+    const binding = bindHardenedClaudePaths(options.cwd, addDirs);
+    cwd = binding.cwd;
+    addDirs = binding.addDirs;
+    release = binding.release;
+    args.push("--bare");
+  }
+  if (options.sessionId) {
+    args.push("--resume", options.sessionId);
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.appendSystemPrompt) {
+    args.push("--append-system-prompt", options.appendSystemPrompt);
+  }
+  if (permission.dangerouslySkipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  } else if (permission.permissionMode && (permission.ceiling === "read-only" || options.permissionMode !== void 0)) {
+    args.push("--permission-mode", permission.permissionMode);
+  }
+  for (const dir of addDirs) {
+    args.push("--add-dir", dir);
+  }
+  if (options.mcpConfig) {
+    args.push("--mcp-config", options.mcpConfig);
+  }
+  if (options.extraArgs?.length) {
+    args.push(...options.extraArgs);
+  }
+  return { args, cwd, release };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function runClaudeTurn(options) {
+  return new Promise((resolve4, reject) => {
+    const command = options.claudeCommand ?? "claude";
+    const launch = prepareClaudeLaunch(options);
+    let child;
+    try {
+      child = spawn(command, launch.args, {
+        cwd: launch.cwd,
+        env: { ...process.env, ...options.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } finally {
+      launch.release();
+    }
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timeoutHandle;
+    const cleanup = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      options.signal?.removeEventListener("abort", onAbort);
+    };
+    const finishReject = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const finishResolve = (result) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve4(result);
+    };
+    const onAbort = () => {
+      child.kill("SIGTERM");
+      finishReject(new Error("Claude turn aborted"));
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        child.kill("SIGTERM");
+        finishReject(new Error("Claude turn aborted"));
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    if (options.timeoutMs) {
+      timeoutHandle = setTimeout(() => {
+        child.kill("SIGTERM");
+        finishReject(new Error(`Claude turn timed out after ${options.timeoutMs}ms`));
+      }, options.timeoutMs);
+    }
+    child.on("error", (error) => {
+      finishReject(new Error(`Failed to spawn "${command}": ${error.message}`, { cause: error }));
+    });
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("close", (exitCode) => {
+      if (settled) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout.trim());
+      } catch {
+        const fallback = stdout.trim() || stderr.trim();
+        finishResolve({
+          sessionId: options.sessionId ?? null,
+          result: fallback,
+          isError: exitCode !== 0,
+          raw: stdout
+        });
+        return;
+      }
+      if (isRecord(parsed) && typeof parsed.result === "string") {
+        finishResolve({
+          sessionId: typeof parsed.session_id === "string" ? parsed.session_id : null,
+          result: parsed.result,
+          isError: Boolean(parsed.is_error),
+          raw: parsed
+        });
+        return;
+      }
+      finishResolve({
+        sessionId: options.sessionId ?? null,
+        result: stdout.trim(),
+        isError: exitCode !== 0,
+        raw: parsed
+      });
+    });
+    child.stdin?.write(options.prompt);
+    child.stdin?.end();
+  });
+}
+
+// claude/worker-config.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { cwd as processCwd } from "node:process";
+
+// broker/paths.ts
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute as isAbsolute2, join as join2, resolve } from "path";
+import { homedir } from "os";
+var INTERCOM_DIR_MODE = 448;
+var INTERCOM_RUNTIME_FILE_MODE = 384;
+var INTERCOM_TCP_HOST = "127.0.0.1";
+var INTERCOM_PROTOCOL_NAME = "pi-intercom";
+var INTERCOM_PROTOCOL_VERSION = 4;
+function sanitizePipeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "default";
+}
+function getAgentDirPath(env = process.env, homeDir = homedir(), cwd = process.cwd()) {
+  const configured = env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return join2(homeDir, ".pi/agent");
+  }
+  return isAbsolute2(configured) ? configured : resolve(cwd, configured);
+}
+function getIntercomDirPath(agentDir = getAgentDirPath()) {
+  return join2(agentDir, "intercom");
+}
+function shouldUseWindowsTcpTransport(platform = process.platform, env = process.env) {
+  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";
+}
+function getBrokerPortFilePath(intercomDir = getIntercomDirPath()) {
+  return join2(intercomDir, "broker.port.json");
+}
+function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDirPath()) {
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
+  }
+  return join2(getIntercomDirPath(agentDir), "broker.sock");
+}
+function getBrokerConnectTarget(platform = process.platform, env = process.env, intercomDir = getIntercomDirPath(getAgentDirPath(env))) {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    const endpointFile = getBrokerPortFilePath(intercomDir);
+    const raw = readFileSync(endpointFile, "utf-8");
+    const parsed = 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;
+    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));
+}
+function ensureIntercomRuntimeDir(intercomDir = getIntercomDirPath(), platform = process.platform) {
+  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (platform !== "win32") {
+    chmodSync(intercomDir, INTERCOM_DIR_MODE);
+  }
+}
+function restrictIntercomRuntimeFile(filePath, platform = process.platform) {
+  if (platform !== "win32") {
+    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
+  }
+}
+
+// broker/validation.ts
+import { types as nodeUtilTypes } from "node:util";
+function isPlainDataRecord(value) {
+  if (typeof value !== "object" || value === null || nodeUtilTypes.isProxy(value) || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) {
+    return false;
+  }
+  try {
+    return Reflect.ownKeys(value).every((key) => {
+      if (typeof key !== "string") return false;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      return descriptor !== void 0 && descriptor.enumerable && Object.hasOwn(descriptor, "value");
+    });
+  } catch {
+    return false;
+  }
+}
+function hasExactDataKeys(value, required, optional = []) {
+  if (!isPlainDataRecord(value)) return false;
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  const keys = Reflect.ownKeys(value);
+  return keys.length >= required.length && keys.every((key) => typeof key === "string" && allowed.has(key)) && required.every((key) => Object.hasOwn(value, key));
+}
+function assertPlainDataGraph(value, path = "$", seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) return;
+  if (nodeUtilTypes.isProxy(value)) {
+    throw new Error(`${path} must not contain a Proxy`);
+  }
+  if (seen.has(value)) {
+    throw new Error(`${path} must not contain a cycle or repeated object reference`);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    if (Object.getPrototypeOf(value) !== Array.prototype) {
+      throw new Error(`${path} must use the exact Array prototype`);
+    }
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    if (lengthDescriptor === void 0 || !Object.hasOwn(lengthDescriptor, "value")) {
+      throw new Error(`${path}.length must be an own data property`);
+    }
+    const length = lengthDescriptor.value;
+    const descriptors = /* @__PURE__ */ new Map();
+    for (const key of Reflect.ownKeys(value)) {
+      if (key === "length") continue;
+      if (typeof key !== "string") throw new Error(`${path} must not contain symbol properties`);
+      const index = Number(key);
+      if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== key) {
+        throw new Error(`${path} must not contain non-index properties`);
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) {
+        throw new Error(`${path}[${index}] must be an enumerable own data property`);
+      }
+      descriptors.set(index, descriptor);
+    }
+    if (descriptors.size !== length) throw new Error(`${path} must be dense`);
+    for (let index = 0; index < length; index += 1) {
+      const descriptor = descriptors.get(index);
+      if (descriptor === void 0) throw new Error(`${path} must be dense`);
+      assertPlainDataGraph(descriptor.value, `${path}[${index}]`, seen);
+    }
+    return;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new Error(`${path} must be a plain data object`);
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") throw new Error(`${path} must not contain symbol properties`);
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === void 0 || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) {
+      throw new Error(`${path}.${key} must be an enumerable own data property`);
+    }
+    assertPlainDataGraph(descriptor.value, `${path}.${key}`, seen);
+  }
+}
+function isDenseArrayOf(value, predicate) {
+  if (typeof value !== "object" || value === null || nodeUtilTypes.isProxy(value) || !Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return false;
+  try {
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+    if (lengthDescriptor === void 0 || !Object.hasOwn(lengthDescriptor, "value")) return false;
+    const length = lengthDescriptor.value;
+    const entries = /* @__PURE__ */ new Map();
+    for (const key of Reflect.ownKeys(value)) {
+      if (key === "length") continue;
+      if (typeof key !== "string") return false;
+      const index = Number(key);
+      if (!Number.isInteger(index) || index < 0 || index >= length || String(index) !== key) return false;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !descriptor.enumerable || !Object.hasOwn(descriptor, "value")) return false;
+      entries.set(index, descriptor.value);
+    }
+    if (entries.size !== length) return false;
+    for (let index = 0; index < length; index += 1) {
+      if (!predicate(entries.get(index), index)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// claude/transport.ts
+import { spawnSync } from "node:child_process";
+var CLAUDE_INTERCOM_TRANSPORT_ENV = "CLAUDE_INTERCOM_TRANSPORT";
+var MIN_NATIVE_CLAUDE_VERSION = "2.1.220";
+var MAX_NATIVE_CLAUDE_VERSION = "2.1.226";
+function parseClaudeIntercomTransport(value, source = "transport") {
+  if (value === void 0 || value === null || value === "") return "auto";
+  if (value === "auto" || value === "native" || value === "mcp") return value;
+  throw new Error(`${source} must be one of auto, native, or mcp`);
+}
+function parseClaudeVersion(output) {
+  const match = output.match(/(?:^|\s)(\d+\.\d+\.\d+)(?:\s|$)/);
+  return match?.[1] ?? null;
+}
+function compareVersions(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+function isNativeClaudeVersionCompatible(version) {
+  return compareVersions(version, MIN_NATIVE_CLAUDE_VERSION) >= 0 && compareVersions(version, MAX_NATIVE_CLAUDE_VERSION) <= 0;
+}
+function probeClaudeVersion(command = "claude") {
+  const result = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status !== 0) {
+    return {
+      command,
+      version: null,
+      compatible: false,
+      reason: `could not run ${command} --version`
+    };
+  }
+  const version = parseClaudeVersion(`${result.stdout}
+${result.stderr}`);
+  if (!version) {
+    return { command, version: null, compatible: false, reason: "Claude version output was not recognized" };
+  }
+  const compatible = isNativeClaudeVersionCompatible(version);
+  return {
+    command,
+    version,
+    compatible,
+    reason: compatible ? `Claude ${version} is within the native transport compatibility window ${MIN_NATIVE_CLAUDE_VERSION}-${MAX_NATIVE_CLAUDE_VERSION}` : `Claude ${version} is outside the verified native transport compatibility window ${MIN_NATIVE_CLAUDE_VERSION}-${MAX_NATIVE_CLAUDE_VERSION}`
+  };
+}
+function resolveClaudeIntercomTransport(options = {}) {
+  const requested = parseClaudeIntercomTransport(
+    options.requested ?? options.env?.[CLAUDE_INTERCOM_TRANSPORT_ENV] ?? "auto",
+    options.requested === void 0 ? CLAUDE_INTERCOM_TRANSPORT_ENV : "transport"
+  );
+  const command = options.claudeCommand || "claude";
+  const versionProbe = (options.probe ?? probeClaudeVersion)(command);
+  if (requested === "mcp") return { requested, selected: "mcp", ...versionProbe };
+  if (requested === "native" && !versionProbe.compatible) {
+    throw new Error(`Native Claude intercom transport was requested, but ${versionProbe.reason}. Use --transport mcp or install a verified-compatible Claude version.`);
+  }
+  return {
+    requested,
+    selected: requested === "native" || versionProbe.compatible ? "native" : "mcp",
+    ...versionProbe
+  };
+}
+
+// claude/worker-config.ts
+var DEFAULT_WORKER_CONFIG_PATH = join3(getIntercomDirPath(), "claude-worker.json");
+var DEFAULT_WORKER_STATE_PATH = join3(getIntercomDirPath(), "claude-worker-state.json");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`${field} must be a string`);
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function requireString(value, field) {
+  const result = optionalString(value, field);
+  if (!result) throw new Error(`${field} must be a non-empty string`);
+  return result;
+}
+function optionalBoolean(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "boolean") throw new Error(`${field} must be a boolean`);
+  return value;
+}
+function optionalStringArray(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (!isDenseArrayOf(value, (_entry) => true)) {
+    throw new Error(`${field} must be an exact dense array`);
+  }
+  return value.map((item, index) => requireString(item, `${field}[${index}]`));
+}
+function normalizeAgent(raw, index) {
+  if (!isRecord2(raw)) throw new Error(`agents[${index}] must be an object`);
+  const id = requireString(raw.id, `agents[${index}].id`);
+  const name = optionalString(raw.name, `agents[${index}].name`) ?? id;
+  const cwdValue = optionalString(raw.cwd, `agents[${index}].cwd`) ?? processCwd();
+  let cwd = resolve2(cwdValue);
+  const permissionModeValue = optionalString(raw.permissionMode, `agents[${index}].permissionMode`);
+  const dangerouslySkipPermissionsValue = optionalBoolean(
+    raw.dangerouslySkipPermissions,
+    `agents[${index}].dangerouslySkipPermissions`
+  );
+  const permissionCeilingValue = optionalString(raw.permissionCeiling, `agents[${index}].permissionCeiling`);
+  if (permissionCeilingValue !== void 0 && permissionCeilingValue !== "standard" && permissionCeilingValue !== "read-only") {
+    throw new Error(`agents[${index}].permissionCeiling must be standard or read-only`);
+  }
+  const bossRoleValue = optionalString(raw.bossRole, `agents[${index}].bossRole`);
+  if (bossRoleValue !== void 0 && bossRoleValue !== "adversary" && bossRoleValue !== "council") {
+    throw new Error(`agents[${index}].bossRole must be adversary or council`);
+  }
+  if (bossRoleValue !== void 0 && permissionCeilingValue === "standard") {
+    throw new Error(`agents[${index}].permissionCeiling cannot widen an Adversary/Council role`);
+  }
+  const permission = resolveClaudePermissionPolicy({
+    permissionMode: permissionModeValue,
+    dangerouslySkipPermissions: dangerouslySkipPermissionsValue,
+    ceiling: bossRoleValue === void 0 ? permissionCeilingValue : "read-only"
+  });
+  const claudeArgs = optionalStringArray(raw.claudeArgs, `agents[${index}].claudeArgs`);
+  let addDirs = optionalStringArray(raw.addDirs, `agents[${index}].addDirs`);
+  const mcpConfig = optionalString(raw.mcpConfig, `agents[${index}].mcpConfig`);
+  assertNoPermissionOverrides(claudeArgs ?? [], `agents[${index}].claudeArgs`, permission.ceiling);
+  if (permission.ceiling === "read-only") {
+    if (mcpConfig !== void 0) {
+      throw new Error(`agents[${index}].mcpConfig cannot add an arbitrary MCP capability to a hardened Claude role`);
+    }
+    const binding = bindHardenedClaudePaths(cwdValue, addDirs ?? [], `agents[${index}]`);
+    try {
+      cwd = binding.cwd;
+      addDirs = binding.addDirs.length ? binding.addDirs : void 0;
+    } finally {
+      binding.release();
+    }
+  }
+  return {
+    id,
+    name,
+    cwd,
+    model: optionalString(raw.model, `agents[${index}].model`),
+    sessionId: optionalString(raw.sessionId, `agents[${index}].sessionId`),
+    instructions: optionalString(raw.instructions, `agents[${index}].instructions`),
+    ...permission.ceiling === "standard" && permissionModeValue === void 0 ? {} : { permissionMode: permission.permissionMode },
+    ...dangerouslySkipPermissionsValue === void 0 && permission.ceiling !== "read-only" ? {} : { dangerouslySkipPermissions: permission.dangerouslySkipPermissions },
+    ...permissionCeilingValue === void 0 && bossRoleValue === void 0 ? {} : { permissionCeiling: permission.ceiling },
+    ...bossRoleValue === void 0 ? {} : { bossRole: bossRoleValue },
+    addDirs,
+    mcpConfig,
+    claudeArgs,
+    transport: raw.transport === void 0 ? void 0 : parseClaudeIntercomTransport(raw.transport, `agents[${index}].transport`)
+  };
+}
+function defaultWorkerConfig(env = process.env) {
+  const id = env.CLAUDE_INTERCOM_WORKER_ID?.trim() || "claude-worker";
+  return {
+    statePath: env.CLAUDE_INTERCOM_WORKER_STATE?.trim() || DEFAULT_WORKER_STATE_PATH,
+    agents: [{
+      id,
+      name: env.CLAUDE_INTERCOM_WORKER_NAME?.trim() || id,
+      cwd: resolve2(env.CLAUDE_INTERCOM_WORKER_CWD?.trim() || processCwd()),
+      model: env.CLAUDE_INTERCOM_WORKER_MODEL?.trim() || void 0,
+      instructions: env.CLAUDE_INTERCOM_WORKER_INSTRUCTIONS?.trim() || void 0,
+      transport: parseClaudeIntercomTransport(env.CLAUDE_INTERCOM_TRANSPORT, "CLAUDE_INTERCOM_TRANSPORT")
+    }]
+  };
+}
+function loadWorkerConfig(path = process.env.CLAUDE_INTERCOM_WORKER_CONFIG || DEFAULT_WORKER_CONFIG_PATH) {
+  if (!existsSync(path)) return defaultWorkerConfig();
+  const parsed = JSON.parse(readFileSync2(path, "utf8"));
+  if (!isRecord2(parsed)) throw new Error("Worker config must be a JSON object");
+  if (!isDenseArrayOf(parsed.agents, (_entry) => true)) {
+    throw new Error("Worker config requires an exact dense agents array");
+  }
+  return {
+    statePath: resolve2(optionalString(parsed.statePath, "statePath") ?? DEFAULT_WORKER_STATE_PATH),
+    claudeCommand: optionalString(parsed.claudeCommand, "claudeCommand"),
+    agents: parsed.agents.map(normalizeAgent)
+  };
+}
+function loadWorkerState(path) {
+  if (!existsSync(path)) return { agents: {} };
+  const parsed = JSON.parse(readFileSync2(path, "utf8"));
+  if (!isRecord2(parsed) || !isRecord2(parsed.agents)) return { agents: {} };
+  const agents = {};
+  for (const [id, value] of Object.entries(parsed.agents)) {
+    if (!isRecord2(value) || typeof value.sessionId !== "string") continue;
+    agents[id] = {
+      sessionId: value.sessionId,
+      updatedAt: typeof value.updatedAt === "number" ? value.updatedAt : 0
+    };
+  }
+  return { agents };
+}
+function saveWorkerState(path, state) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  restrictIntercomRuntimeFile(path);
+}
+
+// broker/client.ts
+import { EventEmitter } from "events";
+import net from "net";
+import { randomUUID as randomUUID2 } from "crypto";
+import { POLICY_SEMANTICS_HASH, POLICY_SEMANTICS_VERSION } from "@ctliz/agent-intercom-core";
+
+// broker/framing.ts
+var MAX_FRAME_BYTES = 1024 * 1024;
+function writeMessage(socket, msg) {
+  const json = JSON.stringify(msg);
+  const payload = Buffer.from(json, "utf-8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0);
+  socket.write(Buffer.concat([header, payload]));
+}
+function createMessageReader(onMessage, onError, maxFrameBytes = MAX_FRAME_BYTES) {
+  let buffer = Buffer.alloc(0);
+  function reportMessage(payload) {
+    let msg;
+    try {
+      msg = JSON.parse(payload.toString("utf-8"));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      onError(new Error(`Failed to parse intercom message: ${message}`, { cause: error }));
+      return false;
+    }
+    try {
+      onMessage(msg);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      onError(new Error(`Failed to handle intercom message: ${message}`, { cause: error }));
+      return false;
+    }
+  }
+  return (data) => {
+    let remaining = data;
+    while (remaining.length > 0) {
+      if (buffer.length < 4) {
+        const headerBytes = Math.min(4 - buffer.length, remaining.length);
+        buffer = Buffer.concat([buffer, remaining.subarray(0, headerBytes)]);
+        remaining = remaining.subarray(headerBytes);
+        if (buffer.length < 4) {
+          return;
+        }
+      }
+      const length = buffer.readUInt32BE(0);
+      if (length > maxFrameBytes) {
+        buffer = Buffer.alloc(0);
+        onError(new Error(`Intercom frame length ${length} exceeds maximum ${maxFrameBytes} bytes`));
+        return;
+      }
+      const missingPayloadBytes = length - Math.max(0, buffer.length - 4);
+      const payloadBytes = Math.min(missingPayloadBytes, remaining.length);
+      if (payloadBytes > 0) {
+        buffer = Buffer.concat([buffer, remaining.subarray(0, payloadBytes)]);
+        remaining = remaining.subarray(payloadBytes);
+      }
+      if (buffer.length < 4 + length) {
+        return;
+      }
+      const payload = buffer.subarray(4, 4 + length);
+      buffer = Buffer.alloc(0);
+      if (!reportMessage(payload)) {
+        return;
+      }
+    }
+  };
+}
+
+// outbound-outbox.ts
+import { createHash } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2 } from "fs";
+import { join as join4 } from "path";
+
+// durable-json.ts
+import { randomUUID } from "crypto";
+import { closeSync as closeSync2, fsyncSync, openSync as openSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3 } from "path";
+function writeDurableJson(filePath, value) {
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync2(temporaryPath, JSON.stringify(value), { encoding: "utf-8", mode: INTERCOM_RUNTIME_FILE_MODE });
+  const fileDescriptor = openSync2(temporaryPath, "r");
+  try {
+    fsyncSync(fileDescriptor);
+  } finally {
+    closeSync2(fileDescriptor);
+  }
+  renameSync(temporaryPath, filePath);
+  restrictIntercomRuntimeFile(filePath);
+  if (process.platform !== "win32") {
+    const directoryDescriptor = openSync2(dirname3(filePath), "r");
+    try {
+      fsyncSync(directoryDescriptor);
+    } finally {
+      closeSync2(directoryDescriptor);
+    }
+  }
+}
+
+// outbound-outbox.ts
+var OUTBOX_STATE_VERSION = 1;
+var MAX_OUTBOX_MESSAGES = 256;
+function fingerprint(entry) {
+  return JSON.stringify({
+    to: entry.to,
+    replyTo: entry.message.replyTo,
+    expectsReply: entry.message.expectsReply,
+    content: entry.message.content
+  });
+}
+function isStoredOutboundMessage(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const entry = value;
+  if (typeof entry.to !== "string" || typeof entry.queuedAt !== "number") return false;
+  if (typeof entry.message !== "object" || entry.message === null || Array.isArray(entry.message)) return false;
+  const message = entry.message;
+  return typeof message.id === "string" && typeof message.timestamp === "number" && typeof message.content === "object" && message.content !== null && typeof message.content.text === "string";
+}
+function fileName(sessionId) {
+  return `${createHash("sha256").update(sessionId).digest("hex")}.json`;
+}
+var PersistentOutboundOutbox = class {
+  directory;
+  filePath;
+  state;
+  constructor(sessionId, intercomDir = getIntercomDirPath()) {
+    ensureIntercomRuntimeDir(intercomDir);
+    this.directory = join4(intercomDir, "outbox");
+    mkdirSync3(this.directory, { recursive: true, mode: INTERCOM_DIR_MODE });
+    if (process.platform !== "win32") chmodSync2(this.directory, INTERCOM_DIR_MODE);
+    this.filePath = join4(this.directory, fileName(sessionId));
+    this.state = this.load();
+  }
+  list() {
+    return this.state.entries.map((entry) => ({ ...entry, message: { ...entry.message, content: { ...entry.message.content } } }));
+  }
+  enqueue(to, message) {
+    const existing = this.state.entries.find((entry) => entry.message.id === message.id);
+    if (existing) {
+      if (fingerprint(existing) !== fingerprint({ to, message })) {
+        throw new Error(`Message ID ${message.id} is already queued with a different payload`);
+      }
+      return "existing";
+    }
+    if (this.state.entries.length >= MAX_OUTBOX_MESSAGES) {
+      throw new Error(`Durable outbox is full (${MAX_OUTBOX_MESSAGES} messages)`);
+    }
+    this.state.entries.push({ to, message, queuedAt: Date.now() });
+    this.persist();
+    return "added";
+  }
+  remove(messageId) {
+    const remaining = this.state.entries.filter((entry) => entry.message.id !== messageId);
+    if (remaining.length === this.state.entries.length) return;
+    this.state.entries = remaining;
+    this.persist();
+  }
+  clear() {
+    if (this.state.entries.length === 0) return;
+    this.state.entries = [];
+    this.persist();
+  }
+  load() {
+    if (!existsSync2(this.filePath)) return { version: OUTBOX_STATE_VERSION, entries: [] };
+    try {
+      const parsed = JSON.parse(readFileSync3(this.filePath, "utf-8"));
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("expected object");
+      const state = parsed;
+      if (state.version !== OUTBOX_STATE_VERSION || !Array.isArray(state.entries) || !state.entries.every(isStoredOutboundMessage)) {
+        throw new Error("invalid outbox state");
+      }
+      return { version: OUTBOX_STATE_VERSION, entries: state.entries };
+    } catch {
+      const corruptPath = `${this.filePath}.corrupt-${Date.now()}`;
+      renameSync2(this.filePath, corruptPath);
+      restrictIntercomRuntimeFile(corruptPath);
+      return { version: OUTBOX_STATE_VERSION, entries: [] };
+    }
+  }
+  persist() {
+    writeDurableJson(this.filePath, this.state);
+  }
+};
+
+// broker/access-credential.ts
+import { readFileSync as readFileSync4 } from "fs";
+var ACCESS_CREDENTIAL_ENV = "AGENT_INTERCOM_ACCESS_CREDENTIAL_PATH";
+var ACCESS_CREDENTIAL_VERSION = 1;
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("\0");
+}
+function loadRemoteAccessCredential(env = process.env) {
+  const path = env[ACCESS_CREDENTIAL_ENV]?.trim();
+  if (!path) return void 0;
+  const parsed = JSON.parse(readFileSync4(path, "utf8"));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid Agent Intercom access credential at ${path}`);
+  }
+  const credential = parsed;
+  if (nonEmptyString(credential.enrollmentToken)) {
+    return { path, access: { enrollmentToken: credential.enrollmentToken }, enrollment: true };
+  }
+  if (credential.version === ACCESS_CREDENTIAL_VERSION && nonEmptyString(credential.sessionCredential) && nonEmptyString(credential.sessionId) && typeof credential.generation === "number" && Number.isSafeInteger(credential.generation) && credential.generation > 0) {
+    return {
+      path,
+      access: {
+        sessionCredential: credential.sessionCredential,
+        sessionId: credential.sessionId,
+        generation: credential.generation
+      },
+      enrollment: false
+    };
+  }
+  throw new Error(`Invalid Agent Intercom access credential at ${path}`);
+}
+function writeRemoteSessionCredential(path, sessionId, metadata) {
+  if (!metadata.sessionCredential) {
+    throw new Error("Remote enrollment response omitted the session credential");
+  }
+  writeDurableJson(path, {
+    version: ACCESS_CREDENTIAL_VERSION,
+    sessionCredential: metadata.sessionCredential,
+    sessionId,
+    generation: metadata.generation
+  });
+}
+
+// protocol-v4/contract.ts
+import {
+  INTERCOM_PROTOCOL_NAME as INTERCOM_PROTOCOL_NAME2,
+  INTERCOM_PROTOCOL_V4_SEMANTICS_HASH,
+  INTERCOM_PROTOCOL_V4_VECTOR_SCHEMA_VERSION,
+  INTERCOM_PROTOCOL_V4_VECTORS,
+  INTERCOM_PROTOCOL_VERSION as INTERCOM_PROTOCOL_VERSION2,
+  INTERCOM_SCOPE_ENV,
+  INTERCOM_SCOPE_ID_PATTERN,
+  INTERCOM_SCOPE_ID_PATTERN_SOURCE,
+  intercomScopeIdFromEnv,
+  parseIntercomScopeId,
+  sameIntercomScope
+} from "@ctliz/agent-intercom-core/protocol-v4";
+var INTERCOM_REGISTRATION_METADATA_ERROR = "Registration metadata is invalid";
+function parseIntercomScopeIdForRegistration(value) {
+  try {
+    return parseIntercomScopeId(value, "registrationMetadata");
+  } catch {
+    throw new Error(INTERCOM_REGISTRATION_METADATA_ERROR);
+  }
+}
+function intercomScopeIdFromEnvForRegistration(env = process.env) {
+  try {
+    return intercomScopeIdFromEnv(env);
+  } catch {
+    throw new Error(INTERCOM_REGISTRATION_METADATA_ERROR);
+  }
+}
+
+// types.ts
+var DELIVERY_FAILURE_CODES = [
+  "INVALID_MESSAGE",
+  "SESSION_NOT_FOUND",
+  "AMBIGUOUS_TARGET",
+  "SENDER_NOT_FOUND",
+  "INVALID_REPLY_TARGET",
+  "MUTUAL_ASK",
+  "ASK_ALREADY_PENDING",
+  "DUPLICATE_MESSAGE_ID",
+  "CONFLICTING_MESSAGE_ID",
+  "TOO_MANY_PENDING_DELIVERIES",
+  "TOO_MANY_PENDING_ASKS",
+  "RECIPIENT_DISCONNECTED",
+  "SENDER_DISCONNECTED",
+  "DELIVERY_TIMEOUT",
+  "CONTROL_DISPATCH_UNAVAILABLE"
+];
+
+// broker/boss-contracts.ts
+import {
+  BOSS_CAPABILITY_FEATURE_DIGEST,
+  BOSS_POLICY_SEMANTICS_HASH,
+  BOSS_RUN_FEATURE,
+  BOSS_RUN_FEATURE_CONTRACT,
+  INTERCOM_BASE_PROTOCOL_VERSION,
+  evaluateBrokerCompatibility,
+  parseBossControlEnvelope,
+  parseBossParticipantBinding,
+  parseBossParticipantCredentialEnvelope,
+  parseBossPolicyPrincipal,
+  parseBossRunFeatureContract,
+  parseBrokerCapabilityAdvertisement,
+  isTerminalParticipantState,
+  parseParticipantState,
+  parseWorkerIdentityV2
+} from "@ctliz/agent-intercom-core/boss";
+import {
+  ContractValidationError,
+  assertExactKeys,
+  assertRecord,
+  readHexDigest
+} from "@ctliz/agent-intercom-core/canonical";
+function assertCompatibleOrdinaryAdvertisement(value) {
+  assertPlainDataGraph(value, "$.capabilities");
+  const advertisement = parseBrokerCapabilityAdvertisement(value);
+  const decision = evaluateBrokerCompatibility({
+    clientKind: "ordinary",
+    supportedBaseProtocolVersions: [INTERCOM_BASE_PROTOCOL_VERSION]
+  }, advertisement);
+  if (!decision.compatible || decision.mode !== "ordinary") {
+    throw new ContractValidationError("$.capabilities", "broker does not support exact base protocol v3");
+  }
+  return advertisement;
+}
+function assertCompatibleBossAdvertisement(value) {
+  assertPlainDataGraph(value, "$.capabilities");
+  const advertisement = parseBrokerCapabilityAdvertisement(value);
+  if (advertisement.baseProtocolVersion !== INTERCOM_BASE_PROTOCOL_VERSION || !advertisement.features.some((feature) => feature.feature === BOSS_RUN_FEATURE)) {
+    throw new ContractValidationError("$.capabilities", "broker did not negotiate the exact required Boss feature");
+  }
+  return advertisement;
+}
+function parseBossRegistrationRequest(value) {
+  assertPlainDataGraph(value, "$.boss");
+  assertRecord(value, "$.boss");
+  assertExactKeys(value, ["featureContract", "capabilityDigest", "credential"], [], "$.boss");
+  const featureContract = parseBossRunFeatureContract(value.featureContract);
+  const capabilityDigest = readHexDigest(value.capabilityDigest, "$.boss.capabilityDigest");
+  if (featureContract.feature !== BOSS_RUN_FEATURE_CONTRACT.feature || featureContract.version !== BOSS_RUN_FEATURE_CONTRACT.version || featureContract.baseProtocolVersion !== INTERCOM_BASE_PROTOCOL_VERSION || featureContract.semanticsHash !== BOSS_RUN_FEATURE_CONTRACT.semanticsHash || featureContract.controlEnvelopeVersion !== BOSS_RUN_FEATURE_CONTRACT.controlEnvelopeVersion || capabilityDigest !== BOSS_CAPABILITY_FEATURE_DIGEST) {
+    throw new ContractValidationError("$.boss", "Boss registration diverges from the canonical feature contract");
+  }
+  return {
+    featureContract,
+    capabilityDigest,
+    credential: parseBossParticipantCredentialEnvelope(value.credential)
+  };
+}
+function parseBossSessionMetadata(value, sessionId) {
+  assertPlainDataGraph(value, "$.boss");
+  assertRecord(value, "$.boss");
+  assertExactKeys(value, [
+    "binding",
+    "principal",
+    "liveWorker",
+    "featureContract",
+    "policySemanticsHash",
+    "capabilityDigest",
+    "brokerIdentityVerified"
+  ], [], "$.boss");
+  const binding = parseBossParticipantBinding(value.binding);
+  const parsedPrincipal = parseBossPolicyPrincipal(value.principal);
+  if (parsedPrincipal.principalClass !== "boss-private") {
+    throw new ContractValidationError("$.boss.principal", "must be a Boss-private principal");
+  }
+  const principal = parsedPrincipal;
+  assertRecord(value.liveWorker, "$.boss.liveWorker");
+  assertExactKeys(value.liveWorker, ["identity", "state"], [], "$.boss.liveWorker");
+  const liveWorkerIdentity = parseWorkerIdentityV2(value.liveWorker.identity);
+  const liveWorkerState = parseParticipantState(value.liveWorker.state, "$.boss.liveWorker.state");
+  const featureContract = parseBossRunFeatureContract(value.featureContract);
+  const policySemanticsHash = readHexDigest(value.policySemanticsHash, "$.boss.policySemanticsHash");
+  const capabilityDigest = readHexDigest(value.capabilityDigest, "$.boss.capabilityDigest");
+  if (value.brokerIdentityVerified !== true) {
+    throw new ContractValidationError("$.boss.brokerIdentityVerified", "must be true for a live Boss session");
+  }
+  if (sessionId !== void 0 && binding.sessionId !== sessionId) {
+    throw new ContractValidationError("$.boss.binding.sessionId", "must match the registered session ID");
+  }
+  if (sessionId !== void 0 && principal.principalId !== sessionId) {
+    throw new ContractValidationError("$.boss.principal.principalId", "must match the registered session ID");
+  }
+  if (!("bossRunId" in liveWorkerIdentity) || sessionId !== void 0 && liveWorkerIdentity.workerId !== sessionId || liveWorkerIdentity.bossRunId !== binding.bossRunId || liveWorkerIdentity.participantId !== binding.participantId || liveWorkerIdentity.bindingEpoch !== binding.bindingEpoch || isTerminalParticipantState(liveWorkerState)) {
+    throw new ContractValidationError(
+      "$.boss.liveWorker",
+      "must attest the same live Boss worker identity and binding as the registered session"
+    );
+  }
+  if (binding.state !== "active" || principal.state !== "active" || binding.bossRunId !== principal.bossRunId || binding.participantId !== principal.participantId || binding.role !== principal.role || binding.bindingEpoch !== principal.bindingEpoch || binding.assignedManagerParticipantId !== principal.assignedManagerParticipantId) {
+    throw new ContractValidationError("$.boss", "binding and policy principal are not the same active participant");
+  }
+  if (featureContract.semanticsHash !== BOSS_RUN_FEATURE_CONTRACT.semanticsHash || policySemanticsHash !== BOSS_POLICY_SEMANTICS_HASH || capabilityDigest !== BOSS_CAPABILITY_FEATURE_DIGEST) {
+    throw new ContractValidationError("$.boss", "Boss session attestation diverges from Core");
+  }
+  return {
+    binding,
+    principal,
+    liveWorker: { identity: liveWorkerIdentity, state: liveWorkerState },
+    featureContract,
+    policySemanticsHash,
+    capabilityDigest,
+    brokerIdentityVerified: true
+  };
+}
+function assertBossRegistrationEcho(requestValue, metadataValue, sessionId) {
+  const request = parseBossRegistrationRequest(requestValue);
+  const metadata = parseBossSessionMetadata(metadataValue, sessionId);
+  const credential = request.credential;
+  const binding = metadata.binding;
+  if (credential.bossRunId !== binding.bossRunId || credential.participantId !== binding.participantId || credential.role !== binding.role || credential.communicationProfile !== binding.communicationProfile || credential.bindingEpoch !== binding.bindingEpoch || request.featureContract.feature !== metadata.featureContract.feature || request.featureContract.version !== metadata.featureContract.version || request.featureContract.baseProtocolVersion !== metadata.featureContract.baseProtocolVersion || request.featureContract.semanticsHash !== metadata.featureContract.semanticsHash || request.featureContract.controlEnvelopeVersion !== metadata.featureContract.controlEnvelopeVersion || request.capabilityDigest !== metadata.capabilityDigest) {
+    throw new ContractValidationError("$.boss", "broker-owned Boss registration echo does not match the requested participant binding");
+  }
+  return metadata;
+}
+function parseCorrelatedBossControl(value, messageId) {
+  assertPlainDataGraph(value, "$.control");
+  const envelope = parseBossControlEnvelope(value);
+  if (messageId !== void 0 && envelope.messageId !== messageId) {
+    throw new ContractValidationError("$.control.messageId", "must match the transport message ID");
+  }
+  return envelope;
+}
+
+// broker/client.ts
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function connectToBrokerTarget(target) {
+  return typeof target === "string" ? net.connect(target) : net.connect({ host: target.host, port: target.port });
+}
+function isAttachment(value) {
+  if (!hasExactDataKeys(value, ["type", "name", "content"], ["language"])) {
+    return false;
+  }
+  const attachment = value;
+  if (attachment.type !== "file" && attachment.type !== "snippet" && attachment.type !== "context") {
+    return false;
+  }
+  if (typeof attachment.name !== "string" || typeof attachment.content !== "string") {
+    return false;
+  }
+  return attachment.language === void 0 || typeof attachment.language === "string";
+}
+function isMessage(value) {
+  if (!hasExactDataKeys(value, ["id", "timestamp", "content"], ["replyTo", "expectsReply", "control"])) {
+    return false;
+  }
+  const message = value;
+  if (typeof message.id !== "string" || typeof message.timestamp !== "number") {
+    return false;
+  }
+  if (message.replyTo !== void 0 && typeof message.replyTo !== "string") {
+    return false;
+  }
+  if (message.expectsReply !== void 0 && typeof message.expectsReply !== "boolean") {
+    return false;
+  }
+  if (message.control !== void 0) {
+    try {
+      parseCorrelatedBossControl(message.control, message.id);
+    } catch {
+      return false;
+    }
+    if (message.replyTo !== void 0 || message.expectsReply !== void 0) return false;
+  }
+  if (!hasExactDataKeys(message.content, ["text"], ["attachments"])) {
+    return false;
+  }
+  const content = message.content;
+  if (typeof content.text !== "string") {
+    return false;
+  }
+  if (message.control !== void 0 && (content.text !== "" || content.attachments !== void 0)) return false;
+  return content.attachments === void 0 || isDenseArrayOf(content.attachments, isAttachment);
+}
+function isSessionInfo(value) {
+  if (!hasExactDataKeys(
+    value,
+    ["id", "cwd", "model", "pid", "startedAt", "lastActivity"],
+    [
+      "name",
+      "status",
+      "peerUid",
+      "trustedLocal",
+      "origin",
+      "remoteHostId",
+      "parentSessionId",
+      "rootSessionId",
+      "generation",
+      "canDelegate",
+      "depth",
+      "maxDepth",
+      "maxChildren",
+      "boss"
+    ]
+  )) {
+    return false;
+  }
+  const session = value;
+  if (typeof session.id !== "string" || typeof session.cwd !== "string" || typeof session.model !== "string" || typeof session.pid !== "number" || typeof session.startedAt !== "number" || typeof session.lastActivity !== "number") {
+    return false;
+  }
+  if (session.name !== void 0 && typeof session.name !== "string") {
+    return false;
+  }
+  if (session.status !== void 0 && typeof session.status !== "string") {
+    return false;
+  }
+  if (session.peerUid !== void 0 && typeof session.peerUid !== "number") {
+    return false;
+  }
+  if (session.trustedLocal !== void 0 && typeof session.trustedLocal !== "boolean") return false;
+  if (session.origin !== void 0 && session.origin !== "local" && session.origin !== "remote") return false;
+  if (session.remoteHostId !== void 0 && typeof session.remoteHostId !== "string") return false;
+  if (session.parentSessionId !== void 0 && typeof session.parentSessionId !== "string") return false;
+  if (session.rootSessionId !== void 0 && typeof session.rootSessionId !== "string") return false;
+  if (session.generation !== void 0 && (typeof session.generation !== "number" || !Number.isSafeInteger(session.generation))) return false;
+  if (session.canDelegate !== void 0 && typeof session.canDelegate !== "boolean") return false;
+  for (const field of ["depth", "maxDepth", "maxChildren"]) {
+    if (session[field] !== void 0 && (typeof session[field] !== "number" || !Number.isSafeInteger(session[field]))) return false;
+  }
+  if (session.boss !== void 0) {
+    try {
+      parseBossSessionMetadata(session.boss, session.id);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function isRemoteAccessMetadata(value) {
+  if (!hasExactDataKeys(
+    value,
+    ["origin", "remoteHostId", "parentSessionId", "rootSessionId", "generation", "canDelegate", "depth", "maxDepth", "maxChildren"],
+    ["sessionCredential"]
+  )) return false;
+  const access = value;
+  return access.origin === "remote" && typeof access.remoteHostId === "string" && typeof access.parentSessionId === "string" && typeof access.rootSessionId === "string" && typeof access.generation === "number" && Number.isSafeInteger(access.generation) && access.generation > 0 && typeof access.canDelegate === "boolean" && typeof access.depth === "number" && Number.isSafeInteger(access.depth) && typeof access.maxDepth === "number" && Number.isSafeInteger(access.maxDepth) && typeof access.maxChildren === "number" && Number.isSafeInteger(access.maxChildren) && (access.sessionCredential === void 0 || typeof access.sessionCredential === "string");
+}
+function isDeliveryFailureCode(value) {
+  return typeof value === "string" && DELIVERY_FAILURE_CODES.includes(value);
+}
+var IntercomClient = class extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.scopeId = options.scopeId === void 0 ? intercomScopeIdFromEnvForRegistration(options.env ?? process.env) : parseIntercomScopeIdForRegistration(options.scopeId);
+  }
+  options;
+  socket = null;
+  scopeId;
+  _sessionId = null;
+  pendingSends = /* @__PURE__ */ new Map();
+  lateDeliveryAcceptances = /* @__PURE__ */ new Map();
+  pendingLists = /* @__PURE__ */ new Map();
+  pendingAskControls = /* @__PURE__ */ new Map();
+  outbox = null;
+  remoteAccessCredential;
+  requestedBossRegistration;
+  bossSessionMetadata;
+  disconnecting = false;
+  disconnectError = null;
+  failPending(error) {
+    for (const pending of this.pendingSends.values()) {
+      pending.reject(error);
+    }
+    this.pendingSends.clear();
+    for (const pending of this.pendingLists.values()) {
+      pending.reject(error);
+    }
+    this.pendingLists.clear();
+    for (const pending of this.pendingAskControls.values()) {
+      clearTimeout(pending.timeout);
+      pending.resolve(false);
+    }
+    this.pendingAskControls.clear();
+    this.lateDeliveryAcceptances.clear();
+  }
+  hasQueuedOutboundMessage(messageId) {
+    return this.outbox?.list().some((entry) => entry.message.id === messageId) ?? false;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get outboxSize() {
+    return this.outbox?.list().length ?? 0;
+  }
+  isConnected() {
+    const socket = this.socket;
+    return Boolean(socket && this._sessionId && !this.disconnecting && !socket.destroyed && !socket.writableEnded && socket.writable);
+  }
+  requireActiveSocket() {
+    if (this.disconnecting) {
+      throw new Error("Client disconnecting");
+    }
+    const socket = this.socket;
+    if (!socket || !this._sessionId) {
+      throw new Error("Not connected");
+    }
+    if (socket.destroyed || socket.writableEnded || !socket.writable) {
+      throw new Error("Client disconnected");
+    }
+    return socket;
+  }
+  connect(session, sessionId) {
+    if (this.socket) {
+      return Promise.reject(new Error("Already connected"));
+    }
+    return new Promise((resolve4, reject) => {
+      let socket;
+      let target;
+      try {
+        this.requestedBossRegistration = session.boss === void 0 ? void 0 : parseBossRegistrationRequest(session.boss);
+        target = getBrokerConnectTarget();
+        this.remoteAccessCredential = loadRemoteAccessCredential();
+        socket = connectToBrokerTarget(target);
+      } catch (error) {
+        this.requestedBossRegistration = void 0;
+        reject(toError(error));
+        return;
+      }
+      this.socket = socket;
+      this.disconnectError = null;
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (!this._sessionId) {
+          cleanupConnectionAttempt();
+          cleanupSocketListeners();
+          if (this.socket === socket) {
+            this.socket = null;
+          }
+          this.requestedBossRegistration = void 0;
+          socket.destroy();
+          reject(new Error("Connection timeout"));
+        }
+      }, 1e4);
+      let connectionEstablished = false;
+      const onRegistered = () => {
+        settled = true;
+        connectionEstablished = true;
+        cleanupConnectionAttempt();
+        resolve4();
+      };
+      const onError = (err) => {
+        settled = true;
+        cleanupConnectionAttempt();
+        cleanupSocketListeners();
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        this.requestedBossRegistration = void 0;
+        socket.destroy();
+        reject(err);
+      };
+      const onClose = () => {
+        const wasConnecting = !settled && !this._sessionId;
+        const wasDisconnecting = this.disconnecting;
+        const disconnectError = this.disconnectError ?? new Error("Client disconnected");
+        this.disconnecting = false;
+        cleanupConnectionAttempt();
+        cleanupSocketListeners();
+        this.failPending(disconnectError);
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        this._sessionId = null;
+        this.requestedBossRegistration = void 0;
+        this.bossSessionMetadata = void 0;
+        this.disconnectError = null;
+        if (connectionEstablished && !wasDisconnecting) {
+          this.emit("disconnected", disconnectError);
+        }
+        if (wasConnecting) {
+          reject(new Error("Connection closed before registration"));
+        }
+      };
+      const onSocketError = (err) => {
+        if (connectionEstablished) {
+          this.disconnectError = err;
+          this.emit("error", err);
+        }
+      };
+      const onReaderError = (error) => {
+        const protocolError = new Error(`Intercom protocol error: ${error.message}`, { cause: error });
+        if (!connectionEstablished) {
+          onError(protocolError);
+          return;
+        }
+        this.disconnectError = protocolError;
+        this.emit("error", protocolError);
+        socket.destroy();
+      };
+      const reader = createMessageReader((msg) => {
+        this.handleBrokerMessage(msg);
+      }, onReaderError);
+      const cleanupConnectionAttempt = () => {
+        this.off("_registered", onRegistered);
+        socket.off("error", onError);
+        clearTimeout(timeout);
+      };
+      const cleanupSocketListeners = () => {
+        socket.off("data", reader);
+        socket.off("error", onSocketError);
+        socket.off("close", onClose);
+      };
+      socket.on("data", reader);
+      socket.on("error", onError);
+      socket.on("close", onClose);
+      socket.on("error", onSocketError);
+      this.once("_registered", onRegistered);
+      try {
+        writeMessage(socket, {
+          type: "register",
+          protocol: INTERCOM_PROTOCOL_NAME,
+          version: INTERCOM_PROTOCOL_VERSION,
+          session,
+          ...!this.remoteAccessCredential && sessionId ? { sessionId } : {},
+          ...this.remoteAccessCredential ? { access: this.remoteAccessCredential.access } : {},
+          ...this.scopeId ? { scopeId: this.scopeId } : {},
+          ...typeof target === "string" ? {} : { stateId: target.stateId }
+        });
+      } catch (error) {
+        cleanupConnectionAttempt();
+        cleanupSocketListeners();
+        if (this.socket === socket) {
+          this.socket = null;
+        }
+        this.requestedBossRegistration = void 0;
+        socket.destroy();
+        reject(toError(error));
+      }
+    });
+  }
+  handleBrokerMessage(msg) {
+    if (!isPlainDataRecord(msg) || typeof msg.type !== "string") {
+      throw new Error("Invalid broker message");
+    }
+    const brokerMessage = msg;
+    if (this._sessionId === null && brokerMessage.type !== "registered" && brokerMessage.type !== "error") {
+      throw new Error(`Received ${brokerMessage.type} before registered`);
+    }
+    switch (brokerMessage.type) {
+      case "registered": {
+        const baseKeys = ["type", "sessionId", "protocol", "version"];
+        if (this.requestedBossRegistration !== void 0 && (brokerMessage.capabilities === void 0 || brokerMessage.boss === void 0)) {
+          throw new Error("Boss registration was downgraded to an ordinary session");
+        }
+        const exactKeys = this.requestedBossRegistration !== void 0 ? [...baseKeys, "capabilities", "boss"] : this.remoteAccessCredential ? [...baseKeys, "remoteAccess", "access"] : baseKeys;
+        const optionalKeys = this.requestedBossRegistration === void 0 ? ["capabilities"] : [];
+        if (!hasExactDataKeys(brokerMessage, exactKeys, optionalKeys) || typeof brokerMessage.sessionId !== "string" || brokerMessage.protocol !== INTERCOM_PROTOCOL_NAME || brokerMessage.version !== INTERCOM_PROTOCOL_VERSION) {
+          throw new Error("Invalid registered message");
+        }
+        if (this._sessionId !== null) {
+          throw new Error("Received duplicate registered message");
+        }
+        if (this.requestedBossRegistration !== void 0) {
+          assertCompatibleBossAdvertisement(brokerMessage.capabilities);
+          this.bossSessionMetadata = assertBossRegistrationEcho(
+            this.requestedBossRegistration,
+            brokerMessage.boss,
+            brokerMessage.sessionId
+          );
+          this.requestedBossRegistration = void 0;
+        } else {
+          if (brokerMessage.boss !== void 0) {
+            throw new Error("Ordinary registration received unsolicited Boss authority metadata");
+          }
+          if (brokerMessage.capabilities !== void 0) {
+            assertCompatibleOrdinaryAdvertisement(brokerMessage.capabilities);
+          }
+          this.bossSessionMetadata = void 0;
+        }
+        if (this.remoteAccessCredential) {
+          const contract = brokerMessage.remoteAccess;
+          const contractFields = hasExactDataKeys(
+            contract,
+            ["feature", "policySemanticsVersion", "policySemanticsHash"]
+          ) ? contract : void 0;
+          if (!contractFields || contractFields.feature !== "remote-access-v1" || contractFields.policySemanticsVersion !== POLICY_SEMANTICS_VERSION || contractFields.policySemanticsHash !== POLICY_SEMANTICS_HASH) {
+            throw new Error("Remote Intercom policy contract is absent or incompatible");
+          }
+          if (!isRemoteAccessMetadata(brokerMessage.access)) {
+            throw new Error("Remote Intercom registration omitted broker-owned provenance");
+          }
+          if (this.remoteAccessCredential.enrollment) {
+            writeRemoteSessionCredential(this.remoteAccessCredential.path, brokerMessage.sessionId, brokerMessage.access);
+          } else {
+            const reconnect = this.remoteAccessCredential.access;
+            if (!isPlainDataRecord(reconnect) || reconnect.sessionId !== brokerMessage.sessionId || reconnect.generation !== brokerMessage.access.generation) {
+              throw new Error("Remote Intercom reconnect identity or generation changed unexpectedly");
+            }
+          }
+        }
+        this._sessionId = brokerMessage.sessionId;
+        this.outbox = new PersistentOutboundOutbox(brokerMessage.sessionId);
+        this.lateDeliveryAcceptances.clear();
+        this.replayOutbox();
+        this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
+        break;
+      }
+      case "sessions": {
+        const { requestId, sessions } = brokerMessage;
+        if (!hasExactDataKeys(brokerMessage, ["type", "requestId", "sessions"]) || typeof requestId !== "string" || !isDenseArrayOf(sessions, isSessionInfo)) {
+          throw new Error("Invalid sessions message");
+        }
+        const pending = this.pendingLists.get(requestId);
+        if (!pending) {
+          return;
+        }
+        this.pendingLists.delete(requestId);
+        pending.resolve(sessions);
+        break;
+      }
+      case "message": {
+        const { deliveryId, from, message } = brokerMessage;
+        if (!hasExactDataKeys(brokerMessage, ["type", "deliveryId", "from", "message"]) || typeof deliveryId !== "string" || !isSessionInfo(from) || !isMessage(message)) {
+          throw new Error("Invalid message event");
+        }
+        if (message.control !== void 0) {
+          if (this.bossSessionMetadata === void 0) {
+            throw new Error("Ordinary session received unavailable Boss control traffic");
+          }
+          this.emit("control", from, message.control, deliveryId);
+        } else {
+          this.emit("message", from, message, deliveryId);
+        }
+        break;
+      }
+      case "delivery_accepted": {
+        const { deliveryId, messageId } = brokerMessage;
+        if (!hasExactDataKeys(brokerMessage, ["type", "messageId", "deliveryId"]) || typeof deliveryId !== "string" || typeof messageId !== "string") {
+          throw new Error("Invalid delivery_accepted message");
+        }
+        const pending = this.pendingSends.get(messageId);
+        if (pending) {
+          if (pending.accepted) {
+            throw new Error("Duplicate delivery_accepted message");
+          }
+          pending.accepted = true;
+          pending.deliveryId = deliveryId;
+          this.emit("delivery_accepted", messageId, deliveryId);
+          break;
+        }
+        if (!this.hasQueuedOutboundMessage(messageId)) {
+          throw new Error("Unexpected delivery_accepted message without a pending send or queued outbox message");
+        }
+        if (this.lateDeliveryAcceptances.has(messageId)) {
+          throw new Error("Duplicate delivery_accepted message");
+        }
+        this.lateDeliveryAcceptances.set(messageId, deliveryId);
+        this.emit("delivery_accepted", messageId, deliveryId);
+        break;
+      }
+      case "delivered": {
+        const { deliveryId, messageId } = brokerMessage;
+        if (!hasExactDataKeys(brokerMessage, ["type", "messageId", "deliveryId"]) || typeof deliveryId !== "string" || typeof messageId !== "string") {
+          throw new Error("Invalid delivered message");
+        }
+        const pending = this.pendingSends.get(messageId);
+        if (pending) {
+          if (!pending.accepted) {
+            throw new Error("Delivered message arrived before delivery acceptance");
+          }
+          if (pending.deliveryId !== deliveryId) {
+            throw new Error("Delivered message used a mismatched delivery ID");
+          }
+          this.outbox?.remove(messageId);
+          this.pendingSends.delete(messageId);
+          this.lateDeliveryAcceptances.delete(messageId);
+          pending.resolve({ id: messageId, accepted: true, delivered: true, deliveryId });
+          break;
+        }
+        if (!this.hasQueuedOutboundMessage(messageId)) {
+          throw new Error("Unexpected delivered message without a pending send or queued outbox message");
+        }
+        const acceptedDeliveryId = this.lateDeliveryAcceptances.get(messageId);
+        if (acceptedDeliveryId === void 0) {
+          throw new Error("Delivered message arrived before delivery acceptance");
+        }
+        if (acceptedDeliveryId !== deliveryId) {
+          throw new Error("Delivered message used a mismatched delivery ID");
+        }
+        this.outbox?.remove(messageId);
+        this.lateDeliveryAcceptances.delete(messageId);
+        this.emit("outbox_delivered", messageId, deliveryId);
+        break;
+      }
+      case "delivery_failed": {
+        const { accepted, code, messageId, reason } = brokerMessage;
+        if (!hasExactDataKeys(brokerMessage, ["type", "messageId", "accepted", "code", "reason"]) || typeof accepted !== "boolean" || !isDeliveryFailureCode(code) || typeof messageId !== "string" || typeof reason !== "string") {
+          throw new Error("Invalid delivery_failed message");
+        }
+        const pending = this.pendingSends.get(messageId);
+        if (pending) {
+          if (accepted !== pending.accepted) {
+            throw new Error("Delivery failure contradicted the accepted delivery state");
+          }
+          this.outbox?.remove(messageId);
+          this.pendingSends.delete(messageId);
+          this.lateDeliveryAcceptances.delete(messageId);
+          pending.resolve({
+            id: messageId,
+            accepted,
+            delivered: false,
+            code,
+            reason,
+            ...pending.deliveryId !== void 0 ? { deliveryId: pending.deliveryId } : {}
+          });
+          break;
+        }
+        if (!this.hasQueuedOutboundMessage(messageId)) {
+          throw new Error("Unexpected delivery_failed message without a pending send or queued outbox message");
+        }
+        if (accepted !== this.lateDeliveryAcceptances.has(messageId)) {
+          throw new Error("Delivery failure contradicted the accepted delivery state");
+        }
+        this.outbox?.remove(messageId);
+        this.lateDeliveryAcceptances.delete(messageId);
+        this.emit("outbox_failed", messageId, code, reason);
+        break;
+      }
+      case "ask_deferred": {
+        const { fromSessionId, messageId } = brokerMessage;
+        if (typeof fromSessionId !== "string" || typeof messageId !== "string") {
+          throw new Error("Invalid ask_deferred message");
+        }
+        this.emit("ask_deferred", messageId, fromSessionId);
+        break;
+      }
+      case "ask_cancelled": {
+        const { fromSessionId, messageId, reason } = brokerMessage;
+        if (typeof fromSessionId !== "string" || typeof messageId !== "string" || typeof reason !== "string") {
+          throw new Error("Invalid ask_cancelled message");
+        }
+        this.emit("ask_cancelled", messageId, fromSessionId, reason);
+        break;
+      }
+      case "ask_control_result": {
+        const { action, applied, messageId, requestId } = brokerMessage;
+        if (action !== "defer" && action !== "cancel" || typeof applied !== "boolean" || typeof messageId !== "string" || typeof requestId !== "string") {
+          throw new Error("Invalid ask_control_result message");
+        }
+        const pending = this.pendingAskControls.get(requestId);
+        if (!pending) return;
+        clearTimeout(pending.timeout);
+        this.pendingAskControls.delete(requestId);
+        pending.resolve(applied);
+        break;
+      }
+      case "session_joined": {
+        if (!isSessionInfo(brokerMessage.session)) {
+          throw new Error("Invalid session_joined message");
+        }
+        this.emit("session_joined", brokerMessage.session);
+        break;
+      }
+      case "session_left": {
+        if (typeof brokerMessage.sessionId !== "string") {
+          throw new Error("Invalid session_left message");
+        }
+        this.emit("session_left", brokerMessage.sessionId);
+        break;
+      }
+      case "presence_update": {
+        if (!isSessionInfo(brokerMessage.session)) {
+          throw new Error("Invalid presence_update message");
+        }
+        this.emit("presence_update", brokerMessage.session);
+        break;
+      }
+      case "error": {
+        if (typeof brokerMessage.code !== "string" || typeof brokerMessage.error !== "string") {
+          throw new Error("Invalid error message");
+        }
+        if (this._sessionId === null) {
+          const error2 = new Error(brokerMessage.error);
+          error2.code = brokerMessage.code;
+          throw error2;
+        }
+        const error = new Error(brokerMessage.error);
+        error.code = brokerMessage.code;
+        this.emit("error", error);
+        break;
+      }
+      default:
+        throw new Error(`Unknown broker message type: ${brokerMessage.type}`);
+    }
+  }
+  async disconnect(preserveAsks = false) {
+    const socket = this.socket;
+    if (!socket) {
+      return;
+    }
+    this.disconnecting = true;
+    this.disconnectError = null;
+    this.failPending(new Error("Client disconnected"));
+    if (!preserveAsks) this.outbox?.clear();
+    await new Promise((resolve4) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeout);
+        socket.off("close", onClose);
+        socket.off("error", onError);
+        resolve4();
+      };
+      const onClose = () => finish();
+      const onError = () => {
+        socket.destroy();
+      };
+      const timeout = setTimeout(() => {
+        socket.destroy();
+      }, 2e3);
+      socket.once("close", onClose);
+      socket.once("error", onError);
+      try {
+        writeMessage(socket, { type: "unregister", ...preserveAsks ? { preserveAsks: true } : {} });
+        socket.end();
+      } catch {
+        socket.destroy();
+      }
+    });
+  }
+  listSessions() {
+    let socket;
+    try {
+      socket = this.requireActiveSocket();
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    return new Promise((resolve4, reject) => {
+      const requestId = randomUUID2();
+      const wrappedResolve = (sessions) => {
+        clearTimeout(timeout);
+        resolve4(sessions);
+      };
+      const wrappedReject = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+      const timeout = setTimeout(() => {
+        if (this.pendingLists.has(requestId)) {
+          this.pendingLists.delete(requestId);
+          wrappedReject(new Error("List sessions timeout"));
+        }
+      }, 5e3);
+      this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject });
+      try {
+        writeMessage(socket, { type: "list", requestId });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingLists.delete(requestId);
+        reject(toError(error));
+      }
+    });
+  }
+  send(to, options) {
+    return this.sendInternal(to, options);
+  }
+  sendControl(to, controlValue) {
+    const control = parseCorrelatedBossControl(controlValue);
+    return this.sendInternal(to, {
+      text: "",
+      messageId: control.messageId,
+      control
+    });
+  }
+  sendInternal(to, options) {
+    let socket;
+    try {
+      socket = this.requireActiveSocket();
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    const messageId = options.messageId ?? randomUUID2();
+    if (this.pendingSends.has(messageId)) {
+      return Promise.resolve({
+        id: messageId,
+        accepted: false,
+        delivered: false,
+        code: "DUPLICATE_MESSAGE_ID",
+        reason: `Message ID ${messageId} is already pending`
+      });
+    }
+    const message = {
+      id: messageId,
+      timestamp: Date.now(),
+      replyTo: options.replyTo,
+      expectsReply: options.expectsReply,
+      ...options.control === void 0 ? {} : { control: options.control },
+      content: {
+        text: options.text,
+        ...options.attachments === void 0 ? {} : { attachments: options.attachments }
+      }
+    };
+    try {
+      this.outbox?.enqueue(to, message);
+    } catch (error) {
+      return Promise.reject(toError(error));
+    }
+    return new Promise((resolve4, reject) => {
+      const wrappedResolve = (result) => {
+        clearTimeout(timeout);
+        resolve4(result);
+      };
+      const wrappedReject = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+      const timeout = setTimeout(() => {
+        const pending = this.pendingSends.get(messageId);
+        if (pending) {
+          if (pending.accepted && pending.deliveryId !== void 0 && this.hasQueuedOutboundMessage(messageId)) {
+            this.lateDeliveryAcceptances.set(messageId, pending.deliveryId);
+          }
+          this.pendingSends.delete(messageId);
+          wrappedReject(new Error("Send timeout"));
+        }
+      }, 1e4);
+      this.pendingSends.set(messageId, {
+        accepted: false,
+        resolve: wrappedResolve,
+        reject: wrappedReject
+      });
+      try {
+        writeMessage(socket, { type: "send", to, message });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingSends.delete(messageId);
+        reject(toError(error));
+      }
+    });
+  }
+  acknowledgeMessage(deliveryId) {
+    return this.writeControlMessage({ type: "message_received", deliveryId });
+  }
+  rejectMessage(deliveryId, reason) {
+    return this.writeControlMessage({ type: "message_rejected", deliveryId, code: "CONFLICTING_MESSAGE_ID", reason });
+  }
+  deferAsk(messageId) {
+    return this.sendAskControl("defer", messageId);
+  }
+  cancelAsk(messageId) {
+    return this.sendAskControl("cancel", messageId);
+  }
+  sendAskControl(action, messageId) {
+    const requestId = randomUUID2();
+    return new Promise((resolve4) => {
+      const timeout = setTimeout(() => {
+        this.pendingAskControls.delete(requestId);
+        resolve4(false);
+      }, 2e3);
+      timeout.unref?.();
+      this.pendingAskControls.set(requestId, { resolve: resolve4, timeout });
+      if (!this.writeControlMessage({ type: action === "defer" ? "defer_ask" : "cancel_ask", requestId, messageId })) {
+        clearTimeout(timeout);
+        this.pendingAskControls.delete(requestId);
+        resolve4(false);
+      }
+    });
+  }
+  writeControlMessage(message) {
+    if (this.disconnecting) {
+      return false;
+    }
+    const socket = this.socket;
+    if (!socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable) {
+      return false;
+    }
+    try {
+      writeMessage(socket, message);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  replayOutbox() {
+    const socket = this.socket;
+    if (!socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable) return;
+    for (const entry of this.outbox?.list() ?? []) {
+      if (this.pendingSends.has(entry.message.id)) continue;
+      this.lateDeliveryAcceptances.delete(entry.message.id);
+      this.pendingSends.set(entry.message.id, {
+        accepted: false,
+        resolve: (result) => {
+          if (result.delivered && result.deliveryId) {
+            this.emit("outbox_delivered", result.id, result.deliveryId);
+          } else {
+            this.emit("outbox_failed", result.id, result.code, result.reason);
+          }
+        },
+        reject: () => {
+        }
+      });
+      try {
+        writeMessage(socket, { type: "send", to: entry.to, message: entry.message });
+      } catch {
+        this.pendingSends.delete(entry.message.id);
+        return;
+      }
+    }
+  }
+  updatePresence(updates) {
+    if (this.disconnecting) {
+      return;
+    }
+    const socket = this.socket;
+    if (!socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable) {
+      return;
+    }
+    writeMessage(socket, { type: "presence", ...updates });
+  }
+};
+
+// broker/spawn.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import net2 from "net";
+import { randomUUID as randomUUID3 } from "crypto";
+import { POLICY_SEMANTICS_HASH as POLICY_SEMANTICS_HASH2, POLICY_SEMANTICS_VERSION as POLICY_SEMANTICS_VERSION2 } from "@ctliz/agent-intercom-core";
+var INTERCOM_DIR = getIntercomDirPath();
+var EXTENSION_DIR = join5(dirname4(fileURLToPath(import.meta.url)), "..");
+var BROKER_PID = join5(INTERCOM_DIR, "broker.pid");
+var BROKER_SPAWN_LOCK = join5(INTERCOM_DIR, "broker.spawn.lock");
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function getBrokerEntryPath(moduleUrl = import.meta.url) {
+  const moduleDir = dirname4(fileURLToPath(moduleUrl));
+  const bundledBroker = join5(moduleDir, "broker.mjs");
+  return existsSync3(bundledBroker) ? bundledBroker : join5(moduleDir, "broker.ts");
+}
+function getTsxCliPath(extensionDir = EXTENSION_DIR) {
+  try {
+    const requireFromExtension = createRequire(import.meta.url);
+    const tsxMain = requireFromExtension.resolve("tsx");
+    return join5(dirname4(tsxMain), "cli.mjs");
+  } catch {
+    return join5(extensionDir, "node_modules", "tsx", "dist", "cli.mjs");
+  }
+}
+function quoteWindowsArg(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function getWindowsHiddenLauncherPath(intercomDir = INTERCOM_DIR) {
+  return join5(intercomDir, "broker-launch.vbs");
+}
+function usesDefaultBrokerCommand(brokerCommand, brokerArgs) {
+  return brokerCommand === "npx" && brokerArgs.length === 2 && brokerArgs[0] === "--no-install" && brokerArgs[1] === "tsx";
+}
+function getWindowsBrokerCommandLine(brokerPath, extensionDir = EXTENSION_DIR, nodePath = process.execPath, brokerCommand = "npx", brokerArgs = ["--no-install", "tsx"]) {
+  if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
+    return [quoteWindowsArg(nodePath), quoteWindowsArg(getTsxCliPath(extensionDir)), quoteWindowsArg(brokerPath)].join(" ");
+  }
+  return [quoteWindowsArg(brokerCommand), ...brokerArgs.map(quoteWindowsArg), quoteWindowsArg(brokerPath)].join(" ");
+}
+function getWindowsHiddenLauncherScript(commandLine) {
+  return [
+    'Set WshShell = CreateObject("WScript.Shell")',
+    `WshShell.Run "${commandLine.replace(/"/g, '""')}", 0, False`,
+    "Set WshShell = Nothing",
+    ""
+  ].join("\r\n");
+}
+function isBrokerHealthOkMessage(message, requestId) {
+  if (!hasExactDataKeys(
+    message,
+    ["type", "requestId", "protocol", "version", "endpoint", "remoteAccess"],
+    ["capabilities"]
+  )) return false;
+  const response = message;
+  if (response.type !== "health_ok" || response.requestId !== requestId || response.protocol !== INTERCOM_PROTOCOL_NAME || response.version !== INTERCOM_PROTOCOL_VERSION || response.endpoint !== "local") return false;
+  const remoteAccess = response.remoteAccess;
+  if (!hasExactDataKeys(remoteAccess, ["feature", "policySemanticsVersion", "policySemanticsHash"])) return false;
+  const contract = remoteAccess;
+  const legacyCompatible = contract.feature === "remote-access-v1" && contract.policySemanticsVersion === POLICY_SEMANTICS_VERSION2 && contract.policySemanticsHash === POLICY_SEMANTICS_HASH2;
+  if (!legacyCompatible) return false;
+  if (response.capabilities !== void 0) {
+    try {
+      assertCompatibleOrdinaryAdvertisement(response.capabilities);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function writeWindowsHiddenLauncher(commandLine, launcherPath = getWindowsHiddenLauncherPath()) {
+  ensureIntercomRuntimeDir(dirname4(launcherPath));
+  writeFileSync3(launcherPath, getWindowsHiddenLauncherScript(commandLine), {
+    encoding: "utf-8",
+    mode: INTERCOM_RUNTIME_FILE_MODE
+  });
+  restrictIntercomRuntimeFile(launcherPath);
+  return launcherPath;
+}
+function getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs, extensionDir = EXTENSION_DIR, platform = process.platform, intercomDir = INTERCOM_DIR, nodePath = process.execPath) {
+  if (platform === "win32") {
+    const launcherPath = getWindowsHiddenLauncherPath(intercomDir);
+    return {
+      kind: "windows-launcher",
+      command: "wscript.exe",
+      args: [launcherPath],
+      launcherPath,
+      launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs)
+    };
+  }
+  if (usesDefaultBrokerCommand(brokerCommand, brokerArgs)) {
+    return {
+      kind: "direct",
+      command: nodePath,
+      args: [getTsxCliPath(extensionDir), brokerPath]
+    };
+  }
+  return {
+    kind: "direct",
+    command: brokerCommand,
+    args: [...brokerArgs, brokerPath]
+  };
+}
+function getBrokerSpawnOptions(extensionDir = EXTENSION_DIR, env = process.env) {
+  return {
+    detached: true,
+    stdio: "ignore",
+    cwd: extensionDir,
+    env: { ...env, PI_CODING_AGENT_DIR: getAgentDirPath(env), NODE_NO_WARNINGS: "1" },
+    windowsHide: true
+  };
+}
+function toError2(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
+  ensureIntercomRuntimeDir(INTERCOM_DIR);
+  if (await isBrokerRunning()) {
+    return;
+  }
+  const ownsLock = acquireSpawnLock();
+  if (!ownsLock) {
+    await waitForBroker();
+    return;
+  }
+  try {
+    if (await isBrokerRunning()) {
+      return;
+    }
+    if (await checkBrokerHealth() === "incompatible") {
+      throw new Error(`Incompatible live intercom broker; expected ${INTERCOM_PROTOCOL_NAME} v${INTERCOM_PROTOCOL_VERSION}. Stop it explicitly during a coordinated migration.`);
+    }
+    const brokerPath = getBrokerEntryPath();
+    const launch = getBrokerLaunchSpec(brokerPath, brokerCommand, brokerArgs);
+    if (launch.kind === "windows-launcher") {
+      writeWindowsHiddenLauncher(launch.launcherCommandLine, launch.launcherPath);
+    }
+    const child = spawn2(launch.command, launch.args, getBrokerSpawnOptions());
+    child.unref();
+    await new Promise((resolve4, reject) => {
+      const cleanup = () => {
+        child.off("error", onError);
+        child.off("exit", onExit);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(new Error(`Failed to spawn intercom broker: ${error.message}`, { cause: error }));
+      };
+      const onExit = (code, signal) => {
+        if (launch.kind === "windows-launcher" && code === 0 && signal === null) {
+          return;
+        }
+        cleanup();
+        if (signal) {
+          reject(new Error(`Intercom broker exited before startup with signal ${signal}`));
+          return;
+        }
+        reject(new Error(`Intercom broker exited before startup with code ${code ?? "unknown"}`));
+      };
+      child.once("error", onError);
+      child.once("exit", onExit);
+      waitForBroker().then(() => {
+        cleanup();
+        resolve4();
+      }, (error) => {
+        cleanup();
+        reject(toError2(error));
+      });
+    });
+  } finally {
+    releaseSpawnLock();
+  }
+}
+async function isBrokerRunning() {
+  if (await checkSocketConnectable()) {
+    return true;
+  }
+  if (!existsSync3(BROKER_PID)) return false;
+  try {
+    const pid = parseInt(readFileSync5(BROKER_PID, "utf-8").trim(), 10);
+    if (!Number.isFinite(pid)) return false;
+    process.kill(pid, 0);
+    return checkSocketConnectable();
+  } catch {
+    return false;
+  }
+}
+function connectToBrokerTarget2(target) {
+  return typeof target === "string" ? net2.connect(target) : net2.connect({ host: target.host, port: target.port });
+}
+async function checkSocketConnectable() {
+  return await checkBrokerHealth() === "compatible";
+}
+function checkBrokerHealth() {
+  return new Promise((resolve4) => {
+    let target;
+    try {
+      target = getBrokerConnectTarget();
+    } catch {
+      resolve4("unreachable");
+      return;
+    }
+    const socket = connectToBrokerTarget2(target);
+    const requestId = randomUUID3();
+    const expectedStateId = typeof target === "string" ? void 0 : target.stateId;
+    let settled = false;
+    const finish = (health) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      socket.off("connect", onConnect);
+      socket.off("error", onError);
+      socket.off("data", reader);
+      socket.destroy();
+      resolve4(health);
+    };
+    const onConnect = () => {
+      try {
+        writeMessage(socket, {
+          type: "health",
+          requestId,
+          ...expectedStateId ? { stateId: expectedStateId } : {}
+        });
+      } catch {
+        finish("unreachable");
+      }
+    };
+    const onError = () => finish("unreachable");
+    const reader = createMessageReader((message) => {
+      if (isBrokerHealthOkMessage(message, requestId)) {
+        finish("compatible");
+        return;
+      }
+      if (isPlainDataRecord(message) && message.type === "health_ok" && message.requestId === requestId) {
+        finish("incompatible");
+        return;
+      }
+      finish("unreachable");
+    }, () => finish("unreachable"));
+    socket.on("connect", onConnect);
+    socket.on("error", onError);
+    socket.on("data", reader);
+    const timeout = setTimeout(() => finish("unreachable"), 1e3);
+  });
+}
+function acquireSpawnLock() {
+  const maxRetries = 5;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      writeFileSync3(BROKER_SPAWN_LOCK, `${process.pid}
+${Date.now()}
+`, {
+        flag: "wx",
+        mode: INTERCOM_RUNTIME_FILE_MODE
+      });
+      restrictIntercomRuntimeFile(BROKER_SPAWN_LOCK);
+      return true;
+    } catch (error) {
+      if (!(error instanceof Error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      if (isSpawnLockStale()) {
+        try {
+          unlinkSync(BROKER_SPAWN_LOCK);
+        } catch {
+        }
+        continue;
+      }
+      return false;
+    }
+  }
+  return false;
+}
+function isSpawnLockStale() {
+  if (!existsSync3(BROKER_SPAWN_LOCK)) {
+    return false;
+  }
+  try {
+    const [pidLine = "", createdAtLine = "0"] = readFileSync5(BROKER_SPAWN_LOCK, "utf-8").trim().split("\n");
+    const pid = Number.parseInt(pidLine, 10);
+    const createdAt = Number.parseInt(createdAtLine, 10);
+    const ageMs = Date.now() - createdAt;
+    if (Number.isFinite(pid)) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return true;
+      }
+    }
+    return !Number.isFinite(createdAt) || ageMs > 1e4;
+  } catch {
+    return true;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync(BROKER_SPAWN_LOCK);
+  } catch {
+  }
+}
+async function waitForBroker(timeoutMs = 5e3) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await checkSocketConnectable()) {
+      return;
+    }
+    await sleep(100);
+  }
+  throw new Error("Broker failed to start within timeout");
+}
+
+// config.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join6, resolve as resolve3 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULT_ASK_TIMEOUT_MS = 45 * 1e3;
+var MAX_ASK_TIMEOUT_MS = 120 * 1e3;
+function getConfigPath() {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ? resolve3(process.env.PI_CODING_AGENT_DIR) : join6(homedir2(), ".pi", "agent");
+  return join6(agentDir, "intercom", "config.json");
+}
+var defaults = {
+  brokerCommand: "npx",
+  brokerArgs: ["--no-install", "tsx"],
+  confirmSend: false,
+  enabled: true,
+  replyHint: true,
+  inboundForkHandlers: {
+    enabled: true,
+    when: "auto",
+    notify: "summary",
+    triggerParentOnSummary: "auto"
+  }
+};
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync4(configPath)) {
+    return { ...defaults };
+  }
+  try {
+    const raw = readFileSync6(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Config must be a JSON object");
+    }
+    const parsedConfig = parsed;
+    const config = { ...defaults };
+    if (Object.hasOwn(parsedConfig, "brokerCommand")) {
+      if (typeof parsedConfig.brokerCommand !== "string") {
+        throw new Error(`"brokerCommand" must be a string`);
+      }
+      const brokerCommand = parsedConfig.brokerCommand.trim();
+      if (!brokerCommand) {
+        throw new Error(`"brokerCommand" must not be empty`);
+      }
+      config.brokerCommand = brokerCommand;
+    }
+    if (Object.hasOwn(parsedConfig, "brokerArgs")) {
+      if (!Array.isArray(parsedConfig.brokerArgs)) {
+        throw new Error(`"brokerArgs" must be an array`);
+      }
+      const brokerArgs = [];
+      for (const arg of parsedConfig.brokerArgs) {
+        if (typeof arg !== "string") {
+          throw new Error(`"brokerArgs" items must be strings`);
+        }
+        brokerArgs.push(arg);
+      }
+      config.brokerArgs = brokerArgs;
+    }
+    if (Object.hasOwn(parsedConfig, "confirmSend")) {
+      if (typeof parsedConfig.confirmSend !== "boolean") {
+        throw new Error(`"confirmSend" must be a boolean`);
+      }
+      config.confirmSend = parsedConfig.confirmSend;
+    }
+    if (Object.hasOwn(parsedConfig, "enabled")) {
+      if (typeof parsedConfig.enabled !== "boolean") {
+        throw new Error(`"enabled" must be a boolean`);
+      }
+      config.enabled = parsedConfig.enabled;
+    }
+    if (Object.hasOwn(parsedConfig, "replyHint")) {
+      if (typeof parsedConfig.replyHint !== "boolean") {
+        throw new Error(`"replyHint" must be a boolean`);
+      }
+      config.replyHint = parsedConfig.replyHint;
+    }
+    if (Object.hasOwn(parsedConfig, "status")) {
+      if (typeof parsedConfig.status !== "string") {
+        throw new Error(`"status" must be a string`);
+      }
+      config.status = parsedConfig.status;
+    }
+    if (Object.hasOwn(parsedConfig, "inboundForkHandlers")) {
+      if (typeof parsedConfig.inboundForkHandlers !== "object" || parsedConfig.inboundForkHandlers === null || Array.isArray(parsedConfig.inboundForkHandlers)) {
+        throw new Error(`"inboundForkHandlers" must be an object`);
+      }
+      const forkConfig = parsedConfig.inboundForkHandlers;
+      config.inboundForkHandlers = { ...defaults.inboundForkHandlers };
+      if (Object.hasOwn(forkConfig, "enabled")) {
+        if (typeof forkConfig.enabled !== "boolean") throw new Error(`"inboundForkHandlers.enabled" must be a boolean`);
+        config.inboundForkHandlers.enabled = forkConfig.enabled;
+      }
+      if (Object.hasOwn(forkConfig, "when")) {
+        if (forkConfig.when !== "auto" && forkConfig.when !== "busy" && forkConfig.when !== "always") throw new Error(`"inboundForkHandlers.when" must be "auto", "busy", or "always"`);
+        config.inboundForkHandlers.when = forkConfig.when;
+      }
+      if (Object.hasOwn(forkConfig, "notify")) {
+        if (forkConfig.notify !== "ack-and-summary" && forkConfig.notify !== "summary" && forkConfig.notify !== "none") throw new Error(`"inboundForkHandlers.notify" must be "ack-and-summary", "summary", or "none"`);
+        config.inboundForkHandlers.notify = forkConfig.notify;
+      }
+      if (Object.hasOwn(forkConfig, "piCommand")) {
+        if (typeof forkConfig.piCommand !== "string") throw new Error(`"inboundForkHandlers.piCommand" must be a string`);
+        const piCommand = forkConfig.piCommand.trim();
+        if (piCommand) config.inboundForkHandlers.piCommand = piCommand;
+      }
+      if (Object.hasOwn(forkConfig, "triggerParentOnSummary")) {
+        const triggerParentOnSummary = forkConfig.triggerParentOnSummary;
+        if (typeof triggerParentOnSummary !== "boolean" && triggerParentOnSummary !== "auto") {
+          throw new Error(`"inboundForkHandlers.triggerParentOnSummary" must be a boolean or "auto"`);
+        }
+        config.inboundForkHandlers.triggerParentOnSummary = triggerParentOnSummary;
+      }
+    }
+    return config;
+  } catch (error) {
+    console.error(`Failed to load intercom config at ${configPath}:`, error);
+    return { ...defaults };
+  }
+}
+
+// claude/team.ts
+import { PARTICIPANT_STATES, TERMINAL_PARTICIPANT_STATES } from "@ctliz/agent-intercom-core/boss";
+var BOSS_NONTERMINAL_STATES = new Set(
+  PARTICIPANT_STATES.filter((state) => !TERMINAL_PARTICIPANT_STATES.includes(state))
+);
+
+// claude/runtime.ts
+function formatAttachments(attachments) {
+  if (!attachments?.length) return "";
+  return attachments.map((attachment) => {
+    if (attachment.language) {
+      return `
+
+---
+Attachment: ${attachment.name}
+~~~${attachment.language}
+${attachment.content}
+~~~`;
+    }
+    return `
+
+---
+Attachment: ${attachment.name}
+${attachment.content}`;
+  }).join("");
+}
+function formatSessionDisplay(session) {
+  const name = session.name || session.id;
+  return session.origin === "remote" ? `${name} [remote:${session.remoteHostId || "unknown-host"}]` : name;
+}
+
+// claude/contact.ts
+import { spawn as spawn3, spawnSync as spawnSync2 } from "node:child_process";
+function formatContactInstruction(current, sessions) {
+  const name = current.name?.trim();
+  const duplicate = Boolean(name && sessions.some((session) => session.id !== current.id && session.name?.trim().toLowerCase() === name.toLowerCase()));
+  return name && !duplicate ? `Intercom target: ${name}
+Stable session ID: ${current.id}` : `Intercom target: ${current.id}`;
+}
+function copyTextToClipboard(text) {
+  const candidates = process.platform === "darwin" ? [["pbcopy", []]] : process.platform === "win32" ? [["clip.exe", []]] : [
+    ...process.env.WAYLAND_DISPLAY ? [["wl-copy", []]] : [],
+    ...process.env.DISPLAY ? [["xclip", ["-selection", "clipboard"]], ["xsel", ["--clipboard", "--input"]]] : [],
+    ["clip.exe", []]
+  ];
+  for (const [command, args] of candidates) {
+    if (spawnSync2("which", [command], { stdio: "ignore" }).status !== 0) continue;
+    if (command === "wl-copy") {
+      const child = spawn3(command, args, { stdio: ["pipe", "ignore", "ignore"] });
+      child.stdin.end(text);
+      child.unref();
+      return true;
+    }
+    if (spawnSync2(command, args, { input: text, stdio: ["pipe", "ignore", "ignore"] }).status === 0) return true;
+  }
+  return false;
+}
+
+// claude/worker-daemon.ts
+var MAX_WAKES_PER_MINUTE = 20;
+function formatWorkerActivity(activity) {
+  const sender = formatSessionDisplay(activity.from);
+  if (activity.type === "started") {
+    return `
+[intercom] Wake from ${sender}: ${activity.message.content.text}
+[intercom] Claude is working\u2026
+`;
+  }
+  if (activity.type === "completed") {
+    const result = activity.result || "(Claude finished without a final message)";
+    return `[intercom] Completed wake from ${sender} (session ${activity.sessionId ?? "none"})
+${result}
+`;
+  }
+  return `[intercom] Wake from ${sender} failed: ${activity.error}
+`;
+}
+function reportToTerminal(activity) {
+  process.stderr.write(formatWorkerActivity(activity));
+}
+function formatMessage(from, message, agent) {
+  const replyInstruction = message.expectsReply ? [
+    "",
+    "",
+    "The sender is blocking on your reply.",
+    "Your FINAL assistant message will be sent back to them automatically as the reply.",
+    "Do not try to use intercom tools to answer; just put your answer in your final message."
+  ].join("\n") : "";
+  const attachments = formatAttachments(message.content.attachments);
+  const custom = agent.instructions ? `
+
+Agent instructions:
+${agent.instructions}` : "";
+  return [
+    `Intercom message for ${agent.name}.`,
+    `From: ${formatSessionDisplay(from)} (${from.id})`,
+    `Message id: ${message.id}`,
+    "",
+    message.content.text,
+    attachments,
+    custom,
+    replyInstruction
+  ].join("\n");
+}
+var VirtualClaudeAgent = class {
+  constructor(agent, state, statePath, claudeCommand, reportActivity = reportToTerminal, runTurn = runClaudeTurn, options = {}) {
+    this.agent = agent;
+    this.state = state;
+    this.statePath = statePath;
+    this.claudeCommand = claudeCommand;
+    this.reportActivity = reportActivity;
+    this.runTurn = runTurn;
+    const scopeId = options.scopeId === void 0 ? intercomScopeIdFromEnvForRegistration(options.env ?? process.env) : parseIntercomScopeIdForRegistration(options.scopeId);
+    const scopeEnv = scopeId === void 0 ? {} : { [INTERCOM_SCOPE_ENV]: scopeId };
+    this.client = options.client ?? new IntercomClient({ env: scopeEnv });
+    this.sessionId = agent.sessionId ?? state.agents[agent.id]?.sessionId ?? null;
+    this.prepareConnection = options.prepareConnection ?? (async () => {
+      const config = loadConfig();
+      await spawnBrokerIfNeeded(config.brokerCommand, config.brokerArgs);
+    });
+    this.reconnectDelays = options.reconnectDelays?.length ? options.reconnectDelays : [250, 500, 1e3, 2e3, 5e3];
+  }
+  agent;
+  state;
+  statePath;
+  claudeCommand;
+  reportActivity;
+  runTurn;
+  client;
+  sessionId;
+  messageQueue = Promise.resolve();
+  wakeTimestamps = [];
+  connectPromise = null;
+  reconnectTimer = null;
+  reconnectAttempt = 0;
+  reconnectEnabled = true;
+  intercomStartedAt = Date.now();
+  prepareConnection;
+  reconnectDelays;
+  get id() {
+    return this.agent.id;
+  }
+  async copyContact() {
+    const sessions = await this.client.listSessions();
+    const current = sessions.find((session) => session.id === this.client.sessionId);
+    const text = current ? formatContactInstruction(current, sessions) : `Intercom target: ${this.client.sessionId ?? this.agent.id}`;
+    return copyTextToClipboard(text) ? `Copied ${text.replace(/\n/g, "; ")}` : `Clipboard unavailable. ${text.replace(/\n/g, "; ")}`;
+  }
+  async listPeers() {
+    const sessions = await this.client.listSessions();
+    return sessions.filter((session) => session.id !== this.client.sessionId);
+  }
+  async sendMessage(to, text) {
+    const sessions = await this.client.listSessions();
+    const normalized = to.toLowerCase();
+    const matches = sessions.filter(
+      (session) => session.id === to || session.id.startsWith(to) || session.name?.toLowerCase() === normalized
+    );
+    if (matches.length > 1) {
+      throw new Error(`Multiple intercom sessions match "${to}"; choose a full ID.`);
+    }
+    const target = matches[0]?.id ?? to;
+    const result = await this.client.send(target, { text });
+    if (!result.delivered) {
+      throw new Error(result.reason ?? `Intercom session "${to}" is unavailable.`);
+    }
+    return `Message sent to ${matches[0]?.name || to}.`;
+  }
+  async start() {
+    this.reconnectEnabled = true;
+    this.client.on("message", (from, message, deliveryId) => {
+      this.routeMessage(from, message);
+      this.client.acknowledgeMessage(deliveryId);
+    });
+    this.client.on("error", (error) => {
+      process.stderr.write(`worker ${this.agent.id}: ${error.message}
+`);
+    });
+    this.client.on("disconnected", () => {
+      this.scheduleReconnect();
+    });
+    await this.connectIntercom();
+  }
+  async connectIntercom() {
+    this.clearReconnectTimer();
+    if (this.client.isConnected()) return;
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = (async () => {
+      await this.prepareConnection();
+      await this.client.connect({
+        name: this.agent.name,
+        cwd: this.agent.cwd,
+        model: this.agent.model ?? "claude",
+        pid: process.pid,
+        startedAt: this.intercomStartedAt,
+        lastActivity: Date.now(),
+        status: "idle"
+      }, this.agent.id);
+      this.reconnectAttempt = 0;
+    })();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  scheduleReconnect() {
+    if (!this.reconnectEnabled || this.reconnectTimer) return;
+    const delay = this.reconnectDelays[Math.min(this.reconnectAttempt, this.reconnectDelays.length - 1)];
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connectIntercom().then(() => {
+        if (!this.client.isConnected()) {
+          this.reconnectAttempt += 1;
+          this.scheduleReconnect();
+        }
+      }).catch((error) => {
+        this.reconnectAttempt += 1;
+        process.stderr.write(`worker ${this.agent.id}: reconnect failed: ${error instanceof Error ? error.message : String(error)}
+`);
+        this.scheduleReconnect();
+      });
+    }, delay);
+    this.reconnectTimer.unref?.();
+  }
+  clearReconnectTimer() {
+    if (!this.reconnectTimer) return;
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+  async stop() {
+    this.reconnectEnabled = false;
+    this.clearReconnectTimer();
+    if (this.connectPromise) {
+      try {
+        await this.connectPromise;
+      } catch {
+      }
+    }
+    await this.client.disconnect();
+  }
+  routeMessage(from, message) {
+    if (this.isRateLimited()) {
+      process.stderr.write(`worker ${this.agent.id}: rate limited, dropping message from ${from.id}
+`);
+      if (message.expectsReply) {
+        void this.client.send(from.id, {
+          text: "This worker is rate limited (too many wakes this minute). Please try again shortly.",
+          replyTo: message.id
+        }).catch((error) => {
+          process.stderr.write(`worker ${this.agent.id}: rate-limit reply failed: ${error instanceof Error ? error.message : String(error)}
+`);
+        });
+      }
+      return;
+    }
+    this.messageQueue = this.messageQueue.catch(() => void 0).then(() => this.handleMessage(from, message));
+  }
+  isRateLimited() {
+    const now = Date.now();
+    this.wakeTimestamps = this.wakeTimestamps.filter((timestamp) => now - timestamp < 6e4);
+    if (this.wakeTimestamps.length >= MAX_WAKES_PER_MINUTE) return true;
+    this.wakeTimestamps.push(now);
+    return false;
+  }
+  async handleMessage(from, message) {
+    try {
+      const prompt = formatMessage(from, message, this.agent);
+      this.client.updatePresence({ status: "active" });
+      this.reportActivity({ type: "started", agent: this.agent, from, message });
+      const result = await this.runTurn({
+        prompt,
+        cwd: this.agent.cwd,
+        sessionId: this.sessionId ?? void 0,
+        model: this.agent.model,
+        appendSystemPrompt: this.agent.instructions,
+        // Historical worker configs omitted both permission fields. Preserve
+        // their noninteractive behavior; hardened roles are normalized to an
+        // explicit plan mode before a VirtualClaudeAgent can be constructed.
+        permissionMode: this.agent.permissionMode ?? "bypassPermissions",
+        dangerouslySkipPermissions: this.agent.dangerouslySkipPermissions,
+        permissionCeiling: this.agent.permissionCeiling,
+        addDirs: this.agent.addDirs,
+        mcpConfig: this.agent.mcpConfig,
+        claudeCommand: this.claudeCommand,
+        extraArgs: this.agent.claudeArgs
+      });
+      if (result.sessionId && result.sessionId !== this.sessionId) {
+        this.sessionId = result.sessionId;
+        this.state.agents[this.agent.id] = { sessionId: result.sessionId, updatedAt: Date.now() };
+        saveWorkerState(this.statePath, this.state);
+      }
+      if (result.isError) {
+        const text = result.result || "Claude exited with an error and no message";
+        this.client.updatePresence({ status: `error: ${text}` });
+        this.reportActivity({ type: "error", agent: this.agent, from, message, error: text });
+      } else {
+        this.client.updatePresence({ status: "idle" });
+        this.reportActivity({
+          type: "completed",
+          agent: this.agent,
+          from,
+          message,
+          result: result.result,
+          sessionId: this.sessionId
+        });
+      }
+      if (message.expectsReply) {
+        await this.client.send(from.id, {
+          text: result.result || "(the worker finished without a final message)",
+          replyTo: message.id
+        });
+        process.stderr.write(`worker ${this.agent.id}: replied to ${from.name || from.id} (session ${this.sessionId ?? "none"})
+`);
+      }
+    } catch (error) {
+      const text = error instanceof Error ? error.message : String(error);
+      this.client.updatePresence({ status: `error: ${text}` });
+      this.reportActivity({ type: "error", agent: this.agent, from, message, error: text });
+      if (message.expectsReply) {
+        await this.client.send(from.id, {
+          text: `Worker error: ${text}`,
+          replyTo: message.id
+        }).catch((sendError) => {
+          process.stderr.write(`worker ${this.agent.id}: error reply failed: ${sendError instanceof Error ? sendError.message : String(sendError)}
+`);
+        });
+      }
+    }
+  }
+};
+var ClaudeWorkerDaemon = class {
+  constructor(config, reportActivity = reportToTerminal, options = {}) {
+    this.config = config;
+    this.reportActivity = reportActivity;
+    this.scopeId = options.scopeId === void 0 ? intercomScopeIdFromEnvForRegistration(options.env ?? process.env) : parseIntercomScopeIdForRegistration(options.scopeId);
+  }
+  config;
+  reportActivity;
+  agents = [];
+  scopeId;
+  async start() {
+    const intercomConfig = loadConfig();
+    await spawnBrokerIfNeeded(intercomConfig.brokerCommand, intercomConfig.brokerArgs);
+    const state = loadWorkerState(this.config.statePath);
+    const claudeCommand = this.config.claudeCommand ?? "claude";
+    this.agents = this.config.agents.map((agent) => {
+      const transport = resolveClaudeIntercomTransport({
+        requested: agent.transport,
+        claudeCommand
+      });
+      process.stderr.write(`worker ${agent.id}: ${transport.selected} transport (${transport.reason})
+`);
+      return new VirtualClaudeAgent(
+        { ...agent, transport: transport.selected },
+        state,
+        this.config.statePath,
+        claudeCommand,
+        this.reportActivity,
+        runClaudeTurn,
+        { scopeId: this.scopeId }
+      );
+    });
+    for (const agent of this.agents) await agent.start();
+    process.stderr.write(`claude-intercom worker running ${this.agents.length} agent(s)
+`);
+  }
+  async stop() {
+    for (const agent of this.agents) await agent.stop().catch(() => void 0);
+  }
+  async copyPrimaryContact() {
+    if (!this.agents[0]) throw new Error("No Claude intercom agent is running");
+    return this.agents[0].copyContact();
+  }
+  async listPrimaryPeers() {
+    if (!this.agents[0]) throw new Error("No Claude intercom agent is running");
+    return this.agents[0].listPeers();
+  }
+  async sendFromPrimary(to, text) {
+    if (!this.agents[0]) throw new Error("No Claude intercom agent is running");
+    return this.agents[0].sendMessage(to, text);
+  }
+};
+async function main() {
+  intercomScopeIdFromEnvForRegistration(process.env);
+  const configPath = process.argv.includes("--config") ? process.argv[process.argv.indexOf("--config") + 1] : void 0;
+  const config = loadWorkerConfig(configPath);
+  if (!config.agents.length) throw new Error("Worker config must include at least one agent");
+  const daemon = new ClaudeWorkerDaemon(config);
+  const stop = () => {
+    void daemon.stop().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  await daemon.start();
+  await once(process, "SIGTERM");
+}
+function invokedFileBasename() {
+  try {
+    return process.argv[1] ? basename(realpathSync2(process.argv[1])) : "";
+  } catch {
+    return process.argv[1] ? basename(process.argv[1]) : "";
+  }
+}
+if (invokedFileBasename() === "worker-daemon.ts" || invokedFileBasename() === "worker-daemon.mjs") {
+  void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  ClaudeWorkerDaemon,
+  VirtualClaudeAgent,
+  formatWorkerActivity
+};