@agentprojectcontext/apx 1.33.1 → 1.34.0

package/src/core/vars/index.js

@@ -0,0 +1,14 @@
+export {
+  globalVarsPath,
+  projectVarsPath,
+  readGlobalVars,
+  writeGlobalVars,
+  readProjectVars,
+  writeProjectVars,
+  loadAllVars,
+  setVar,
+  deleteVar,
+  maskValue,
+} from "./sources.js";
+
+export { interpolate, findRefs, MissingVarError } from "./interpolate.js";

package/src/core/vars/interpolate.js

@@ -0,0 +1,86 @@
+// ${var.NAME} interpolation engine.
+//
+// Used at MCP boot (and any other site that opts in) so files committed to
+// the repo can hold references like
+//   "Authorization": "Bearer ${var.ASANA_TOKEN}"
+// while the real value lives in ~/.apx/vars.json or
+// <storagePath>/vars.json (see ./sources.js).
+//
+// Semantics:
+//   - Only top-level strings inside the input object/array are walked
+//     recursively. Numbers/booleans/null pass through.
+//   - A `${var.NAME}` token where NAME is missing throws a MissingVarError
+//     listing every missing name (so the UI can show a single useful message
+//     instead of "first failure wins").
+//   - Names match [A-Z0-9_] / [a-z0-9_] / dot — we don't enforce a charset
+//     beyond "no whitespace and no closing brace". Stay liberal here, strict
+//     at the UI.
+
+const VAR_RE = /\$\{var\.([^}\s]+)\}/g;
+
+export class MissingVarError extends Error {
+  constructor(missing) {
+    super(
+      `Undefined variable${missing.length > 1 ? "s" : ""}: ${missing
+        .map((n) => `\${var.${n}}`)
+        .join(", ")}`
+    );
+    this.name = "MissingVarError";
+    this.missing = missing;
+  }
+}
+
+// Collect every `${var.NAME}` reference found in `value` (deep walk).
+// Returns an array of unique names in encounter order.
+export function findRefs(value) {
+  const seen = new Set();
+  const walk = (v) => {
+    if (typeof v === "string") {
+      let m;
+      VAR_RE.lastIndex = 0;
+      while ((m = VAR_RE.exec(v)) !== null) seen.add(m[1]);
+      return;
+    }
+    if (Array.isArray(v)) {
+      for (const x of v) walk(x);
+      return;
+    }
+    if (v && typeof v === "object") {
+      for (const x of Object.values(v)) walk(x);
+    }
+  };
+  walk(value);
+  return Array.from(seen);
+}
+
+// Replace every `${var.NAME}` inside `value` using the `vars` lookup. Missing
+// names accumulate and surface as a single MissingVarError at the end so
+// callers can show "missing: TOKEN_A, TOKEN_B" in one shot.
+export function interpolate(value, vars) {
+  const missing = new Set();
+
+  const replaceString = (s) => {
+    return s.replace(VAR_RE, (_, name) => {
+      if (Object.prototype.hasOwnProperty.call(vars, name)) {
+        return String(vars[name]);
+      }
+      missing.add(name);
+      return _;
+    });
+  };
+
+  const walk = (v) => {
+    if (typeof v === "string") return replaceString(v);
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, x] of Object.entries(v)) out[k] = walk(x);
+      return out;
+    }
+    return v;
+  };
+
+  const result = walk(value);
+  if (missing.size) throw new MissingVarError(Array.from(missing));
+  return result;
+}

package/src/core/vars/sources.js

@@ -0,0 +1,151 @@
+// Variable storage for APX. Two scopes:
+//   global  — ~/.apx/vars.json                              (chmod 0600)
+//   project — <storagePath>/vars.json                       (chmod 0600)
+//             i.e. ~/.apx/projects/<apxId>/vars.json
+//
+// Both files live outside the project repo so values never get committed.
+// The .apc/ files committed to the repo only reference vars by name
+// (e.g. `${var.ASANA_TOKEN}`) — actual values live here.
+//
+// Each file is a flat object: { "NAME": "value", ... }. Names are
+// uppercase letters / digits / underscore by convention (we don't enforce it
+// — anything safe to interpolate works).
+//
+// project wins over global when the same name exists in both.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const APX_HOME = path.join(os.homedir(), ".apx");
+const GLOBAL_VARS_FILE = path.join(APX_HOME, "vars.json");
+const PROJECT_VARS_FILENAME = "vars.json";
+
+export function globalVarsPath() {
+  return GLOBAL_VARS_FILE;
+}
+
+export function projectVarsPath(storagePath) {
+  if (!storagePath) return null;
+  return path.join(storagePath, PROJECT_VARS_FILENAME);
+}
+
+function readJsonSafe(absPath) {
+  if (!absPath || !fs.existsSync(absPath)) return {};
+  try {
+    const json = JSON.parse(fs.readFileSync(absPath, "utf8"));
+    return json && typeof json === "object" && !Array.isArray(json) ? json : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeJsonSecure(absPath, obj) {
+  fs.mkdirSync(path.dirname(absPath), { recursive: true });
+  fs.writeFileSync(absPath, JSON.stringify(obj, null, 2) + "\n");
+  try {
+    fs.chmodSync(absPath, 0o600);
+  } catch {
+    // Best effort on non-POSIX filesystems.
+  }
+}
+
+export function readGlobalVars() {
+  return readJsonSafe(GLOBAL_VARS_FILE);
+}
+
+export function writeGlobalVars(obj) {
+  writeJsonSecure(GLOBAL_VARS_FILE, obj);
+}
+
+export function readProjectVars(storagePath) {
+  return readJsonSafe(projectVarsPath(storagePath));
+}
+
+export function writeProjectVars(storagePath, obj) {
+  if (!storagePath) throw new Error("writeProjectVars: storagePath required");
+  writeJsonSecure(projectVarsPath(storagePath), obj);
+}
+
+function sanitizeMap(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj || {})) {
+    out[k] = String(v)
+      .replace(/[\u200B-\u200F\u202A-\u202E\u2060\uFEFF]/g, "")
+      .replace(/\u00A0/g, " ")
+      .trim();
+  }
+  return out;
+}
+
+// Aggregate project + global with project winning.
+// Returns { project, global, effective, sources } where sources[name] is
+// "project" or "global" so callers know where each effective value came from.
+// Values are sanitized at read time so legacy entries written before the
+// save-time trim land also come out clean.
+export function loadAllVars({ storagePath } = {}) {
+  const project = sanitizeMap(storagePath ? readProjectVars(storagePath) : {});
+  const global = sanitizeMap(readGlobalVars());
+  const effective = { ...global, ...project };
+  const sources = {};
+  for (const name of Object.keys(global)) sources[name] = "global";
+  for (const name of Object.keys(project)) sources[name] = "project";
+  return { project, global, effective, sources };
+}
+
+// Strip leading/trailing whitespace + invisible chars (ZWSP, BOM, …). The #1
+// reason a pasted token "doesn't work" is a stray newline picked up from the
+// copy buffer; defaulting to trim removes that whole class of bugs while
+// leaving real values untouched.
+function sanitizeVarValue(raw) {
+  return String(raw)
+    .replace(/[\u200B-\u200F\u202A-\u202E\u2060\uFEFF]/g, "")
+    .replace(/\u00A0/g, " ")
+    .trim();
+}
+
+// Convenience: set/unset on either scope. Returns the new full object.
+export function setVar({ storagePath, scope, name, value }) {
+  const v = sanitizeVarValue(value);
+  if (scope === "project") {
+    if (!storagePath) throw new Error("project scope requires storagePath");
+    const obj = readProjectVars(storagePath);
+    obj[name] = v;
+    writeProjectVars(storagePath, obj);
+    return obj;
+  }
+  if (scope === "global") {
+    const obj = readGlobalVars();
+    obj[name] = v;
+    writeGlobalVars(obj);
+    return obj;
+  }
+  throw new Error(`unknown scope "${scope}"`);
+}
+
+export function deleteVar({ storagePath, scope, name }) {
+  if (scope === "project") {
+    if (!storagePath) throw new Error("project scope requires storagePath");
+    const obj = readProjectVars(storagePath);
+    if (!(name in obj)) return false;
+    delete obj[name];
+    writeProjectVars(storagePath, obj);
+    return true;
+  }
+  if (scope === "global") {
+    const obj = readGlobalVars();
+    if (!(name in obj)) return false;
+    delete obj[name];
+    writeGlobalVars(obj);
+    return true;
+  }
+  throw new Error(`unknown scope "${scope}"`);
+}
+
+// Mask helper for read paths — never send the raw value to the UI by default.
+export function maskValue(value) {
+  if (value == null) return "";
+  const s = String(value);
+  if (s.length <= 4) return "•".repeat(s.length);
+  return "•".repeat(Math.min(s.length - 4, 8)) + s.slice(-4);
+}

package/src/core/voice/audio-decode.js

@@ -0,0 +1,38 @@
+// Decode the `audio` field from a voice/turn request into a filesystem path
+// the STT layer can read. Three input shapes:
+//   - undefined / null  → returns null (caller falls through to text-only)
+//   - filesystem path   → returns it as-is (cleanup: false)
+//   - base64 (raw or `data:...;base64,...`) → writes to tmp, cleanup: true
+//
+// `cleanup: true` means the caller must `fs.unlinkSync(decoded.path)` when
+// done. Pure helper, no daemon dependencies.
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+
+const MAX_PATH_LEN = 1024;
+
+export async function decodeAudioInput({ audio, format = "webm" }) {
+  if (!audio) return null;
+  // A short string that starts with "/" and exists on disk is treated as a
+  // path. Anything else is interpreted as base64 (optionally with a data:
+  // prefix).
+  if (
+    typeof audio === "string" &&
+    audio.length < MAX_PATH_LEN &&
+    audio.startsWith("/") &&
+    fs.existsSync(audio)
+  ) {
+    return { path: audio, cleanup: false };
+  }
+  let b64 = audio;
+  const m = /^data:[^;]+;base64,(.+)$/.exec(b64);
+  if (m) b64 = m[1];
+  const buf = Buffer.from(b64, "base64");
+  if (!buf.length) throw new Error("decodeAudioInput: decoded audio is empty");
+  const ext = String(format || "webm").replace(/^\./, "");
+  const tmp = path.join(os.tmpdir(), `apx-voice-${Date.now()}-${randomUUID()}.${ext}`);
+  fs.writeFileSync(tmp, buf);
+  return { path: tmp, cleanup: true };
+}

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") });