@agentprojectcontext/apx 1.33.1 → 1.35.0

package/src/host/daemon/api/routines.js

@@ -15,7 +15,7 @@ import {
   deleteRoutine,
   setEnabled as setRoutineEnabled,
   runRoutineNow,
-} from "../routines.js";
+} from "#core/routines/index.js";
 
 export function register(app, { projects, registries, plugins, project, config }) {
   app.get("/projects/:pid/routines", (req, res) => {

package/src/host/daemon/api/runtimes.js

@@ -8,11 +8,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { readAgents } from "#core/apc/parser.js";
+import { apcProjectFile, apcAgentsDir } from "#core/apc/paths.js";
 import { readSessionFrontmatter } from "#core/stores/sessions.js";
 import { buildAgentSystem } from "#core/agent/build-agent-system.js";
 import { CHANNELS } from "#core/constants/channels.js";
 import { getRuntime, RUNTIME_IDS } from "../runtimes/index.js";
-import { detectAll } from "../env-detect.js";
+import { detectAll } from "#core/runtimes/detect.js";
 import { buildRuntimeBridgeHint as buildApfHint } from "#core/agent/runtime-bridge.js";
 import {
   createRuntimeSession,
@@ -52,7 +53,7 @@ export function register(app, { projects, registries, plugins, project, config }
     let projectName = path.basename(p.path);
     try {
       const meta = JSON.parse(
-        fs.readFileSync(path.join(p.path, ".apc", "project.json"), "utf8")
+        fs.readFileSync(apcProjectFile(p.path), "utf8")
       );
       if (meta.name) projectName = meta.name;
     } catch {}
@@ -152,7 +153,7 @@ export function register(app, { projects, registries, plugins, project, config }
 
     const sessionRoots = [
       path.join(p.storagePath || p.path, "agents"),
-      path.join(p.path, ".apc", "agents"),
+      apcAgentsDir(p.path),
     ];
     let sessionFile = null;
     let agentSlug = null;

package/src/host/daemon/api/sessions-search.js

@@ -2,169 +2,53 @@
 //   GET  /sessions/search?q=…&project=…&limit=20
 //   POST /sessions/:id/compact     resolves which project/agent owns the file
 //                                  then delegates to compactConversation.
-import fs from "node:fs";
 import path from "node:path";
 import { readAgents } from "#core/apc/parser.js";
-import { compactConversation } from "../compact.js";
+import { compactConversation } from "#core/stores/conversations-compactor.js";
+import { searchSessions, findSessionFile } from "#core/stores/sessions-search.js";
+
+function resolveProjects(projects, projectRef) {
+  const all = projects.list();
+  if (projectRef != null) {
+    const ref = String(projectRef);
+    const found = all.find((p) => String(p.id) === ref || p.path === path.resolve(ref));
+    return found ? [projects.get(found.id)] : [];
+  }
+  return all.map((p) => projects.get(p.id)).filter(Boolean);
+}
 
 export function register(app, { projects, config }) {
   app.get("/sessions/search", (req, res) => {
     const { q, project: projectRef, limit = "20" } = req.query;
     if (!q) return res.status(400).json({ error: "q required" });
     const lim = Math.min(parseInt(limit, 10) || 20, 200);
-    const needle = q.toLowerCase();
-
-    const allProjects = projects.list();
-    const targetProjects = (() => {
-      if (projectRef != null) {
-        const ref = String(projectRef);
-        const found = allProjects.find(
-          (p) => String(p.id) === ref || p.path === path.resolve(ref)
-        );
-        return found ? [projects.get(found.id)] : [];
-      }
-      return allProjects.map((p) => projects.get(p.id)).filter(Boolean);
-    })();
-
-    const matches = [];
-
-    for (const p of targetProjects) {
-      if (!p) continue;
-
-      // 1) Legacy session files in the repo (.apc/agents/<slug>/sessions/)
-      const sessionAgentsDir = path.join(p.path, ".apc", "agents");
-      if (fs.existsSync(sessionAgentsDir)) {
-        for (const slug of fs.readdirSync(sessionAgentsDir)) {
-          const sessionsDir = path.join(sessionAgentsDir, slug, "sessions");
-          if (!fs.existsSync(sessionsDir)) continue;
-          for (const f of fs
-            .readdirSync(sessionsDir)
-            .filter((x) => x.endsWith(".md"))) {
-            const filePath = path.join(sessionsDir, f);
-            try {
-              const text = fs.readFileSync(filePath, "utf8");
-              if (text.toLowerCase().includes(needle)) {
-                const lines = text.split("\n");
-                const matchLine = lines.findIndex((l) =>
-                  l.toLowerCase().includes(needle)
-                );
-                const excerpt = lines
-                  .slice(Math.max(0, matchLine - 1), matchLine + 3)
-                  .join("\n");
-                matches.push({
-                  type: "session",
-                  project: p.id,
-                  agent: slug,
-                  filename: f,
-                  path: filePath,
-                  excerpt: excerpt.slice(0, 300),
-                });
-                if (matches.length >= lim) break;
-              }
-            } catch {}
-          }
-          if (matches.length >= lim) break;
-        }
-      }
-
-      if (matches.length >= lim) break;
-
-      // 2) Conversation files in daemon storage (~/.apx/…/conversations/)
-      const convAgentsDir = path.join(p.storagePath, "agents");
-      if (fs.existsSync(convAgentsDir)) {
-        for (const slug of fs.readdirSync(convAgentsDir)) {
-          const convDir = path.join(convAgentsDir, slug, "conversations");
-          if (!fs.existsSync(convDir)) continue;
-          for (const f of fs
-            .readdirSync(convDir)
-            .filter((x) => x.endsWith(".md"))) {
-            const filePath = path.join(convDir, f);
-            try {
-              const text = fs.readFileSync(filePath, "utf8");
-              if (text.toLowerCase().includes(needle)) {
-                const lines = text.split("\n");
-                const matchLine = lines.findIndex((l) =>
-                  l.toLowerCase().includes(needle)
-                );
-                const excerpt = lines
-                  .slice(Math.max(0, matchLine - 1), matchLine + 3)
-                  .join("\n");
-                matches.push({
-                  type: "conversation",
-                  project: p.id,
-                  agent: slug,
-                  filename: f,
-                  path: filePath,
-                  excerpt: excerpt.slice(0, 300),
-                });
-                if (matches.length >= lim) break;
-              }
-            } catch {}
-          }
-          if (matches.length >= lim) break;
-        }
-      }
-
-      if (matches.length >= lim) break;
-    }
-
-    res.json({ q, count: matches.length, results: matches });
+    const targets = resolveProjects(projects, projectRef);
+    const results = searchSessions(targets, q, lim);
+    res.json({ q, count: results.length, results });
   });
 
   app.post("/sessions/:id/compact", async (req, res) => {
     const { id } = req.params;
     const { model: modelOverride, project: projectRef } = req.body || {};
-
-    const candidates =
-      projectRef != null
-        ? (() => {
-            const ref = String(projectRef);
-            const found = projects
-              .list()
-              .find(
-                (p) => String(p.id) === ref || p.path === path.resolve(ref)
-              );
-            return found ? [projects.get(found.id)] : [];
-          })()
-        : projects.list().map((p) => projects.get(p.id)).filter(Boolean);
-
-    let found = null;
-    const filename = id.endsWith(".md") ? id : `${id}.md`;
-
-    for (const p of candidates) {
-      if (!p) continue;
-      const agentsDir = path.join(p.storagePath, "agents");
-      if (fs.existsSync(agentsDir)) {
-        for (const slug of fs.readdirSync(agentsDir)) {
-          const f = path.join(agentsDir, slug, "conversations", filename);
-          if (fs.existsSync(f)) {
-            found = { p, slug };
-            break;
-          }
-        }
-      }
-      if (found) break;
-    }
+    const candidates = resolveProjects(projects, projectRef);
+    const found = findSessionFile(candidates, id);
 
     if (!found) {
-      return res
-        .status(404)
-        .json({ error: `session/conversation "${id}" not found` });
+      return res.status(404).json({ error: `session/conversation "${id}" not found` });
     }
 
-    const { p, slug } = found;
+    const { project: p, agentSlug, filename } = found;
     const agents = readAgents(p.path);
-    const agent = agents.find((a) => a.slug === slug);
+    const agent = agents.find((a) => a.slug === agentSlug);
     const modelId = modelOverride || agent?.fields?.Model;
-    if (!modelId)
-      return res
-        .status(400)
-        .json({ error: "agent has no model; pass model in body" });
+    if (!modelId) {
+      return res.status(400).json({ error: "agent has no model; pass model in body" });
+    }
 
     try {
       const result = await compactConversation({
         storagePath: p.storagePath,
-        agentSlug: slug,
+        agentSlug,
         filename,
         modelId,
         config: p.config || config,

package/src/host/daemon/api/sessions.js

@@ -4,9 +4,15 @@
 //   GET  /projects/:pid/sessions/:sid              by filename (cross-agent lookup)
 import fs from "node:fs";
 import path from "node:path";
-import { parseSessionFrontmatter, readAgents } from "#core/apc/parser.js";
+import { readAgents } from "#core/apc/parser.js";
+import {
+  parseSessionFrontmatter,
+} from "#core/apc/parser.js";
+import {
+  agentSessionsDir,
+  createAgentSessionFile,
+} from "#core/stores/sessions.js";
 import { collectAllSessions } from "#interfaces/cli/commands/sessions.js";
-import { nowIso } from "./shared.js";
 
 export function register(app, { projects, project }) {
   // Cross-engine sessions (apx · claude · codex), newest first.
@@ -29,12 +35,7 @@ export function register(app, { projects, project }) {
     const agents = readAgents(p.path);
     if (!agents.find((a) => a.slug === req.params.slug))
       return res.status(404).json({ error: "agent not found" });
-    const sessionsDir = path.join(
-      p.storagePath,
-      "agents",
-      req.params.slug,
-      "sessions"
-    );
+    const sessionsDir = agentSessionsDir(p.storagePath, req.params.slug);
     if (!fs.existsSync(sessionsDir)) return res.json([]);
     const sessions = fs
       .readdirSync(sessionsDir)
@@ -62,32 +63,13 @@ export function register(app, { projects, project }) {
     if (!p) return;
     const { title, body = "" } = req.body || {};
     if (!title) return res.status(400).json({ error: "title required" });
-    const sessionsDir = path.join(
+    const { filename, path: filePath } = createAgentSessionFile(
       p.storagePath,
-      "agents",
       req.params.slug,
-      "sessions"
+      { title, body }
     );
-    fs.mkdirSync(sessionsDir, { recursive: true });
-    const titleSlug =
-      title
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "") || "session";
-    const today = new Date().toISOString().slice(0, 10);
-    let candidate = path.join(sessionsDir, `${today}-${titleSlug}.md`);
-    let n = 2;
-    while (fs.existsSync(candidate)) {
-      candidate = path.join(sessionsDir, `${today}-${titleSlug}-${n}.md`);
-      n++;
-    }
-    const started = nowIso();
-    const content = `---\ntitle: ${title}\nstarted: ${started}\n---\n\n# ${title}\n\n${body}\n`;
-    fs.writeFileSync(candidate, content);
     projects.rebuild(p.id);
-    res
-      .status(201)
-      .json({ filename: path.basename(candidate), path: candidate });
+    res.status(201).json({ filename, path: filePath });
   });
 
   // GET session by filename (sid may include or omit the .md extension)

package/src/host/daemon/api/shared.js

@@ -8,6 +8,7 @@ import { randomUUID } from "node:crypto";
 import { appendErrorTrace, previewText } from "#core/logging.js";
 import { readAgents } from "#core/apc/parser.js";
 import { agentMemoryPath } from "#core/agent/memory.js";
+import { apcMemoryFile } from "#core/apc/paths.js";
 import { CHANNELS } from "#core/constants/channels.js";
 
 export const nowIso = () =>
@@ -117,7 +118,7 @@ export function makeTopProjectResolver(projects) {
 export function resolveMemoryPath(p) {
   const firstAgent = readAgents(p.path)[0];
   if (firstAgent) return agentMemoryPath(p, firstAgent.slug);
-  return path.join(p.path, ".apc", "memory.md");
+  return apcMemoryFile(p.path);
 }
 
 // Channel context passed to the super-agent loop. `api` is the default when

package/src/host/daemon/api/skills.js

@@ -1,12 +1,42 @@
-// Lightweight `/skills` listing for UI surfaces (web composer picker,
-// future palettes). Same data backing `list_skills` tool, but here without
-// auth-binding to a project — anyone with a valid daemon token can ask
-// "which skills are around right now?".
+// `/skills` listing + Skill Inspector control surface for UI clients.
 //
-// Returns the catalog already condensed (slug + first-sentence description)
-// so the picker doesn't have to repeat the cleanup work.
+//   GET  /skills                       catalog (slug + condensed description)
+//   GET  /skills/inspector             inspector config + index status
+//   PUT  /skills/inspector             toggle / tune inspector config
+//   POST /skills/index                 (re)build the inspector vector index
+//   POST /skills/inspect               dry-run the inspector for a prompt
+//
+// The listing is the same data backing `list_skills` (no auth-binding to a
+// project). The inspector routes mirror /embeddings/* so the web admin can
+// configure the skill RAG exactly like it configures the memory RAG.
 import { listSkills } from "#core/agent/skills/loader.js";
 import { condenseSkillDescription } from "#core/agent/skills/catalog.js";
+import {
+  inspectPromptForSkills,
+  INSPECTOR_DEFAULTS,
+} from "#core/agent/skills/inspector.js";
+import {
+  ensureIndex,
+  planIndex,
+  readIndex,
+} from "#core/agent/skills/index-store.js";
+import { readConfig, writeConfig } from "#core/config/index.js";
+
+const KNOWN_KEYS = Object.keys(INSPECTOR_DEFAULTS);
+
+function mergedInspectorConfig(cfg) {
+  return { ...INSPECTOR_DEFAULTS, ...(cfg?.skills?.inspector || {}) };
+}
+
+function indexStatus() {
+  const idx = readIndex();
+  return {
+    count: Object.keys(idx.items || {}).length,
+    embedder: idx.embedder || null,
+    dim: idx.dim || null,
+    updated_at: idx.updated_at || null,
+  };
+}
 
 export function register(app /*, ctx */) {
   app.get("/skills", (req, res) => {
@@ -27,4 +57,108 @@ export function register(app /*, ctx */) {
       res.status(500).json({ error: e.message });
     }
   });
+
+  // ---- Inspector config + status -----------------------------------------
+
+  app.get("/skills/inspector", (_req, res) => {
+    try {
+      const cfg = readConfig();
+      res.json({
+        config: mergedInspectorConfig(cfg),
+        defaults: INSPECTOR_DEFAULTS,
+        keys: KNOWN_KEYS,
+        index: indexStatus(),
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  app.put("/skills/inspector", (req, res) => {
+    try {
+      const patch = req.body || {};
+      const cfg = readConfig();
+      cfg.skills = cfg.skills || {};
+      const current = mergedInspectorConfig(cfg);
+      const next = { ...current };
+
+      for (const [k, v] of Object.entries(patch)) {
+        if (!KNOWN_KEYS.includes(k)) continue;
+        const def = INSPECTOR_DEFAULTS[k];
+        if (typeof def === "boolean") next[k] = !!v;
+        else if (typeof def === "number") {
+          const n = Number(v);
+          if (Number.isFinite(n)) next[k] = n;
+        } else {
+          next[k] = v;
+        }
+      }
+
+      cfg.skills.inspector = next;
+      writeConfig(cfg);
+      res.json({ ok: true, config: next, index: indexStatus() });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  // ---- Index build --------------------------------------------------------
+
+  app.post("/skills/index", async (req, res) => {
+    try {
+      const { project_path, force } = req.body || {};
+      const cfg = readConfig();
+      const plan = planIndex({ projectPath: project_path });
+      const out = await ensureIndex({
+        projectPath: project_path,
+        embedOpts: { globalConfig: cfg },
+        force: !!force,
+      });
+      res.json({
+        ok: true,
+        embedder: out.embedder,
+        dim: out.dim,
+        planned: {
+          missing: plan.missing.length,
+          stale: plan.stale.length,
+          gone: plan.gone.length,
+          total: plan.total,
+        },
+        changed: {
+          added: out.changed.added.length,
+          refreshed: out.changed.refreshed.length,
+          removed: out.changed.removed.length,
+          kept: out.changed.kept.length,
+        },
+        index: indexStatus(),
+      });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
+  // ---- Dry-run ------------------------------------------------------------
+
+  app.post("/skills/inspect", async (req, res) => {
+    try {
+      const { prompt, project_path } = req.body || {};
+      if (!prompt || typeof prompt !== "string") {
+        return res.status(400).json({ error: "prompt required" });
+      }
+      const cfg = readConfig();
+      // Force enabled for the dry-run so the operator sees what it WOULD do
+      // even when the feature is currently off.
+      const probed = structuredClone(cfg);
+      probed.skills = probed.skills || {};
+      probed.skills.inspector = { ...mergedInspectorConfig(cfg), enabled: true };
+      const out = await inspectPromptForSkills({
+        prompt,
+        projectPath: project_path,
+        globalConfig: probed,
+      });
+      res.json({ trace: out.trace, contextNote: out.contextNote });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
 }

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

@@ -15,10 +15,30 @@ import { appendGlobalMessage } from "#core/stores/messages.js";
 import { createWebConfirmAdapter } from "#core/confirmation/adapters/web.js";
 import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
 import { suggestSkillForPrompt } from "#core/agent/skills/rag.js";
+import { inspectPromptForSkills, isInspectorEnabled, summarizeTrace } from "#core/agent/skills/inspector.js";
 import { CHANNELS } from "#core/constants/channels.js";
 
 const log = loggerFor("super-agent");
 
+// Emit a single, readable line so `apx log -f` shows exactly what the skill
+// inspector decided this turn (which skills it loaded/hinted, the embedder, and
+// the top similarity). Best-effort: logging must never break a reply.
+function logInspectorDecision(trace, { trace_id, channel } = {}) {
+  if (!trace) return;
+  try {
+    const top = trace.scored?.[0];
+    const topStr = top ? ` top=${top.slug}@${top.sim}` : "";
+    log.info(`skill inspector: ${summarizeTrace(trace)} [${trace.embedder || "?"}]${topStr}`, {
+      trace_id,
+      channel,
+      loaded: trace.loaded || [],
+      hinted: trace.hinted || [],
+    });
+  } catch {
+    /* logging is best-effort */
+  }
+}
+
 // Persist human web turns to the cross-channel message store so they feed the
 // RAG index, search_messages, and the "active threads" awareness block. Only
 // the human surfaces (web big chat + sidebar) — not generic "api"/automation
@@ -79,10 +99,25 @@ export function register(app, { projects, registries, plugins, project, config }
     // slug is unknown.
     const slashed = tryResolveSkillCommand(rawPrompt, { projectPath: p.path });
     const prompt = slashed.handled ? slashed.prompt : rawPrompt;
+    const inspectorOn = isInspectorEnabled(config);
+    let inspectorTrace = null;
     if (slashed.handled) {
       ctx.contextNote = [ctx.contextNote, slashed.contextNote].filter(Boolean).join("\n\n");
+    } else if (inspectorOn) {
+      // Inspector middleware: per-turn semantic RAG. Replaces both the passive
+      // suggestSkillForPrompt nudge AND the static slug-dump in the system
+      // prompt — see runSuperAgent({ skipSkillsHint }).
+      const out = await inspectPromptForSkills({
+        prompt,
+        projectPath: p.path,
+        globalConfig: config,
+      });
+      inspectorTrace = out.trace;
+      if (out.contextNote) {
+        ctx.contextNote = [ctx.contextNote, out.contextNote].filter(Boolean).join("\n\n");
+      }
     } else {
-      // Semantic skill nudge — only when there was no explicit /slug.
+      // Legacy path — passive nudge, still works when inspector is off.
       const hint = await suggestSkillForPrompt(prompt, { projectPath: p.path });
       if (hint) ctx.contextNote = [ctx.contextNote, hint].filter(Boolean).join("\n\n");
     }
@@ -101,6 +136,14 @@ export function register(app, { projects, registries, plugins, project, config }
       channel: ctx.channel,
     });
 
+    // Surface the inspector decision to clients before model_start so the web
+    // debug panel / TUI can render "loaded: X" the moment the turn begins.
+    if (inspectorTrace) {
+      try { onEvent({ type: "skill_inspector", inspector: inspectorTrace }); }
+      catch { /* trace is best-effort */ }
+      logInspectorDecision(inspectorTrace, { trace_id: req.apxTraceId, channel: ctx.channel });
+    }
+
     // 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 });
@@ -122,6 +165,7 @@ export function register(app, { projects, registries, plugins, project, config }
         ...(completionContract ? { completionContract: true } : {}),
         onEvent,
         requestConfirmation,
+        skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
       logWebTurn(ctx.channel, { prompt, replyText: saResult.text });
@@ -194,6 +238,16 @@ export function register(app, { projects, registries, plugins, project, config }
       req.body || {};
     if (!prompt) return res.status(400).json({ error: "prompt required" });
     const ctx = resolveSuperAgentContext(req, p);
+    const inspectorOn = isInspectorEnabled(config);
+    if (inspectorOn) {
+      try {
+        const out = await inspectPromptForSkills({ prompt, projectPath: p.path, globalConfig: config });
+        if (out.contextNote) {
+          ctx.contextNote = [ctx.contextNote, out.contextNote].filter(Boolean).join("\n\n");
+        }
+        logInspectorDecision(out.trace, { trace_id: req.apxTraceId, channel: ctx.channel });
+      } catch { /* inspector failure must not block the turn */ }
+    }
     try {
       const saResult = await runSuperAgent({
         globalConfig: config,
@@ -213,6 +267,7 @@ export function register(app, { projects, registries, plugins, project, config }
           trace_id: req.apxTraceId,
           channel: ctx.channel,
         }),
+        skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
       logWebTurn(ctx.channel, { prompt, replyText: saResult.text });

package/src/host/daemon/api/telegram.js

@@ -39,17 +39,7 @@ import {
   removeRole,
 } from "#core/config/index.js";
 
-function redactChannel(channel) {
-  if (!channel?.bot_token) return channel;
-  return {
-    ...channel,
-    bot_token: `*** set *** (...${String(channel.bot_token).slice(-5)})`,
-  };
-}
-
-function isSecretMarker(value) {
-  return typeof value === "string" && value.startsWith("*** set ***");
-}
+import { redactChannel, isSecretMarker } from "#core/config/redact.js";
 
 export function register(app, { telegram }) {
   app.get("/telegram/status", (_req, res) => {

package/src/host/daemon/api/tools.js

@@ -4,12 +4,12 @@
 //   search / glob / grep                    → filesystem-bounded
 //   registry                                → /:name wildcard, MOUNT LAST so it
 //                                             doesn't shadow the specific paths
-import { buildBrowserRouter } from "#core/tools/browser.js";
-import { buildFetchRouter } from "#core/tools/fetch.js";
-import { buildSearchRouter } from "#core/tools/search.js";
-import { buildRegistryRouter } from "#core/tools/registry.js";
-import { buildGlobRouter } from "#core/tools/glob.js";
-import { buildGrepRouter } from "#core/tools/grep.js";
+import { buildBrowserRouter } from "#core/http-tools/browser.js";
+import { buildFetchRouter } from "#core/http-tools/fetch.js";
+import { buildSearchRouter } from "#core/http-tools/search.js";
+import { buildRegistryRouter } from "#core/http-tools/registry.js";
+import { buildGlobRouter } from "#core/http-tools/glob.js";
+import { buildGrepRouter } from "#core/http-tools/grep.js";
 
 export function register(app, { express, projects, registries }) {
   app.use("/tools/fetch", buildFetchRouter(express));

package/src/host/daemon/api/transcribe.js

@@ -11,7 +11,7 @@ export function register(app) {
   // the first real utterance doesn't pay the cold-load cost.
   app.get("/transcribe/warmup", async (_req, res) => {
     try {
-      const { warmupWhisper } = await import("../transcription.js");
+      const { warmupWhisper } = await import("../whisper-server.js");
       res.json(await warmupWhisper());
     } catch (e) {
       res.status(500).json({ ok: false, error: e.message });
@@ -29,7 +29,7 @@ export function register(app) {
       const language = req.headers["x-language"] || "auto";
       const provider = req.headers["x-provider"];
       try {
-        const { transcribeBuffer } = await import("../transcription.js");
+        const { transcribeBuffer } = await import("#core/voice/transcription.js");
         const result = await transcribeBuffer(buf, format, {
           language: language === "auto" ? undefined : language,
           beam_size: 3,