@spinabot/brigade 0.1.1 → 1.0.0

package/dist/agents/memory/consolidate.js

@@ -0,0 +1,275 @@
+/**
+ * Memory consolidation — the LEAN, off-hot-path semantic cleanup that handles
+ * what write-time lexical dedup can't: CONTRADICTED facts (e.g. "user is on
+ * Windows" lingering next to a later "user is on macOS now" correction the
+ * model never wired with `supersedes`) and semantic (non-lexical) duplicates.
+ *
+ * Design (scalable): a SINGLE LLM call — given the active fact set, return
+ * the ids to archive. (A 3-LLM debate Proposer/Adversary/Judge every 24h is
+ * the heavier alternative; we explicitly avoid it.) It runs inside the
+ * gateway's existing background sweep (off the hot path), THROTTLED
+ * (default once / 30 min) and only when there are enough facts to be
+ * worth it — so per-turn cost is unaffected and the extra call is rare.
+ * Archive (not delete) keeps an audit trail; decay GC handles pure age-out
+ * separately.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createSubsystemLogger } from "../../logging/subsystem-logger.js";
+import { tryGetRuntimeContext } from "../../storage/runtime-context.js";
+import { cosine } from "./embedder.js";
+import { balancedObjects, makeIsolatedLlm } from "./extract.js";
+import { compareRichness, contentSimilarity, DEDUP_SIMILARITY, FactStore, IDEMPOTENT_COSINE_BAR, IDEMPOTENT_JACCARD_BAR, originBucketKey, } from "./records.js";
+const log = createSubsystemLogger("memory/consolidate");
+const CONSOLIDATE_STATE_PATH = path.join("memory", ".dreams", "consolidate-state.json");
+/** Skip consolidation below this many active facts (nothing to merge). */
+const MIN_FACTS_TO_CONSOLIDATE = 6;
+/** Throttle: at most one consolidation call per this window. */
+export const DEFAULT_CONSOLIDATE_INTERVAL_MS = 30 * 60 * 1000;
+export const CONSOLIDATION_PROMPT = `You are a memory-consolidation subagent for a personal AI assistant.
+Below are the user's currently-remembered facts, each prefixed with an id.
+Identify facts to ARCHIVE because they are EITHER:
+- Contradicted or superseded by a newer / more-specific fact in the same list (keep the current one, archive the stale or now-wrong one), OR
+- Redundant duplicates of another fact (keep the best, archive the rest).
+
+Be CONSERVATIVE. Do NOT archive a fact merely for being old, low-importance, or narrowly specific. Only archive facts that are genuinely contradicted or duplicated by another fact present in the list. When in doubt, keep it. Never archive every copy of a fact — always keep one.
+
+The user message contains the fact list (one per line: [id] (segment, importance) content).
+Return STRICT JSON only, no prose, no fences:
+{"archive":["<id>", ...]}
+Use an empty array if nothing should be archived.`;
+/**
+ * Parse the consolidation reply into the list of ids to archive. Never throws.
+ * Scans every top-level balanced `{...}` (string-aware) and uses the FIRST that
+ * carries an `archive` array — the same scanner the sibling extractor adopted
+ * (`balancedObjects`), mirroring how `parseExtractedFacts` picks the first object
+ * with a `facts` array. This replaces a greedy first-to-LAST `{...}` match that
+ * broke on prose-with-braces before the payload (e.g. a reasoning model emitting
+ * `My analysis: {…}. Result: {"archive":[…]}`) AND on a LEADING stray object —
+ * both spanned/shadowed the real payload, failed `JSON.parse`, and returned [].
+ */
+export function parseConsolidationArchive(text) {
+    if (!text)
+        return [];
+    for (const block of balancedObjects(text)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(block);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(parsed.archive))
+            continue;
+        return parsed.archive.filter((x) => typeof x === "string" && x.length > 0);
+    }
+    return [];
+}
+// Origin-isolation bucket key is the CANONICAL one from records.ts (injective +
+// accountId-aware) — a local copy previously drifted (unescaped ':' join could
+// collide two distinct channel origins into one consolidation bucket).
+/**
+ * Run one consolidation pass: read active facts, ask the LLM which to archive,
+ * validate the ids (only archive ones that actually exist + are active, and
+ * never let it archive ALL of them via a runaway response), apply. LLM injected
+ * for testability. No-op below `minFacts`.
+ *
+ * ORIGIN ISOLATION: facts are bucketed by origin and consolidated SEPARATELY —
+ * the owner and each channel peer get their own LLM call. A single cross-origin
+ * prompt would (a) expose one peer's private content to another's consolidation
+ * and (b) let one origin's facts drive another's archival — both break the
+ * `MemoryRecordOrigin` isolation invariant. One call per origin with >= minFacts.
+ */
+export async function runConsolidation(args) {
+    const store = new FactStore(args.workspaceDir);
+    const active = store.list(); // active-only
+    const min = args.minFacts ?? MIN_FACTS_TO_CONSOLIDATE;
+    const buckets = new Map();
+    for (const f of active) {
+        const key = originBucketKey(f);
+        const arr = buckets.get(key);
+        if (arr)
+            arr.push(f);
+        else
+            buckets.set(key, [f]);
+    }
+    let ran = false;
+    let archived = 0;
+    for (const bucket of buckets.values()) {
+        if (bucket.length < min)
+            continue; // too few in this origin to be worth a call
+        const block = bucket
+            .map((f) => `[${f.memoryId}] (${f.segment}, importance ${f.importance.toFixed(2)}) ${f.content}`)
+            .join("\n");
+        let reply = "";
+        try {
+            reply = await args.llm(block);
+        }
+        catch (err) {
+            log.warn("consolidation llm failed", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            continue;
+        }
+        ran = true;
+        const requested = parseConsolidationArchive(reply);
+        const bucketIds = new Set(bucket.map((f) => f.memoryId));
+        let toArchive = requested.filter((id) => bucketIds.has(id));
+        // Safety: never archive EVERYTHING in an origin (a runaway model emptying it).
+        if (toArchive.length >= bucket.length) {
+            log.warn("consolidation tried to archive all facts in an origin — refusing", {
+                requested: toArchive.length,
+                active: bucket.length,
+            });
+            toArchive = [];
+        }
+        // RICHNESS GUARD (Fix 2 + 3): the LLM names ids to archive but has NO notion of
+        // metadata richness — it can (and on real data DID) pick the subject-bearing
+        // `identity`/`preference` ORIGINAL over its reworded subject-less `knowledge`
+        // twin, archiving the rich record and keeping the churn copy (the vault graph
+        // then loses the hub-anchoring subjectKey). So for each archive the model
+        // requested, if a near-duplicate twin would REMAIN active that is POORER than
+        // the record being archived, redirect: keep the richer record, archive the
+        // poorer twin instead. Either way the surviving record first inherits the
+        // richer metadata of the one it replaces, so no subjectKey / segment is dropped.
+        {
+            const byId = new Map(bucket.map((f) => [f.memoryId, f]));
+            const archiveSet = new Set(toArchive);
+            const merges = [];
+            // Pre-resolve, per requested drop, its near-duplicate twins in the bucket. A
+            // twin is a content near-duplicate (>= the strict dedup bar) OR a subject-
+            // anchored paraphrase: when EITHER record is subject-bearing (exactly the
+            // records extraction churns a subject-less copy beside), the loose idempotency
+            // bars apply on BOTH lanes — embedding cosine (over the stored vectors) OR
+            // content Jaccard — mirroring `FactStore.findEquivalentActive`, so a reworded
+            // twin with low lexical overlap ("peanut allergy" ~ "allergic to peanuts",
+            // Jaccard 0.2 but cosine ~0.5) is still recognised.
+            const isTwin = (x, y) => {
+                const jac = contentSimilarity(x.content, y.content);
+                if (jac >= DEDUP_SIMILARITY)
+                    return true;
+                if (x.subjectKey === undefined && y.subjectKey === undefined)
+                    return false;
+                const cos = x.embedding && y.embedding && x.embedding.length === y.embedding.length && x.embedding.length > 0
+                    ? cosine(x.embedding, y.embedding)
+                    : 0;
+                return cos >= IDEMPOTENT_COSINE_BAR || jac >= IDEMPOTENT_JACCARD_BAR;
+            };
+            for (const id of [...toArchive]) {
+                const dropRec = byId.get(id);
+                if (!dropRec || !archiveSet.has(id))
+                    continue;
+                // Active twins that would REMAIN (not currently in the archive set).
+                const remainingTwins = bucket.filter((r) => r.memoryId !== id && !archiveSet.has(r.memoryId) && isTwin(dropRec, r));
+                if (remainingTwins.length === 0)
+                    continue;
+                // The richest record across the dropRec + its remaining twins must survive.
+                const richestTwin = remainingTwins.reduce((best, r) => (compareRichness(r, best) > 0 ? r : best));
+                if (compareRichness(dropRec, richestTwin) > 0) {
+                    // The model picked the wrong survivor: keep dropRec, archive the poorer twin.
+                    archiveSet.delete(id);
+                    archiveSet.add(richestTwin.memoryId);
+                    merges.push({ keep: dropRec.memoryId, drop: richestTwin.memoryId });
+                }
+                else {
+                    // The kept twin is already at least as rich — fine; just preserve metadata.
+                    merges.push({ keep: richestTwin.memoryId, drop: id });
+                }
+            }
+            // Inherit richer metadata into each survivor BEFORE archiving its duplicate.
+            for (const m of merges) {
+                if (!archiveSet.has(m.keep))
+                    store.mergeMetadataInto(m.keep, m.drop);
+            }
+            toArchive = [...archiveSet];
+        }
+        // Archive via `store.evict` (not `setLifecycle`) so the removal lands in the
+        // append-only event log — matching the DETERMINISTIC sibling (dream.ts archives
+        // near-duplicates/decayed facts through invalidate/evict, both of which emit).
+        // `setLifecycle` flips lifecycle SILENTLY, so an LLM-driven consolidation archive
+        // would otherwise leave no provenance ("evicted" per id stamps at/memoryId/segment),
+        // making "why did this fact disappear from recall?" unanswerable for the one
+        // mutation driven by an attacker-influenceable reading. evict skips non-active ids
+        // (all here are active — the bucket comes from the active list) and returns the ids
+        // actually archived, so `archived` reflects the real count. (In convex mode, emit
+        // routes through `appendMemoryEvent` best-effort when the hook is present; degrades
+        // to no audit trail when absent — lifecycle flip always applies.)
+        const evicted = toArchive.length > 0 ? store.evict(toArchive, { now: Date.now() }) : [];
+        archived += evicted.length;
+        log.info("consolidation sweep (origin)", { considered: bucket.length, archived: evicted.length });
+    }
+    return { ran, archived, considered: active.length };
+}
+/* ───────────────────────── throttle ───────────────────────── */
+function statePath(workspaceDir) {
+    return path.join(workspaceDir, CONSOLIDATE_STATE_PATH);
+}
+// Convex-mode throttle cache. A miss reads "eligible" once; the stamp lands
+// both here and in the backend so subsequent ticks throttle normally.
+// KNOWN LIMITATION (convex multi-agent, tracked): this stamp AND the backend SPI
+// (getConsolidateLastRunAt / markConsolidateRunAt) are NOT keyed per workspace, so with
+// ≥2 convex agents one agent's run throttles the others (non-primary agents under-
+// consolidate). The complete fix threads a workspaceId through the SPI (mirroring the
+// per-session extract cursor) + the convex schema. Filesystem mode is already
+// per-workspace (the state file is under activeWorkspaceDir), so this only bites
+// convex + multi-agent — deferred over a deep SPI/schema change at low blast radius.
+let convexLastRunAt;
+/** Test-only. */
+export function __resetConsolidateCacheForTests() {
+    convexLastRunAt = undefined;
+}
+/** True when consolidation hasn't run within `intervalMs` (and records nothing). */
+export function shouldRunConsolidation(workspaceDir, intervalMs = DEFAULT_CONSOLIDATE_INTERVAL_MS, now = Date.now()) {
+    const rctx = tryGetRuntimeContext();
+    if (rctx?.mode === "convex") {
+        if (convexLastRunAt === undefined) {
+            // Async backfill for the next tick; this tick reads "eligible" —
+            // at worst consolidation runs once more than strictly needed,
+            // which is harmless (it's idempotent over the same facts).
+            void rctx.store.memory
+                .getConsolidateLastRunAt()
+                .then((at) => {
+                if (convexLastRunAt === undefined && typeof at === "number") {
+                    convexLastRunAt = at;
+                }
+            })
+                .catch(() => { });
+            return true;
+        }
+        return now - convexLastRunAt >= intervalMs;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statePath(workspaceDir), "utf8"));
+        const last = typeof parsed.lastRunAt === "number" ? parsed.lastRunAt : 0;
+        return now - last >= intervalMs;
+    }
+    catch {
+        return true; // no state yet → eligible
+    }
+}
+/** Stamp the last-run time so the throttle window starts now. */
+export function markConsolidationRun(workspaceDir, now = Date.now()) {
+    const rctx = tryGetRuntimeContext();
+    if (rctx?.mode === "convex") {
+        convexLastRunAt = now;
+        void rctx.store.memory.markConsolidateRunAt(now).catch((err) => {
+            console.error(`brigade: consolidate stamp to convex failed — ${err.message}`);
+        });
+        return;
+    }
+    const p = statePath(workspaceDir);
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+        fs.writeFileSync(tmp, JSON.stringify({ lastRunAt: now }), "utf8");
+        fs.renameSync(tmp, p);
+    }
+    catch {
+        /* best-effort — a missed stamp just means consolidation may run again sooner */
+    }
+}
+/** The consolidation distiller — `makeIsolatedLlm` with CONSOLIDATION_PROMPT pinned. */
+export function makeConsolidationLlm(args) {
+    return makeIsolatedLlm(CONSOLIDATION_PROMPT, args);
+}
+//# sourceMappingURL=consolidate.js.map

package/dist/agents/memory/consolidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidate.js","sourceRoot":"","sources":["../../../src/agents/memory/consolidate.ts"],"names":[],"mappings":"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"}

package/dist/agents/memory/contradiction.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Contradiction detection + bi-temporal invalidation (Tideline v2, step 15).
+ *
+ * When a new belief conflicts with a stored one, surface it — and on confirm,
+ * close the stale fact's VALID interval (`validTo`) + archive it, rather than
+ * deleting it. That's a BI-TEMPORAL supersede: the old fact stays in history
+ * (transaction time `createdAt` is untouched), it just stops being true in valid
+ * time. Recall already serves only `active`, so an invalidated fact disappears
+ * from results but the audit trail survives.
+ *
+ * The candidate-find is DETERMINISTIC + model-free (same subject, divergent
+ * claim). Picking the WINNER (which fact is right) is the seam
+ * — an NLI/LLM check, or the caller/`write_memory(supersedes)`. We never
+ * auto-invalidate on the heuristic alone; we surface candidates.
+ */
+import type { MemoryRecord } from "./records.js";
+export interface ContradictionCandidate {
+    /** The (typically newer) fact. */
+    a: MemoryRecord;
+    /** The (typically older) fact it may contradict. */
+    b: MemoryRecord;
+    /** Token-set overlap (same topic/subject). */
+    overlap: number;
+    /** 1 − content similarity (divergent claim). */
+    divergence: number;
+    /** overlap × divergence — higher = more likely a contradiction. */
+    score: number;
+}
+/**
+ * Find candidate contradictions among ACTIVE records (caller pre-filters to
+ * active + same origin — contradictions are within ONE belief-holder). Two facts
+ * in the SAME segment that share topic tokens (overlap ≥ `minOverlap`) but
+ * diverge in claim (low embedding similarity → high divergence) score above
+ * `threshold`. Returns pairs newest-first as `a`. O(n²) over the candidate set —
+ * fine at single-operator scale; gate to a segment/recent window for big stores.
+ *
+ * NOTE: surface-only — callers choose the winner and call `FactStore.invalidate`
+ * after (e.g. `dream.ts` consolidation, `manage-memory-tool` write path).
+ */
+export declare function findContradictions(records: readonly MemoryRecord[], opts?: {
+    threshold?: number;
+    minOverlap?: number;
+}): ContradictionCandidate[];
+//# sourceMappingURL=contradiction.d.ts.map

package/dist/agents/memory/contradiction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradiction.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/contradiction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD,MAAM,WAAW,sBAAsB;IACtC,kCAAkC;IAClC,CAAC,EAAE,YAAY,CAAC;IAChB,oDAAoD;IACpD,CAAC,EAAE,YAAY,CAAC;IAChB,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;CACd;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,sBAAsB,EAAE,CAyC1B"}

package/dist/agents/memory/contradiction.js

@@ -0,0 +1,86 @@
+/**
+ * Contradiction detection + bi-temporal invalidation (Tideline v2, step 15).
+ *
+ * When a new belief conflicts with a stored one, surface it — and on confirm,
+ * close the stale fact's VALID interval (`validTo`) + archive it, rather than
+ * deleting it. That's a BI-TEMPORAL supersede: the old fact stays in history
+ * (transaction time `createdAt` is untouched), it just stops being true in valid
+ * time. Recall already serves only `active`, so an invalidated fact disappears
+ * from results but the audit trail survives.
+ *
+ * The candidate-find is DETERMINISTIC + model-free (same subject, divergent
+ * claim). Picking the WINNER (which fact is right) is the seam
+ * — an NLI/LLM check, or the caller/`write_memory(supersedes)`. We never
+ * auto-invalidate on the heuristic alone; we surface candidates.
+ */
+import { cosine } from "./embedder.js";
+import { tokenize } from "./scoring.js";
+function jaccard(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const x of a)
+        if (b.has(x))
+            inter += 1;
+    return inter / (a.size + b.size - inter);
+}
+/**
+ * Find candidate contradictions among ACTIVE records (caller pre-filters to
+ * active + same origin — contradictions are within ONE belief-holder). Two facts
+ * in the SAME segment that share topic tokens (overlap ≥ `minOverlap`) but
+ * diverge in claim (low embedding similarity → high divergence) score above
+ * `threshold`. Returns pairs newest-first as `a`. O(n²) over the candidate set —
+ * fine at single-operator scale; gate to a segment/recent window for big stores.
+ *
+ * NOTE: surface-only — callers choose the winner and call `FactStore.invalidate`
+ * after (e.g. `dream.ts` consolidation, `manage-memory-tool` write path).
+ */
+export function findContradictions(records, opts = {}) {
+    const threshold = opts.threshold ?? 0.12;
+    const minOverlap = opts.minOverlap ?? 0.2;
+    const toks = records.map((r) => new Set(tokenize(r.content)));
+    const out = [];
+    for (let i = 0; i < records.length; i++) {
+        for (let j = i + 1; j < records.length; j++) {
+            const ri = records[i];
+            const rj = records[j];
+            if (!ri || !rj || ri.segment !== rj.segment)
+                continue;
+            const ti = toks[i] ?? new Set();
+            const tj = toks[j] ?? new Set();
+            const overlap = jaccard(ti, tj);
+            if (overlap < minOverlap)
+                continue;
+            // Divergence from embeddings when both carry one (convex/both-modes),
+            // else from token SYMMETRIC-DIFFERENCE: the fraction of value-bearing
+            // tokens unique to EITHER side (|A xor B| / |A ∪ B|, i.e. 1 − overlap).
+            // High shared-subject + high unique-claim = likely contradiction.
+            // (Inverse-overlap was perverse — it scored the MOST-similar pairs
+            // lowest and dropped legacy contradictions.)
+            let divergence;
+            if (ri.embedding && rj.embedding && ri.embedding.length === rj.embedding.length) {
+                divergence = 1 - Math.max(0, cosine(ri.embedding, rj.embedding));
+            }
+            else {
+                let inter = 0;
+                for (const x of ti)
+                    if (tj.has(x))
+                        inter += 1;
+                const symDiff = ti.size + tj.size - 2 * inter;
+                const union = inter + symDiff;
+                divergence = union > 0 ? symDiff / union : 0;
+            }
+            const score = overlap * divergence;
+            if (score < threshold)
+                continue;
+            // Newest fact is `a` (the one likely superseding the other). On a
+            // createdAt tie, fall back to a deterministic memoryId compare so the
+            // pick does NOT depend on input array order.
+            const inI = ri.createdAt > rj.createdAt || (ri.createdAt === rj.createdAt && ri.memoryId >= rj.memoryId);
+            const [a, b] = inI ? [ri, rj] : [rj, ri];
+            out.push({ a, b, overlap, divergence, score });
+        }
+    }
+    return out.sort((x, y) => y.score - x.score);
+}
+//# sourceMappingURL=contradiction.js.map

package/dist/agents/memory/contradiction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contradiction.js","sourceRoot":"","sources":["../../../src/agents/memory/contradiction.ts"],"names":[],"mappings":"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"}

package/dist/agents/memory/curator.d.ts

@@ -0,0 +1,22 @@
+import { type DreamOpts } from "./dream.js";
+import type { FactStore, RecordOriginFilter } from "./records.js";
+export interface CuratorResult {
+    /** Number of per-origin passes run. */
+    origins: number;
+    confirmed: number;
+    consolidated: number;
+    evicted: number;
+    /** Active fact count after the pass (the bloat metric). */
+    activeAfter: number;
+    /** Notes re-rendered to the markdown vault this pass (0 unless `vaultDir` set + something changed). */
+    vaultWritten?: number;
+}
+export declare function runCurator(store: FactStore, opts?: {
+    origins?: readonly RecordOriginFilter[];
+    dream?: Omit<DreamOpts, "origin">;
+    /** When set (filesystem mode only), re-render the owner's vault here AFTER a
+     *  pass that actually changed facts — the "re-render after a dream" promise,
+     *  change-gated so an idle sweep does no disk churn. */
+    vaultDir?: string;
+}): CuratorResult;
+//# sourceMappingURL=curator.d.ts.map

package/dist/agents/memory/curator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curator.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/curator.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,SAAS,EAAY,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlE,MAAM,WAAW,aAAa;IAC7B,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,uGAAuG;IACvG,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,UAAU,CACzB,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE;IACL,OAAO,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACxC,KAAK,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAClC;;4DAEwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACb,GACJ,aAAa,CAwCf"}

package/dist/agents/memory/curator.js

@@ -0,0 +1,52 @@
+// src/agents/memory/curator.ts
+//
+// Tideline Step 34 — the curator: the background daemon that keeps the store
+// from bloating as it learns. Runs the dream's maintenance (confirm /
+// consolidate / evict) PER ORIGIN and reports an aggregate.
+//
+// ORIGIN SAFETY: the default (no `origins` passed) fans out over the store's
+// DISTINCT origins — one runDream pass per principal — so maintenance never
+// runs over a mixed-origin set (a whole-store pass would let consolidation merge
+// an owner fact with a channel peer's). An explicit `origins: []` is a no-op
+// (run nothing), distinct from "omitted" (fan out over all).
+import { tryGetRuntimeContext } from "../../storage/runtime-context.js";
+import { runDream } from "./dream.js";
+import { writeVault } from "./vault.js";
+export function runCurator(store, opts = {}) {
+    // One pinned instant for the whole pass — deterministic given a fixed clock.
+    const now = opts.dream?.now ?? Date.now();
+    const dream = { ...opts.dream, now };
+    // Explicit origins (incl. []) are honoured verbatim; OMITTED → fan out over
+    // the store's distinct origins (NEVER a single whole-store pass).
+    const passes = opts.origins ? [...opts.origins] : store.distinctOrigins();
+    let confirmed = 0;
+    let consolidated = 0;
+    let evicted = 0;
+    for (const origin of passes) {
+        const r = runDream(store, { ...(origin ? { origin } : {}), ...dream });
+        confirmed += r.confirmed.length;
+        consolidated += r.consolidated.length;
+        evicted += r.evicted.length;
+    }
+    // Re-render the owner's markdown vault AFTER the pass — but only when the dream
+    // actually changed something (no idle-sweep churn) and only in filesystem mode
+    // (in convex mode the store is authoritative; an on-disk vault would be an
+    // un-synced transient). The 3-way merge preserves any human-pinned edits.
+    let vaultWritten;
+    const changed = confirmed + consolidated + evicted > 0;
+    if (opts.vaultDir && changed && tryGetRuntimeContext()?.mode !== "convex") {
+        // Active + restorable-archived + prune: a purged/superseded fact's note is removed
+        // (no stale plaintext after a shred), while a reversibly-retracted fact's note and
+        // its human-pinned edits are kept (listForVault), and survivors' edits are merged.
+        vaultWritten = writeVault(opts.vaultDir, store.listForVault({ kind: "owner" }), { prune: true }).written;
+    }
+    return {
+        origins: passes.length,
+        confirmed,
+        consolidated,
+        evicted,
+        activeAfter: store.list().length,
+        ...(vaultWritten !== undefined ? { vaultWritten } : {}),
+    };
+}
+//# sourceMappingURL=curator.js.map

package/dist/agents/memory/curator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curator.js","sourceRoot":"","sources":["../../../src/agents/memory/curator.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,6EAA6E;AAC7E,sEAAsE;AACtE,4DAA4D;AAC5D,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAC5E,iFAAiF;AACjF,6EAA6E;AAC7E,6DAA6D;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAkB,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAcxC,MAAM,UAAU,UAAU,CACzB,KAAgB,EAChB,OAOI,EAAE;IAEN,6EAA6E;IAC7E,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;IAC1C,MAAM,KAAK,GAA8B,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;IAEhE,4EAA4E;IAC5E,kEAAkE;IAClE,MAAM,MAAM,GAA0C,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;IAEjH,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,MAAM,MAAM,IAAI,MAAM,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;QACvE,SAAS,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;QAChC,YAAY,IAAI,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC;QACtC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,CAAC;IAED,gFAAgF;IAChF,+EAA+E;IAC/E,2EAA2E;IAC3E,0EAA0E;IAC1E,IAAI,YAAgC,CAAC;IACrC,MAAM,OAAO,GAAG,SAAS,GAAG,YAAY,GAAG,OAAO,GAAG,CAAC,CAAC;IACvD,IAAI,IAAI,CAAC,QAAQ,IAAI,OAAO,IAAI,oBAAoB,EAAE,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3E,mFAAmF;QACnF,mFAAmF;QACnF,mFAAmF;QACnF,YAAY,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC;IAC1G,CAAC;IAED,OAAO;QACN,OAAO,EAAE,MAAM,CAAC,MAAM;QACtB,SAAS;QACT,YAAY;QACZ,OAAO;QACP,WAAW,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM;QAChC,GAAG,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACvD,CAAC;AACH,CAAC"}

package/dist/agents/memory/decay.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Memory decay GC — file-store version of recall-frequency-driven promotion.
+ * Pure arithmetic over importance / accessCount / lastAccessedAt — no model
+ * call — so it runs cheaply inside the gateway's background sweep alongside
+ * extraction.
+ *
+ * A fact's live score decays exponentially with time-since-last-access, on a
+ * half-life that's LONGER for important facts (so identity sticks, context
+ * fades), and is reinforced by how often it's been recalled. Neglected facts
+ * archive then prune; `permanent`-tier facts (identity) never decay. This is
+ * the self-pruning that keeps the structured store from growing without
+ * bound.
+ */
+import { type MemoryRecord } from "./records.js";
+/**
+ * Current live score in [0,1]. `permanent` tier is pinned at 1 (never decays).
+ * Effective-score formula: importance-scaled half-life, per-segment decay
+ * trim, and log-reinforcement from recall count.
+ */
+export declare function effectiveScore(rec: MemoryRecord, now?: number): number;
+export interface DecayResult {
+    archived: number;
+    pruned: number;
+    kept: number;
+}
+/**
+ * Sweep active facts: prune the dead, archive the faded (non-`long`), keep the
+ * rest. `permanent` facts are always kept. Idempotent + cheap; safe to run on
+ * every background sweep (decay is gradual — most runs change nothing).
+ */
+export declare function runDecayGc(workspaceDir: string, now?: number): DecayResult;
+//# sourceMappingURL=decay.d.ts.map

package/dist/agents/memory/decay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decay.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/decay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAa,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAW5D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,CASlF;AAED,MAAM,WAAW,WAAW;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,WAAW,CAkCtF"}

package/dist/agents/memory/decay.js

@@ -0,0 +1,86 @@
+/**
+ * Memory decay GC — file-store version of recall-frequency-driven promotion.
+ * Pure arithmetic over importance / accessCount / lastAccessedAt — no model
+ * call — so it runs cheaply inside the gateway's background sweep alongside
+ * extraction.
+ *
+ * A fact's live score decays exponentially with time-since-last-access, on a
+ * half-life that's LONGER for important facts (so identity sticks, context
+ * fades), and is reinforced by how often it's been recalled. Neglected facts
+ * archive then prune; `permanent`-tier facts (identity) never decay. This is
+ * the self-pruning that keeps the structured store from growing without
+ * bound.
+ */
+import { FactStore } from "./records.js";
+const DAY_MS = 86_400_000;
+/** Base half-life in days; scaled up by importance. */
+const BASE_HALF_LIFE_DAYS = 11.25;
+const DECAY_BETA = 0.8;
+/** Below this live score → prune (dead) for short/context facts; long-tier facts archive instead (never hard-pruned). */
+const PRUNE_THRESHOLD = 0.05;
+/** Below this (and not a long-tier fact) → archive (kept, out of active recall). */
+const ARCHIVE_THRESHOLD = 0.15;
+/**
+ * Current live score in [0,1]. `permanent` tier is pinned at 1 (never decays).
+ * Effective-score formula: importance-scaled half-life, per-segment decay
+ * trim, and log-reinforcement from recall count.
+ */
+export function effectiveScore(rec, now = Date.now()) {
+    if (rec.tier === "permanent")
+        return 1;
+    const daysSinceAccess = Math.max(0, (now - rec.lastAccessedAt) / DAY_MS);
+    const adaptiveHalfLife = BASE_HALF_LIFE_DAYS * (1 + rec.importance);
+    const lambda = (Math.LN2 / Math.max(adaptiveHalfLife, 0.001)) * DECAY_BETA;
+    const effectiveLambda = lambda * (1 + rec.decayRate);
+    const decayed = rec.importance * Math.exp(-effectiveLambda * daysSinceAccess);
+    const reinforcement = 1 + Math.log1p(rec.accessCount) * 0.1;
+    return Math.max(0, Math.min(1, decayed * reinforcement));
+}
+/**
+ * Sweep active facts: prune the dead, archive the faded (non-`long`), keep the
+ * rest. `permanent` facts are always kept. Idempotent + cheap; safe to run on
+ * every background sweep (decay is gradual — most runs change nothing).
+ */
+export function runDecayGc(workspaceDir, now = Date.now()) {
+    const store = new FactStore(workspaceDir);
+    const active = store.list(); // active-only
+    const toPrune = [];
+    const toArchive = [];
+    for (const r of active) {
+        if (r.tier === "permanent")
+            continue;
+        // A confirmed fact is eviction-immune — it has been promoted by the dream
+        // pass as a settled belief and must survive until explicitly demoted.
+        // Mirrors the `r.status !== "confirmed"` guard in dream.ts's EVICT path.
+        if (r.status === "confirmed")
+            continue;
+        const score = effectiveScore(r, now);
+        // Long-tier (identity/preference/correction/relationship/project) is the DURABLE
+        // tier: decay may at most ARCHIVE it (kept, recoverable via reactivate), NEVER
+        // hard-prune it — so it stays active down to the prune floor, then ARCHIVES rather
+        // than pruning. (Previously the `!== "long"` guard sat ONLY on the archive branch,
+        // so a long fact skipped the archived grace state and jumped active → pruned — the
+        // MORE durable tier ended up LESS recoverable, since reactivate() restores only
+        // archived.) Short/context facts age out fully: active → archived → pruned.
+        if (r.tier === "long") {
+            if (score < PRUNE_THRESHOLD)
+                toArchive.push(r.memoryId);
+        }
+        else if (score < PRUNE_THRESHOLD) {
+            toPrune.push(r.memoryId);
+        }
+        else if (score < ARCHIVE_THRESHOLD) {
+            toArchive.push(r.memoryId);
+        }
+    }
+    if (toPrune.length > 0)
+        store.setLifecycle(toPrune, "pruned");
+    if (toArchive.length > 0)
+        store.setLifecycle(toArchive, "archived");
+    return {
+        archived: toArchive.length,
+        pruned: toPrune.length,
+        kept: active.length - toPrune.length - toArchive.length,
+    };
+}
+//# sourceMappingURL=decay.js.map