@agentprojectcontext/apx 1.73.1 → 1.74.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentprojectcontext/apx",
-  "version": "1.73.1",
+  "version": "1.74.1",
   "description": "APX — unified CLI + daemon for the Agent Project Context (APC) standard.",
   "publishConfig": {
     "access": "public"
@@ -67,7 +67,8 @@
     "react": "^19.2.0",
     "remeda": "^2.21.0",
     "safer-buffer": "^2.1.2",
-    "solid-js": "^1.9.13"
+    "solid-js": "^1.9.13",
+    "ws": "^8.21.3"
   },
   "optionalDependencies": {
     "better-sqlite3": "^11.3.0",

package/src/core/channels/telegram/ask-callbacks.js

@@ -181,6 +181,7 @@ export async function runResumedTurn(self, ctx) {
   let replyText;
   let replyAuthor;
   let saUsage = null;
+  let saModel = null;
   try {
     const sa = await runTelegramSuperAgent(self, {
       chat_id,
@@ -216,10 +217,12 @@ export async function runResumedTurn(self, ctx) {
     replyText = sa.text;
     replyAuthor = sa.name || agentDisplay;
     saUsage = sa.usage;
+    saModel = sa.model || state.model || null;
   } catch (e) {
     self.log(`telegram[${self.channel.name}] ask resume failed: ${e.message}`);
     replyText = telegramErrorText(self, e);
     replyAuthor = agentDisplay;
+    saModel = state.model || null;
   }
 
   stopTyping();
@@ -231,6 +234,7 @@ export async function runResumedTurn(self, ctx) {
     replyActorId: SUPERAGENT_ACTOR_ID,
     replyKind: "superagent",
     saUsage,
+    saModel,
     streamedCount: state.streamedCount,
     lastStreamedText: state.lastStreamedText,
     agentDisplay,

package/src/core/channels/telegram/dispatch.js

@@ -226,6 +226,8 @@ export async function handleUpdate(self, u) {
     let replyAuthor;
     let replyActorId = SUPERAGENT_ACTOR_ID;   // stable id: super_agent | agent slug
     let replyKind = "superagent";             // actor_kind: superagent | agent
+    let replyModel = null;                    // model that actually produced the reply
+    let replyUsage = null;                    // token accounting for this turn
     const projectCfg = target.config || self.globalConfig;
     // Display name for the super-agent persona on this channel (from identity.json).
     const agentDisplay = resolveAgentName(self.globalConfig);
@@ -254,6 +256,10 @@ export async function handleUpdate(self, u) {
           replyAuthor = agent.slug;
           replyActorId = agent.slug;
           replyKind = "agent";
+          // Fully-qualified id from the agent card (provider:model) — callEngine
+          // resolves it internally and doesn't hand it back.
+          replyModel = agent.fields.Model;
+          replyUsage = result.usage || null;
         } catch (e) {
           self.log(`telegram[${self.channel.name}] agent reply failed: ${e.message}`);
           replyText = t("telegram.error_agent", {
@@ -263,6 +269,8 @@ export async function handleUpdate(self, u) {
           replyAuthor = agentDisplay;
           replyActorId = SUPERAGENT_ACTOR_ID;
           replyKind = "superagent";
+          replyModel = null;
+          replyUsage = null;
         }
       } else {
         self.log(
@@ -276,7 +284,6 @@ export async function handleUpdate(self, u) {
     // calls are logged but never sent (internal). The streamed turn + its final
     // send live in ./reply.js so this dispatcher and the ask-flow resume
     // (_runResumedTurn in the host poller) share ONE reply path — no drift.
-    let saUsage = null;
     let streamedCount = 0;
     let lastStreamedText = "";
     if (!replyText && isSuperAgentEnabled(self.globalConfig)) {
@@ -327,7 +334,8 @@ export async function handleUpdate(self, u) {
         replyAuthor = sa.name || agentDisplay;
         replyActorId = SUPERAGENT_ACTOR_ID;
         replyKind = "superagent";
-        saUsage = sa.usage;
+        replyUsage = sa.usage;
+        replyModel = sa.model || state.model || null;
 
         // ── ask_questions integration ────────────────────────────────────
         // If the super-agent ended this turn by calling ask_questions, hand off
@@ -374,6 +382,7 @@ export async function handleUpdate(self, u) {
         replyAuthor = agentDisplay;
         replyActorId = SUPERAGENT_ACTOR_ID;
         replyKind = "superagent";
+        replyModel = state.model || null;
       }
     }
 
@@ -386,7 +395,8 @@ export async function handleUpdate(self, u) {
       replyAuthor,
       replyActorId,
       replyKind,
-      saUsage,
+      saUsage: replyUsage,
+      saModel: replyModel,
       streamedCount,
       lastStreamedText,
       agentDisplay,

package/src/core/channels/telegram/reply.js

@@ -23,12 +23,19 @@ import { buildTelegramMeta, resolveBotToken } from "./helpers.js";
  * (audit trail / other channels — never sent to Telegram). Returns the handler
  * plus a live `state` the caller reads AFTER the run to drive the final send.
  *
- * @returns {{ onEvent: Function, state: { streamedCount: number, lastStreamedText: string } }}
+ * `state.model` tracks the model actually answering RIGHT NOW (it can rotate
+ * mid-turn on a fallback), so every record this handler writes is stamped with
+ * the model that produced it — not with the one the turn happened to end on.
+ *
+ * @returns {{ onEvent: Function, state: { streamedCount: number, lastStreamedText: string, model: string } }}
  */
 export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
-  const state = { streamedCount: 0, lastStreamedText: "", sentHeadsUp: false };
+  const state = { streamedCount: 0, lastStreamedText: "", sentHeadsUp: false, model: "" };
   const onEvent = async (ev) => {
     try {
+      if ((ev.type === "model_start" || ev.type === "model_routed" || ev.type === "final_wrapup") && ev.model) {
+        state.model = ev.model;
+      }
       if (ev.type === "tool_start" && !state.sentHeadsUp && state.streamedCount === 0) {
         state.sentHeadsUp = true;
         const heads = t("telegram.heads_up", { lang: resolveLang(self.globalConfig) });
@@ -42,7 +49,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           agent_slug: SUPERAGENT_ACTOR_ID,
           author: agentDisplay,
           body: heads,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, heads_up: true },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, heads_up: true, ...(state.model ? { model: state.model } : {}) },
         });
         return;
       }
@@ -61,7 +68,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           agent_slug: SUPERAGENT_ACTOR_ID,
           author: agentDisplay,
           body: piece,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, streamed: true, iteration: ev.iteration },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, streamed: true, iteration: ev.iteration, ...(state.model ? { model: state.model } : {}) },
         });
       } else if (ev.type === "tool_result" && ev.trace) {
         // Logged for the audit trail / other channels — NOT sent to Telegram.
@@ -74,7 +81,7 @@ export function buildStreamHandler(self, { chat_id, update_id, agentDisplay }) {
           actor_kind: "tool",
           author: agentDisplay,
           body: `${tr.tool}(${JSON.stringify(tr.args || {}).slice(0, 200)})`,
-          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, tool: tr.tool, args: tr.args, result: tr.result, iteration: ev.iteration },
+          meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, tool: tr.tool, args: tr.args, result: tr.result, iteration: ev.iteration, ...(state.model ? { model: state.model } : {}) },
         });
       } else if (ev.type === "engine_failed") {
         // A model in the fallback chain errored; the loop is rotating to the
@@ -175,6 +182,7 @@ export async function runFollowupTurn(self, {
     let replyText;
     let replyAuthor;
     let saUsage = null;
+    let saModel = null;
     try {
       const sa = await runTelegramSuperAgent(self, {
         chat_id,
@@ -191,10 +199,12 @@ export async function runFollowupTurn(self, {
       replyText = sa.text;
       replyAuthor = sa.name || agentDisplay;
       saUsage = sa.usage;
+      saModel = sa.model || state.model || null;
     } catch (e) {
       self.log(`telegram[${self.channel.name}] a2a followup failed: ${e.message}`);
       replyText = telegramErrorText(self, e);
       replyAuthor = agentDisplay;
+      saModel = state.model || null;
     }
     stopTyping();
     await sendFinalReply(self, {
@@ -205,6 +215,7 @@ export async function runFollowupTurn(self, {
       replyActorId: SUPERAGENT_ACTOR_ID,
       replyKind: "superagent",
       saUsage,
+      saModel,
       streamedCount: state.streamedCount,
       lastStreamedText: state.lastStreamedText,
       agentDisplay,
@@ -233,7 +244,7 @@ export function telegramErrorText(self, e) {
  */
 export async function sendFinalReply(self, {
   chat_id, update_id, replyText, replyAuthor, replyActorId, replyKind,
-  saUsage = null, streamedCount = 0, lastStreamedText = "", agentDisplay,
+  saUsage = null, saModel = null, streamedCount = 0, lastStreamedText = "", agentDisplay,
   extraMeta = {},
 }) {
   const finalClean = replyText ? stripThinking(replyText).trim() : "";
@@ -255,6 +266,7 @@ export async function sendFinalReply(self, {
     const meta = { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, final: true, ...extraMeta };
     if (replyText && stripThinking(replyText) !== replyText) meta.thinking_stripped = true;
     if (saUsage) meta.usage = saUsage;
+    if (saModel) meta.model = saModel;
     appendGlobalMessage({
       channel: CHANNELS.TELEGRAM,
       direction: "out",
@@ -277,7 +289,7 @@ export async function sendFinalReply(self, {
       agent_slug: actorId,
       author: replyAuthor || agentDisplay,
       body: `[send_failed] ${toSend}`,
-      meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, send_error: e.message, ...(saUsage ? { usage: saUsage } : {}) },
+      meta: { chat_id, tg_channel: self.channel.name, in_reply_to: update_id, send_error: e.message, ...(saUsage ? { usage: saUsage } : {}), ...(saModel ? { model: saModel } : {}) },
     });
   }
 }

package/src/core/desktop/autostart.js

@@ -18,6 +18,7 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { augmentedPath } from "#core/util/path-env.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname  = path.dirname(__filename);
@@ -55,6 +56,12 @@ function escapeXml(s) {
 export function buildPlist(runner, logFile) {
   const args = [...runner, "desktop", "start"];
   const argsXml = args.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+  // Absolute ProgramArguments (see getApxRunner) only save the *first* hop.
+  // Everything the daemon spawns below itself — ffmpeg for whisper, npx/node
+  // for stdio MCPs — still resolves through PATH, and launchd's is
+  // /usr/bin:/bin:/usr/sbin:/sbin. Baking the installing shell's augmented
+  // PATH in makes the whole tree behave the same at login as in a terminal.
+  const pathEnv = augmentedPath();
   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">
@@ -64,6 +71,10 @@ export function buildPlist(runner, logFile) {
   <array>
 ${argsXml}
   </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${escapeXml(pathEnv)}</string>
+  </dict>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><false/>
   <key>ProcessType</key><string>Interactive</string>
@@ -76,12 +87,18 @@ ${argsXml}
 
 // ── public API ───────────────────────────────────────────────────────────
 
+// The three functions below take `platform` instead of reading process.platform
+// inline so the unsupported-platform branch is reachable from a test on any
+// machine — it's the only branch with no filesystem/registry side effect, and
+// hard-coding process.platform meant it could only ever be exercised on a
+// freebsd/sunos box. Callers always omit it.
+
 /** Boolean: is the autostart entry currently registered on this platform? */
-export function autostartIsOn() {
+export function autostartIsOn(platform = process.platform) {
   try {
-    if (process.platform === "darwin") return fs.existsSync(MAC_PLIST_PATH);
-    if (process.platform === "linux")  return fs.existsSync(LINUX_DESKTOP_PATH);
-    if (process.platform === "win32") {
+    if (platform === "darwin") return fs.existsSync(MAC_PLIST_PATH);
+    if (platform === "linux")  return fs.existsSync(LINUX_DESKTOP_PATH);
+    if (platform === "win32") {
       const out = execFileSync("reg", ["query", WIN_RUN_KEY, "/v", WIN_RUN_NAME], {
         stdio: ["ignore", "pipe", "ignore"],
       }).toString();
@@ -95,12 +112,12 @@ export function autostartIsOn() {
  * Enable autostart. Idempotent — running twice is safe.
  * @returns {{ ok: boolean, message?: string, error?: string, runs?: string, path?: string }}
  */
-export function autostartInstall() {
+export function autostartInstall(platform = process.platform) {
   const runner = getApxRunner();
   const sh = (s) => `"${String(s).replace(/"/g, '\\"')}"`;
   const cmdline = [...runner, "desktop", "start"].map(sh).join(" ");
 
-  if (process.platform === "darwin") {
+  if (platform === "darwin") {
     try {
       fs.mkdirSync(path.dirname(MAC_PLIST_PATH), { recursive: true });
       fs.mkdirSync(path.dirname(AUTOSTART_LOG_PATH), { recursive: true });
@@ -110,7 +127,7 @@ export function autostartInstall() {
       return { ok: true, runs: cmdline, path: MAC_PLIST_PATH };
     } catch (e) { return { ok: false, error: e.message }; }
   }
-  if (process.platform === "win32") {
+  if (platform === "win32") {
     try {
       execFileSync("reg", [
         "add", WIN_RUN_KEY, "/v", WIN_RUN_NAME, "/t", "REG_SZ", "/d", cmdline, "/f",
@@ -118,7 +135,7 @@ export function autostartInstall() {
       return { ok: true, runs: cmdline, path: `${WIN_RUN_KEY}\\${WIN_RUN_NAME}` };
     } catch (e) { return { ok: false, error: e.message }; }
   }
-  if (process.platform === "linux") {
+  if (platform === "linux") {
     try {
       fs.mkdirSync(path.dirname(LINUX_DESKTOP_PATH), { recursive: true });
       fs.writeFileSync(LINUX_DESKTOP_PATH,
@@ -127,15 +144,15 @@ export function autostartInstall() {
       return { ok: true, runs: cmdline, path: LINUX_DESKTOP_PATH };
     } catch (e) { return { ok: false, error: e.message }; }
   }
-  return { ok: false, error: `autostart not supported on platform: ${process.platform}` };
+  return { ok: false, error: `autostart not supported on platform: ${platform}` };
 }
 
 /**
  * Disable autostart. Idempotent — no-op if not installed.
  * @returns {{ ok: boolean, removed?: boolean, path?: string, error?: string }}
  */
-export function autostartUninstall() {
-  if (process.platform === "darwin") {
+export function autostartUninstall(platform = process.platform) {
+  if (platform === "darwin") {
     if (!fs.existsSync(MAC_PLIST_PATH)) return { ok: true, removed: false };
     try {
       try { execFileSync("launchctl", ["unload", "-w", MAC_PLIST_PATH], { stdio: "ignore" }); } catch {}
@@ -143,7 +160,7 @@ export function autostartUninstall() {
       return { ok: true, removed: true, path: MAC_PLIST_PATH };
     } catch (e) { return { ok: false, error: e.message }; }
   }
-  if (process.platform === "win32") {
+  if (platform === "win32") {
     try {
       execFileSync("reg", ["delete", WIN_RUN_KEY, "/v", WIN_RUN_NAME, "/f"], { stdio: "ignore" });
       return { ok: true, removed: true, path: `${WIN_RUN_KEY}\\${WIN_RUN_NAME}` };
@@ -151,12 +168,12 @@ export function autostartUninstall() {
       return { ok: true, removed: false };
     }
   }
-  if (process.platform === "linux") {
+  if (platform === "linux") {
     if (!fs.existsSync(LINUX_DESKTOP_PATH)) return { ok: true, removed: false };
     try {
       fs.unlinkSync(LINUX_DESKTOP_PATH);
       return { ok: true, removed: true, path: LINUX_DESKTOP_PATH };
     } catch (e) { return { ok: false, error: e.message }; }
   }
-  return { ok: false, error: `autostart not supported on platform: ${process.platform}` };
+  return { ok: false, error: `autostart not supported on platform: ${platform}` };
 }

package/src/core/mcp/runner.js

@@ -9,6 +9,7 @@ import { spawn } from "node:child_process";
 import { loadAll } from "./sources.js";
 import { interpolate, MissingVarError } from "#core/vars/interpolate.js";
 import { loadAllVars } from "#core/vars/sources.js";
+import { envWithPath } from "#core/util/path-env.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const LOG_CAP = 64;            // entries per MCP we keep in memory
@@ -59,8 +60,12 @@ class McpProcess {
   start() {
     if (this.proc) return;
     this._log("info", `spawn ${this.command} ${(this.args || []).join(" ")}`);
+    // envWithPath, not a bare process.env spread: most stdio MCPs are launched
+    // via `npx`/`node`, which live in the nvm/pnpm bin dir. Booted from launchd
+    // the daemon only has /usr/bin:/bin:/usr/sbin:/sbin and every one of them
+    // fails with "spawn npx ENOENT".
     this.proc = spawn(this.command, this.args, {
-      env: { ...process.env, ...this.env },
+      env: envWithPath(this.env),
       stdio: ["pipe", "pipe", "pipe"],
     });
     this.startedAt = nowIso();

package/src/core/net/ipv4-first.js

@@ -0,0 +1,32 @@
+// Prefer IPv4 for all outbound connections made by this process.
+//
+// Some networks — notably machines on Tailscale, or misconfigured dual-stack
+// setups — advertise an IPv6 route that black-holes. A dual-stack host such as
+// api.telegram.org then resolves to an unreachable AAAA address, and Node's
+// fetch/undici stalls on it with ETIMEDOUT instead of falling back to the
+// reachable IPv4 the way `curl` does. The symptom is every daemon outbound
+// `fetch` failing ("fetch failed") — Telegram long-poll, some LLM providers —
+// while the shell and `curl -4` work fine.
+//
+// Forcing ipv4first + disabling Happy-Eyeballs family auto-selection makes
+// `fetch` use the reachable A record. On a healthy IPv6 network this is a no-op
+// preference (IPv4 is still universally reachable); opt out with
+// APX_NET_IPV4_FIRST=0 if you specifically need IPv6-first.
+import dns from "node:dns";
+import net from "node:net";
+
+if (process.env.APX_NET_IPV4_FIRST !== "0") {
+  // Available on Node ≥17; guarded for older runtimes.
+  try {
+    dns.setDefaultResultOrder("ipv4first");
+  } catch {
+    /* older node — ignore */
+  }
+  // Available on Node ≥18.13; disabling it stops undici from racing an
+  // unreachable IPv6 address and timing out before it tries IPv4.
+  try {
+    net.setDefaultAutoSelectFamily?.(false);
+  } catch {
+    /* older node — ignore */
+  }
+}

package/src/core/stores/messages.js

@@ -643,12 +643,18 @@ export function listGlobalThreads({ channels, _globalMessagesDir } = {}) {
 }
 
 // Read one channel+day thread shaped for the web chat viewer:
-// { id, channel, messages: [{ role, content, ts }] } — or null when missing.
+// { id, channel, messages: [{ role, content, ts, … }] } — or null when missing.
 // Tool records are INCLUDED (role:"tool" with structured tool/args/result from
 // meta) so the web viewer can render tool executions the same way the live
 // stream does. They're persisted by every channel (e.g. telegram reply.js) but
 // never sent to the channel itself; dropping them here is what made Telegram
 // tool calls invisible in the web chat even though they were on disk.
+//
+// Assistant rows also carry their ATTRIBUTION — which agent answered
+// (agent/agent_name/actor_kind) and on which model, plus the turn's token
+// usage. All of it is already on disk in `meta`; dropping it here is what made
+// a reloaded thread render "0 tok" with no model, even though the live stream
+// showed both.
 export function readGlobalThread({ channel, date, _globalMessagesDir } = {}) {
   if (!CHANNEL_NAME_RE.test(String(channel || ""))) return null;
   if (!/^\d{4}-\d{2}-\d{2}$/.test(String(date || ""))) return null;
@@ -668,10 +674,21 @@ export function readGlobalThread({ channel, date, _globalMessagesDir } = {}) {
           result: r.meta?.result,
         };
       }
+      if (r.type === "user") {
+        return { role: "user", content: r.body || "", ts: r.ts };
+      }
+      const usage = r.meta?.usage;
       return {
-        role: r.type === "user" ? "user" : "assistant",
+        role: "assistant",
         content: r.body || "",
         ts: r.ts,
+        // Stable id of who answered (super_agent | project-agent slug) plus the
+        // display name that was shown on the channel.
+        ...(r.agent_slug || r.actor_id ? { agent: r.agent_slug || r.actor_id } : {}),
+        ...(r.author ? { agent_name: r.author } : {}),
+        ...(r.actor_kind ? { actor_kind: r.actor_kind } : {}),
+        ...(r.meta?.model ? { model: r.meta.model } : {}),
+        ...(usage && typeof usage === "object" ? { usage } : {}),
       };
     });
   return { id: date, channel, messages };

package/src/core/util/index.js

@@ -1,2 +1,3 @@
 export * from "./time.js";
 export * from "./ids.js";
+export * from "./path-env.js";

package/src/core/util/path-env.js

@@ -0,0 +1,73 @@
+// PATH repair for processes APX spawns.
+//
+// When the daemon is booted from a GUI context — the launchd agent
+// (dev.apx.desktop), a .app bundle, an IDE — it inherits launchd's minimal
+// PATH: /usr/bin:/bin:/usr/sbin:/sbin. No Homebrew, no nvm, no pnpm. Every
+// child we spawn then dies with ENOENT on binaries that work fine in a
+// terminal:
+//
+//   - whisper-server.py → "No such file or directory: 'ffmpeg'" (mlx/faster
+//     whisper shell out to ffmpeg to decode .oga/.webm)
+//   - stdio MCP servers  → "spawn npx ENOENT" / "spawn node ENOENT"
+//
+// getApxRunner() in core/desktop/autostart.js already dodges this for the
+// node binary itself by using an absolute process.execPath. This module is
+// the same idea for everything spawned *below* that process.
+//
+// Extra dirs are APPENDED, never prepended: an inherited PATH that already
+// resolves a binary keeps winning, we only fill the gaps.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/**
+ * Directories worth appending on this machine, in priority order. Only ones
+ * that actually exist are returned, so PATH stays free of dead entries.
+ */
+export function extraBinDirs() {
+  const home = os.homedir();
+  // dirname(process.execPath) is the bin/ of the node currently running us —
+  // under nvm/fnm/volta that's also where npm and npx live, which is exactly
+  // what stdio MCP servers need.
+  const candidates = process.platform === "win32"
+    ? [path.dirname(process.execPath)]
+    : [
+        path.dirname(process.execPath),
+        "/opt/homebrew/bin",      // Homebrew on Apple Silicon
+        "/opt/homebrew/sbin",
+        "/usr/local/bin",         // Homebrew on Intel, most manual installs
+        "/usr/local/sbin",
+        path.join(home, ".local", "bin"),
+        path.join(home, "Library", "pnpm"),
+        path.join(home, ".bun", "bin"),
+        path.join(home, ".cargo", "bin"),
+      ];
+  return candidates.filter((dir) => {
+    try { return fs.existsSync(dir); } catch { return false; }
+  });
+}
+
+/**
+ * `basePath` with every missing entry from extraBinDirs() appended.
+ * @param {string} [basePath]  defaults to the current process PATH
+ */
+export function augmentedPath(basePath = process.env.PATH || "") {
+  const sep = path.delimiter;
+  const seen = new Set(basePath.split(sep).filter(Boolean));
+  const additions = extraBinDirs().filter((dir) => !seen.has(dir));
+  if (!additions.length) return basePath;
+  return [...basePath.split(sep).filter(Boolean), ...additions].join(sep);
+}
+
+/**
+ * An env object for child_process.spawn: process.env + `extra`, with PATH
+ * repaired. A PATH supplied in `extra` is respected as the base and augmented
+ * too, so callers can still pin their own dirs first.
+ */
+export function envWithPath(extra = {}) {
+  const merged = { ...process.env, ...extra };
+  // Windows env keys are case-insensitive and may arrive as "Path".
+  const key = Object.keys(merged).find((k) => k.toUpperCase() === "PATH") || "PATH";
+  merged[key] = augmentedPath(merged[key] || "");
+  return merged;
+}

package/src/core/voice/transcription.js

@@ -174,12 +174,37 @@ export function listSttProviders(rawConfig = {}) {
   return { configured_provider: provider, engines };
 }
 
+// Host-injected "make sure the whisper subprocess is alive" hook. Core must
+// not import from host/daemon, so host/daemon/whisper-server.js registers
+// ensureWhisperServer() here at module load instead. Stays null in contexts
+// that have no subprocess to manage (tests, CLI talking to a remote daemon),
+// where transcribeViaLocalServer just fetches as before.
+let _ensureLocalServer = null;
+
+/** @param {((opts:object)=>Promise<void>)|null} fn */
+export function setLocalServerEnsure(fn) {
+  _ensureLocalServer = typeof fn === "function" ? fn : null;
+}
+
 /**
- * Call the local whisper-server.py over HTTP. Does NOT spawn or check the
- * subprocess — that's host/daemon/whisper-server.js's job. If the server is
- * down, this throws a clear "ECONNREFUSED" the caller can surface.
+ * Call the local whisper-server.py over HTTP.
+ *
+ * The server shuts itself down after `idle_minutes` (10 by default), so on any
+ * request that isn't back-to-back with the last one the port is simply dead.
+ * We therefore ask the host to (re)spawn it first — ensureWhisperServer() is a
+ * cheap health check when the process is already up. Without this, the first
+ * voice message after an idle gap always failed with a bare "fetch failed".
  */
 export async function transcribeViaLocalServer(filePath, opts) {
+  if (_ensureLocalServer) {
+    try {
+      await _ensureLocalServer(opts);
+    } catch (e) {
+      // Not fatal: the server may still be reachable (e.g. an orphan listener
+      // this process doesn't own). Let the fetch below decide.
+      logWarn("whisper", `ensure local server failed, trying anyway: ${e.message}`);
+    }
+  }
   const language = (opts.language || DEFAULT_LOCAL.language) === "auto"
     ? null
     : (opts.language || null);

package/src/host/daemon/api/super-agent.js

@@ -44,12 +44,21 @@ function logInspectorDecision(trace, { trace_id, channel } = {}) {
 // the human surfaces (web big chat + sidebar) — not generic "api"/automation
 // callers. Best-effort: a logging failure never breaks the reply.
 const WEB_LOGGED_CHANNELS = new Set([CHANNELS.WEB, CHANNELS.WEB_SIDEBAR]);
-function logWebTurn(channel, { prompt, replyText }) {
+function logWebTurn(channel, { prompt, replyText, name, model, usage }) {
   if (!WEB_LOGGED_CHANNELS.has(channel)) return;
   try {
     appendGlobalMessage({ channel, direction: "in", type: "user", author: "user", body: prompt });
     if (replyText) {
-      appendGlobalMessage({ channel, direction: "out", type: "agent", body: replyText });
+      // Attribution rides along on the record: which model answered and what the
+      // turn cost. Without it a reloaded thread renders "0 tok" and no model.
+      appendGlobalMessage({
+        channel,
+        direction: "out",
+        type: "agent",
+        author: name || undefined,
+        body: replyText,
+        meta: { ...(model ? { model } : {}), ...(usage ? { usage } : {}) },
+      });
     }
   } catch {
     /* best-effort */
@@ -146,7 +155,12 @@ export function register(app, { projects, registries, plugins, project, config }
 
     // Web/TUI channels receive a "confirmation_required" SSE event and respond
     // via POST /super-agent/confirm/:correlationId (see api/confirm.js).
-    const requestConfirmation = createWebConfirmAdapter({ onEvent });
+    // Non-interactive callers (e.g. `apx exec`, which streams only to render a
+    // progress indicator) send `confirm: false` to opt out: they have no way to
+    // answer the round-trip, so they fall back to the default permission policy —
+    // exactly matching the blocking POST /super-agent/chat endpoint's semantics.
+    const requestConfirmation =
+      req.body?.confirm === false ? undefined : createWebConfirmAdapter({ onEvent });
 
     try {
       const saResult = await runSuperAgent({
@@ -168,13 +182,22 @@ export function register(app, { projects, registries, plugins, project, config }
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
-      logWebTurn(ctx.channel, { prompt, replyText: saResult.text });
+      logWebTurn(ctx.channel, {
+        prompt,
+        replyText: saResult.text,
+        name: saResult.name,
+        model: saResult.model,
+        usage: saResult.usage,
+      });
       send({
         type: "final",
         result: {
           text: saResult.text,
           usage: saResult.usage,
+          // `name` is the agent persona; `model` is the engine that answered
+          // (it can differ from the configured one after a routing fallback).
           name: saResult.name,
+          model: saResult.model,
           trace: saResult.trace,
         },
       });
@@ -270,11 +293,18 @@ export function register(app, { projects, registries, plugins, project, config }
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
-      logWebTurn(ctx.channel, { prompt, replyText: saResult.text });
+      logWebTurn(ctx.channel, {
+        prompt,
+        replyText: saResult.text,
+        name: saResult.name,
+        model: saResult.model,
+        usage: saResult.usage,
+      });
       res.json({
         text: saResult.text,
         usage: saResult.usage,
         name: saResult.name,
+        model: saResult.model,
         trace: saResult.trace,
       });
     } catch (e) {