@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/src/pi-intercom/broker/snapshots.ts

@@ -0,0 +1,241 @@
+import { randomUUID } from "node:crypto";
+import { isRecord, type UnknownRecord } from "../../shared/unknown.ts";
+import {
+  isTopicUpdate,
+  isTopicSubscription,
+  type SessionInfo,
+  type TopicUpdate,
+  type Message,
+  type BrokerMessage,
+  type TopicSubscription,
+  type SendResult,
+} from "../types.ts";
+import { validateIntercomMessageSize } from "./framing.ts";
+
+/** Direct messages and old clients receive identity, not potentially large topic state. */
+export function messageSender(info: SessionInfo): SessionInfo {
+  const { topics: _topics, subscriptions: _subscriptions, ...identity } = info;
+  return identity;
+}
+
+function topicFrames(requestId: string, info: SessionInfo): BrokerMessage[] {
+  const frames: BrokerMessage[] = [
+    {
+      type: "sessions",
+      requestId,
+      sessions: [
+        {
+          ...messageSender(info),
+          ...(info.topics ? { topics: [] } : {}),
+          ...(info.subscriptions ? { subscriptions: [] } : {}),
+        },
+      ],
+      more: true,
+    },
+  ];
+  for (const topic of info.topics ?? []) {
+    frames.push({
+      type: "sessions",
+      requestId,
+      sessions: [{ id: info.id, topics: [topic] }],
+      more: true,
+    });
+  }
+  for (const subscription of info.subscriptions ?? []) {
+    frames.push({
+      type: "sessions",
+      requestId,
+      sessions: [{ id: info.id, subscriptions: [subscription] }],
+      more: true,
+    });
+  }
+  return frames;
+}
+
+export function snapshotFrames(
+  requestId: string,
+  infos: readonly SessionInfo[],
+  stream: boolean,
+): BrokerMessage[] {
+  // ponytail: one record per frame; pack records only if measured socket overhead warrants it.
+  const frames: BrokerMessage[] = stream
+    ? [
+        ...infos.flatMap((info) => topicFrames(requestId, info)),
+        { type: "sessions", requestId, sessions: [], more: false },
+      ]
+    : [{ type: "sessions", requestId, sessions: infos.map(messageSender) }];
+  for (const frame of frames) {
+    const error = validateIntercomMessageSize(frame);
+    if (error) {
+      throw error;
+    }
+  }
+  return frames;
+}
+
+type TopicMutation =
+  | { readonly kind: "publication"; readonly topic: TopicUpdate; readonly publish: boolean }
+  | { readonly kind: "subscription"; readonly subscription: TopicSubscription }
+  | { readonly kind: "unsubscribe"; readonly topic: string };
+
+function validPublication(topic: unknown): TopicUpdate {
+  if (!isTopicUpdate(topic) || topic.text.trim().length === 0) {
+    throw new Error("Invalid topic publication");
+  }
+  if (
+    topic.event === "release" &&
+    ((topic.resource ?? "").length === 0 || topic.ownership !== "released")
+  ) {
+    throw new Error("Invalid topic publication");
+  }
+  return topic;
+}
+
+function topicMutation(change: UnknownRecord): TopicMutation {
+  if (change.action === "publish") {
+    return { kind: "publication", topic: validPublication(change.topic), publish: true };
+  }
+  if (change.action === "restore" && isTopicUpdate(change.topic)) {
+    return { kind: "publication", topic: validPublication(change.topic), publish: false };
+  }
+  if (
+    (change.action === "subscribe" || change.action === "restore") &&
+    isTopicSubscription(change.subscription)
+  ) {
+    return { kind: "subscription", subscription: change.subscription };
+  }
+  if (change.action === "unsubscribe" && typeof change.topic === "string") {
+    return { kind: "unsubscribe", topic: change.topic };
+  }
+  throw new Error("Invalid topic change");
+}
+
+function publicationUpdate(
+  topic: TopicUpdate,
+  previous: TopicUpdate | undefined,
+  publish: boolean,
+): TopicUpdate {
+  const revision = publish
+    ? Math.max(previous?.revision ?? 0, topic.revision - 1) + 1
+    : topic.revision;
+  if (!Number.isSafeInteger(revision) || revision <= 0) {
+    throw new Error("Invalid topic revision");
+  }
+  return { ...topic, revision };
+}
+
+class TopicSnapshot {
+  private readonly info: SessionInfo;
+  private readonly topics: Map<string, TopicUpdate>;
+  private readonly subscriptions: Map<string, TopicSubscription>;
+
+  constructor(info: SessionInfo) {
+    this.info = info;
+    this.topics = new Map((info.topics ?? []).map((topic) => [topic.topic, topic]));
+    this.subscriptions = new Map((info.subscriptions ?? []).map((entry) => [entry.topic, entry]));
+  }
+
+  apply(mutation: TopicMutation): TopicUpdate | undefined {
+    switch (mutation.kind) {
+      case "publication": {
+        const previous = this.topics.get(mutation.topic.topic);
+        const update = publicationUpdate(mutation.topic, previous, mutation.publish);
+        if (mutation.publish || (previous?.revision ?? 0) < update.revision) {
+          this.topics.set(update.topic, update);
+        }
+        if (mutation.publish) {
+          return update;
+        }
+        return;
+      }
+      case "subscription":
+        this.subscriptions.set(mutation.subscription.topic, mutation.subscription);
+        return;
+      case "unsubscribe":
+        this.subscriptions.delete(mutation.topic);
+        return;
+    }
+  }
+
+  snapshot(publication?: TopicUpdate): SessionInfo {
+    return {
+      ...this.info,
+      topics: [...this.topics.values()],
+      subscriptions: [...this.subscriptions.values()],
+      ...(publication ? { lastIntercomActivity: Date.now() } : {}),
+    };
+  }
+}
+
+/** Prepare a change without mutating the usable broker snapshot before frame validation. */
+export function prepareTopicChange(
+  info: SessionInfo,
+  change: unknown,
+  supported: boolean,
+): {
+  readonly info: SessionInfo;
+  readonly publication?: TopicUpdate;
+  readonly restore: boolean;
+} {
+  if (change === undefined) {
+    return { info, restore: false };
+  }
+  if (!supported || !isRecord(change)) {
+    throw new Error("Topic snapshots unavailable for this client");
+  }
+  const pending = new TopicSnapshot(info);
+  const publication = pending.apply(topicMutation(change));
+  return {
+    info: pending.snapshot(publication),
+    restore: change.action === "restore",
+    ...(publication ? { publication } : {}),
+  };
+}
+
+export function deliveryAcknowledgement(receipt: SendResult): BrokerMessage {
+  if (!receipt.accepted) {
+    return {
+      type: "delivery_failed",
+      messageId: receipt.id,
+      reason: receipt.reason ?? "Delivery failed",
+    };
+  }
+  if (receipt.queued === true) {
+    return {
+      type: "delivery_queued",
+      messageId: receipt.id,
+      reason: receipt.reason ?? "Queued for replace-mode delivery",
+    };
+  }
+  return { type: "delivered", messageId: receipt.id };
+}
+
+export function shouldReplaceDelivery(message: Message, info: SessionInfo): boolean {
+  if (
+    message.delivery !== "queue" ||
+    message.queueMode !== "replace" ||
+    (message.threadId ?? "").length === 0
+  ) {
+    return false;
+  }
+  const status = info.status ?? "";
+  return (
+    message.expectsReply === true ||
+    ((status === "idle" || status.startsWith("idle ")) && info.acceptsAsks !== false)
+  );
+}
+
+export function publicationMessage(publication: TopicUpdate, awaitRelease: boolean): Message {
+  const urgent =
+    publication.event === "blocker" ||
+    publication.event === "decision" ||
+    (publication.event === "release" && awaitRelease);
+  return {
+    id: randomUUID(),
+    timestamp: Date.now(),
+    topic: publication,
+    content: { text: publication.text },
+    delivery: urgent ? "steer" : "queue",
+    ...(urgent ? {} : { queueMode: "replace", threadId: `topic:${publication.topic}` }),
+  };
+}

package/src/pi-intercom/broker/spawn.ts

@@ -7,6 +7,7 @@ import net from "net";
 import { getPiAgentDir } from "../agent-dir.ts";
 import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.ts";
 import { isBrokerPidReused } from "./pid.ts";
+import { errorMessage, hasErrorCode } from "../../shared/unknown.ts";
 
 const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
@@ -14,20 +15,24 @@ const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
 const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
 
 function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
-function usesLegacyTsxDefault(brokerCommand: string, brokerArgs: string[]): boolean {
-  return brokerCommand === "npx"
-    && brokerArgs.length === 2
-    && brokerArgs[0] === "--no-install"
-    && brokerArgs[1] === "tsx";
+function usesLegacyTsxDefault(brokerCommand: string, brokerArgs: readonly string[]): boolean {
+  return (
+    brokerCommand === "npx" &&
+    brokerArgs.length === 2 &&
+    brokerArgs[0] === "--no-install" &&
+    brokerArgs[1] === "tsx"
+  );
 }
 
 export function getBrokerLaunchSpec(
   brokerPath: string,
   brokerCommand: string,
-  brokerArgs: string[],
+  brokerArgs: readonly string[],
 ): { command: string; args: string[] } {
   if (usesLegacyTsxDefault(brokerCommand, brokerArgs)) {
     return {
@@ -57,10 +62,13 @@ export function getBrokerSpawnOptions(): {
 }
 
 function toError(error: unknown): Error {
-  return error instanceof Error ? error : new Error(String(error));
+  return error instanceof Error ? error : new Error(errorMessage(error));
 }
 
-export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: string[]): Promise<void> {
+export async function spawnBrokerIfNeeded(
+  brokerCommand: string,
+  brokerArgs: readonly string[],
+): Promise<void> {
   await mkdir(INTERCOM_DIR, { recursive: true });
 
   if (await isBrokerRunning()) {
@@ -93,14 +101,14 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
         child.off("exit", onExit);
       };
 
-      const onError = (error: Error) => {
+      const onError = (error: Readonly<Error>) => {
         cleanup();
         reject(new Error(`Failed to spawn intercom broker: ${error.message}`, { cause: error }));
       };
 
       const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
         cleanup();
-        if (signal) {
+        if (signal !== null) {
           reject(new Error(`Intercom broker exited before startup with signal ${signal}`));
           return;
         }
@@ -109,13 +117,15 @@ export async function spawnBrokerIfNeeded(brokerCommand: string, brokerArgs: str
 
       child.once("error", onError);
       child.once("exit", onExit);
-      waitForBroker().then(() => {
-        cleanup();
-        resolve();
-      }, (error) => {
-        cleanup();
-        reject(toError(error));
-      });
+      waitForBroker()
+        .then(() => {
+          cleanup();
+          resolve();
+        })
+        .catch((error: unknown) => {
+          cleanup();
+          reject(toError(error));
+        });
     });
   } finally {
     releaseSpawnLock();
@@ -127,7 +137,9 @@ export async function isBrokerRunning(): Promise<boolean> {
 }
 
 function readLivePid(): number | null {
-  if (!existsSync(BROKER_PID)) return null;
+  if (!existsSync(BROKER_PID)) {
+    return null;
+  }
   let raw: string;
   try {
     raw = readFileSync(BROKER_PID, "utf-8");
@@ -135,27 +147,37 @@ function readLivePid(): number | null {
     return null;
   }
   const pid = parseInt(raw.trim(), 10);
-  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return null;
+  }
   try {
     process.kill(pid, 0);
   } catch (error) {
-    return (error as NodeJS.ErrnoException).code === "EPERM" ? pid : null;
+    return hasErrorCode(error, "EPERM") ? pid : null;
   }
   return isBrokerPidReused(pid, raw) ? null : pid;
 }
 
 export async function stopUnhealthyBrokerBeforeSpawn(): Promise<void> {
-  if (await checkSocketConnectable()) return;
+  if (await checkSocketConnectable()) {
+    return;
+  }
   const pid = readLivePid();
-  if (pid === null) return;
-  throw new Error(`Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`);
+  if (pid === null) {
+    return;
+  }
+  throw new Error(
+    `Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`,
+  );
 }
 
 async function checkSocketConnectable(): Promise<boolean> {
   const preferred = getBrokerSocketPath();
-  if (isOwnedBrokerSocket(preferred) && await checkOneSocket(preferred)) return true;
+  if (isOwnedBrokerSocket(preferred) && (await checkOneSocket(preferred))) {
+    return true;
+  }
   const legacy = getLegacyBrokerSocketPath();
-  return legacy !== preferred && isOwnedBrokerSocket(legacy) && await checkOneSocket(legacy);
+  return legacy !== preferred && isOwnedBrokerSocket(legacy) && (await checkOneSocket(legacy));
 }
 
 function checkOneSocket(brokerSocket: string): Promise<boolean> {
@@ -173,7 +195,7 @@ function checkOneSocket(brokerSocket: string): Promise<boolean> {
     socket.on("connect", onConnect);
     socket.on("error", onError);
     const timeout = setTimeout(() => finish(false), 1000);
-    timeout.unref?.();
+    timeout.unref();
   });
 }
 
@@ -184,15 +206,11 @@ function acquireSpawnLock(): boolean {
       writeFileSync(BROKER_SPAWN_LOCK, `${process.pid}\n${Date.now()}\n`, { flag: "wx" });
       return true;
     } catch (error) {
-      if (!(error instanceof Error) || (error as NodeJS.ErrnoException).code !== "EEXIST") {
+      if (!hasErrorCode(error, "EEXIST")) {
         throw error;
       }
       if (isSpawnLockStale()) {
-        try {
-          unlinkSync(BROKER_SPAWN_LOCK);
-        } catch {
-          // If we can't delete the stale lock, retry a few times before giving up
-        }
+        releaseSpawnLock();
         continue;
       }
       return false;
@@ -207,7 +225,9 @@ function isSpawnLockStale(): boolean {
   }
 
   try {
-    const [pidLine = "", createdAtLine = "0"] = readFileSync(BROKER_SPAWN_LOCK, "utf-8").trim().split("\n");
+    const [pidLine = "", createdAtLine = "0"] = readFileSync(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;
@@ -239,9 +259,13 @@ function releaseSpawnLock(): void {
 async function waitForBroker(timeoutMs = 5000): Promise<void> {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
+    // Each probe must finish before the next to avoid parallel socket attempts.
+    // oxlint-disable-next-line no-await-in-loop
     if (await checkSocketConnectable()) {
       return;
     }
+    // Polling waits between probes rather than starting an unbounded batch.
+    // oxlint-disable-next-line no-await-in-loop
     await sleep(100);
   }
   throw new Error("Broker failed to start within timeout");

package/src/pi-intercom/config.ts

@@ -1,41 +1,29 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { Key, type KeyId } from "@earendil-works/pi-tui";
 import { getPiAgentDir } from "./agent-dir.ts";
+import { isRecord, isUnknownArray } from "./validation.ts";
 
 export interface IntercomConfig {
   /** Toggle owned agents, or open peer messaging when the agent view is unavailable. */
-  shortcut: KeyId;
-
-  /** Broker command used to spawn the broker process (for example, Node 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;
-
-  /** Show reply hint in incoming messages (default: true) */
-  replyHint: boolean;
-
-  /** How long ordinary intercom `ask` waits for a reply before giving up, in ms (default: 120000 = 2 minutes). */
-  askTimeoutMs: number;
-
-  /** How long the client waits for the broker to acknowledge message delivery, in ms (default: 8000). */
-  sendTimeoutMs: number;
-
-  /** How long the client waits for a session list response, in ms (default: 5000). */
-  listTimeoutMs: number;
-}
-
-function getConfigPath(): string {
-  return join(getPiAgentDir(), "intercom", "config.json");
+  readonly shortcut: KeyId;
+  /** Broker command used to spawn the broker process (for example, Node or Bun). */
+  readonly brokerCommand: string;
+  /** Arguments passed to the broker command before the broker script path. */
+  readonly brokerArgs: readonly string[];
+  /** Require confirmation before non-reply sends from interactive sessions. */
+  readonly confirmSend: boolean;
+  /** Optional custom status suffix shown after automatic lifecycle status. */
+  readonly status?: string;
+  /** Show reply hint in incoming messages (default: true). */
+  readonly replyHint: boolean;
+  /** Ordinary ask reply timeout, in milliseconds (default: 120000 = 2 minutes). */
+  readonly askTimeoutMs: number;
+  /** Broker delivery acknowledgement timeout, in milliseconds (default: 8000). */
+  readonly sendTimeoutMs: number;
+  /** Session list response timeout, in milliseconds (default: 5000). */
+  readonly listTimeoutMs: number;
 }
-
 const defaults: IntercomConfig = {
   shortcut: Key.altShift("m"),
   brokerCommand: process.execPath,
@@ -46,95 +34,112 @@ const defaults: IntercomConfig = {
   sendTimeoutMs: 8000,
   listTimeoutMs: 5000,
 };
-
 const namedKeys = new Set<string>(Object.values(Key).filter((key) => typeof key === "string"));
 function isShortcut(value: string): value is KeyId {
   const prefix = value.match(/^(?:(?:ctrl|shift|alt|super)\+)+/)?.[0] ?? "";
   const modifiers = prefix.split("+").filter(Boolean);
   const key = value.slice(prefix.length);
-  return new Set(modifiers).size === modifiers.length && (namedKeys.has(key) || /^[a-z0-9]$/.test(key));
+  return (
+    new Set(modifiers).size === modifiers.length && (namedKeys.has(key) || /^[a-z0-9]$/.test(key))
+  );
+}
+function configuredString(
+  parsed: Readonly<Record<string, unknown>>,
+  key: "brokerCommand" | "status",
+): string | undefined {
+  if (!Object.hasOwn(parsed, key)) {
+    return defaults[key];
+  }
+  const value = parsed[key];
+  if (typeof value !== "string") {
+    throw new Error(`"${key}" must be a string`);
+  }
+  if (key === "status") {
+    return value;
+  }
+  if (value.trim() === "") {
+    throw new Error('"brokerCommand" must not be empty');
+  }
+  return value.trim();
+}
+function brokerCommand(parsed: Readonly<Record<string, unknown>>): string {
+  return configuredString(parsed, "brokerCommand") ?? defaults.brokerCommand;
+}
+function configuredShortcut(parsed: Readonly<Record<string, unknown>>): KeyId {
+  if (!Object.hasOwn(parsed, "shortcut")) {
+    return defaults.shortcut;
+  }
+  if (typeof parsed.shortcut !== "string") {
+    throw new Error('"shortcut" must be a native key identifier');
+  }
+  const shortcut = parsed.shortcut.trim();
+  if (!isShortcut(shortcut)) {
+    throw new Error('"shortcut" must be a native key identifier, for example alt+shift+m');
+  }
+  return shortcut;
+}
+function configuredArgs(parsed: Readonly<Record<string, unknown>>): readonly string[] {
+  if (!Object.hasOwn(parsed, "brokerArgs")) {
+    return defaults.brokerArgs;
+  }
+  if (!isUnknownArray(parsed.brokerArgs)) {
+    throw new Error('"brokerArgs" must be an array');
+  }
+  return parsed.brokerArgs.map((arg) => {
+    if (typeof arg !== "string") {
+      throw new Error('"brokerArgs" items must be strings');
+    }
+    return arg;
+  });
+}
+function configuredBoolean(
+  parsed: Readonly<Record<string, unknown>>,
+  key: "confirmSend" | "replyHint",
+): boolean {
+  if (!Object.hasOwn(parsed, key)) {
+    return defaults[key];
+  }
+  const value = parsed[key];
+  if (typeof value !== "boolean") {
+    throw new Error(`"${key}" must be a boolean`);
+  }
+  return value;
+}
+function configuredTimeout(
+  parsed: Readonly<Record<string, unknown>>,
+  key: "askTimeoutMs" | "sendTimeoutMs" | "listTimeoutMs",
+): number {
+  if (!Object.hasOwn(parsed, key)) {
+    return defaults[key];
+  }
+  const value = parsed[key];
+  const min = key === "askTimeoutMs" ? 1000 : 500;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min) {
+    throw new Error(`"${key}" must be a finite number >= ${min}`);
+  }
+  return value;
 }
-
 export function loadConfig(): IntercomConfig {
-  const configPath = getConfigPath();
+  const configPath = join(getPiAgentDir(), "intercom", "config.json");
   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)) {
+    const parsed: unknown = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!isRecord(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, "shortcut")) {
-      if (typeof parsedConfig.shortcut !== "string") throw new Error('"shortcut" must be a native key identifier');
-      const shortcut = parsedConfig.shortcut.trim();
-      if (!isShortcut(shortcut)) throw new Error('"shortcut" must be a native key identifier, for example alt+shift+m');
-      config.shortcut = shortcut;
-    }
-
-    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, "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;
-    }
-
-    for (const [key, min] of [["askTimeoutMs", 1000], ["sendTimeoutMs", 500], ["listTimeoutMs", 500]] as const) {
-      if (Object.hasOwn(parsedConfig, key)) {
-        const value = parsedConfig[key];
-        if (typeof value !== "number" || !Number.isFinite(value) || value < min) {
-          throw new Error(`"${key}" must be a finite number >= ${min}`);
-        }
-        config[key] = value;
-      }
-    }
-
-    return config;
+    return {
+      shortcut: configuredShortcut(parsed),
+      brokerCommand: brokerCommand(parsed),
+      brokerArgs: configuredArgs(parsed),
+      confirmSend: configuredBoolean(parsed, "confirmSend"),
+      replyHint: configuredBoolean(parsed, "replyHint"),
+      status: configuredString(parsed, "status"),
+      askTimeoutMs: configuredTimeout(parsed, "askTimeoutMs"),
+      sendTimeoutMs: configuredTimeout(parsed, "sendTimeoutMs"),
+      listTimeoutMs: configuredTimeout(parsed, "listTimeoutMs"),
+    };
   } catch (error) {
     console.error(`Failed to load intercom config at ${configPath}:`, error);
     return { ...defaults };