@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/core/stores/organization.js

@@ -27,6 +27,11 @@ export const ORG_SLUG_RE = /^[a-z][a-z0-9_-]*$/;
 // auto-slug behavior so a name typed in either surface yields the same slug.
 export function slugifyName(name) {
   return String(name || "")
+    // Strip diacritics first so "José" → "jose" (not "jos") and "Ñaña" → "nana".
+    // Without the NFD pass the accented letter is simply dropped by the a-z
+    // filter below, silently losing a character from the slug.
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
     .trim()
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")
@@ -34,6 +39,35 @@ export function slugifyName(name) {
     .replace(/-{2,}/g, "-");
 }
 
+/**
+ * Canonical area key for an agent.
+ *
+ * Agents historically stored the display name (`Growth`) while the org chart
+ * uses the slug (`growth`). The team view groups by exact string, so mixed
+ * case splits one area into two pills that look identical (the label is
+ * CSS-uppercased). Resolve against the org chart first (slug or name,
+ * case-insensitive), then fall back to slugify so two free-text values that
+ * mean the same thing still land in one bucket.
+ *
+ * Empty / missing input → null. Unknown free text is still allowed — areas
+ * are optional groupings, not a closed enum.
+ */
+export function resolveAreaSlug(input, org) {
+  const raw = String(input || "").trim();
+  if (!raw) return null;
+  const areas = org?.areas || [];
+  const lower = raw.toLowerCase();
+  const slugified = slugifyName(raw);
+  const match = areas.find(
+    (a) =>
+      a.slug === slugified ||
+      String(a.slug || "").toLowerCase() === lower ||
+      String(a.name || "").toLowerCase() === lower,
+  );
+  if (match) return match.slug;
+  return slugified || null;
+}
+
 function emptyOrg() {
   return { areas: [], roles: [] };
 }

package/src/core/stores/project-memory.js

@@ -0,0 +1,71 @@
+// A project's LOCAL memory — `~/.apx/projects/<apxId>/memory.md`.
+//
+// A project has two durable memories and the difference between them is a
+// safety boundary, not a filing preference:
+//
+//   local    ~/.apx/projects/<apxId>/memory.md   THIS file. Never committed.
+//                                                Written by the agent (`remember`
+//                                                with a `project`).
+//   curated  <repo>/.apc/memory.md               core/apc/project-memory.js.
+//                                                Committed, team-safe, written
+//                                                by a person who read it first.
+//
+// APC draws that line itself: "private runtime memory" is runtime state and
+// belongs in the runtime's own store, out of `.apc/`, because it "often contains
+// sensitive prompts, credentials pasted by mistake, customer data" — while
+// `.apc/` memory is "only for curated project facts safe for the team", and the
+// route from one to the other is a human extracting the durable, sanitized part.
+//
+// So an agent appending a note about a project — a decision, a stack detail, a
+// thing the owner said in passing — writes HERE. Committing that stream straight
+// into someone's repo is how an API key ends up in a public git history, and no
+// scrubber makes an automatic write safe enough to skip the reading.
+//
+// Promotion is manual and stays manual: the Memories screen shows both files, so
+// moving a line from this one into the repo's is a thing a person does after
+// looking at it.
+import fs from "node:fs";
+import path from "node:path";
+import { projectStorageRoot } from "../config/index.js";
+import { getOrCreateApxId } from "../apc/scaffold.js";
+import { appendDatedBullet } from "#core/memory/dated-log.js";
+
+// Accepts a registry entry ({ storagePath }) or a bare project root, matching
+// core/agent/memory.js — the same two shapes callers already have in hand.
+export function projectLocalMemoryPath(projectOrRoot) {
+  const storagePath =
+    typeof projectOrRoot === "object" && projectOrRoot?.storagePath
+      ? projectOrRoot.storagePath
+      : null;
+  const root = typeof projectOrRoot === "string" ? projectOrRoot : projectOrRoot?.path;
+  const base = storagePath || projectStorageRoot(getOrCreateApxId(root));
+  return path.join(base, "memory.md");
+}
+
+/** Read the body. "" when the file doesn't exist. Never throws. */
+export function readProjectLocalMemory(projectOrRoot) {
+  try {
+    return fs.readFileSync(projectLocalMemoryPath(projectOrRoot), "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/** Replace the whole body (the Memories editor's Save). */
+export function writeProjectLocalMemory(projectOrRoot, body) {
+  const file = projectLocalMemoryPath(projectOrRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, body);
+  return { path: file, bytes: Buffer.byteLength(body, "utf8") };
+}
+
+/** Append one dated note. Creates the file on first write. */
+export function appendProjectLocalMemory(projectOrRoot, note, { channel = "", projectName = "" } = {}) {
+  const text = String(note || "").trim();
+  if (!text) throw new Error("nothing to remember (empty note)");
+  const header = projectName
+    ? `# ${projectName} — local memory (not committed)`
+    : "# Project local memory (not committed)";
+  const next = appendDatedBullet(readProjectLocalMemory(projectOrRoot), text, { channel, header });
+  return { ...writeProjectLocalMemory(projectOrRoot, next), note: text };
+}

package/src/core/stores/routine-memory.js

@@ -12,6 +12,7 @@
 //   - Super-agent self-memory (~/.apx/memory.md) — global to the super-agent.
 import fs from "node:fs";
 import path from "node:path";
+import { appendDatedBullet } from "#core/memory/dated-log.js";
 
 const PROMPT_LIMIT = 1500;
 
@@ -52,20 +53,27 @@ export function ensureRoutineMemory(storagePath, routineId, routineName = "") {
   return true;
 }
 
+/**
+ * Resolve a routine run's storagePath from the projects registry — never from
+ * a model-supplied path. `projectPath` (channelMeta) narrows to the owning
+ * project; without it, the first project with storage wins.
+ */
+export function resolveRoutineStorage(projects, projectPath = "") {
+  for (const entry of projects?.list?.() || []) {
+    if (projectPath && entry.path !== projectPath) continue;
+    const storagePath = projects?.get?.(entry.id)?.storagePath || "";
+    if (storagePath) return storagePath;
+  }
+  return "";
+}
+
 /** Append a dated note to the routine memory. Creates the file on first write. */
 export function appendRoutineMemory(storagePath, routineId, note, { routineName = "" } = {}) {
   const text = String(note || "").trim();
   if (!text) throw new Error("nothing to remember (empty note)");
   ensureRoutineMemory(storagePath, routineId, routineName);
   const file = routineMemoryPath(storagePath, routineId);
-  const today = new Date().toISOString().slice(0, 10);
-  const heading = `## ${today}`;
-  const oneLine = text.replace(/\n+/g, " ").trim();
-  const bullet = `- ${oneLine}`;
-  const existing = fs.readFileSync(file, "utf8");
-  const next = existing.includes(heading)
-    ? existing.trimEnd() + `\n${bullet}\n`
-    : existing.trimEnd() + `\n\n${heading}\n${bullet}\n`;
+  const next = appendDatedBullet(fs.readFileSync(file, "utf8"), text);
   fs.writeFileSync(file, next);
   return { path: file, note: text };
 }

package/src/core/stores/routines.js

@@ -1,6 +1,5 @@
 // File-based routines store: read/write .apc/routines.json.
 // Replaces the SQLite `routines` table for project-scoped scheduled tasks.
-import fs from "node:fs";
 import path from "node:path";
 import { CronExpressionParser } from "cron-parser";
 import { nowIso, isoToMs } from "../util/time.js";
@@ -89,62 +88,17 @@ export function computeNextRun(routine, baseMs = Date.now()) {
   return null;
 }
 
-// --------------------- ids + migration --------------------------------------
-
-// Routines are addressed by `name` everywhere (getRoutine/deleteRoutine/
-// setEnabled/updateRunState), but per-routine memory is keyed by `id`
-// (stores/routine-memory.js). Records written before ids existed have none, so
-// every one of them resolved to the shared `routines/_unknown/memory.md`.
-//
-// This migration is deliberately NOT inside readFile(): that helper is on the
-// scheduler's 5s polling path, and writing from it would mean write
-// amplification plus a read-modify-write race against a concurrent CLI edit.
-// Instead the public read entry points call this, and it early-returns without
-// touching disk once every record has an id — so the write happens once per
-// project, ever.
-
-/**
- * Backfill `id` on any routine record that predates the field.
- * Returns the number of records migrated (0 when there was nothing to do).
- */
-export function ensureRoutineIds(storagePath) {
-  const routines = readFile(storagePath);
-  const missing = routines.filter((r) => r && !r.id);
-  if (missing.length === 0) return 0;
-
-  for (const r of missing) r.id = shortId("r");
-  writeFile(storagePath, routines);
-
-  // Anything already written under routines/_unknown/ belonged to an
-  // indeterminate set of routines — we can't know which, so we leave it where
-  // it is rather than guess, and say so out loud once.
-  const orphan = path.join(storagePath, "routines", "_unknown");
-  if (fs.existsSync(orphan)) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      `[apx] routines: assigned ids to ${missing.length} routine(s). Pre-existing shared\n` +
-      `      memory at ${orphan} was left untouched — it cannot be attributed to a single\n` +
-      `      routine. Copy anything worth keeping into the per-routine memory files.`
-    );
-  }
-  return missing.length;
-}
-
 // --------------------- CRUD -------------------------------------------------
 
 export function listRoutines(projectPath) {
-  ensureRoutineIds(projectPath);
   return readFile(projectPath);
 }
 
 export function getRoutine(projectPath, name) {
-  // Callers hand the record straight to the runner, which needs `id` for
-  // per-routine memory.
-  ensureRoutineIds(projectPath);
   return readFile(projectPath).find((r) => r.name === name) || null;
 }
 
-export function upsertRoutine(storagePath, { name, kind, schedule, spec, enabled = true, permission_mode, allowed_tools, pre_commands, post_commands, skip_prompt_on, origin, origin_hash }) {
+export function upsertRoutine(storagePath, { name, kind, schedule, spec, enabled = true, permission_mode, allowed_tools, pre_commands, post_commands, skip_prompt_on, deliver_to, origin, origin_hash }) {
   if (!name || !kind || !schedule) throw new Error("routine requires name, kind, schedule");
   const now = nowIso();
   const routines = readFile(storagePath);
@@ -172,6 +126,14 @@ export function upsertRoutine(storagePath, { name, kind, schedule, spec, enabled
     //   "always"      — never run the LLM (shell-only routine)
     //   "never"       — always run the LLM regardless of pre_commands
     skip_prompt_on: skip_prompt_on || prev?.skip_prompt_on || "signal",
+    // Where the run's output is delivered (core/routines/delivery.js).
+    // `null` and `[]` are NOT the same value here, and this is the one place
+    // that has to keep them apart: `null` means "nobody said", so the
+    // deployment default still applies, while `[]` means "deliver nowhere" and
+    // stops the fallthrough. Defaulting an absent field to `[]` is exactly the
+    // bug allowed_tools had — every routine created the obvious way silently
+    // carried a deliberate-looking empty list nobody wrote.
+    deliver_to: Array.isArray(deliver_to) ? deliver_to : (deliver_to === null ? null : (prev?.deliver_to ?? null)),
     // Provenance. A routine installed by a persona package carries
     // origin: "persona:<id>" so it can be disabled or removed with that
     // package without touching the user's own routines. `origin_hash` is the
@@ -197,6 +159,24 @@ export function upsertRoutine(storagePath, { name, kind, schedule, spec, enabled
   return entry;
 }
 
+// Repoint every routine that targets `oldSlug` to `newSlug`. Called when an
+// agent is renamed so its scheduled tasks don't silently point at a slug that
+// no longer exists. Returns the number of routines rewritten.
+export function renameRoutineAgent(storagePath, oldSlug, newSlug) {
+  if (!oldSlug || !newSlug || oldSlug === newSlug) return 0;
+  const routines = readFile(storagePath);
+  let changed = 0;
+  for (const r of routines) {
+    if (r?.spec && r.spec.agent === oldSlug) {
+      r.spec = { ...r.spec, agent: newSlug };
+      r.updated_at = nowIso();
+      changed += 1;
+    }
+  }
+  if (changed) writeFile(storagePath, routines);
+  return changed;
+}
+
 export function deleteRoutine(projectPath, name) {
   const routines = readFile(projectPath);
   const idx = routines.findIndex((r) => r.name === name);
@@ -231,8 +211,6 @@ export function updateRunState(projectPath, name, { last_run_at, last_status, la
 }
 
 export function getDueRoutines(projectPath, nowStr) {
-  // The runner keys per-routine memory off `id`, so due records must carry one.
-  ensureRoutineIds(projectPath);
   return readFile(projectPath).filter((r) => {
     if (!r.enabled) return false;
     // CRITICAL: If the schedule cannot be parsed, NEVER run it.

package/src/core/stores/sessions.js

@@ -4,6 +4,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { parseFrontmatter } from "#core/apc/frontmatter.js";
 import { nowIso } from "../util/time.js";
 
 export function agentSessionsDir(storageRoot, agentSlug) {
@@ -30,14 +31,9 @@ export function readSessionFrontmatter(filePath) {
   if (!fs.existsSync(filePath)) return null;
   const text = fs.readFileSync(filePath, "utf8");
   if (!text.startsWith("---\n")) return null;
-  const end = text.indexOf("\n---", 4);
-  if (end === -1) return null;
-  const fm = {};
-  for (const line of text.slice(4, end).split("\n")) {
-    const m = line.match(/^([a-zA-Z_]+):\s*(.*)$/);
-    if (m) fm[m[1]] = m[2].trim();
-  }
-  return { fm, body: text.slice(end + 4).replace(/^\n+/, "") };
+  const { fm, body, bodyStart } = parseFrontmatter(text);
+  if (bodyStart === 0) return null;
+  return { fm, body };
 }
 
 function slugifyTitle(title) {