@ctliz/agent-intercom-codex 0.11.0-connect.2

package/codex/team.ts

@@ -0,0 +1,249 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDirPath } from "../broker/paths.ts";
+import {
+  BOSS_PARTICIPANT_ROLES,
+  parseParticipantState,
+  parseWorkerIdentityV2,
+  workerIdentityFromEnvironment,
+  type WorkerIdentityV2,
+} from "@ctliz/agent-intercom-core/boss";
+
+export interface TeamSession {
+  id: string;
+  name?: string;
+  boss?: {
+    binding?: {
+      bossRunId?: unknown;
+      participantId?: unknown;
+      bindingEpoch?: unknown;
+      role?: unknown;
+      sessionId?: unknown;
+      state?: unknown;
+    };
+    workerIdentity?: unknown;
+    participantState?: unknown;
+  };
+}
+
+interface StoredWorker {
+  id?: unknown;
+  runId?: unknown;
+  workerIncarnationId?: unknown;
+  workerGeneration?: unknown;
+  bossRunId?: unknown;
+  participantId?: unknown;
+  bindingEpoch?: unknown;
+  harness?: unknown;
+  role?: unknown;
+  state?: unknown;
+  owned?: unknown;
+  managerSessionId?: unknown;
+  intercomTarget?: unknown;
+  canonicalIdentity?: WorkerIdentityV2;
+}
+
+export interface TeamMember { id: string; target: string; harness?: string; role?: string; state?: string; connected: boolean; }
+export interface IntercomTeam { teamId?: string; self: { id: string; workerId?: string; isManager: boolean }; manager?: { target: string; connected: boolean }; coworkers: TeamMember[]; }
+
+const LEGACY_LIVE_STATES = new Set(["provisioning", "running", "idle", "needs_attention", "stopping"]);
+const CANONICAL_LIVE_STATES = new Set(["provisioning", "registering", "ready", "working", "waiting", "paused", "stalled", "blocked", "unreachable"]);
+const stringValue = (value: unknown): string | undefined => typeof value === "string" && value.trim() ? value.trim() : undefined;
+const connectedTo = (sessions: TeamSession[], target: string): boolean => {
+  const normalized = target.toLowerCase();
+  return sessions.some((session) => session.id === target || session.name?.toLowerCase() === normalized);
+};
+
+function bossIdentityFromEnvironment(env: NodeJS.ProcessEnv): WorkerIdentityV2 | undefined {
+  const bossKeys = ["AGENT_INTERCOM_BOSS_RUN_ID", "AGENT_INTERCOM_PARTICIPANT_ID", "AGENT_INTERCOM_BINDING_EPOCH"] as const;
+  if (!bossKeys.some((key) => env[key] !== undefined)) return undefined;
+  const identity = workerIdentityFromEnvironment(env);
+  if (!("bossRunId" in identity)) throw new Error("Incomplete Boss worker identity cannot discover a team");
+  return identity;
+}
+
+function canonicalWorker(value: unknown): StoredWorker {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("worker must be an object");
+  const worker = value as StoredWorker;
+  const identity = parseWorkerIdentityV2({
+    version: "orc.worker-identity.v2",
+    workerId: worker.id,
+    workerIncarnationId: worker.workerIncarnationId,
+    workerGeneration: worker.workerGeneration,
+    ...(worker.bossRunId === undefined ? {} : { bossRunId: worker.bossRunId }),
+    ...(worker.participantId === undefined ? {} : { participantId: worker.participantId }),
+    ...(worker.bindingEpoch === undefined ? {} : { bindingEpoch: worker.bindingEpoch }),
+  });
+  parseParticipantState(worker.state, "$.worker.state");
+  if (typeof worker.role !== "string" || !BOSS_PARTICIPANT_ROLES.includes(worker.role as never)) {
+    throw new Error("worker role is not canonical");
+  }
+  if (worker.owned !== true || !stringValue(worker.managerSessionId) || !stringValue(worker.intercomTarget)) {
+    throw new Error("canonical worker ownership routing is incomplete");
+  }
+  return { ...worker, canonicalIdentity: identity };
+}
+
+function exactBossRosterSession(sessions: TeamSession[], worker: StoredWorker): TeamSession | undefined {
+  const identity = worker.canonicalIdentity;
+  const target = stringValue(worker.intercomTarget);
+  const role = stringValue(worker.role);
+  const state = stringValue(worker.state);
+  if (!identity || !("bossRunId" in identity) || !target || !role || !state) return undefined;
+  const matches = sessions.filter((candidate) => candidate.id === target);
+  if (matches.length !== 1) return undefined;
+  const [session] = matches;
+  if (!session?.boss?.binding || session.boss.workerIdentity === undefined || session.boss.participantState === undefined) return undefined;
+  try {
+    const sessionIdentity = parseWorkerIdentityV2(session.boss.workerIdentity);
+    const sessionState = parseParticipantState(session.boss.participantState, "$.session.boss.participantState");
+    const binding = session.boss.binding;
+    return (
+      "bossRunId" in sessionIdentity
+      && session.id === target
+      && binding.sessionId === session.id
+      && binding.state === "active"
+      && binding.bossRunId === identity.bossRunId
+      && binding.participantId === identity.participantId
+      && binding.bindingEpoch === identity.bindingEpoch
+      && binding.role === role
+      && sessionIdentity.workerId === identity.workerId
+      && sessionIdentity.workerIncarnationId === identity.workerIncarnationId
+      && sessionIdentity.workerGeneration === identity.workerGeneration
+      && sessionIdentity.bossRunId === identity.bossRunId
+      && sessionIdentity.participantId === identity.participantId
+      && sessionIdentity.bindingEpoch === identity.bindingEpoch
+      && sessionState === state
+    ) ? session : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function readWorkers(agentDir: string): Promise<{ version: 1 | 2; workers: StoredWorker[] }> {
+  try {
+    const parsed: unknown = JSON.parse(await readFile(join(agentDir, "intercom", "orchestrator", "workers.json"), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("worker snapshot must be an object");
+    const snapshot = parsed as { version?: unknown; workers?: unknown };
+    if ((snapshot.version !== 1 && snapshot.version !== 2) || !Array.isArray(snapshot.workers)) throw new Error("unsupported worker snapshot version");
+    if (snapshot.version === 1) return { version: 1, workers: snapshot.workers as StoredWorker[] };
+    return { version: 2, workers: snapshot.workers.map(canonicalWorker) };
+  } catch {
+    return { version: 1, workers: [] };
+  }
+}
+
+export async function resolveIntercomTeam(input: { selfId: string; sessions: TeamSession[]; env?: NodeJS.ProcessEnv; agentDir?: string }): Promise<IntercomTeam> {
+  const env = input.env ?? process.env;
+  const snapshot = await readWorkers(input.agentDir ?? getAgentDirPath());
+  const workers = snapshot.workers;
+  const workerId = stringValue(env.AGENT_INTERCOM_WORKER_ID);
+  const bossIdentity = bossIdentityFromEnvironment(env);
+  const runId = stringValue(env.AGENT_INTERCOM_RUN_ID);
+  const currentMatches = workerId ? workers.filter((worker) => (
+    stringValue(worker.id) === workerId
+    && (bossIdentity === undefined
+      ? (!runId || stringValue(worker.runId) === runId)
+      : snapshot.version === 2
+        && worker.canonicalIdentity?.workerId === bossIdentity.workerId
+        && worker.canonicalIdentity.workerIncarnationId === bossIdentity.workerIncarnationId
+        && worker.canonicalIdentity.workerGeneration === bossIdentity.workerGeneration
+        && "bossRunId" in worker.canonicalIdentity
+        && "bossRunId" in bossIdentity
+        && worker.canonicalIdentity.bossRunId === bossIdentity.bossRunId
+        && worker.canonicalIdentity.participantId === bossIdentity.participantId
+        && worker.canonicalIdentity.bindingEpoch === bossIdentity.bindingEpoch)
+  )) : [];
+  const current = bossIdentity === undefined ? currentMatches[0] : currentMatches.length === 1 ? currentMatches[0] : undefined;
+  const currentTarget = stringValue(current?.intercomTarget);
+  const exactCurrentProjection = current !== undefined
+    && currentTarget === input.selfId
+    && workers.filter((worker) => stringValue(worker.id) === workerId).length === 1
+    && workers.filter((worker) => stringValue(worker.intercomTarget) === currentTarget).length === 1
+    && exactBossRosterSession(input.sessions, current) !== undefined;
+
+  // Privileged Boss discovery is rooted in one exact current worker/session
+  // projection. A substituted self ID, ambiguous ID/target, or stale binding
+  // never unlocks a roster assembled from ambient same-run records.
+  if (bossIdentity !== undefined && !exactCurrentProjection) {
+    return { self: { id: input.selfId, ...(workerId ? { workerId } : {}), isManager: false }, coworkers: [] };
+  }
+
+  const managerTarget = stringValue(current?.managerSessionId)
+    ?? (bossIdentity === undefined ? stringValue(env.AGENT_INTERCOM_MANAGER_TARGET) ?? stringValue(env.AGENT_INTERCOM_MANAGER_SESSION_ID) : undefined);
+  const teamId = managerTarget ?? input.selfId;
+  const currentRole = stringValue(current?.role);
+  const canDiscoverOwnedRoster = bossIdentity === undefined || currentRole === "manager" || currentRole === "controller";
+  const coworkers = (canDiscoverOwnedRoster ? workers : []).filter((worker) => worker.owned === true)
+    .filter((worker) => bossIdentity === undefined || (
+      snapshot.version === 2
+      && worker.canonicalIdentity !== undefined
+      && "bossRunId" in worker.canonicalIdentity
+      && "bossRunId" in bossIdentity
+      && worker.canonicalIdentity.bossRunId === bossIdentity.bossRunId
+    ))
+    .filter((worker) => stringValue(worker.managerSessionId) === teamId)
+    .filter((worker) => stringValue(worker.intercomTarget) !== managerTarget)
+    .filter((worker) => (snapshot.version === 2 ? CANONICAL_LIVE_STATES : LEGACY_LIVE_STATES).has(stringValue(worker.state) ?? ""))
+    .filter((worker) => stringValue(worker.id) !== workerId)
+    .map((worker): TeamMember | undefined => {
+      const id = stringValue(worker.id);
+      if (!id) return undefined;
+      const target = stringValue(worker.intercomTarget) ?? id;
+      const connected = bossIdentity === undefined
+        ? connectedTo(input.sessions, target)
+        : exactBossRosterSession(input.sessions, worker) !== undefined;
+      if (!connected) return undefined;
+      return {
+        id,
+        target,
+        ...(stringValue(worker.harness) ? { harness: stringValue(worker.harness) } : {}),
+        ...(stringValue(worker.role) ? { role: stringValue(worker.role) } : {}),
+        ...(stringValue(worker.state) ? { state: stringValue(worker.state) } : {}),
+        connected,
+      };
+    }).filter((member): member is TeamMember => Boolean(member));
+
+  const managerWorker = managerTarget === undefined
+    ? undefined
+    : workers.find((worker) => (
+      stringValue(worker.intercomTarget) === managerTarget
+      && (bossIdentity === undefined || (
+        snapshot.version === 2
+        && stringValue(worker.role) === "manager"
+        && worker.canonicalIdentity !== undefined
+        && "bossRunId" in worker.canonicalIdentity
+        && "bossRunId" in bossIdentity
+        && worker.canonicalIdentity.bossRunId === bossIdentity.bossRunId
+      ))
+    ));
+  const managerConnected = managerTarget === undefined
+    ? true
+    : bossIdentity === undefined
+      ? connectedTo(input.sessions, managerTarget)
+      : managerWorker !== undefined && exactBossRosterSession(input.sessions, managerWorker) !== undefined;
+  return {
+    teamId,
+    self: { id: input.selfId, ...(workerId ? { workerId } : {}), isManager: bossIdentity === undefined && !managerTarget },
+    ...(managerTarget
+      ? { manager: { target: managerTarget, connected: managerConnected } }
+      : bossIdentity === undefined ? { manager: { target: input.selfId, connected: true } } : {}),
+    coworkers,
+  };
+}
+
+export function formatIntercomTeam(team: IntercomTeam): string {
+  const lines = [
+    `Manager: ${team.manager ? `${team.manager.target} [${team.manager.connected ? "connected" : "not connected"}]` : "unknown"}`,
+    `You: ${team.self.workerId ?? team.self.id}${team.self.isManager ? " [manager]" : ""}`,
+  ];
+  if (!team.coworkers.length) lines.push("Coworkers: none");
+  else {
+    lines.push("Coworkers:");
+    for (const coworker of team.coworkers) {
+      const metadata = [coworker.harness, coworker.role, coworker.state].filter(Boolean).join(", ");
+      lines.push(`- ${coworker.id} target=${coworker.target}${metadata ? ` (${metadata})` : ""} [${coworker.connected ? "connected" : "not connected"}]`);
+    }
+  }
+  return lines.join("\n");
+}

package/codex/tui-input.ts

@@ -0,0 +1,174 @@
+import { StringDecoder } from "node:string_decoder";
+
+const ESC = "\x1b";
+const ALT_MODIFIER_BIT = 0b10;
+const LOCK_MODIFIER_BITS = 0b1100_0000;
+const DISALLOWED_MODIFIER_BITS = 0b0011_1101;
+const KEY_I = 105;
+const KEY_M = 109;
+
+export interface FilteredTuiInput {
+  forwarded: string;
+  pending: string;
+  altICount: number;
+  altMCount: number;
+}
+
+interface ShortcutMatch {
+  consume: boolean;
+  trigger: boolean;
+}
+
+function parseNumber(value: string | undefined): number | null {
+  if (!value || !/^\d+$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+
+function isAltOnlyModifier(encodedModifier: number): boolean {
+  const bits = encodedModifier - 1;
+  if (bits < 0 || (bits & ALT_MODIFIER_BIT) === 0) return false;
+  return (bits & DISALLOWED_MODIFIER_BITS) === 0
+    && (bits & ~(ALT_MODIFIER_BIT | LOCK_MODIFIER_BITS)) === 0;
+}
+
+function matchKittyAltKey(sequence: string, key: number): ShortcutMatch {
+  if (!sequence.endsWith("u")) return { consume: false, trigger: false };
+  const params = sequence.slice(2, -1).split(";");
+  if (params.length < 2) return { consume: false, trigger: false };
+
+  const keyParts = params[0].split(":");
+  const primaryKey = parseNumber(keyParts[0]);
+  const baseLayoutKey = parseNumber(keyParts[2]);
+  const modifierParts = params[1].split(":");
+  const modifier = parseNumber(modifierParts[0]);
+  const eventType = modifierParts[1] === undefined ? 1 : parseNumber(modifierParts[1]);
+  if (modifier === null || eventType === null || !isAltOnlyModifier(modifier)) {
+    return { consume: false, trigger: false };
+  }
+
+  if (primaryKey !== key && baseLayoutKey !== key) {
+    return { consume: false, trigger: false };
+  }
+
+  // Consume repeat/release events for the shortcut, but trigger only on press.
+  return { consume: true, trigger: eventType === 1 };
+}
+
+function matchModifyOtherKeysAltKey(sequence: string, expectedKey: number): ShortcutMatch {
+  if (!sequence.endsWith("~")) return { consume: false, trigger: false };
+  const params = sequence.slice(2, -1).split(";");
+  if (params.length !== 3 || params[0] !== "27") return { consume: false, trigger: false };
+  const modifier = parseNumber(params[1]);
+  const key = parseNumber(params[2]);
+  const matches = modifier !== null && key === expectedKey && isAltOnlyModifier(modifier);
+  return { consume: matches, trigger: matches };
+}
+
+function matchAltKeySequence(sequence: string, key: number): ShortcutMatch {
+  if (sequence === `${ESC}${String.fromCharCode(key)}`) return { consume: true, trigger: true };
+  if (!sequence.startsWith(`${ESC}[`)) return { consume: false, trigger: false };
+  if (sequence.endsWith("u")) return matchKittyAltKey(sequence, key);
+  if (sequence.endsWith("~")) return matchModifyOtherKeysAltKey(sequence, key);
+  return { consume: false, trigger: false };
+}
+
+function findCsiEnd(source: string, start: number): number {
+  for (let index = start + 2; index < source.length; index += 1) {
+    const code = source.charCodeAt(index);
+    if (code >= 0x40 && code <= 0x7e) return index;
+  }
+  return -1;
+}
+
+/**
+ * Remove semantic Alt+I key events while preserving all other terminal input.
+ * `pending` carries a partial escape sequence across input chunks.
+ */
+export function filterAltIInput(input: string, pending = ""): FilteredTuiInput {
+  const source = pending + input;
+  let forwarded = "";
+  let altICount = 0;
+  let altMCount = 0;
+  let index = 0;
+
+  while (index < source.length) {
+    if (source[index] !== ESC) {
+      forwarded += source[index];
+      index += 1;
+      continue;
+    }
+
+    if (index + 1 >= source.length) {
+      return { forwarded, pending: source.slice(index), altICount, altMCount };
+    }
+
+    if (source[index + 1] === "i") {
+      altICount += 1;
+      index += 2;
+      continue;
+    }
+    if (source[index + 1] === "m") {
+      altMCount += 1;
+      index += 2;
+      continue;
+    }
+
+    if (source[index + 1] !== "[") {
+      forwarded += source[index];
+      index += 1;
+      continue;
+    }
+
+    const end = findCsiEnd(source, index);
+    if (end === -1) {
+      return { forwarded, pending: source.slice(index), altICount, altMCount };
+    }
+
+    const sequence = source.slice(index, end + 1);
+    const altI = matchAltKeySequence(sequence, KEY_I);
+    const altM = matchAltKeySequence(sequence, KEY_M);
+    if (altI.consume || altM.consume) {
+      if (altI.trigger) altICount += 1;
+      if (altM.trigger) altMCount += 1;
+    } else {
+      forwarded += sequence;
+    }
+    index = end + 1;
+  }
+
+  return { forwarded, pending: "", altICount, altMCount };
+}
+
+/** UTF-8-safe stateful wrapper for terminal chunks and partial escape sequences. */
+export class TuiInputDecoder {
+  private readonly utf8 = new StringDecoder("utf8");
+  private pending = "";
+
+  write(chunk: Buffer | string): Omit<FilteredTuiInput, "pending"> {
+    const text = typeof chunk === "string" ? chunk : this.utf8.write(chunk);
+    const filtered = filterAltIInput(text, this.pending);
+    this.pending = filtered.pending;
+    return { forwarded: filtered.forwarded, altICount: filtered.altICount, altMCount: filtered.altMCount };
+  }
+
+  hasPendingEscape(): boolean {
+    return this.pending.length > 0;
+  }
+
+  flushPendingEscape(): string {
+    const pending = this.pending;
+    this.pending = "";
+    return pending;
+  }
+
+  end(): Omit<FilteredTuiInput, "pending"> {
+    const filtered = filterAltIInput(this.utf8.end(), this.pending);
+    this.pending = "";
+    return {
+      forwarded: filtered.forwarded + filtered.pending,
+      altICount: filtered.altICount,
+      altMCount: filtered.altMCount,
+    };
+  }
+}

package/config.ts

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+
+export const DEFAULT_ASK_TIMEOUT_MS = 45 * 1000;
+export const MAX_ASK_TIMEOUT_MS = 120 * 1000;
+
+export function validateAskTimeoutMs(value: unknown, name = "timeout_ms"): number {
+  if (!Number.isSafeInteger(value) || typeof value !== "number" || value <= 0) {
+    throw new Error(`${name} must be a positive integer number of milliseconds`);
+  }
+  if (value > MAX_ASK_TIMEOUT_MS) {
+    throw new Error(`${name} must be ${MAX_ASK_TIMEOUT_MS} ms or less; use intercom_send plus intercom_pending for longer-running work`);
+  }
+  return value;
+}
+
+export function getAskTimeoutMs(): number {
+  const raw = process.env.PI_INTERCOM_ASK_TIMEOUT_MS;
+  if (raw === undefined || raw.trim() === "") {
+    return DEFAULT_ASK_TIMEOUT_MS;
+  }
+
+  const value = Number(raw);
+  return validateAskTimeoutMs(value, "PI_INTERCOM_ASK_TIMEOUT_MS");
+}
+
+export interface InboundForkHandlersConfig {
+  /** Route inbound intercom messages to background fork handlers (default: true) */
+  enabled: boolean;
+
+  /** When to fork: automatically while parent is busy/queued, only while busy, or for all inbound messages */
+  when: "auto" | "busy" | "always";
+
+  /** Parent notification policy for launched handlers */
+  notify: "ack-and-summary" | "summary" | "none";
+
+  /** Optional Pi executable override for handler launch */
+  piCommand?: string;
+
+  /** Trigger a parent turn when the handler summary arrives (default: auto; ignored when notify is "none") */
+  triggerParentOnSummary: boolean | "auto";
+}
+
+export interface IntercomConfig {
+  /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
+  brokerCommand: string;
+
+  /** Arguments passed to the broker command before the broker script path */
+  brokerArgs: string[];
+
+  /** Require confirmation before non-reply sends from interactive sessions */
+  confirmSend: boolean;
+
+  /** Optional custom status suffix shown after automatic lifecycle status */
+  status?: string;
+
+  /** Enable/disable intercom (default: true) */
+  enabled: boolean;
+
+  /** Show reply hint in incoming messages (default: true) */
+  replyHint: boolean;
+
+  /** Optional inbound background fork-handler routing */
+  inboundForkHandlers: InboundForkHandlersConfig;
+}
+
+export function getConfigPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR
+    ? resolve(process.env.PI_CODING_AGENT_DIR)
+    : join(homedir(), ".pi", "agent");
+  return join(agentDir, "intercom", "config.json");
+}
+
+const defaults: IntercomConfig = {
+  brokerCommand: "npx",
+  brokerArgs: ["--no-install", "tsx"],
+  confirmSend: false,
+  enabled: true,
+  replyHint: true,
+  inboundForkHandlers: {
+    enabled: true,
+    when: "auto",
+    notify: "summary",
+    triggerParentOnSummary: "auto",
+  },
+};
+
+export function loadConfig(): IntercomConfig {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...defaults };
+  }
+
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Config must be a JSON object");
+    }
+
+    const parsedConfig = parsed as Record<string, unknown>;
+    const config: IntercomConfig = { ...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: string[] = [];
+      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 as Record<string, unknown>;
+      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 };
+  }
+}