@agentprojectcontext/apx 1.33.0 → 1.34.0

package/src/core/voice/transcription.js

@@ -0,0 +1,225 @@
+// Audio transcription client. Two backends, both pure (no subprocess lifecycle):
+//
+//   - LOCAL: HTTP client that talks to the persistent whisper-server.py at
+//     localhost:WHISPER_LOCAL_PORT. The server itself is spun up/down by
+//     host/daemon/whisper-server.js — this file just assumes it is reachable.
+//   - OPENAI: Whisper-1 cloud API. Needs OPENAI_API_KEY or
+//     engines.openai.api_key in config.
+//
+// Provider selection in ~/.apx/config.json:
+//   "transcription": {
+//     "provider": "auto" | "local" | "openai",
+//     "local": { model, device, compute_type, language, beam_size, idle_minutes }
+//   }
+// "auto" tries local first, falls back to OpenAI if a key is configured.
+//
+// The split rule: anything that boots/teardown a process lives in host/daemon.
+// Anything that sends bytes over HTTP and parses JSON lives here.
+import fs from "node:fs";
+import path from "node:path";
+import { logInfo, logWarn } from "#core/logging.js";
+
+/** Port the host-side whisper-server.py listens on. Single source of truth. */
+export const WHISPER_LOCAL_PORT = 18765;
+
+export const DEFAULT_LOCAL = {
+  model: "small",
+  device: "cpu",
+  compute_type: "int8",
+  language: "auto",
+  beam_size: 5,
+  idle_minutes: 10,
+  // Long audio (Telegram voice notes > 10 min) can take several minutes on
+  // CPU. 20 minutes covers ~60-minute notes on a small int8 model.
+  timeout_ms: 20 * 60_000,
+};
+
+/**
+ * Resolve the effective transcription language. Priority:
+ *   explicit local config → config.user.language → "auto" (whisper detects).
+ */
+export function resolveTranscriptionLanguage(localCfg, userLang) {
+  if (localCfg.language && localCfg.language !== "auto") return localCfg.language;
+  if (userLang) return userLang;
+  return "auto";
+}
+
+export async function getConfig() {
+  try {
+    const { readConfig } = await import("#core/config/index.js");
+    const cfg = readConfig() || {};
+    const t = cfg.transcription || {};
+    const openaiKey = cfg.engines?.openai?.api_key || process.env.OPENAI_API_KEY || "";
+    const userLang = cfg.user?.language || "";
+    const localBase = { ...DEFAULT_LOCAL, ...(t.local || {}) };
+    localBase.language = resolveTranscriptionLanguage(localBase, userLang);
+    return {
+      provider: t.provider || "auto",
+      local: localBase,
+      openaiKey,
+    };
+  } catch {
+    return {
+      provider: "auto",
+      local: { ...DEFAULT_LOCAL },
+      openaiKey: process.env.OPENAI_API_KEY || "",
+    };
+  }
+}
+
+/**
+ * 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.
+ */
+export async function transcribeViaLocalServer(filePath, opts) {
+  const language = (opts.language || DEFAULT_LOCAL.language) === "auto"
+    ? null
+    : (opts.language || null);
+
+  const timeoutMs = Number(opts.timeout_ms) > 0
+    ? Number(opts.timeout_ms)
+    : DEFAULT_LOCAL.timeout_ms;
+
+  const body = JSON.stringify({
+    audio_path: filePath,
+    language,
+    beam_size: opts.beam_size || DEFAULT_LOCAL.beam_size,
+  });
+
+  // Long transcriptions on CPU sometimes trip undici keep-alive on the
+  // outbound socket — retry once on generic "fetch failed".
+  const maxAttempts = 2;
+  let lastErr = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const t0 = Date.now();
+    try {
+      logInfo("whisper", `transcribeViaLocalServer attempt ${attempt}/${maxAttempts}`, {
+        file: path.basename(filePath),
+        language: language || "auto",
+        timeout_ms: timeoutMs,
+      });
+      const res = await fetch(`http://127.0.0.1:${WHISPER_LOCAL_PORT}/transcribe`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "connection": "close" },
+        body,
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+      const json = await res.json();
+      if (!json.ok) throw new Error(json.error || "transcription failed");
+      logInfo("whisper", `transcribeViaLocalServer ok in ${Date.now() - t0}ms`, {
+        chars: (json.text || "").length,
+        language: json.language,
+        duration: json.duration,
+      });
+      return {
+        ok: true,
+        backend: "local",
+        text: json.text || "",
+        language: json.language || null,
+        language_probability: json.language_probability ?? null,
+        duration: json.duration ?? null,
+        model: json.model,
+        compute_type: json.compute_type,
+      };
+    } catch (e) {
+      lastErr = e;
+      const isRetriable = /fetch failed|ECONNRESET|socket hang up|terminated/i.test(e.message || "");
+      const dt = Date.now() - t0;
+      logWarn("whisper", `transcribeViaLocalServer attempt ${attempt} failed in ${dt}ms`, {
+        error: e.message,
+        retriable: isRetriable,
+        will_retry: isRetriable && attempt < maxAttempts,
+      });
+      if (!isRetriable || attempt >= maxAttempts) break;
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  throw lastErr || new Error("transcribeViaLocalServer: unknown failure");
+}
+
+/** OpenAI Whisper-1 cloud API. Needs an api_key. */
+export async function transcribeOpenAI(filePath, apiKey) {
+  if (!apiKey) throw new Error("openai transcription: no api_key");
+  const buf = fs.readFileSync(filePath);
+  const ext = path.extname(filePath).slice(1).toLowerCase() || "webm";
+  const fileType = ext === "ogg" || ext === "oga" ? "audio/ogg"
+    : ext === "mp3" ? "audio/mpeg"
+    : ext === "m4a" ? "audio/mp4"
+    : ext === "wav" ? "audio/wav"
+    : ext === "webm" ? "audio/webm"
+    : "application/octet-stream";
+
+  const form = new FormData();
+  form.append("model", "whisper-1");
+  form.append("file", new Blob([buf], { type: fileType }), path.basename(filePath));
+
+  const res = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+    method: "POST",
+    headers: { authorization: `Bearer ${apiKey}` },
+    body: form,
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => "");
+    throw new Error(`openai whisper ${res.status}: ${errBody.slice(0, 240)}`);
+  }
+  const json = await res.json();
+  return {
+    ok: true,
+    backend: "openai",
+    text: json.text || "",
+    language: json.language || null,
+  };
+}
+
+/**
+ * Transcribe a file. Provider chosen by config:
+ *   - "openai": cloud only
+ *   - "local":  whisper-server only (no fallback)
+ *   - "auto":   local first, OpenAI fallback if api_key present
+ */
+export async function transcribe(filePath, overrides = {}) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    throw new Error(`transcribe: file not found: ${filePath}`);
+  }
+  const cfg = await getConfig();
+  const provider = overrides.provider || cfg.provider;
+  const localOpts = { ...cfg.local, ...overrides };
+
+  if (provider === "openai") {
+    return transcribeOpenAI(filePath, cfg.openaiKey);
+  }
+  if (provider === "local") {
+    return transcribeViaLocalServer(filePath, localOpts);
+  }
+  // auto: local first, fall back to openai if a key is configured
+  try {
+    return await transcribeViaLocalServer(filePath, localOpts);
+  } catch (localErr) {
+    if (cfg.openaiKey) {
+      return transcribeOpenAI(filePath, cfg.openaiKey);
+    }
+    throw new Error(`local transcription failed: ${localErr.message}`);
+  }
+}
+
+/**
+ * Transcribe raw audio bytes. Saves to a temp file, transcribes, cleans up.
+ * @param {Buffer} buf
+ * @param {string} format  extension hint ("webm" | "ogg" | "wav" | "mp3")
+ */
+export async function transcribeBuffer(buf, format = "webm", overrides = {}) {
+  if (!buf || !buf.length) throw new Error("transcribeBuffer: empty buffer");
+  const ext = format.replace(/^\./, "") || "webm";
+  const tmpFile = path.join(
+    (await import("node:os")).default.tmpdir(),
+    `apx-audio-${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`
+  );
+  try {
+    fs.writeFileSync(tmpFile, buf);
+    return await transcribe(tmpFile, overrides);
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+}

package/src/host/daemon/api/admin-config.js

@@ -9,88 +9,11 @@ import { readConfig, writeConfig } from "#core/config/index.js";
 import { resolveAgentName } from "#core/identity/index.js";
 import { setDottedKey, unsetDottedKey } from "../project-config.js";
 import { PERMISSION_MODES, DEFAULT_PERMISSION_MODE } from "#core/constants/permissions.js";
-
-const SECRET_PATHS = [
-  "engines.anthropic.api_key",
-  "engines.openai.api_key",
-  "engines.groq.api_key",
-  "engines.openrouter.api_key",
-  "engines.gemini.api_key",
-  "voice.tts.elevenlabs.api_key",
-  "voice.tts.openai.api_key",
-  "voice.tts.gemini.api_key",
-  "memory.embeddings.openai.api_key",
-  "memory.embeddings.gemini.api_key",
-  "telegram.channels.*.bot_token",
-];
-
-function getDotted(obj, dotted) {
-  const parts = dotted.split(".");
-  let cur = obj;
-  for (const p of parts) {
-    if (cur == null) return undefined;
-    cur = cur[p];
-  }
-  return cur;
-}
-
-function secretMarker(value) {
-  if (typeof value !== "string" || !value.length) return value;
-  const suffix = value.slice(-5);
-  return `*** set *** (...${suffix})`;
-}
-
-function isSecretMarker(value) {
-  return typeof value === "string" && value.startsWith("*** set ***");
-}
-
-// Returns a deep copy with `*** set ***` for every present secret value.
-function redact(cfg) {
-  const out = JSON.parse(JSON.stringify(cfg || {}));
-  const mark = (val) => (typeof val === "string" && val.length ? secretMarker(val) : val);
-
-  // Engine api keys + voice tts keys
-  for (const path of SECRET_PATHS) {
-    if (path.includes("*")) continue;
-    const parts = path.split(".");
-    let cur = out;
-    for (let i = 0; i < parts.length - 1; i++) {
-      if (!cur[parts[i]] || typeof cur[parts[i]] !== "object") { cur = null; break; }
-      cur = cur[parts[i]];
-    }
-    if (cur && cur[parts[parts.length - 1]]) {
-      cur[parts[parts.length - 1]] = mark(cur[parts[parts.length - 1]]);
-    }
-  }
-  // Telegram channels — array, redact bot_token per item (keep the suffix so
-  // the UI can show which token is set, e.g. "*** set *** (...AB12)").
-  const channels = out?.telegram?.channels;
-  if (Array.isArray(channels)) {
-    for (const ch of channels) {
-      if (ch && typeof ch.bot_token === "string" && ch.bot_token.length) {
-        ch.bot_token = mark(ch.bot_token);
-      }
-    }
-  }
-  return out;
-}
-
-function mergeRedactedChannels(nextChannels, priorChannels) {
-  if (!Array.isArray(nextChannels)) return nextChannels;
-  const priorByName = new Map(
-    (Array.isArray(priorChannels) ? priorChannels : [])
-      .filter((c) => c && typeof c.name === "string")
-      .map((c) => [c.name, c])
-  );
-  return nextChannels.map((channel) => {
-    if (!channel || typeof channel !== "object") return channel;
-    const prior = priorByName.get(channel.name);
-    if (prior?.bot_token && (channel.bot_token === undefined || isSecretMarker(channel.bot_token))) {
-      return { ...channel, bot_token: prior.bot_token };
-    }
-    return channel;
-  });
-}
+import {
+  redactConfig as redact,
+  isSecretMarker,
+  mergeRedactedChannels,
+} from "#core/config/redact.js";
 
 export function register(app, { config, scheduler, plugins }) {
   app.get("/admin/config", (_req, res) => {

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

@@ -7,6 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { readAgents, readVaultAgents, readVaultAgent } from "#core/apc/parser.js";
+import { apcAgentFile, apcDir, apcMemoryFile } from "#core/apc/paths.js";
 import {
   writeAgentFile,
   writeVaultAgentFile,
@@ -202,7 +203,7 @@ export function register(app, { projects, project }) {
     const p = project(req, res);
     if (!p) return;
     const slug = req.params.slug;
-    const file = path.join(p.path, ".apc", "agents", `${slug}.md`);
+    const file = apcAgentFile(p.path, slug);
     const runtimeDir = path.dirname(agentMemoryPath(p, slug));
     const legacyDir = path.dirname(legacyAgentMemoryPath(p.path, slug));
     if (!fs.existsSync(file) && !fs.existsSync(runtimeDir) && !fs.existsSync(legacyDir))
@@ -222,7 +223,7 @@ export function register(app, { projects, project }) {
   app.get("/projects/:pid/memory", (req, res) => {
     const p = project(req, res);
     if (!p) return;
-    const memPath = path.join(p.path, ".apc", "memory.md");
+    const memPath = apcMemoryFile(p.path);
     const body = fs.existsSync(memPath) ? fs.readFileSync(memPath, "utf8") : "";
     res.json({ body, path: memPath });
   });
@@ -233,9 +234,8 @@ export function register(app, { projects, project }) {
     const { body } = req.body || {};
     if (typeof body !== "string")
       return res.status(400).json({ error: "body must be string" });
-    const apcDir = path.join(p.path, ".apc");
-    fs.mkdirSync(apcDir, { recursive: true });
-    const memPath = path.join(apcDir, "memory.md");
+    fs.mkdirSync(apcDir(p.path), { recursive: true });
+    const memPath = apcMemoryFile(p.path);
     fs.writeFileSync(memPath, body);
     try { projects.rebuild(p.id); } catch {}
     res.json({ ok: true, bytes: Buffer.byteLength(body, "utf8") });

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

@@ -16,6 +16,7 @@ import { runSuperAgent } from "#core/agent/super-agent.js";
 import { appendSuperAgentErrorTrace } from "./shared.js";
 import { createWebConfirmAdapter } from "#core/confirmation/adapters/web.js";
 import { CHANNELS } from "#core/constants/channels.js";
+import { CODE_MODES, DEFAULT_CODE_MODE } from "#core/constants/code-modes.js";
 import {
   listCodeSessions,
   getCodeSession,
@@ -23,181 +24,28 @@ import {
   updateCodeSession,
   removeCodeSession,
   appendTurn,
+  codeSessionHistory,
 } from "#core/stores/code-sessions.js";
+import { makeTurnAccumulator } from "#core/agent/stream/turn-accumulator.js";
 import { captureBaseline, diffAgainstBaseline, initGitRepo } from "#core/git-baseline.js";
 import { loggerFor } from "#core/logging.js";
 import { readAgents } from "#core/apc/parser.js";
+import { CODE_PLAN_TOOLS, CODE_BUILD_TOOLS } from "#core/agent/tools/names.js";
+import { codeModeGuidance } from "#core/agent/prompts/modes/index.js";
 
 const log = loggerFor("code");
 
-// Read-only tool allowlist for PLAN mode: the agent can explore the repo but
-// not mutate it (no write/edit/shell/delegation/side-effects). Build mode gets
-// the unrestricted set ("*"). Names must match super-agent-tools/index.js.
-const PLAN_TOOLS = [
-  "read_file",
-  "list_files",
-  "search_files",
-  "grep",
-  "glob",
-  "list_projects",
-  "list_agents",
-  "list_mcps",
-  "read_agent_memory",
-  "read_self_memory",
-  "search_sessions",
-  "search_messages",
-  "tail_messages",
-  "list_skills",
-  "load_skill",
-  "list_tasks",
-  "ask_questions",
-  "fetch",
-  "search",
-];
-
+// Mode-specific tool allow-lists and prompt fragments are owned by core/:
+//   - tool names + plan/build lists → #core/agent/tools/names.js
+//   - per-mode guidance text         → #core/agent/prompts/modes/*.md
+// This file just picks the right pair for the request.
 function modeGuidanceFor(mode) {
-  if (mode === "plan") {
-    return [
-      "MODE: plan. Investigate the codebase (read/list/search/grep) and propose",
-      "an approach with the EXACT changes you would make (files + diffs/snippets).",
-      "Do NOT write or edit files and do NOT run mutating shell commands — your",
-      "editing tools are disabled in this mode. End with a concise, ordered plan.",
-    ].join(" ");
-  }
-  return [
-    "MODE: build. Make the changes directly using your file and shell tools",
-    "(read_file, write_file, edit_file, run_shell, …). Do not ask for",
-    "confirmation and do not stop after one step — keep calling tools until the",
-    "entire task is done, then briefly summarize what you changed and why.",
-    "Prefer surgical edits over rewrites.",
-    "When the user asks for a reusable script, snippet, or 'artifact' (something",
-    "they want to keep and run later), put it under `artifacts/<name>` inside",
-    "the project — it then shows up in the Artifacts tab. Don't drop reusable",
-    "scripts at the project root.",
-    "If a parameter you need is missing (API key, app id, target URL, …), call",
-    "`ask_questions` ONCE with all your questions and stop — control returns",
-    "to the user. Do not call ask_questions again in the same turn; you'll just",
-    "get the same blank state back. Each question can be a string (free-text",
-    "answer) OR an object {question, options:[{label, description}], multiSelect}",
-    "for choices. Prefer 2–4 mutually-exclusive options when a question has a",
-    "natural shortlist (yes/no, which-of-these, …); leave options empty for",
-    "open-ended answers (API keys, names, free-form ideas).",
-    "If the previous assistant turn already asked these same questions and the",
-    "current user message is the compiled answers, DO NOT call ask_questions",
-    "again — process the answers and proceed with the task.",
-  ].join(" ");
-}
-
-// Build the [{role, content}] history the super-agent expects from the stored
-// rich transcript: flatten each turn's text parts. Tool parts are normally
-// internal, but ask_questions is special — without surfacing it the model
-// loses track that it ALREADY asked, sees the user's compiled-answer reply
-// as a fresh request, and asks again forever. We render a one-line synthetic
-// summary of each ask_questions call so the next turn's context shows
-// "I asked X, the user replied Y" naturally.
-function summarizeAskQuestionsPart(part) {
-  const raw = part?.args?.questions;
-  if (!Array.isArray(raw) || raw.length === 0) return null;
-  const lines = raw
-    .map((q) => {
-      if (typeof q === "string") return `- ${q}`;
-      if (!q || typeof q !== "object" || typeof q.question !== "string") return null;
-      const opts = Array.isArray(q.options) ? q.options : [];
-      const optStr = opts
-        .map((o) => (typeof o === "string" ? o : (o && typeof o.label === "string" ? o.label : "")))
-        .filter(Boolean)
-        .join(", ");
-      return optStr ? `- ${q.question} (opciones: ${optStr})` : `- ${q.question}`;
-    })
-    .filter(Boolean);
-  if (lines.length === 0) return null;
-  return `[ask_questions]\n${lines.join("\n")}`;
-}
-
-function historyFrom(session) {
-  return (session.messages || []).map((m) => {
-    const chunks = [];
-    for (const p of m.parts || []) {
-      if (!p) continue;
-      if (p.kind === "text" && p.text) chunks.push(p.text);
-      else if (p.kind === "tool" && p.tool === "ask_questions") {
-        const summary = summarizeAskQuestionsPart(p);
-        if (summary) chunks.push(summary);
-      }
-    }
-    return { role: m.role, content: chunks.join("\n\n").trim() };
-  });
+  return codeModeGuidance(mode);
 }
 
-// Accumulate stream events into the rich ChatPart shape so the persisted
-// assistant turn matches exactly what the UI rendered live. Mirrors the
-// front-end reducer in hooks/useChat.ts (applyStreamEvent).
-function makeTurnAccumulator() {
-  const parts = [];
-  const notes = [];
-  let model = null;
-  let usage = null;
-  const findTool = (id) => parts.find((p) => p.kind === "tool" && p.id === id);
-  return {
-    apply(ev) {
-      switch (ev?.type) {
-        case "model_start":
-          if (ev.model) model = ev.model;
-          break;
-        case "model_routed":
-          if (ev.model) model = ev.model;
-          if (ev.from_fallback) notes.push(`routing fell back → ${ev.model}`);
-          break;
-        case "engine_failed":
-          notes.push(`engine ${ev.model || "?"} failed → ${ev.retry_with || "retry"}`);
-          break;
-        case "model_retry":
-          notes.push(`retry (${ev.reason || "?"})`);
-          break;
-        case "tools_suppressed":
-          notes.push(`tools suppressed: ${(ev.tools || []).join(", ")}`);
-          break;
-        case "assistant_text":
-          if (ev.text) parts.push({ kind: "text", text: ev.text });
-          break;
-        case "tool_start":
-          if (ev.trace)
-            parts.push({
-              kind: "tool",
-              id: ev.trace.id,
-              tool: ev.trace.tool,
-              args: ev.trace.args,
-              status: "running",
-            });
-          break;
-        case "tool_deduped": {
-          const t = ev.trace && findTool(ev.trace.id);
-          if (t) t.status = "deduped";
-          break;
-        }
-        case "tool_result": {
-          const t = ev.trace && findTool(ev.trace.id);
-          if (t) {
-            t.result = ev.trace.result;
-            const errored =
-              ev.trace.result && typeof ev.trace.result === "object" && ev.trace.result.error;
-            t.status = errored ? "error" : t.status === "deduped" ? "deduped" : "done";
-          }
-          break;
-        }
-        case "final":
-          usage = ev.result?.usage ?? usage;
-          if (!model) model = ev.result?.name || null;
-          break;
-        default:
-          break;
-      }
-    },
-    build() {
-      return { parts, notes, model, usage };
-    },
-  };
-}
+// History flattening + stream-event accumulator now live in core/ — see
+// codeSessionHistory() (transcript → engine messages) and makeTurnAccumulator()
+// (stream events → persistable ChatParts) imported above.
 
 export function register(app, { projects, project, config, registries, plugins }) {
   const findProject = (req, res) => project(req, res);
@@ -290,8 +138,8 @@ export function register(app, { projects, project, config, registries, plugins }
     const { prompt } = req.body || {};
     if (!prompt) return res.status(400).json({ error: "prompt required" });
 
-    const mode = session.mode === "plan" ? "plan" : "build";
-    const previousMessages = historyFrom(session);
+    const mode = session.mode === CODE_MODES.PLAN ? CODE_MODES.PLAN : DEFAULT_CODE_MODE;
+    const previousMessages = codeSessionHistory(session);
 
     // If a project agent is selected, inject its system prompt as a suffix so
     // the super-agent's tool loop runs with the agent's personality/context.
@@ -340,7 +188,7 @@ export function register(app, { projects, project, config, registries, plugins }
         previousMessages,
         systemSuffix: agentSystemSuffix,
         overrideModel: session.model || undefined,
-        allowedTools: mode === "plan" ? PLAN_TOOLS : "*",
+        allowedTools: mode === CODE_MODES.PLAN ? CODE_PLAN_TOOLS : CODE_BUILD_TOOLS,
         // Coding tasks are multi-step: give the loop a high safety ceiling so it
         // can chain 20-30+ tools (read → edit → run → verify …) and a real
         // output budget for substantial code / explanations per turn. The
@@ -351,7 +199,7 @@ export function register(app, { projects, project, config, registries, plugins }
         // Build mode = the model must keep calling tools until it calls `finish`.
         // Plan mode is read-only investigation that ends with a written plan, so
         // it keeps the normal "text ends the turn" behavior.
-        completionContract: mode === "build",
+        completionContract: mode === CODE_MODES.BUILD,
         onEvent,
         requestConfirmation: createWebConfirmAdapter({ onEvent }),
       });

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

@@ -10,10 +10,9 @@ import {
   setDottedKey,
   unsetDottedKey,
 } from "../project-config.js";
+import { apcProjectFile, apcProjectConfigFile } from "#core/apc/paths.js";
 
-function projectJsonPath(root) {
-  return path.join(root, ".apc", "project.json");
-}
+const projectJsonPath = apcProjectFile;
 
 function readProjectJson(root) {
   const p = projectJsonPath(root);
@@ -34,7 +33,7 @@ export function register(app, { projects, project }) {
     res.json({
       effective: p.config || {},
       project_only: readProjectConfig(p.path),
-      project_config_path: path.join(p.path, ".apc", "config.json"),
+      project_config_path: apcProjectConfigFile(p.path),
       apc_project: readProjectJson(p.path),
       project_json_path: projectJsonPath(p.path),
     });

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

@@ -4,12 +4,10 @@
 //   POST /projects/:pid/agents/:slug/compact
 //   POST /projects/:pid/agents/:slug/conversations/:id/compact
 //   POST /projects/:pid/send                                   (agent-to-agent)
-import fs from "node:fs";
-import path from "node:path";
 import { readAgents } from "#core/apc/parser.js";
-import { callEngine } from "#core/engines/index.js";
-import { listConversations, readConversation } from "../conversations.js";
-import { compactConversation } from "../compact.js";
+import { listConversations, readConversation } from "#core/stores/conversations.js";
+import { compactConversation } from "#core/stores/conversations-compactor.js";
+import { replyAsAgent } from "#core/agent/a2a/reply.js";
 import { nowIso } from "./shared.js";
 
 export function register(app, { project, config }) {
@@ -102,30 +100,11 @@ export function register(app, { project, config }) {
     let reply = null;
     if (deliver && toAgent.fields.Model) {
       try {
-        const tf = toAgent.fields;
-        const parts = [];
-        if (tf.Description) parts.push(tf.Description);
-        if (tf.Role) parts.push(`Role: ${tf.Role}`);
-        if (tf.Language) parts.push(`Default language: ${tf.Language}`);
-        parts.push(
-          `You are ${toAgent.slug}. You just received a message from ${fromAgent.slug}. Reply concisely.`
-        );
-        const memPath = path.join(
-          p.path,
-          ".apc",
-          "agents",
-          toAgent.slug,
-          "memory.md"
-        );
-        if (fs.existsSync(memPath))
-          parts.push("## Memory\n" + fs.readFileSync(memPath, "utf8"));
-
-        const result = await callEngine({
-          modelId: toAgent.fields.Model,
-          system: parts.join("\n\n"),
-          messages: [
-            { role: "user", content: `From ${fromAgent.slug}:\n\n${body}` },
-          ],
+        const result = await replyAsAgent({
+          projectPath: p.path,
+          toAgent,
+          fromAgent,
+          body,
           config: p.config || config,
         });