@anhlp/alp-client 0.0.0-beta.1

package/dist/rpc/reconnect.js

@@ -0,0 +1,227 @@
+// packages/client/src/rpc/reconnect.js
+import { AlpRpcError, ERROR } from "@anhlp/alp-protocol";
+import { AlpRpcClient } from "./client.js";
+import { AlpClientError } from "./errors.js";
+function backoffDelay(attempt, { initialMs = 250, maxMs = 1e4, factor = 2, jitter = 0.2 } = {}, random = Math.random) {
+  const base = Math.min(maxMs, initialMs * factor ** Math.max(0, attempt - 1));
+  return Math.max(0, Math.round(base * (1 + jitter * (2 * random() - 1))));
+}
+function retryable(error) {
+  return !(error instanceof AlpRpcError && error.code === ERROR.protocol);
+}
+function controller() {
+  if (typeof globalThis.AbortController === "function") {
+    const native = new globalThis.AbortController();
+    return {
+      signal: (
+        /** @type {AbortSignalLike} */
+        native.signal
+      ),
+      /** @param {unknown} reason */
+      abort: (reason) => native.abort(reason)
+    };
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const signal = {
+    aborted: false,
+    /** @type {unknown} */
+    reason: void 0,
+    /** @param {'abort'} _type @param {() => void} listener */
+    addEventListener(_type, listener) {
+      listeners.add(listener);
+    },
+    /** @param {'abort'} _type @param {() => void} listener */
+    removeEventListener(_type, listener) {
+      listeners.delete(listener);
+    }
+  };
+  return {
+    signal,
+    /** @param {unknown} reason */
+    abort(reason) {
+      if (signal.aborted) return;
+      signal.aborted = true;
+      signal.reason = reason;
+      for (const listener of [...listeners]) listener();
+      listeners.clear();
+    }
+  };
+}
+function createReconnectingClient({ connect, onConnect, onDisconnect, backoff = {}, maxAttempts = Infinity, stableMs = 5e3, shouldRetry = retryable, client: clientOptions, random = Math.random }) {
+  if (typeof connect !== "function") throw new TypeError("createReconnectingClient needs connect()");
+  let state = "connecting";
+  let current;
+  let attempt = 0;
+  let connectedBefore = false;
+  let timer;
+  const run = controller();
+  const events = /* @__PURE__ */ new Set();
+  const notifications = /* @__PURE__ */ new Set();
+  const states = /* @__PURE__ */ new Set();
+  const waiters = /* @__PURE__ */ new Set();
+  const onListenerError = clientOptions?.onListenerError ?? ((error) => {
+    setTimeout(() => {
+      throw error;
+    }, 0);
+  });
+  const dispatch = (listener, ...args) => {
+    try {
+      listener(...args);
+    } catch (error) {
+      onListenerError(error);
+    }
+  };
+  const enter = (next, error) => {
+    state = next;
+    for (const listener of [...states]) {
+      dispatch(listener, next, error);
+      if (state !== next) return;
+    }
+    if (next === "open" && current) for (const waiter of [...waiters]) {
+      waiters.delete(waiter);
+      waiter.resolve(current);
+    }
+    if (next === "stopped") for (const waiter of [...waiters]) {
+      waiters.delete(waiter);
+      waiter.reject(error ?? new AlpClientError("ALP connection stopped", { reason: "closed" }));
+    }
+  };
+  const retry = (error) => {
+    if (state === "stopped") return;
+    if (attempt >= maxAttempts || !shouldRetry(error)) return enter("stopped", error);
+    enter("waiting", error);
+    if (state !== "waiting") return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      void open();
+    }, backoffDelay(attempt, backoff, random));
+  };
+  const open = async () => {
+    if (state === "stopped") return;
+    attempt++;
+    enter("connecting");
+    const { signal } = run;
+    if (state !== "connecting" || signal.aborted) return;
+    let candidate;
+    const closeCandidate = () => candidate?.close();
+    signal.addEventListener("abort", closeCandidate, { once: true });
+    try {
+      const transport = await connect({ attempt, signal });
+      if (signal.aborted) {
+        try {
+          transport.close();
+        } catch {
+        }
+        return;
+      }
+      candidate = new AlpRpcClient(transport, clientOptions);
+      candidate.onEvent((envelope) => {
+        for (const listener of [...events]) dispatch(listener, envelope);
+      });
+      candidate.onNotification((method, params) => {
+        for (const listener of [...notifications]) dispatch(listener, method, params);
+      });
+      if (onConnect) await onConnect(candidate, { attempt, reconnect: connectedBefore, signal });
+      if (signal.aborted) {
+        candidate.close();
+        return;
+      }
+      if (candidate.closed) throw new AlpClientError("ALP connection closed during onConnect", { reason: "disconnected" });
+    } catch (error) {
+      candidate?.close();
+      if (signal.aborted) return;
+      return retry(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      signal.removeEventListener("abort", closeCandidate);
+    }
+    const connected = (
+      /** @type {AlpRpcClient} */
+      candidate
+    );
+    current = connected;
+    const reconnect = connectedBefore;
+    connectedBefore = true;
+    const openedAt = Date.now();
+    connected.onClose((error) => {
+      if (current !== connected) return;
+      current = void 0;
+      if (Date.now() - openedAt >= stableMs) attempt = 0;
+      dispatch(() => onDisconnect?.(error, { reconnect }));
+      retry(error);
+    });
+    enter("open");
+  };
+  void open();
+  return {
+    get state() {
+      return state;
+    },
+    get client() {
+      return current;
+    },
+    get attempt() {
+      return attempt;
+    },
+    ready({ signal } = {}) {
+      if (state === "open" && current) return Promise.resolve(current);
+      if (state === "stopped") return Promise.reject(new AlpClientError("ALP connection stopped", { reason: "closed" }));
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          /** @param {AlpRpcClient} client */
+          resolve: (client) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(client);
+          },
+          /** @param {Error} error */
+          reject: (error) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(error);
+          }
+        };
+        const onAbort = () => {
+          waiters.delete(waiter);
+          reject(new AlpClientError("Waiting for the ALP connection was aborted", { reason: "aborted", cause: signal?.reason }));
+        };
+        if (signal?.aborted) return onAbort();
+        waiters.add(waiter);
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    },
+    request(method, params, options) {
+      if (state !== "open" || !current) return Promise.reject(new AlpClientError("ALP daemon connection closed", { reason: state === "stopped" ? "closed" : "disconnected" }));
+      return current.request(method, params, options);
+    },
+    onEvent(listener) {
+      events.add(listener);
+      return () => events.delete(listener);
+    },
+    onNotification(listener) {
+      notifications.add(listener);
+      return () => notifications.delete(listener);
+    },
+    onState(listener) {
+      states.add(listener);
+      return () => states.delete(listener);
+    },
+    stop() {
+      if (state === "stopped") return;
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      run.abort(new AlpClientError("ALP connection stopped", { reason: "closed" }));
+      const last = current;
+      current = void 0;
+      enter("stopped");
+      last?.close();
+      events.clear();
+      notifications.clear();
+      states.clear();
+    }
+  };
+}
+export {
+  backoffDelay,
+  createReconnectingClient,
+  retryable
+};

package/dist/rpc/timers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A timeout option as a setTimeout delay. `undefined` means no timer: no timeout given, Infinity,
+ * or a wait longer than any timer can (about 24.8 days). Anything that is not a non-negative
+ * number is a TypeError, so a typo cannot turn into an instant timeout.
+ * @param {unknown} value
+ * @param {string} [name]
+ * @returns {number | undefined}
+ */
+export function timerDelay(value: unknown, name?: string): number | undefined;
+/** The longest delay setTimeout honours; a longer one fires at once, in browsers, Node and Hermes. */
+export const MAX_TIMER_MS: 2147483647;

package/dist/rpc/timers.js

@@ -0,0 +1,11 @@
+// packages/client/src/rpc/timers.js
+var MAX_TIMER_MS = 2147483647;
+function timerDelay(value, name = "timeoutMs") {
+  if (value === void 0 || value === Infinity) return void 0;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 0) throw new TypeError(`${name} must be a non-negative number of milliseconds`);
+  return value > MAX_TIMER_MS ? void 0 : value;
+}
+export {
+  MAX_TIMER_MS,
+  timerDelay
+};

package/dist/service.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Where and how alpd for `home` is defined as a service on `platform`, or undefined
+ * where ALP has no service support. Each ALP_HOME gets its own service.
+ */
+export function serviceFor({ home, env, platform, uid }: {
+    home: any;
+    env?: NodeJS.ProcessEnv | undefined;
+    platform?: NodeJS.Platform | undefined;
+    uid?: number | undefined;
+}): {
+    kind: string;
+    name: string;
+    file: string;
+    install: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    start: (string | string[])[][];
+    uninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    afterUninstall?: undefined;
+} | {
+    kind: string;
+    name: string;
+    file: string;
+    install: (string | string[])[][];
+    start: (string | string[])[][];
+    uninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+    afterUninstall: (string | string[] | {
+        ignore: boolean;
+    })[][];
+} | undefined;
+/** The service definition that runs `entry` with `execPath` for `home`. */
+export function serviceDefinition(service: any, { home, entry, execPath, env }: {
+    home: any;
+    entry: any;
+    execPath?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}): string;
+/** The program an installed definition runs: [node, alpd.js], or undefined when it is not installed. */
+export function installedProgram(service: any): Promise<any[] | undefined>;
+/** Writes the definition and loads it, which starts alpd. */
+export function installService(service: any, options: any, run?: typeof runCommand): Promise<void>;
+/** Starts an installed service's alpd. */
+export function startService(service: any, run?: typeof runCommand): Promise<void>;
+/** Unloads the service, which stops its alpd, and removes the definition; false when none was installed. */
+export function uninstallService(service: any, run?: typeof runCommand): Promise<boolean>;
+import { runCommand } from './command.js';

package/dist/service.js

@@ -0,0 +1,143 @@
+// packages/client/src/service.js
+import { createHash } from "node:crypto";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { runCommand } from "./command.js";
+var CARRIED = ["ALP_RUN_LOG_DIR", "ALP_CODEX_BIN", "ALP_CLAUDE_BIN", "ALP_ANTIGRAVITY_BIN", "ALP_GH_BIN"];
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var quoteUnit = (value) => `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+function serviceFor({ home, env = process.env, platform = process.platform, uid = process.getuid?.() ?? 0 }) {
+  const custom = path.resolve(home) !== path.join(os.homedir(), ".alp");
+  const suffix = custom ? createHash("sha256").update(path.resolve(home)).digest("hex").slice(0, 8) : "";
+  if (platform === "darwin") {
+    const label = `com.alp.alpd${suffix ? `.${suffix}` : ""}`;
+    const directory = env.ALP_SERVICE_DIR || path.join(os.homedir(), "Library", "LaunchAgents");
+    const launchctl = env.ALP_LAUNCHCTL || "launchctl";
+    const target = `gui/${uid}/${label}`;
+    const file = path.join(directory, `${label}.plist`);
+    return {
+      kind: "launchd",
+      name: label,
+      file,
+      install: [[launchctl, ["bootout", target], { ignore: true }], [launchctl, ["bootstrap", `gui/${uid}`, file]]],
+      start: [[launchctl, ["kickstart", target]]],
+      uninstall: [[launchctl, ["bootout", target], { ignore: true }]]
+    };
+  }
+  if (platform === "linux") {
+    const name = `alpd${suffix ? `-${suffix}` : ""}`;
+    const directory = env.ALP_SERVICE_DIR || path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "systemd", "user");
+    const systemctl = env.ALP_SYSTEMCTL || "systemctl";
+    return {
+      kind: "systemd",
+      name,
+      file: path.join(directory, `${name}.service`),
+      install: [[systemctl, ["--user", "daemon-reload"]], [systemctl, ["--user", "enable", "--now", `${name}.service`]]],
+      start: [[systemctl, ["--user", "start", `${name}.service`]]],
+      uninstall: [[systemctl, ["--user", "disable", "--now", `${name}.service`], { ignore: true }]],
+      afterUninstall: [[systemctl, ["--user", "daemon-reload"], { ignore: true }]]
+    };
+  }
+  return void 0;
+}
+function serviceDefinition(service, { home, entry, execPath = process.execPath, env = process.env }) {
+  const variables = { ALP_HOME: path.resolve(home), PATH: env.PATH ?? "" };
+  for (const name of CARRIED) if (env[name]) variables[name] = env[name];
+  const program = [execPath, entry, "--service"];
+  const fatal = path.join(path.resolve(home), "logs", "alpd.service.log");
+  if (service.kind === "launchd") {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(service.name)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${program.map((arg) => `    <string>${escapeXml(arg)}</string>`).join("\n")}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+${Object.entries(variables).map(([key, value]) => `    <key>${escapeXml(key)}</key>
+    <string>${escapeXml(value)}</string>`).join("\n")}
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>Crashed</key>
+    <true/>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(fatal)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(fatal)}</string>
+</dict>
+</plist>
+`;
+  }
+  return `[Unit]
+Description=ALP daemon (alpd) for ${path.resolve(home)}
+
+[Service]
+ExecStart=${program.map(quoteUnit).join(" ")}
+${Object.entries(variables).map(([key, value]) => `Environment=${quoteUnit(`${key}=${value}`)}`).join("\n")}
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${fatal}
+StandardError=append:${fatal}
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function installedProgram(service) {
+  const text = await readFile(service.file, "utf8").catch(() => void 0);
+  if (text === void 0) return void 0;
+  if (service.kind === "launchd") {
+    const array = text.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/)?.[1] ?? "";
+    const unescape = (value) => value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+    return [...array.matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => unescape(match[1])).slice(0, 2);
+  }
+  const line = text.match(/^ExecStart=(.*)$/m)?.[1] ?? "";
+  return [...line.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1].replace(/\\(.)/g, "$1")).slice(0, 2);
+}
+async function runAll(steps, run) {
+  for (const [command, args, { ignore = false } = {}] of steps) {
+    const result = await run(command, args);
+    if (result.code !== 0 && !ignore) throw new Error(`${command} ${args.join(" ")} failed: ${(result.stderr || result.stdout).trim() || `exit ${result.code}`}`);
+  }
+}
+async function installService(service, options, run = runCommand) {
+  await mkdir(path.dirname(service.file), { recursive: true });
+  await mkdir(path.join(path.resolve(options.home), "logs"), { recursive: true, mode: 448 });
+  await writeFile(service.file, serviceDefinition(service, options), { mode: 420 });
+  await runAll(service.install, run);
+}
+async function startService(service, run = runCommand) {
+  await runAll(service.start, run);
+}
+async function uninstallService(service, run = runCommand) {
+  if (await installedProgram(service) === void 0) return false;
+  await runAll(service.uninstall, run);
+  await unlink(service.file).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+  await runAll(service.afterUninstall ?? [], run);
+  return true;
+}
+export {
+  installService,
+  installedProgram,
+  serviceDefinition,
+  serviceFor,
+  startService,
+  uninstallService
+};

package/dist/setup.d.ts

@@ -0,0 +1,2 @@
+/** Write Phở and Cafe's agent profiles into a project's .alp/settings.json, without installing software or calling models. */
+export function setup(args: any, home: any): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,146 @@
+// packages/client/src/setup.js
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { initProject } from "@anhlp/alp-core/init";
+import { MODELS } from "@anhlp/alp-core/models";
+import { fitEffort, modelEfforts } from "@anhlp/alp-core/profiles";
+import { resolveTeam } from "@anhlp/alp-core/teams";
+import { validateSettings } from "@anhlp/alp-core/validation";
+import { Cancelled, select, text } from "./prompt.js";
+var PROVIDERS = ["claude", "codex"];
+var PROVIDER_LABEL = { claude: "Claude", codex: "Codex" };
+var DEFAULTS = {
+  main: { claude: ["claude-opus-5-5", "high"], codex: ["gpt-6.1-sol", "high"] },
+  worker: { claude: ["claude-opus-5-5", "high"], codex: ["gpt-6.1-sol", "high"] },
+  supervisor: { claude: ["claude-sonnet-5", "medium"], codex: ["gpt-6-luna", "medium"] },
+  oracle: { claude: ["claude-fable-5-1", "high"], codex: ["gpt-6-astra", "high"] }
+};
+var FLAGS = { main: "model", worker: "model", supervisor: "supervisor", oracle: "oracle" };
+var SEAT_LABEL = { main: "main", worker: "lead, reviewer", supervisor: "supervisor", oracle: "oracle" };
+var ANY_EFFORT = ["low", "medium", "high", "xhigh", "max"];
+async function setup(args, home) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: Object.fromEntries(
+    ["runtime", "prefer", ...PROVIDERS.flatMap((provider) => Object.values(FLAGS).map((flag) => `${provider}-${flag}`))].map((name) => [name, { type: "string" }])
+  ) });
+  if (positionals.length > 1) throw new Error("setup takes at most one directory");
+  const root = path.resolve(positionals[0] ?? process.cwd());
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  try {
+    const runtime = values.runtime ?? (interactive ? await select({ message: "Runtime", initial: "mix", choices: [
+      { label: "Mix", value: "mix", hint: "Claude and Codex: main runs on one, the others can run on either" },
+      { label: "Codex only", value: "codex" },
+      { label: "Claude only", value: "claude" }
+    ] }) : void 0);
+    if (runtime === void 0) throw new Error("Pass --runtime codex, claude or mix when setup is not running in a terminal");
+    if (!["codex", "claude", "mix"].includes(runtime)) throw new Error("--runtime must be codex, claude or mix");
+    const prefer = values.prefer ?? (runtime !== "mix" ? runtime : interactive ? await select({ message: "Main runs on", initial: "claude", choices: [
+      { label: "Claude", value: "claude", hint: "Claude first for the others too" },
+      { label: "Codex", value: "codex", hint: "Codex first for the others too" }
+    ] }) : "claude");
+    if (!PROVIDERS.includes(prefer) || runtime !== "mix" && prefer !== runtime) throw new Error("--prefer must be an enabled runtime");
+    const enabled = runtime === "mix" ? [prefer, ...PROVIDERS.filter((provider) => provider !== prefer)] : [runtime];
+    for (const provider of PROVIDERS) {
+      for (const flag of Object.values(FLAGS)) {
+        if (!enabled.includes(provider) && values[`${provider}-${flag}`]) throw new Error(`--${provider}-${flag} is unavailable in ${runtime}-only mode`);
+      }
+    }
+    const seats = {};
+    for (const [seat, flag] of Object.entries(FLAGS)) {
+      seats[seat] = (seat === "main" ? [prefer] : enabled).map((provider) => {
+        const option = `${provider}-${flag}`;
+        const [fallback, effort] = DEFAULTS[seat][provider];
+        const model = nativeModel(values[option] ?? fallback, provider, `--${option}`);
+        return { provider, model, effort: fitEffort(`${provider}:${model}`, effort) };
+      });
+    }
+    const peers = enabled.map((provider) => `${provider}:*`);
+    const file = path.join(root, ".alp/settings.json");
+    const settings = await readFile(file, "utf8").then((content) => {
+      try {
+        return JSON.parse(content);
+      } catch (error) {
+        throw new Error(`${file} is not valid JSON: ${error.message}`);
+      }
+    }, (error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw new Error(`${file}: ${error.message}`);
+    });
+    const show = () => {
+      for (const [seat, choices] of Object.entries(seats)) console.log(`  ${SEAT_LABEL[seat]}: ${choices.map(describe).join(", ")}`);
+      console.log(`  peer: ${peers.join(", ")} (any model: whoever assigns a peer picks its model and effort for the task)`);
+    };
+    console.log(`Profiles for Ph\u1EDF and Cafe in ${file}:`);
+    show();
+    const replaced = ["pho", "cafe"].filter((id) => (settings?.team ?? settings?.profile)?.[id]);
+    if (replaced.length) console.log(`These replace the ${replaced.join(" and ")} profiles already in the file; a backup is kept in ${file}.bak.`);
+    if (interactive) {
+      for (; ; ) {
+        const next2 = await select({ message: "Save these profiles?", initial: "save", choices: [
+          { label: "Save", value: "save" },
+          { label: "Change a model", value: "change" },
+          { label: "Cancel", value: "cancel" }
+        ] });
+        if (next2 === "cancel") throw new Cancelled();
+        if (next2 === "save") break;
+        await change(seats);
+        show();
+      }
+    }
+    const profile = await profiles(root, home, seats, peers, settings);
+    validateSettings({ ...settings ?? {}, team: { ...settings?.profile ?? {}, ...settings?.team ?? {}, ...profile } }, file);
+    if (!settings) await initProject(root, { library: home });
+    else if (replaced.length) await copyFile(file, `${file}.bak`);
+    const written = settings ?? JSON.parse(await readFile(file, "utf8"));
+    const next = { ...written, team: { ...written.profile ?? {}, ...written.team ?? {}, ...profile } };
+    delete next.profile;
+    await writeFile(file, JSON.stringify(next, null, 2) + "\n");
+    console.log("Setup saved. New sessions in this project use these profiles; edit the file to change one agent. Run alp doctor to check that each CLI is installed and logged in.");
+  } catch (error) {
+    if (!(error instanceof Cancelled)) throw error;
+    console.log(error.message);
+  }
+}
+var describe = (choice) => `${choice.provider}:${choice.model}${choice.effort ? `:${choice.effort}` : ""}`;
+async function change(seats) {
+  const [seat, at] = await select({ message: "Which model?", choices: Object.entries(seats).flatMap(([seat2, choices]) => choices.map((choice, at2) => ({ label: `${SEAT_LABEL[seat2]} \xB7 ${PROVIDER_LABEL[choice.provider]}`, value: [seat2, at2], hint: describe(choice) }))) });
+  const current = seats[seat][at];
+  const offered = MODELS.filter((model2) => model2.runtime === current.provider);
+  const picked = await select({ message: `${SEAT_LABEL[seat]} on ${PROVIDER_LABEL[current.provider]}`, initial: current.model, choices: [
+    ...offered.map((model2) => ({ label: model2.label, value: model2.id, hint: `${model2.id} \xB7 ${model2.description}` })),
+    { label: "Other\u2026", value: void 0, hint: "type a model ID" }
+  ] });
+  const model = picked ?? nativeModel(await text(`${PROVIDER_LABEL[current.provider]} model ID:`), current.provider, "The model ID");
+  const efforts = modelEfforts(`${current.provider}:${model}`) ?? ANY_EFFORT;
+  const effort = efforts.length > 1 ? await select({
+    message: "Effort",
+    initial: efforts.includes(current.effort) ? current.effort : DEFAULTS[seat][current.provider][1],
+    choices: efforts.map((effort2) => ({ label: effort2, value: effort2 }))
+  }) : efforts[0];
+  seats[seat][at] = { provider: current.provider, model, ...effort ? { effort } : {} };
+}
+async function profiles(root, home, seats, peers, settings) {
+  const profile = {};
+  for (const id of ["pho", "cafe"]) {
+    const team = await resolveTeam(root, id, { library: home });
+    const agents = {};
+    const seat = (name, choices) => {
+      agents[name] = { profiles: choices.map((choice) => typeof choice === "string" ? choice : describe(choice)), autocompact: (settings?.team ?? settings?.profile)?.[id]?.[name]?.autocompact ?? "auto" };
+    };
+    for (const [name, member] of Object.entries(team.members)) {
+      if (name !== "oracle") seat(name, name === team.main ? seats.main : member.role === "peer" ? peers : seats.worker);
+    }
+    if (team.supervisor) seat(team.supervisor.agent, seats.supervisor);
+    if (team.members.oracle) seat("oracle", seats.oracle);
+    profile[id] = agents;
+  }
+  return profile;
+}
+function nativeModel(id, provider, where) {
+  const model = id.startsWith(`${provider}:`) ? id.slice(provider.length + 1) : id;
+  if (!model || /\s/.test(model) || /^(codex|claude):/.test(model) || model.includes(":") && !id.startsWith(`${provider}:`)) throw new Error(`${where} expects a ${provider} model, got '${id}'`);
+  return model;
+}
+export {
+  setup
+};

package/dist/supervise.d.ts

@@ -0,0 +1,12 @@
+export function holdDaemon(home: string, by?: string): Promise<void>;
+export function releaseHold(home: string): Promise<void>;
+export function daemonHeld(home: string): Promise<boolean>;
+export function startDaemon(options: { home: string; entry?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number }): Promise<string>;
+export function superviseDaemon(options: {
+  home: string;
+  entry?: string | (() => string | undefined);
+  env?: NodeJS.ProcessEnv;
+  intervalMs?: number;
+  misses?: number;
+  log?: (message: string) => void;
+}): (() => Promise<void>) & { started: Promise<void> };