@agentprojectcontext/apx 1.77.3 → 1.79.0

package/src/host/daemon/api.js

@@ -1,15 +1,26 @@
 // Express REST API for APX. See APC docs reference/apx-daemon.
 //
 // Routes are split by domain under ./api/*.js — each module exports
-// `register(app, ctx)`. This file is purely orchestration: middlewares,
+// `register(router, ctx)`. This file is purely orchestration: middlewares,
 // context construction, mount order, 404 catch-all.
+//
+// EVERY data route lives under /api. Domain modules still declare their paths
+// root-relative (`/projects/:pid/tasks`); they register on an express.Router()
+// that is mounted at API_PREFIX, so the effective URL is /api/projects/:pid/
+// tasks. The root namespace belongs exclusively to the admin panel (static
+// bundle + client-side routes), which is why the "is this an API path?" test
+// is now a single startsWith instead of a hand-maintained prefix list.
 import express from "express";
 
+import { API_PREFIX } from "./api/prefix.js";
+import { logError } from "#core/logging.js";
+
 import {
   traceIdMiddleware,
   buildAuthMiddleware,
   makeProjectResolver,
   makeTopProjectResolver,
+  errorMiddleware,
 } from "./api/shared.js";
 
 import { register as registerTools } from "./api/tools.js";
@@ -35,6 +46,7 @@ import { register as registerRoutines } from "./api/routines.js";
 import { register as registerArtifacts } from "./api/artifacts.js";
 import { register as registerArtifactPreview } from "./api/artifact-preview.js";
 import { register as registerTasks } from "./api/tasks.js";
+import { register as registerCommitments } from "./api/commitments.js";
 import { register as registerOrganization } from "./api/organization.js";
 import { register as registerProjectFiles } from "./api/files-project.js";
 import { register as registerConfig } from "./api/config.js";
@@ -53,7 +65,9 @@ import { register as registerAdminConfig } from "./api/admin-config.js";
 import { register as registerIdentity } from "./api/identity.js";
 import { register as registerProfiles } from "./api/profiles.js";
 import { register as registerInbox } from "./api/inbox.js";
-import { register as registerWeb } from "./api/web.js";
+import { register as registerSelfMemory } from "./api/self-memory.js";
+import { register as registerNudges } from "./api/nudges.js";
+import { register as registerWeb, registerWebToken } from "./api/web.js";
 import { register as registerConfirm } from "./api/confirm.js";
 
 export function buildApi({
@@ -70,6 +84,9 @@ export function buildApi({
 }) {
   const telegram = plugins?.get("telegram");
   const app = express();
+  // Every domain module registers on this router; it is mounted at /api at the
+  // bottom of this function. Modules keep declaring root-relative paths.
+  const api = express.Router();
 
   // ---- Global middleware -------------------------------------------
   app.use(express.json({ limit: "2mb" }));
@@ -103,62 +120,74 @@ export function buildApi({
   };
 
   // ---- Tool routers — must mount BEFORE wildcard registry below ----
-  registerTools(app, ctx);
+  registerTools(api, ctx);
 
   // ---- Health (unauthenticated) ------------------------------------
-  registerHealth(app, ctx);
+  registerHealth(api, ctx);
 
   // ---- Projects + per-project surfaces -----------------------------
-  registerProjects(app, ctx);
-  registerAgents(app, ctx);
-  registerSessions(app, ctx);
-  registerMcps(app, ctx);
-  registerIntegrations(app, ctx);
-  registerVars(app, ctx);
-  registerMessages(app, ctx);
-  registerEngines(app, ctx);
-  registerSkills(app, ctx);
-  registerExec(app, ctx);
-  registerSuperAgent(app, ctx);
-  registerConfirm(app, ctx);
-  registerCode(app, ctx);
-  registerConversations(app, ctx);
-  registerConnections(app, ctx);
-  registerRuntimes(app, ctx);
-  registerRoutines(app, ctx);
-  registerArtifacts(app, ctx);
-  registerArtifactPreview(app, ctx);
-  registerTasks(app, ctx);
-  registerOrganization(app, ctx);
-  registerProjectFiles(app, ctx);
-  registerConfig(app, ctx);
+  registerProjects(api, ctx);
+  registerAgents(api, ctx);
+  registerSessions(api, ctx);
+  registerMcps(api, ctx);
+  registerIntegrations(api, ctx);
+  registerVars(api, ctx);
+  registerMessages(api, ctx);
+  registerEngines(api, ctx);
+  registerSkills(api, ctx);
+  registerExec(api, ctx);
+  registerSuperAgent(api, ctx);
+  registerConfirm(api, ctx);
+  registerCode(api, ctx);
+  registerConversations(api, ctx);
+  registerConnections(api, ctx);
+  registerRuntimes(api, ctx);
+  registerRoutines(api, ctx);
+  registerArtifacts(api, ctx);
+  registerArtifactPreview(api, ctx);
+  registerTasks(api, ctx);
+  registerCommitments(api, ctx);
+  registerOrganization(api, ctx);
+  registerProjectFiles(api, ctx);
+  registerConfig(api, ctx);
 
   // ---- Top-level shortcuts (MCP server clients) --------------------
-  registerRun(app, ctx);
-  registerTopLevel(app, ctx);
-  registerSessionsSearch(app, ctx);
+  registerRun(api, ctx);
+  registerTopLevel(api, ctx);
+  registerSessionsSearch(api, ctx);
 
   // ---- Channels & plugin surfaces ----------------------------------
-  registerTelegram(app, ctx);
-  registerPlugins(app, ctx);
-  registerTranscribe(app, ctx);
-  registerTts(app, ctx);
-  registerEmbeddings(app, ctx);
-  registerVoice(app, ctx);
-  registerDesktop(app, ctx);
-  registerDeck(app, ctx);
-  registerPairing(app, ctx);
+  registerTelegram(api, ctx);
+  registerPlugins(api, ctx);
+  registerTranscribe(api, ctx);
+  registerTts(api, ctx);
+  registerEmbeddings(api, ctx);
+  registerVoice(api, ctx);
+  registerDesktop(api, ctx);
+  registerDeck(api, ctx);
+  registerPairing(api, ctx);
 
   // ---- Admin -------------------------------------------------------
-  registerAdmin(app, ctx);
-  registerAdminConfig(app, ctx);
-  registerIdentity(app, ctx);
-  registerProfiles(app, ctx);
-  registerInbox(app, ctx);
-
-  // ---- Web admin panel (static SPA, must mount before 404) ---------
-  // Serves src/interfaces/web/dist when present + the /admin/web-token
-  // localhost-only token endpoint. No-op until the panel is built.
+  registerAdmin(api, ctx);
+  registerAdminConfig(api, ctx);
+  registerIdentity(api, ctx);
+  registerProfiles(api, ctx);
+  registerInbox(api, ctx);
+  registerSelfMemory(api, ctx);
+  registerNudges(api, ctx);
+  registerWebToken(api, ctx);
+
+  // ---- API 404 (MUST be last on the router) ------------------------
+  // Terminal for the /api namespace: an unknown /api/* path answers JSON here
+  // instead of falling through to the SPA shell below.
+  api.use((req, res) =>
+    res.status(404).json({ error: `no route ${req.method} ${req.baseUrl}${req.path}` })
+  );
+
+  app.use(API_PREFIX, api);
+
+  // ---- Web admin panel (static SPA, must mount after /api) ---------
+  // Serves src/interfaces/web/dist when present. No-op until the panel is built.
   registerWeb(app, ctx);
 
   // ---- 404 catch-all (MUST be last) --------------------------------
@@ -166,5 +195,11 @@ export function buildApi({
     res.status(404).json({ error: `no route ${req.method} ${req.path}` })
   );
 
+  // ---- Error handler (MUST be after everything) --------------------
+  // Express only recognises the 4-argument shape, and only when it is mounted
+  // last. Anything an asyncRoute() rejects lands here as JSON instead of an
+  // unhandled rejection that kills the daemon.
+  app.use(errorMiddleware(logError));
+
   return app;
 }

package/src/host/daemon/callback-reconciler.js

@@ -15,6 +15,8 @@
 // session close captured remains). The rich A2A relay (Roby re-voicing the
 // result) stays the job of the live in-process path.
 import { listPendingCallbacks, deletePendingCallback, readSessionState } from "#core/stores/runtime-callbacks.js";
+import { readConfig } from "#core/config/index.js";
+import { canNudge, recordNudge } from "#core/nudge/index.js";
 
 const GRACE_MS = 30_000;               // let the live in-process path win a fresh completion
 const STALE_MS = 24 * 60 * 60 * 1000;  // drop IOUs for runs that never finished in a day
@@ -62,11 +64,25 @@ export async function reconcilePendingCallbacks({ plugins, log }) {
       if (Number.isFinite(compAge) && compAge < GRACE_MS) continue;
 
       if (!telegram) continue; // telegram plugin not up this boot — retry next tick
+
+      // PUSH PATH 4 OF 4. Declared SOLICITED, and that is a judgement worth
+      // stating: the user launched this runtime and is waiting for its result.
+      // Arriving late does not make it an interruption, and holding it back
+      // for quiet hours would mean losing an answer they asked for. It still
+      // passes through the gate so the audit is real and so a future policy
+      // can reach it without hunting for a fifth path nobody remembered.
+      const gate = canNudge(
+        { kind: "session_result", severity: "normal", unsolicited: false, channel: "telegram" },
+        readConfig(),
+      );
+      if (!gate.allowed) continue; // never today; retry next tick if it ever is
+
       await telegram.send({
         channel: entry.tg_channel || undefined,
         chat_id: entry.chat_id,
         text: deliverText(entry, state),
       });
+      recordNudge(gate, { chat_id: entry.chat_id });
       deletePendingCallback(entry.session_id);
       log?.(`callback-reconciler: delivered late callback for ${entry.session_id} → chat ${entry.chat_id}`);
     } catch (e) {

package/src/host/daemon/db.js

@@ -5,7 +5,7 @@ import path from "node:path";
 import { appendMessageToFs } from "#core/stores/messages.js";
 import { effectiveConfig } from "./project-config.js";
 import { readAgents } from "#core/apc/parser.js";
-import { apcDir, apcProjectFile, apcAgentsDir, apcCommandsDir } from "#core/apc/paths.js";
+import { apcProjectFile, apcAgentsDir, apcCommandsDir } from "#core/apc/paths.js";
 import { getOrCreateApxId } from "#core/apc/scaffold.js";
 import {
   ensureProjectStorage,

package/src/host/daemon/desktop-ws.js

@@ -1,5 +1,6 @@
 // Singleton WebSocket hub for the desktop channel.
 // Imported by api.js (to register connections) and by plugins/desktop/index.js (to broadcast).
+import { apiPath } from "./api/prefix.js";
 
 const _clients = new Set(); // Set<WebSocket>
 let _messageHandler = null; // (ws, data) => void — set by desktop plugin
@@ -12,7 +13,7 @@ export function setDesktopMessageHandler(fn) {
 
 // --- WS upgrade auth helpers (shared by the daemon upgrade handler + tests) ---
 //
-// The desktop WS channel must authenticate the same way the HTTP /desktop/*
+// The desktop WS channel must authenticate the same way the HTTP /api/desktop/*
 // routes do: a bearer token (master or paired client) carried on the upgrade
 // request. The legitimate desktop window sends `Authorization: Bearer <token>`
 // (src/interfaces/desktop/main.js); browser clients can pass `?token=`. Without
@@ -20,11 +21,14 @@ export function setDesktopMessageHandler(fn) {
 // when host is set to 0.0.0.0) could open the channel and drive the
 // super-agent. See QA BUG-WS-AUTH.
 
-/** Path-gate: is this upgrade for the desktop (or legacy overlay) WS channel? */
+/** The desktop channel's upgrade path. Lives under /api like every other route. */
+export const DESKTOP_WS_PATH = apiPath("/desktop/ws");
+
+/** Path-gate: is this upgrade for the desktop WS channel? */
 export function isDesktopUpgradePath(url) {
   let pathname = url || "";
   try { pathname = new URL(url, "http://localhost").pathname; } catch { /* keep raw */ }
-  return pathname === "/desktop/ws" || pathname === "/overlay/ws";
+  return pathname === DESKTOP_WS_PATH;
 }
 
 /** Extract the bearer token from the upgrade request (header first, ?token= fallback). */

package/src/host/daemon/index.js

@@ -12,12 +12,10 @@ import { randomBytes } from "node:crypto";
 const LOOPBACK_HOST = "127.0.0.1";
 import {
   readConfig,
-  writeConfig,
   effectiveHost,
   effectivePort,
   addProject as addProjectInConfig,
   PID_PATH,
-  LOG_PATH,
   APX_HOME,
   TOKEN_PATH,
 } from "#core/config/index.js";
@@ -297,12 +295,11 @@ async function main() {
     }).catch(() => {});
   });
 
-  // Attach WebSocket upgrade for the desktop channel on /desktop/ws
-  // (legacy /overlay/ws still accepted for one release).
+  // Attach WebSocket upgrade for the desktop channel on /api/desktop/ws.
   server.on("upgrade", async (req, socket, head) => {
     if (!isDesktopUpgradePath(req.url)) { socket.destroy(); return; }
     // Auth: the WS upgrade must carry a valid token (master or paired client),
-    // matching the HTTP /desktop/* routes. Without this, any client that can
+    // matching the HTTP /api/desktop/* routes. Without this, any client that can
     // reach the daemon (host binds 0.0.0.0 → the LAN) could open the desktop
     // channel and drive the super-agent (permission_mode "total"). The
     // legitimate desktop window already sends the bearer token. See QA BUG-WS-AUTH.
@@ -358,6 +355,15 @@ async function main() {
   process.on("uncaughtException", (e) => {
     log(`uncaughtException: ${e.stack || e.message}`);
   });
+  // Node >= 15 terminates the process on an unhandled rejection. The CLI has
+  // always registered this; the daemon had not, so one un-awaited failure in a
+  // route or a plugin took down the process serving the SPA, Telegram polling,
+  // voice and the deck at once. Log and keep running — the request-level
+  // errorMiddleware already answers the caller.
+  process.on("unhandledRejection", (reason) => {
+    const e = reason instanceof Error ? reason : new Error(String(reason));
+    log(`unhandledRejection: ${e.stack || e.message}`);
+  });
 }
 
 main().catch((e) => {

package/src/host/daemon/plugins/desktop/index.js

@@ -25,6 +25,7 @@ import {
 import { runSuperAgent, isSuperAgentEnabled } from "#core/agent/super-agent.js";
 import { appendGlobalMessage } from "#core/stores/messages.js";
 import { stripEmotionTags } from "#core/voice/emotions.js";
+import { stripReasoning } from "#core/util/thinking.js";
 import { CHANNELS } from "#core/constants/channels.js";
 import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
 
@@ -103,7 +104,7 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
     await appendGlobalMessage({ channel: CHANNEL, direction: "in", type: "user", author: "user", body: text });
   } catch {}
 
-  let toolsExecuted = [];
+  const toolsExecuted = [];
 
   // Per-segment streaming: instead of merging the whole turn into one blob, we
   // emit each assistant text piece as its own `segment` (an intro before a tool,
@@ -123,7 +124,12 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
     emittedSegments.push(seg);
     // `text` is what the bubble shows (no [tags]); `speak` keeps the inline
     // emotion tags so the renderer's per-segment TTS can use them.
-    _send(ws, { type: "segment", seq: ++segSeq, text: stripEmotionTags(seg), speak: seg });
+    // Desktop is voice-first: an unstripped reasoning dump would be spoken
+    // aloud, at length, in the wrong language. Drop the segment entirely
+    // rather than narrate the model's notes.
+    const spoken = stripReasoning(seg).answer;
+    if (!spoken.trim()) return;
+    _send(ws, { type: "segment", seq: ++segSeq, text: stripEmotionTags(spoken), speak: spoken });
   };
 
   try {

package/src/host/daemon/plugins/telegram/index.js

@@ -311,9 +311,13 @@ export default {
       // that bot; otherwise first available bot-tokened channel. Always logs
       // the outbound on `messages` of the channel's target project so audit
       // trails are complete.
-      async send({ channel: channelName, chat_id, text, author = resolveAgentName(config), project }) {
+      // `reply_markup` carries the interruption-budget feedback keyboard on
+      // proactive pushes (core/nudge). It is NOT a gate: the gate belongs at
+      // the call sites that decide to speak unprompted, because this method
+      // also carries traffic the user asked for.
+      async send({ channel: channelName, chat_id, text, reply_markup, author = resolveAgentName(config), meta: extraMeta }) {
         const p = pickPoller(pollers, channelName);
-        const result = await p._send({ chat_id, text });
+        const result = await p._send({ chat_id, text, reply_markup });
         appendGlobalMessage({
           channel: CHANNELS.TELEGRAM,
           direction: "out",
@@ -327,6 +331,7 @@ export default {
             chat_id: chat_id || resolveChatId(p.channel),
             tg_channel: p.channel.name,
             via: channelName ? "explicit" : "auto",
+            ...(extraMeta || {}),
           },
         });
         return result;

package/src/host/daemon/stt-venv.js

@@ -1,27 +1,33 @@
-// Dedicated Python virtualenv for the STT engines.
+// Which Python runs whisper-server.py.
 //
-// We never install into the system or user-site Python — mlx-whisper drags in
+// APX owns a dedicated virtualenv at ~/.apx/runtime/whisper-venv rather than
+// installing into the system or user-site Python: mlx-whisper drags in
 // torch/scipy/numba and would pollute (or clash with) the user's other
-// projects. Instead APX owns ~/.apx/runtime/whisper-venv: create it, install
-// faster-whisper / mlx-whisper into it, and spawn whisper-server.py with its
-// interpreter. "Reset the engine" = delete the folder and recreate it.
-import os from "node:os";
+// projects.
+//
+// This module used to also create that venv and pip-install into it
+// (ensureVenv, pipInstall, venvHasModule, removeVenv, ENGINE_PACKAGES). None of
+// it was ever called — the installer path was built and then superseded — so it
+// was ~120 lines of dead code sitting next to a live one-liner. Removed. If
+// venv provisioning comes back, it belongs in its own module with a caller.
 import path from "node:path";
 import fs from "node:fs";
-import { spawn } from "node:child_process";
-
-export const VENV_DIR = path.join(os.homedir(), ".apx", "runtime", "whisper-venv");
+import { WHISPER_VENV_DIR } from "#core/config/paths.js";
 
 /** Path to the venv's python (…/bin/python on POSIX, …/Scripts on Windows). */
-export function venvPython() {
+function venvPython() {
   return process.platform === "win32"
-    ? path.join(VENV_DIR, "Scripts", "python.exe")
-    : path.join(VENV_DIR, "bin", "python");
+    ? path.join(WHISPER_VENV_DIR, "Scripts", "python.exe")
+    : path.join(WHISPER_VENV_DIR, "bin", "python");
 }
 
 /** True once the venv has a usable interpreter. */
-export function venvExists() {
-  try { return fs.existsSync(venvPython()); } catch { return false; }
+function venvExists() {
+  try {
+    return fs.existsSync(venvPython());
+  } catch {
+    return false;
+  }
 }
 
 /**
@@ -31,70 +37,3 @@ export function venvExists() {
 export function pythonForWhisper() {
   return venvExists() ? venvPython() : "python3";
 }
-
-function run(cmd, args, onLine) {
-  return new Promise((resolve) => {
-    let proc;
-    try {
-      proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-    } catch (e) {
-      onLine?.(`spawn failed: ${e.message}`);
-      return resolve({ ok: false, code: -1 });
-    }
-    const pump = (chunk) => {
-      for (const line of chunk.toString().split(/\r?\n/)) {
-        if (line.trim()) onLine?.(line);
-      }
-    };
-    proc.stdout.on("data", pump);
-    proc.stderr.on("data", pump);
-    proc.on("exit", (code) => resolve({ ok: code === 0, code }));
-    proc.on("error", (e) => { onLine?.(e.message); resolve({ ok: false, code: -1 }); });
-  });
-}
-
-/** Create the venv (idempotent). Streams progress lines to onLine. */
-export async function ensureVenv(onLine) {
-  if (venvExists()) return { ok: true, created: false };
-  fs.mkdirSync(path.dirname(VENV_DIR), { recursive: true });
-  onLine?.(`creating venv at ${VENV_DIR}…`);
-  const r = await run("python3", ["-m", "venv", VENV_DIR], onLine);
-  if (!r.ok || !venvExists()) return { ok: false, error: "venv creation failed" };
-  // Upgrade pip once so wheel resolution is fast/modern.
-  await run(venvPython(), ["-m", "pip", "install", "--upgrade", "pip", "wheel"], onLine);
-  return { ok: true, created: true };
-}
-
-/** Is a module importable inside the venv? */
-export function venvHasModule(mod) {
-  return new Promise((resolve) => {
-    if (!venvExists()) return resolve(false);
-    const p = spawn(venvPython(), ["-c", `import ${mod}`], { stdio: "ignore" });
-    p.on("exit", (code) => resolve(code === 0));
-    p.on("error", () => resolve(false));
-  });
-}
-
-/** pip install <pkgs> into the venv, streaming progress. Creates the venv first. */
-export async function pipInstall(pkgs, onLine) {
-  const ensured = await ensureVenv(onLine);
-  if (!ensured.ok) return ensured;
-  const list = Array.isArray(pkgs) ? pkgs : [pkgs];
-  onLine?.(`installing ${list.join(", ")}…`);
-  const r = await run(venvPython(), ["-m", "pip", "install", "--upgrade", ...list], onLine);
-  return { ok: r.ok, code: r.code };
-}
-
-/** Delete the whole venv (so the engine can be reinstalled clean). */
-export async function removeVenv(onLine) {
-  if (!fs.existsSync(VENV_DIR)) return { ok: true, removed: false };
-  onLine?.(`removing ${VENV_DIR}…`);
-  await fs.promises.rm(VENV_DIR, { recursive: true, force: true });
-  return { ok: !fs.existsSync(VENV_DIR), removed: true };
-}
-
-/** Engine → the pip package(s) it needs in the venv. */
-export const ENGINE_PACKAGES = {
-  faster: ["faster-whisper"],
-  mlx: ["mlx-whisper"],
-};

package/src/host/daemon/wakeup.js

@@ -2,6 +2,7 @@
 import fetch from "node-fetch";
 import { readIdentity, writeIdentity } from "#core/identity/index.js";
 import { resolveProvider, getAdapter } from "#core/engines/index.js";
+import { canNudge, recordNudge, nudgeFeedbackKeyboard } from "#core/nudge/index.js";
 
 const WAKEUP_COOLDOWN_MS = 30 * 60 * 1000; // 30 min
 
@@ -18,7 +19,7 @@ export function detectLanguage(identity, config) {
   if (cfgLang) return ISO_TO_LANGUAGE[cfgLang.toLowerCase()] || cfgLang;
   if (identity?.language) return identity.language;
   const lang = process.env.LANG || process.env.LC_MESSAGES || process.env.LC_ALL || "";
-  const code = lang.split(/[_\.]/)[0].toLowerCase();
+  const code = lang.split(/[_.]/)[0].toLowerCase();
   return ISO_TO_LANGUAGE[code] || "English";
 }
 
@@ -50,12 +51,12 @@ async function generateMessage(identity, engineConfig) {
   }
 }
 
-async function sendTelegram(token, chatId, text) {
+async function sendTelegram(token, chatId, text, reply_markup) {
   const url = `https://api.telegram.org/bot${token}/sendMessage`;
   const res = await fetch(url, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ chat_id: chatId, text }),
+    body: JSON.stringify({ chat_id: chatId, text, ...(reply_markup ? { reply_markup } : {}) }),
   });
   const json = await res.json();
   if (!json.ok) throw new Error(json.description || "telegram send failed");
@@ -75,10 +76,23 @@ export async function triggerWakeup(config, log) {
     if (elapsed < WAKEUP_COOLDOWN_MS) return;
   }
 
+  // PUSH PATH 1 OF 4 — nobody asked for this one. "I restarted" is the least
+  // interesting thing APX can say, so it is also the first thing a budget
+  // should be allowed to swallow.
+  const gate = canNudge(
+    { kind: "wakeup", severity: "low", unsolicited: true, channel: "telegram" },
+    config,
+  );
+  if (!gate.allowed) {
+    log?.(`wakeup: suppressed by the interruption budget — ${gate.reason}`);
+    return;
+  }
+
   try {
     const message = await generateMessage(identity, config);
     const text = message || `${identity.agent_name} online. Ready.`;
-    await sendTelegram(tg.bot_token, tg.chat_id, text);
+    await sendTelegram(tg.bot_token, tg.chat_id, text, nudgeFeedbackKeyboard(gate.nudge_id));
+    recordNudge(gate, { chat_id: tg.chat_id, preview: text });
     writeIdentity({ last_wakeup: new Date().toISOString() });
     log?.(`wakeup: sent to Telegram chat ${tg.chat_id}`);
   } catch (e) {

package/src/interfaces/acp/index.js

@@ -6,7 +6,7 @@
 //
 // Like the mcp-server surface, this is a thin adapter over the daemon HTTP
 // API: each `session/prompt` becomes a POST to the NDJSON stream endpoint
-// `/projects/:pid/super-agent/chat/stream` and the stream events are mapped
+// `/api/projects/:pid/super-agent/chat/stream` and the stream events are mapped
 // onto ACP `session/update` notifications:
 //
 //   assistant_text         → agent_message_chunk
@@ -179,7 +179,7 @@ export class AcpAgentServer {
     session.activeTurn = turn;
     try {
       const final = await this.client.streamPost(
-        `/projects/${session.project.id}/super-agent/chat/stream`,
+        `/api/projects/${session.project.id}/super-agent/chat/stream`,
         {
           prompt: promptText,
           // ACP clients are coding surfaces (IDEs) — the `code` channel gives
@@ -314,7 +314,7 @@ export class AcpAgentServer {
     }
     try {
       await this.client.post(
-        `/super-agent/confirm/${encodeURIComponent(event.correlationId)}`,
+        `/api/super-agent/confirm/${encodeURIComponent(event.correlationId)}`,
         { confirmed }
       );
     } catch (e) {

package/src/interfaces/acp/session.js

@@ -129,12 +129,12 @@ export async function resolveProjectForCwd(client, cwd) {
       `No APC project found at or above: ${cwd}. Run \`apx init\` in the workspace first.`
     );
   }
-  const projects = await client.get("/projects");
+  const projects = await client.get("/api/projects");
   const match = (projects || []).find(
     (p) => path.resolve(p.path) === path.resolve(root)
   );
   if (match) return match;
-  return client.post("/projects", { path: root });
+  return client.post("/api/projects", { path: root });
 }
 
 /** Flatten an ACP prompt (ContentBlock[]) into the text the daemon expects. */

package/src/interfaces/cli/commands/a2a.js

@@ -26,7 +26,7 @@ export async function cmdSend(args) {
   if (!body) throw new Error("apx send: body is empty");
 
   const pid = await resolveProjectId(args?.flags?.project);
-  const result = await http.post(`/projects/${pid}/send`, {
+  const result = await http.post(`/api/projects/${pid}/send`, {
     from,
     to,
     body,
@@ -48,7 +48,7 @@ export async function cmdConnections(args) {
   const slug = args._[0];
   if (!slug) throw new Error("apx connections: missing <agent-slug>");
   const pid = await resolveProjectId(args?.flags?.project);
-  const peers = await http.get(`/projects/${pid}/agents/${slug}/connections`);
+  const peers = await http.get(`/api/projects/${pid}/agents/${slug}/connections`);
   if (peers.length === 0) {
     console.log(`(no connections logged for ${slug} yet)`);
     return;

package/src/interfaces/cli/commands/agent.js

@@ -24,9 +24,9 @@ function requireRoot() {
 async function nudgeDaemon(root) {
   try {
     if (!(await http.ping())) return;
-    const projects = await http.get("/projects", { autoStart: false });
+    const projects = await http.get("/api/projects", { autoStart: false });
     const me = projects.find((p) => p.path === root);
-    if (me) await http.post(`/projects/${me.id}/rebuild`, undefined, { autoStart: false });
+    if (me) await http.post(`/api/projects/${me.id}/rebuild`, undefined, { autoStart: false });
   } catch { /* daemon hiccup */ }
 }
 
@@ -116,7 +116,7 @@ export async function cmdAgentRemove(args) {
     }
   }
   const pid = await resolveProjectId(args?.flags?.project);
-  await http.delete(`/projects/${pid}/agents/${slug}`);
+  await http.delete(`/api/projects/${pid}/agents/${slug}`);
   console.log(`${tag("removed")}  ${bold(slug)}  ${gray("(agent file + runtime memory deleted)")}`);
 }