@agentprojectcontext/apx 1.15.6 → 1.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.15.6",
+  "version": "1.17.0",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"
@@ -10,11 +10,13 @@
   "bin": {
     "apx": "./src/cli/index.js",
     "apx-daemon": "./src/daemon/index.js",
-    "apx-mcp": "./src/mcp/index.js"
+    "apx-mcp": "./src/mcp/index.js",
+    "apx-ng": "./dist/cli/index.js"
   },
   "files": [
     "src/",
     "skills/",
+    "dist/",
     "README.md"
   ],
   "engines": {
@@ -24,28 +26,66 @@
     "start": "node src/daemon/index.js",
     "smoke": "node src/daemon/smoke.js",
     "test": "node --test --test-reporter=spec tests/*.test.js",
+    "build": "node scripts/build-cli.js",
+    "build:watch": "node scripts/build-cli.js --watch",
+    "typecheck": "tsc --noEmit -p tsconfig.cli.json",
     "upgrade": "pnpm install && pnpm add -g .",
     "prepack": "node scripts/sync-apc-skill.js",
     "postinstall": "node src/cli/postinstall.js"
   },
   "packageManager": "pnpm@10.25.0",
   "dependencies": {
+    "@langchain/anthropic": "^0.3.34",
+    "@langchain/community": "^0.3.59",
+    "@langchain/core": "^0.3.80",
+    "@langchain/ollama": "^0.2.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentui/core": "^0.2.8",
+    "@opentui/keymap": "^0.2.8",
+    "@opentui/solid": "^0.2.8",
+    "@solid-primitives/event-bus": "^1.1.3",
+    "@solid-primitives/keyboard": "^1.3.5",
+    "@solid-primitives/scheduled": "^1.5.3",
+    "ansi-regex": "^6.2.2",
     "chalk": "^5.6.2",
     "cli-cursor": "^5.0.0",
+    "cli-sound": "^1.1.3",
+    "clipboardy": "^5.3.1",
     "cron-parser": "^5.5.0",
+    "effect": "^3.21.2",
     "express": "^4.21.0",
-    "node-fetch": "^3.3.2"
+    "fuzzysort": "^3.1.0",
+    "jsonc-parser": "^3.3.1",
+    "langchain": "^0.3.37",
+    "node-fetch": "^3.3.2",
+    "open": "^11.0.0",
+    "opentui-spinner": "^0.0.6",
+    "react": "^19.2.6",
+    "remeda": "^2.34.1",
+    "semver": "^7.8.0",
+    "solid-js": "^1.9.12",
+    "strip-ansi": "^7.2.0",
+    "yargs": "^18.0.0",
+    "zod": "^3.25.76"
   },
   "optionalDependencies": {
     "fast-glob": "^3.3.2",
-    "puppeteer": "^22.0.0"
+    "puppeteer": "^22.0.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@babel/core": "^7.29.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
+    "@types/node": "^25.7.0",
+    "@types/yargs": "^17.0.35",
+    "babel-preset-solid": "^1.9.12",
     "better-sqlite3": "^11.3.0",
-    "conventional-changelog-conventionalcommits": "^9.3.1"
+    "conventional-changelog-conventionalcommits": "^9.3.1",
+    "electron": "^33.4.11",
+    "esbuild": "^0.28.0",
+    "esbuild-plugin-solid": "^0.6.0",
+    "typescript": "^6.0.3"
   },
   "keywords": [
     "apc",
@@ -59,6 +99,7 @@
   "pnpm": {
     "onlyBuiltDependencies": [
       "better-sqlite3",
+      "electron",
       "puppeteer"
     ]
   },

package/src/cli/commands/log.js

@@ -0,0 +1,113 @@
+// apx log — read the unified daemon log (~/.apx/logs/apx.log)
+//
+//   apx log            tail last 100 lines
+//   apx log --tail N   tail last N lines
+//   apx log -f         follow (tail -f)
+//   apx log --follow   same as -f
+//   apx log --errors   only show [ERROR] lines (works with --tail / -f too)
+//
+// Every line written through core/logging.js or the daemon's log() lands
+// here, regardless of which module produced it (telegram, whisper, super-agent…).
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const APX_LOG_PATH = path.join(os.homedir(), ".apx", "logs", "apx.log");
+const ERROR_TRACE_PATH = path.join(os.homedir(), ".apx", "logs", "errors.jsonl");
+
+const c = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  green: "\x1b[32m", red: "\x1b[31m", yellow: "\x1b[33m",
+  cyan: "\x1b[36m", gray: "\x1b[90m", white: "\x1b[97m",
+};
+const colorize = (line) =>
+  line
+    .replace(/^\[([\d-]+\s[\d:.]+)\]/, (_m, ts) => `[${c.gray}${ts}${c.reset}]`)
+    .replace(/\[ERROR\s*\]/, `[${c.red}ERROR${c.reset}]`)
+    .replace(/\[WARN\s*\]/, `[${c.yellow}WARN ${c.reset}]`)
+    .replace(/\[INFO\s*\]/, `[${c.cyan}INFO ${c.reset}]`)
+    .replace(/\[([a-z_-]+)\]/i, (_m, mod) => `[${c.bold}${mod}${c.reset}]`);
+
+function readLastLines(file, n) {
+  if (!fs.existsSync(file)) return [];
+  const content = fs.readFileSync(file, "utf8");
+  return content.split("\n").filter(Boolean).slice(-n);
+}
+
+function shouldShow(line, opts) {
+  if (opts.errors) return /\[ERROR\s*\]/.test(line);
+  return true;
+}
+
+export async function cmdLog(args = {}) {
+  const flags = args.flags || {};
+  const follow = !!(flags.follow || flags.f);
+  const errorsOnly = !!flags.errors;
+  const tail = flags.tail ? parseInt(flags.tail, 10) : 100;
+
+  // --errors without an explicit log file inspects both the unified log AND
+  // the structured errors.jsonl, since some surfaces (api routes) only emit
+  // there. We surface a small banner when we hit the structured file.
+  if (!fs.existsSync(APX_LOG_PATH)) {
+    console.log(`${c.gray}  (no log yet at ${APX_LOG_PATH})${c.reset}`);
+    if (errorsOnly && fs.existsSync(ERROR_TRACE_PATH)) {
+      console.log(`${c.gray}  showing structured errors from ${ERROR_TRACE_PATH}:${c.reset}\n`);
+      const traces = readLastLines(ERROR_TRACE_PATH, tail);
+      for (const t of traces) {
+        try {
+          const j = JSON.parse(t);
+          console.log(`${c.gray}[${j.ts}]${c.reset} ${c.red}ERROR${c.reset} ${c.bold}${j.surface || "api"}${c.reset} ${j.route || ""} ${j.error?.message || ""}`);
+        } catch { console.log(t); }
+      }
+    }
+    return;
+  }
+
+  const lines = readLastLines(APX_LOG_PATH, tail);
+  const filtered = lines.filter((l) => shouldShow(l, { errors: errorsOnly }));
+  for (const line of filtered) {
+    console.log(colorize(line));
+  }
+
+  if (errorsOnly && fs.existsSync(ERROR_TRACE_PATH)) {
+    const traces = readLastLines(ERROR_TRACE_PATH, tail);
+    if (traces.length > 0) {
+      console.log(`\n${c.gray}── structured errors (${ERROR_TRACE_PATH}) ──${c.reset}`);
+      for (const t of traces) {
+        try {
+          const j = JSON.parse(t);
+          console.log(`${c.gray}[${j.ts}]${c.reset} ${c.red}ERROR${c.reset} ${c.bold}${j.surface || "api"}${c.reset} ${j.route || ""} ${j.error?.message || ""}`);
+        } catch { console.log(t); }
+      }
+    }
+  }
+
+  if (!follow) return;
+
+  // tail -f mode. fs.watch on macOS sometimes loses events on heavy writes,
+  // so we also poll size every 500ms as a safety net.
+  let currentSize = fs.statSync(APX_LOG_PATH).size;
+
+  const drain = () => {
+    let newSize;
+    try { newSize = fs.statSync(APX_LOG_PATH).size; }
+    catch { return; }
+    if (newSize === currentSize) return;
+    if (newSize < currentSize) { currentSize = newSize; return; } // truncated/rotated
+    const fd = fs.openSync(APX_LOG_PATH, "r");
+    const buf = Buffer.alloc(newSize - currentSize);
+    fs.readSync(fd, buf, 0, buf.length, currentSize);
+    fs.closeSync(fd);
+    currentSize = newSize;
+    const chunkLines = buf.toString("utf8").split("\n").filter(Boolean);
+    for (const l of chunkLines) {
+      if (shouldShow(l, { errors: errorsOnly })) console.log(colorize(l));
+    }
+  };
+
+  try { fs.watch(APX_LOG_PATH, () => drain()); } catch {}
+  const poll = setInterval(drain, 500);
+  // Keep process alive
+  return new Promise(() => { void poll; });
+}

package/src/cli/commands/overlay.js

@@ -0,0 +1,253 @@
+// apx overlay — launch/manage the floating voice overlay window.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { http } from "../http.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+
+const OVERLAY_MAIN  = path.resolve(__dirname, "../../overlay/main.js");
+const OVERLAY_PID   = path.join(os.homedir(), ".apx", "overlay.pid");
+
+// ── ANSI ─────────────────────────────────────────────────────────────────────
+const c = { reset:"\x1b[0m", bold:"\x1b[1m", dim:"\x1b[2m", green:"\x1b[32m",
+            red:"\x1b[31m", yellow:"\x1b[33m", cyan:"\x1b[36m", gray:"\x1b[90m" };
+const fmt = {
+  bold:(s)=>`${c.bold}${s}${c.reset}`, dim:(s)=>`${c.dim}${s}${c.reset}`,
+  green:(s)=>`${c.green}${s}${c.reset}`, red:(s)=>`${c.red}${s}${c.reset}`,
+  cyan:(s)=>`${c.cyan}${s}${c.reset}`,  gray:(s)=>`${c.gray}${s}${c.reset}`,
+};
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function readPid() {
+  try { return parseInt(fs.readFileSync(OVERLAY_PID, "utf8").trim(), 10); } catch { return null; }
+}
+function writePid(pid) {
+  fs.mkdirSync(path.dirname(OVERLAY_PID), { recursive: true });
+  fs.writeFileSync(OVERLAY_PID, String(pid));
+}
+function clearPid() { try { fs.unlinkSync(OVERLAY_PID); } catch {} }
+function pidAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function findElectron() {
+  // 1. Local node_modules (pnpm/npm install electron)
+  const candidates = [
+    path.resolve(__dirname, "../../../node_modules/.bin/electron"),
+    path.resolve(__dirname, "../../../node_modules/electron/cli.js"),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  // 2. Global electron
+  try {
+    const which = execFileSync("which", ["electron"], { stdio: ["ignore","pipe","ignore"] }).toString().trim();
+    if (which) return which;
+  } catch {}
+  // 3. npx electron
+  return null;
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+export async function cmdOverlayStart(args = {}) {
+  const debug = !!(args.debug || args.d);
+
+  const pid = readPid();
+  if (pidAlive(pid)) {
+    if (debug) {
+      console.log(`\n  ${fmt.cyan("●")} Overlay already running ${fmt.dim("pid " + pid)} — stop it first with: apx overlay stop\n`);
+      return;
+    }
+    console.log(`\n  ${fmt.cyan("●")} Overlay already running ${fmt.dim("pid " + pid)}\n`);
+    return;
+  }
+  clearPid();
+
+  if (!fs.existsSync(OVERLAY_MAIN)) {
+    console.error(`\n  ${fmt.red("✗")} Overlay app not found at ${fmt.dim(OVERLAY_MAIN)}\n`);
+    process.exit(1);
+  }
+
+  const electronBin = findElectron();
+  if (!electronBin) {
+    console.error(
+      `\n  ${fmt.red("✗")} Electron not found.\n` +
+      `  Install it with:  ${fmt.cyan("pnpm add -D electron")}\n` +
+      `  or globally:      ${fmt.cyan("npm install -g electron")}\n`
+    );
+    process.exit(1);
+  }
+
+  // Get daemon port from running daemon or env
+  let daemonPort = process.env.APX_PORT || "7430";
+  try {
+    const health = await http.get("/health").catch(() => null);
+    if (health?.port) daemonPort = String(health.port);
+  } catch {}
+
+  const isScript = electronBin.endsWith(".js");
+  const cmd  = isScript ? process.execPath : electronBin;
+  const argv = isScript
+    ? [electronBin, OVERLAY_MAIN, "--port", daemonPort]
+    : [OVERLAY_MAIN, "--port", daemonPort];
+
+  const logFile = path.join(os.homedir(), ".apx", "overlay.log");
+
+  if (debug) {
+    // ── Debug mode: start overlay normally, then tail -f the log ─────────
+    // Truncate log so we only see fresh output
+    try { fs.writeFileSync(logFile, `--- APX Overlay debug started ${new Date().toISOString()} ---\n`); } catch {}
+
+    const logFd = fs.openSync(logFile, "a");
+    const child = spawn(cmd, argv, {
+      detached: false,
+      stdio: ["ignore", logFd, logFd],
+      env: { ...process.env, ELECTRON_ENABLE_LOGGING: "1" },
+    });
+    fs.closeSync(logFd);
+
+    if (child.pid) writePid(child.pid);
+
+    // Small pause so Electron writes its first lines before we tail
+    await new Promise(r => setTimeout(r, 600));
+
+    console.log(
+      `\n  ${fmt.cyan("◉")} ${fmt.bold("APX Overlay")} ${fmt.yellow("[DEBUG]")}` +
+      `  pid ${child.pid}  port ${daemonPort}` +
+      `\n  ${fmt.dim("Tailing:")} ${logFile}` +
+      `\n  ${fmt.dim("Press Ctrl+C to stop tailing (overlay keeps running).")}\n`
+    );
+
+    // Tail the log file live — read new bytes as they arrive
+    const logStream = fs.createReadStream(logFile, { encoding: "utf8", start: 0 });
+    logStream.pipe(process.stdout);
+
+    // After initial content, watch for new data
+    const watcher = fs.watch(logFile, () => {});
+    let pos = fs.statSync(logFile).size;
+    const interval = setInterval(() => {
+      const stat = fs.statSync(logFile);
+      if (stat.size > pos) {
+        const stream = fs.createReadStream(logFile, { start: pos, end: stat.size });
+        stream.on("data", (chunk) => {
+          const lines = chunk.toString();
+          // Filter Chromium noise
+          lines.split("\n").forEach(line => {
+            if (!/^\[[\d:]+\]/.test(line.trim())) process.stdout.write(line + (line ? "\n" : ""));
+          });
+        });
+        pos = stat.size;
+      }
+    }, 300);
+
+    child.on("exit", (code) => {
+      clearInterval(interval);
+      watcher.close();
+      console.log(`\n  ${code === 0 ? fmt.green("✓") : fmt.red("✗")} Overlay exited (code ${code})\n`);
+      clearPid();
+      process.exit(code || 0);
+    });
+
+    await new Promise((resolve) => {
+      process.on("SIGINT", () => {
+        clearInterval(interval);
+        watcher.close();
+        console.log(`\n  ${fmt.dim("Stopped tailing. Overlay is still running.")}\n`);
+        resolve();
+      });
+      process.on("SIGTERM", resolve);
+    });
+    return;
+  }
+
+  // ── Normal (detached) mode ────────────────────────────────────────────
+  const logFd = fs.openSync(logFile, "a");
+  const child = spawn(cmd, argv, {
+    detached: false,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, ELECTRON_ENABLE_LOGGING: "1" },
+  });
+
+  // Give the process 1.5s to fail fast, then detach and let it run
+  await new Promise((res) => {
+    let exited = false;
+    child.on("exit", (code) => {
+      exited = true;
+      if (code !== 0) {
+        console.error(
+          `\n  ${fmt.red("✗")} Overlay exited with code ${code}\n` +
+          `  ${fmt.dim("Check log:")} ${logFile}\n` +
+          `  ${fmt.dim("Or run with:")} ${fmt.cyan("apx overlay start --debug")}\n`
+        );
+      }
+      res();
+    });
+    setTimeout(() => {
+      if (!exited) {
+        child.unref();
+        res();
+      }
+    }, 1500);
+  });
+
+  if (!child.exitCode && child.pid) writePid(child.pid);
+  else return;
+
+  // Read configured shortcut (if any) for display
+  let shortcutHint = "⌘G (macOS) / Ctrl+G (Win/Linux)";
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".apx", "config.json"), "utf8"));
+    if (cfg?.overlay?.shortcut) shortcutHint = cfg.overlay.shortcut;
+  } catch {}
+
+  console.log(
+    `\n  ${fmt.green("●")} ${fmt.bold("APX Overlay")} started` +
+    `  ${fmt.dim("pid " + child.pid)}` +
+    `  ${fmt.dim("port " + daemonPort)}` +
+    `\n  ${fmt.dim("Shortcut:")} ${fmt.cyan(shortcutHint)}` +
+    `\n  ${fmt.dim("Debug:")}    ${fmt.gray("apx overlay start --debug")}` +
+    `\n  ${fmt.dim("Log:")}      ${fmt.gray(logFile)}\n`
+  );
+}
+
+export async function cmdOverlayStop(_args = {}) {
+  const pid = readPid();
+  if (!pidAlive(pid)) {
+    console.log(`\n  ${fmt.dim("Overlay is not running.")}\n`);
+    clearPid();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    clearPid();
+    console.log(`\n  ${fmt.green("✓")} Overlay stopped ${fmt.dim("(pid " + pid + ")")}\n`);
+  } catch (e) {
+    console.error(`\n  ${fmt.red("✗")} Could not stop overlay: ${e.message}\n`);
+  }
+}
+
+export async function cmdOverlayStatus(_args = {}) {
+  const pid = readPid();
+  const alive = pidAlive(pid);
+
+  let daemonClients = 0;
+  try {
+    const s = await http.get("/overlay/status").catch(() => null);
+    daemonClients = s?.connected_clients ?? 0;
+  } catch {}
+
+  const icon  = alive ? fmt.green("●") : fmt.dim("○");
+  const state = alive ? fmt.green("running") : fmt.dim("stopped");
+  console.log(
+    `\n  ${icon} ${fmt.bold("APX Overlay")}  ${state}` +
+    (pid ? `  ${fmt.dim("pid " + pid)}` : "") +
+    `\n  ${fmt.dim("daemon connections:")} ${daemonClients}\n`
+  );
+}

package/src/cli/commands/sys.js

@@ -10,8 +10,15 @@ import {
   renderTerminalChat,
   titlecase,
 } from "../terminal-chat/renderer.js";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
 
-const MAIN_PALETTE_OPTIONS = ["Switch model", "Connect provider", "Open editor", "Exit"];
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TUI_SRC = resolve(__dirname, "../../tui/run.ts");
+
+const MAIN_PALETTE_OPTIONS = ["Switch model", "Switch agent", "Connect provider", "Open editor", "Exit"];
 
 // Message Actions overlay options for a queued message
 const MSG_ACTION_SEND   = "Send now  (interrupt current)";
@@ -24,6 +31,20 @@ export async function cmdSys(args) {
   const cfg = readConfig();
   const id = readIdentity();
 
+  // Launch new Solid.js TUI via bun (runs TS source directly — no esbuild bundle needed)
+  if (existsSync(TUI_SRC)) {
+    const bunBin = process.env.BUN_PATH || "bun";
+    spawnSync(bunBin, [
+      "--preload", "@opentui/solid/preload",
+      TUI_SRC,
+      "--pid", pid,
+      "--agent", id?.agent_name || cfg.super_agent?.name || "super-agent",
+      "--model", cfg.super_agent?.model || "claude-3-5-sonnet",
+    ], { stdio: "inherit", cwd: resolve(__dirname, "../../..") });
+    return;
+  }
+
+
   const state = {
     currentModeIdx: 0,
     inputText: "",
@@ -162,7 +183,7 @@ export async function cmdSys(args) {
     }
 
     if (state.inCommandPalette) {
-      await handlePaletteKey(key, cfg, state, renderScreen, close);
+      await handlePaletteKey(key, pid, cfg, state, renderScreen, close);
       return;
     }
 
@@ -341,7 +362,7 @@ export function handleScrollKey(key, state, renderScreen) {
   return false;
 }
 
-async function handlePaletteKey(key, cfg, state, renderScreen, close) {
+async function handlePaletteKey(key, pid, cfg, state, renderScreen, close) {
   if (key.name === "up") {
     state.paletteSelection = Math.max(0, state.paletteSelection - 1);
     renderScreen();
@@ -362,19 +383,28 @@ async function handlePaletteKey(key, cfg, state, renderScreen, close) {
   const selected = state.paletteOptions[state.paletteSelection];
 
   if (state.paletteState === "main") {
-    if (selected === "Exit") close();
+    if (selected === "Exit") { close(); return; }
 
     if (selected === "Switch model") {
       state.paletteState = "switch_model";
       state.paletteOptions = ["Loading models..."];
       state.paletteSelection = 0;
       renderScreen();
-      loadModelOptions(cfg, state, renderScreen);
+      loadModelOptions(pid, cfg, state, renderScreen);
+      return;
+    }
+
+    if (selected === "Switch agent") {
+      state.paletteState = "switch_agent";
+      state.paletteOptions = ["Loading agents..."];
+      state.paletteSelection = 0;
+      renderScreen();
+      loadAgentOptions(pid, state, renderScreen);
       return;
     }
 
     state.inCommandPalette = false;
-    state.transcript.push({ type: "status", text: `Executing command: ${selected} (not implemented yet)` });
+    state.transcript.push({ type: "status", text: `Command: ${selected} (not implemented yet)` });
     renderScreen();
     return;
   }
@@ -393,7 +423,20 @@ async function handlePaletteKey(key, cfg, state, renderScreen, close) {
     configModule.writeConfig(currentCfg);
 
     state.inCommandPalette = false;
-    state.transcript.push({ type: "status", text: `Model updated globally to ${selected}` });
+    state.transcript.push({ type: "status", text: `Model → ${selected}` });
+    renderScreen();
+    return;
+  }
+
+  if (
+    state.paletteState === "switch_agent" &&
+    !selected.startsWith("Loading") &&
+    !selected.startsWith("Failed") &&
+    !selected.startsWith("No ")
+  ) {
+    state.activeAgent = selected;
+    state.inCommandPalette = false;
+    state.transcript.push({ type: "status", text: `Agent → ${selected}` });
     renderScreen();
     return;
   }
@@ -401,23 +444,52 @@ async function handlePaletteKey(key, cfg, state, renderScreen, close) {
   renderScreen();
 }
 
-function loadModelOptions(cfg, state, renderScreen) {
-  const baseUrl = cfg.engines?.ollama?.base_url || "http://127.0.0.1:11434";
-  fetch(`${baseUrl}/api/tags`)
+function loadModelOptions(pid, cfg, state, renderScreen) {
+  // Load engines from APX daemon first, then fall back to Ollama tags
+  const apxEnginesPromise = pid
+    ? http.get("/engines").then((d) => d?.engines || []).catch(() => [])
+    : Promise.resolve([]);
+
+  const ollamaBaseUrl = cfg.engines?.ollama?.base_url || "http://127.0.0.1:11434";
+  const ollamaPromise = fetch(`${ollamaBaseUrl}/api/tags`)
     .then((r) => r.json())
-    .then((data) => {
-      state.paletteOptions = data.models?.length
-        ? data.models.map((m) => "ollama:" + m.name)
-        : ["No Ollama models found"];
-      state.paletteOptions.push("openai:gpt-4o", "anthropic:claude-3-5-sonnet-20240620");
+    .then((d) => (d.models || []).map((m) => "ollama:" + m.name))
+    .catch(() => []);
+
+  Promise.all([apxEnginesPromise, ollamaPromise])
+    .then(([apxEngines, ollamaModels]) => {
+      const all = [
+        ...apxEngines.filter((e) => typeof e === "string"),
+        ...ollamaModels,
+      ];
+      state.paletteOptions = all.length ? all : ["No models found"];
       if (state.paletteState === "switch_model") renderScreen();
     })
     .catch(() => {
-      state.paletteOptions = ["Failed to load from Ollama", "openai:gpt-4o", "anthropic:claude-3-5-sonnet-20240620"];
+      state.paletteOptions = ["Failed to load models"];
       if (state.paletteState === "switch_model") renderScreen();
     });
 }
 
+function loadAgentOptions(pid, state, renderScreen) {
+  if (!pid) {
+    state.paletteOptions = ["No project selected"];
+    renderScreen();
+    return;
+  }
+  http.get(`/projects/${pid}/agents`)
+    .then((agents) => {
+      state.paletteOptions = Array.isArray(agents) && agents.length
+        ? agents.map((a) => a.slug || a.name || String(a))
+        : ["No agents found"];
+      if (state.paletteState === "switch_agent") renderScreen();
+    })
+    .catch(() => {
+      state.paletteOptions = ["Failed to load agents"];
+      if (state.paletteState === "switch_agent") renderScreen();
+    });
+}
+
 export function handleEditingKey(str, key, state, renderScreen) {
   if (key.name === "tab") {
     state.currentModeIdx = (state.currentModeIdx + 1) % MODES.length;