@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/core/memory/prune.js

@@ -0,0 +1,182 @@
+// Pruning the notebook — collapse replicated entries, keep the newest.
+//
+// THE MESS THIS CLEANS: consolidate.js guards what gets IN going forward, but
+// nothing ever looked back. A routine that called `remember` every day filled
+// ~/.apx/memory.md with sixty near-identical weather bullets — sixty days of
+// weather is zero facts. The remember handler now diverts that chatter at the
+// source; this module removes what already accumulated.
+//
+// Deterministic on purpose (no LLM): the same file pruned twice gives the same
+// answer, and what gets removed is explainable line by line. Two passes:
+//
+//   1. SERIES. Daily chatter varies in the middle (-8°C today, 1°C tomorrow)
+//      but keeps its opening words ("Hoy en Bariloche hace…"). Entries on the
+//      same channel sharing their normalized opener, appearing series_min+
+//      times, are one habit, not N facts — the newest survives. The opener
+//      alone is not enough: "Se agregó el MCP 'atlassian'" and "Se agregó el
+//      MCP 'dokploy'" open identically and are two facts, so an older member
+//      is only dropped when it also shares the TEMPLATE with another member
+//      (digit-blind, all-words similarity ≥ series_sim).
+//   2. NEAR-DUPLICATES. The same fact recorded twice anywhere (Jaccard ≥
+//      near_dup, via consolidate's similarity) keeps only its newest copy.
+//
+// Like consolidate: propose by default, write only on request, and every write
+// leaves a timestamped backup next to the file.
+import fs from "node:fs";
+import {
+  readSelfMemory,
+  parseSelfMemoryEntries,
+  SELF_MEMORY_PATH,
+} from "#core/agent/self-memory.js";
+import { similarity, stripEmptyDays } from "./consolidate.js";
+
+export const DEFAULT_PRUNE = Object.freeze({
+  /** Same-opener entries on one channel before it counts as a series. */
+  series_min: 3,
+  /**
+   * Jaccard overlap at which two entries are the same fact said twice. Higher
+   * than consolidate's dedup_threshold (0.5) on purpose: consolidate declines
+   * to ADD a maybe-duplicate, which costs nothing; prune DELETES, so it must
+   * be surer.
+   */
+  near_dup: 0.75,
+  /** Opening words that form a series signature. */
+  opener_words: 4,
+  /**
+   * Template overlap (digit-blind, all words) an older series member must
+   * share with SOME other member before it is dropped. Keeps same-opener but
+   * different-fact entries ("Se agregó el MCP 'X'" / "…'Y'") apart.
+   */
+  series_sim: 0.5,
+});
+
+/**
+ * The series fingerprint: first N words, lowercased, digits stripped so
+ * temperatures, speeds and dates never break a match.
+ */
+function normalizedWords(text) {
+  return String(text || "")
+    .toLowerCase()
+    .replace(/[\p{N}]+/gu, " ")
+    .replace(/[^\p{L}\s]/gu, " ")
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function openerSignature(text, words = DEFAULT_PRUNE.opener_words) {
+  return normalizedWords(text).slice(0, words).join(" ");
+}
+
+/**
+ * Quoted identifiers are the OBJECT of a note: "Se agregó el MCP 'dokploy'"
+ * and "…'brightbean'" share their whole template yet record two facts. Two
+ * entries whose quoted sets differ are never the same series member.
+ */
+function quotedIdentifiers(text) {
+  const out = new Set();
+  for (const m of String(text || "").matchAll(/['"`]([^'"`]{1,80})['"`]/g)) {
+    out.add(m[1].trim().toLowerCase());
+  }
+  return out;
+}
+
+function quotesConflict(a, b) {
+  const A = quotedIdentifiers(a);
+  const B = quotedIdentifiers(b);
+  if (!A.size || !B.size) return false;
+  if (A.size !== B.size) return true;
+  for (const q of A) if (!B.has(q)) return true;
+  return false;
+}
+
+/**
+ * Template overlap: Jaccard over ALL normalized words, digits stripped. Unlike
+ * consolidate's similarity (content words only), the skeleton words ("con",
+ * "de", "y") count — a templated series shares its skeleton even when every
+ * number and condition changes.
+ */
+function templateSimilarity(a, b) {
+  const A = new Set(normalizedWords(a));
+  const B = new Set(normalizedWords(b));
+  if (!A.size || !B.size) return 0;
+  let shared = 0;
+  for (const w of A) if (B.has(w)) shared += 1;
+  return shared / (A.size + B.size - shared);
+}
+
+/**
+ * Decide what a prune would remove. Pure — no filesystem.
+ *
+ * @param {string} text  the notebook body
+ * @returns {{ entries: object[], removed: object[], kept: number }}
+ *   `removed` entries carry the parser's `line` index into `text`.
+ */
+export function planPrune(text, opts = {}) {
+  const cfg = { ...DEFAULT_PRUNE, ...(opts || {}) };
+  const entries = parseSelfMemoryEntries(text); // oldest → newest
+  const drop = new Set();
+
+  // Pass 1 — series.
+  const groups = new Map();
+  entries.forEach((e, i) => {
+    const sig = `${e.channel}|${openerSignature(e.text, cfg.opener_words)}`;
+    if (!groups.has(sig)) groups.set(sig, []);
+    groups.get(sig).push(i);
+  });
+  for (const idxs of groups.values()) {
+    if (idxs.length < cfg.series_min) continue;
+    for (const i of idxs.slice(0, -1)) {
+      const cohesive = idxs.some(
+        (j) =>
+          j !== i &&
+          !quotesConflict(entries[i].text, entries[j].text) &&
+          templateSimilarity(entries[i].text, entries[j].text) >= cfg.series_sim,
+      );
+      if (cohesive) drop.add(i);
+    }
+  }
+
+  // Pass 2 — near-duplicates. Chronological order means "a later twin exists"
+  // is exactly "this copy is not the newest".
+  for (let i = 0; i < entries.length; i++) {
+    if (drop.has(i)) continue;
+    for (let j = i + 1; j < entries.length; j++) {
+      if (drop.has(j)) continue;
+      if (similarity(entries[i].text, entries[j].text) >= cfg.near_dup) {
+        drop.add(i);
+        break;
+      }
+    }
+  }
+
+  const removed = [...drop].sort((a, b) => a - b).map((i) => entries[i]);
+  return { entries, removed, kept: entries.length - removed.length };
+}
+
+/**
+ * Prune ~/.apx/memory.md. Dry by default — pass { apply: true } to write.
+ * Removal is line-precise: prose, headers, and anything the parser doesn't
+ * recognize stay exactly as written. A write first copies the file to
+ * memory.md.bak-<stamp>.
+ */
+export function pruneSelfMemory(opts = {}) {
+  const text = readSelfMemory();
+  const base = { path: SELF_MEMORY_PATH, applied: false, backup: "" };
+  if (!text.trim()) return { ...base, kept: 0, removed: [] };
+
+  const { removed, kept } = planPrune(text, opts);
+  if (!removed.length || !opts.apply) return { ...base, kept, removed };
+
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backup = `${SELF_MEMORY_PATH}.bak-${stamp}`;
+  fs.copyFileSync(SELF_MEMORY_PATH, backup);
+
+  const dropLines = new Set(removed.map((e) => e.line));
+  const lines = text.split("\n").filter((_, idx) => !dropLines.has(idx));
+  let body = stripEmptyDays(lines).join("\n");
+  body = body.replace(/\n{3,}/g, "\n\n");
+  if (!body.endsWith("\n")) body += "\n";
+  fs.writeFileSync(SELF_MEMORY_PATH, body);
+
+  return { ...base, applied: true, backup, kept, removed };
+}

package/src/core/memory/store.js

@@ -99,6 +99,22 @@ export class JsonStore {
     this._flush();
   }
 
+  /** Drop every row on one channel. Used when a scoped channel key stops being
+   *  valid — an agent renamed away from `agent:<projdir>:<slug>` — so the rows
+   *  cannot be inherited by whoever takes that key next. */
+  dropChannel(channel) {
+    if (!channel) return 0;
+    let n = 0;
+    for (const [id, row] of this.rows) {
+      if (row.channel === channel) {
+        this.rows.delete(id);
+        n++;
+      }
+    }
+    if (n) this._flush();
+    return n;
+  }
+
   search(vector, { embedder, k = 5, channel, scope } = {}) {
     const scopeArr = Array.isArray(scope) ? scope : null;
     const scored = [];
@@ -190,6 +206,12 @@ class SqliteVecStore {
     this.db.prepare("DELETE FROM chunks").run();
   }
 
+  /** Drop every row on one channel (see JsonStore.dropChannel). */
+  dropChannel(channel) {
+    if (!channel) return 0;
+    return this.db.prepare("DELETE FROM chunks WHERE channel = ?").run(channel).changes || 0;
+  }
+
   search(vector, { embedder, k = 5, channel, scope } = {}) {
     const blob = vecToBlob(vector);
     const where = ["embedder = ?", "dim = ?"];

package/src/core/memory/summarizer.js

@@ -13,8 +13,12 @@
 import { callEngine } from "../engines/index.js";
 
 // Structured state summaries carry several labelled sections, so they need more
-// room than the old ~800-token narrative recap.
-export const COMPACT_MAX_TOKENS = 1200;
+// room than the old ~800-token narrative recap — and the budget has to cover
+// the model's THINKING too. A reasoner spends a chain of thought before it
+// writes a word: at 1200 the reasoning ate the budget and the summary came back
+// cut off mid-section, which is the one failure mode this whole file exists to
+// avoid. ~900 tokens of summary + room to think.
+export const COMPACT_MAX_TOKENS = 3200;
 
 export const CONDENSER_SYSTEM =
   "You are maintaining a context-aware state summary for an interactive agent. " +
@@ -98,12 +102,68 @@ export function buildCondenserPrompt({ eventsBlock, openingBlock = "" }) {
   return `${CONDENSER_INSTRUCTIONS}\n\n${opening}${eventsBlock}`;
 }
 
+// A compact record REPLACES the raw turns it covers — the reader drops them and
+// keeps only this text. So a summary that came back truncated, empty-ish, or
+// stripped of its sections is not a degraded summary: it is amnesia written to
+// disk, permanently, for every turn it covered. It has happened in production —
+// one flaky response wrote `"USER_CONTEXT:\n- Manu"` over 350 turns and the
+// agent spent the rest of the day re-deriving what it already knew.
+//
+// So a summary has to earn the right to stand in for the history:
+const MIN_SUMMARY_CHARS = 400;
+// …and at least this many of the labelled sections it was asked for, otherwise
+// the model answered with prose or stopped mid-header.
+const MIN_SUMMARY_SECTIONS = 2;
+// A threaded summary must SUBSUME the previous one. Coming back at a fraction
+// of its size means state was dropped, not condensed.
+const PREV_SUMMARY_FLOOR = 0.5;
+
+// A section header opens a line: optional markdown bullet/heading marks, the
+// label, a colon. What follows on the line is free — real summaries put the
+// bullets underneath, but a one-line "LABEL: value" is still a section.
+const SECTION_RE =
+  /^[ \t]*[-*#>\s]*(USER_CONTEXT|TASK_TRACKING|COMPLETED|PENDING|CURRENT_STATE|CODE_STATE|TESTS|CHANGES|DEPS|VERSION_CONTROL_STATUS)[ \t]*:/gim;
+
+/** How many labelled sections a summary actually carries. */
+export function countSummarySections(text) {
+  const seen = new Set();
+  for (const m of String(text || "").matchAll(SECTION_RE)) seen.add(m[1].toUpperCase());
+  return seen.size;
+}
+
+/**
+ * Is this text fit to REPLACE the turns it covers? Returns null when usable,
+ * else a short reason (for the log — a silent reject is undiagnosable).
+ */
+export function summaryRejectReason(text, { prevSummary = "" } = {}) {
+  const t = String(text || "").trim();
+  if (!t) return "empty";
+  if (t.length < MIN_SUMMARY_CHARS) return `too short (${t.length} chars)`;
+  const sections = countSummarySections(t);
+  if (sections < MIN_SUMMARY_SECTIONS) return `only ${sections} section(s)`;
+  const prev = String(prevSummary || "").trim();
+  if (prev && t.length < prev.length * PREV_SUMMARY_FLOOR) {
+    return `shrank past the previous summary (${t.length} vs ${prev.length} chars)`;
+  }
+  return null;
+}
+
 /**
  * Run the summarizer over a prompt, walking the model chain. Returns
- * { text, model } or null when no model produced text (caller decides what a
- * null means — skip compaction, keep raw history, etc.).
+ * { text, model } or null when no model produced a USABLE summary (caller
+ * decides what a null means — skip compaction, keep raw history, etc.).
+ *
+ * `prevSummary` is the summary this one is meant to subsume; it is used only to
+ * validate that the new text did not lose it.
  */
-export async function summarizeStructured({ prompt, models, config, maxTokens = COMPACT_MAX_TOKENS }) {
+export async function summarizeStructured({
+  prompt,
+  models,
+  config,
+  maxTokens = COMPACT_MAX_TOKENS,
+  prevSummary = "",
+  onReject = null,
+}) {
   for (const modelId of [models.primary, models.fallback]) {
     if (!modelId) continue;
     try {
@@ -116,9 +176,13 @@ export async function summarizeStructured({ prompt, models, config, maxTokens =
         temperature: 0.2,
       });
       const text = String(r.text || "").trim();
-      if (text) return { text, model: modelId };
-    } catch {
-      /* try next model */
+      const reject = summaryRejectReason(text, { prevSummary });
+      if (!reject) return { text, model: modelId };
+      if (typeof onReject === "function") onReject({ model: modelId, reason: reject, text });
+    } catch (e) {
+      if (typeof onReject === "function") {
+        onReject({ model: modelId, reason: `engine error: ${e?.message || e}`, text: "" });
+      }
     }
   }
   return null;

package/src/core/mobility/answer.js

@@ -0,0 +1,80 @@
+// What a proximity answer DOES, in one place.
+//
+// It used to live inside the Telegram callback handler, which was the only
+// surface that could answer. Now the phone and the head unit can too, and the
+// same tap has to mean the same thing wherever it lands — an answer that
+// records a promise on Telegram and merely dismisses a notification in the car
+// is two features wearing one name.
+//
+// Closing the task is NOT here. It needs the daemon's project registry to
+// resolve which project the task lives in, and core does not import the daemon
+// (AGENTS.md rule 8: core is the home, adapters supply what only they have).
+// The caller passes it in.
+import { t } from "#core/i18n/index.js";
+import { lockTripErrand } from "./geofence.js";
+import { getMobilityAlert, recordMobilityResponse, updateMobilityAlert } from "./state.js";
+
+/** Every answer a card can carry, on any surface. */
+export const MOBILITY_ANSWERS = Object.freeze([
+  // While driving.
+  "navigate", "add_stop", "go", "next", "skip",
+  // After the trip, from the follow-up.
+  "done", "open",
+]);
+
+/**
+ * Apply one answer to one alert.
+ *
+ * @param {string} alertId
+ * @param {string} action              one of MOBILITY_ANSWERS
+ * @param {object} [opts]
+ * @param {string} [opts.lang]
+ * @param {(alert: object) => boolean} [opts.closeTask]
+ *        Closes the task an alert was about. Only `done` uses it; omit it and
+ *        `done` records the answer without touching the task.
+ * @returns {{ok: boolean, ack: string, reason?: string, alert?: object}}
+ */
+export function answerMobilityAlert(alertId, action, { lang = "es", closeTask = null } = {}) {
+  const alert = getMobilityAlert(alertId);
+  if (!alert) return { ok: false, ack: "", reason: "unknown-alert" };
+  if (!MOBILITY_ANSWERS.includes(action)) return { ok: false, ack: "", reason: "unknown-action" };
+
+  const now = new Date().toISOString();
+  let ack = "";
+
+  // NAVIGATE and ADD_STOP are "voy" in its most committed form: the driver did
+  // not say they would go, they started going. On Telegram those two are URL
+  // chips that cannot report a tap, which is why "go" exists as its own answer
+  // there — here they land on the same branch, so the end-of-trip follow-up
+  // asks about them exactly as it does about a promise.
+  if (action === "navigate" || action === "add_stop" || action === "go") {
+    updateMobilityAlert(alert.id, { answer: "go", answered_at: now });
+    // The last word on WHICH shop: settle the errand there so a later
+    // re-search cannot re-point it at another branch mid-drive.
+    lockTripErrand(alert.trip_id, alert.task_id, "accepted");
+    ack = t("mobility.ack_going", { lang });
+  } else if (action === "next") {
+    // "Not this branch" — not "forget it". The record keeps the place it named
+    // so the geofence knows which shop to stop offering, and `answer: "next"`
+    // is what stops this errand counting as announced.
+    updateMobilityAlert(alert.id, { answer: "next", answered_at: now, outcome: "skipped_place" });
+    ack = t("mobility.ack_next", { lang });
+  } else if (action === "skip") {
+    // The whole errand goes quiet for the trip. Nothing else is needed to make
+    // that stick: mobilityAlertFired() counts any answer other than "next" as
+    // announced, so the question comes back on the next drive, not in ten
+    // blocks. This is the card's "No ahora".
+    updateMobilityAlert(alert.id, { answer: "skip", answered_at: now, outcome: "skipped" });
+    ack = t("mobility.ack_dismissed", { lang });
+  } else if (action === "done") {
+    const closed = closeTask ? closeTask(alert) : false;
+    updateMobilityAlert(alert.id, { outcome: closed ? "done" : "done_unlinked" });
+    ack = t("mobility.ack_done", { lang });
+  } else if (action === "open") {
+    updateMobilityAlert(alert.id, { outcome: "still_open" });
+    ack = t("mobility.ack_still_open", { lang });
+  }
+
+  recordMobilityResponse(action);
+  return { ok: true, ack, alert: getMobilityAlert(alert.id) };
+}