@miller-tech/uap 1.175.13 → 1.178.0

package/dist/memory/reconstruct-store.js

@@ -0,0 +1,312 @@
+/**
+ * Wiring active reconstruction to UAP's real memory stores (harness plan E3).
+ *
+ * Resolves where the graph lives, fills it from the stores UAP already writes
+ * (short-term SQLite AND the long-term semantic store), and exposes the entry
+ * point callers use: `recallActive`.
+ *
+ * The graph is a DERIVED index, never a source of truth: it can be deleted and
+ * rebuilt at any time. (It is not side-effect free, though — opening the
+ * short-term store runs `ensureShortTermSchema`, which creates indexes and can
+ * backfill FTS. That means a build needs a writable store.)
+ *
+ * COVERAGE IS THE CORRECTNESS PROPERTY HERE. The passive path queries short-term
+ * FTS *and* the long-term semantic store. If active recall indexed only the
+ * short-term store — a rolling ~50-entry window — then routing a query here
+ * would silently drop every durable memory the project has, which is a
+ * regression wearing a feature's clothes. So ingestion covers both tiers, and
+ * `recallActive` reports what it covered.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadUapConfig } from '../utils/config-loader.js';
+import { MemoryGraph, reconstruct, heuristicPolicy, activeReconstructionEnabled, } from './reconstruct.js';
+import { ingestItems, itemKey } from './reconstruct-ingest.js';
+/** Where the derived graph lives, alongside the stores it indexes. */
+export function memoryGraphPath(cwd) {
+    return join(cwd, 'agents', 'data', 'memory', 'memory-graph.db');
+}
+/**
+ * Resolve short-term store + project id the way `uap memory query` does.
+ *
+ * Reading these from the config rather than hardcoding defaults matters: a
+ * project with a configured store path, or any project not literally named
+ * "project", was otherwise indexing zero rows while reporting success — because
+ * `getRecent` filters on `project_id`.
+ */
+export function resolveStoreConfig(cwd, opts = {}) {
+    const config = loadUapConfig(cwd);
+    return {
+        shortTermPath: opts.shortTermPath ||
+            config?.memory?.shortTerm?.path ||
+            join(cwd, 'agents', 'data', 'memory', 'short_term.db'),
+        projectId: opts.projectId ?? config?.project?.name ?? 'project',
+    };
+}
+export function openMemoryGraph(cwd) {
+    return new MemoryGraph(memoryGraphPath(cwd));
+}
+export function memoryGraphExists(cwd) {
+    return existsSync(memoryGraphPath(cwd));
+}
+/**
+ * Read UAP's short-term store into `IngestItem`s.
+ *
+ * Isolated and best-effort: a missing or unreadable store yields an empty list
+ * rather than failing the build, because the graph is derived and a partial
+ * index is more useful than none.
+ */
+export async function itemsFromShortTerm(cwd, opts = {}) {
+    const { shortTermPath: dbPath, projectId } = resolveStoreConfig(cwd, opts);
+    if (!existsSync(dbPath))
+        return [];
+    const { SQLiteShortTermMemory } = await import('./short-term/sqlite.js');
+    let store = null;
+    try {
+        store = new SQLiteShortTermMemory({
+            dbPath,
+            projectId,
+            maxEntries: opts.limit ?? 2000,
+        });
+        const rows = (await store.getRecent(opts.limit ?? 2000)) ?? [];
+        return rows.map((r) => ({
+            id: `st:${r.id ?? itemKey({ text: r.content })}`,
+            text: r.content,
+            type: r.type,
+            occurredAt: r.timestamp,
+        }));
+    }
+    catch {
+        return [];
+    }
+    finally {
+        // A throw in getRecent used to skip close(), leaking the handle (plus WAL and
+        // SHM refs) once per query, since recall refreshes on every call.
+        try {
+            await store?.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/**
+ * Read the LONG-TERM semantic store into ingest items.
+ *
+ * This tier holds everything durable — `memory store`, `sync-files`,
+ * `prepopulate`. Omitting it would make active recall a strict downgrade from
+ * the passive path it replaces. Best-effort: an unreachable Qdrant yields [] and
+ * the caller reports reduced coverage rather than failing.
+ */
+export async function itemsFromLongTerm(cwd, limit = 2000) {
+    try {
+        const config = loadUapConfig(cwd);
+        const endpoint = config?.memory?.longTerm?.endpoint || 'localhost:6333';
+        const url = /^https?:\/\//.test(endpoint) ? endpoint : `http://${endpoint}`;
+        const collection = config?.memory?.longTerm?.collection || 'agent_memory';
+        const apiKey = config?.memory?.longTerm?.qdrantCloud?.apiKey || process.env.QDRANT_API_KEY;
+        const { getQdrantClientClass } = await import('../utils/lazy-imports.js');
+        const QdrantClientClass = await getQdrantClientClass();
+        // The client defaults to a 300_000ms timeout. On the AGENT path this call
+        // is awaited during context assembly, so a black-holed endpoint (firewall
+        // drop, not a fast ECONNREFUSED) would block a model turn for five minutes.
+        const timeout = Number(process.env.UAP_MEMORY_QDRANT_TIMEOUT_MS) || 3000;
+        const client = new QdrantClientClass({ url, apiKey, checkCompatibility: false, timeout });
+        const collections = await client.getCollections();
+        const names = [collection, `${collection}_prepopulated`].filter((c) => collections.collections.some((col) => col.name === c));
+        const items = [];
+        for (const name of names) {
+            // Scroll the payloads only — the graph indexes text, not vectors.
+            let offset = undefined;
+            while (items.length < limit) {
+                const page = await client.scroll(name, {
+                    limit: Math.min(256, limit - items.length),
+                    with_payload: true,
+                    with_vector: false,
+                    offset,
+                });
+                for (const point of page.points ?? []) {
+                    const payload = (point.payload ?? {});
+                    const text = String(payload.content ?? '');
+                    if (!text)
+                        continue;
+                    items.push({
+                        id: `lt:${name}:${String(point.id)}`,
+                        text,
+                        type: String(payload.type ?? 'knowledge'),
+                        tags: Array.isArray(payload.tags) ? payload.tags : undefined,
+                        occurredAt: typeof payload.timestamp === 'string' ? payload.timestamp : undefined,
+                    });
+                }
+                offset = page.next_page_offset;
+                if (!offset)
+                    break;
+            }
+        }
+        return items;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build or refresh the graph from the stores.
+ *
+ * Incremental by default: source keys already ingested are skipped, so this is
+ * cheap to re-run and safe to call before a query.
+ */
+export async function buildMemoryGraph(cwd, opts = {}) {
+    const graph = openMemoryGraph(cwd);
+    try {
+        if (!graph.acquireBuildLock(Date.now())) {
+            // Another process is building. Duplicating that work would insert every
+            // item a second time under fresh ids — permanent, since the ledger then
+            // reports them indexed.
+            return {
+                ingested: 0, skipped: 0, storedKeys: [], cues: 0, tags: 0, bridgingTags: 0,
+                considered: 0, graphPath: memoryGraphPath(cwd),
+                coverage: { shortTerm: 0, longTerm: 0 },
+                skippedConcurrentBuild: true,
+            };
+        }
+        const shortTerm = await itemsFromShortTerm(cwd, opts);
+        const longTerm = opts.includeLongTerm === false ? [] : await itemsFromLongTerm(cwd, opts.limit);
+        const items = [...shortTerm, ...longTerm, ...(opts.extra ?? [])];
+        if (opts.rebuild) {
+            // A real rebuild TRUNCATES. Clearing only the in-memory dedupe set left
+            // every row in place and re-inserted the whole corpus under fresh ids, so
+            // two rebuilds meant every memory twice — permanently, since the ledger
+            // then reported them as already indexed.
+            graph.clear();
+        }
+        const seen = opts.rebuild ? new Set() : graph.ingestedKeys();
+        const result = ingestItems(graph, items, { seen });
+        // Mark ONLY what was stored — see IngestResult.storedKeys.
+        graph.markIngested(result.storedKeys);
+        // Heartbeat REGARDLESS of whether anything was stored. Deriving staleness
+        // from stored keys means a refresh that finds nothing new never advances the
+        // clock, so the TTL never clears and the index rebuilds every retrieval.
+        graph.markRefreshed(new Date().toISOString());
+        return {
+            ...result,
+            considered: items.length,
+            graphPath: memoryGraphPath(cwd),
+            coverage: { shortTerm: shortTerm.length, longTerm: longTerm.length },
+        };
+    }
+    finally {
+        graph.releaseBuildLock();
+        graph.close();
+    }
+}
+/**
+ * Recall by ACTIVE RECONSTRUCTION: traverse the graph while reasoning, pruning
+ * weak paths before they cost context, instead of one passive top-k pull.
+ *
+ * This is the caller area E was missing. It is invoked by `uap memory query
+ * --active` and by anything that opts in; passive retrieval remains the default
+ * until the paired bench measures the lift on our own suite.
+ */
+export async function recallActive(cwd, query, opts = {}) {
+    const build = (await shouldRefresh(cwd, opts))
+        ? await buildMemoryGraph(cwd, opts.buildOptions)
+        : undefined;
+    const graph = openMemoryGraph(cwd);
+    try {
+        if (graph.isEmpty()) {
+            return {
+                context: [],
+                steps: [],
+                converged: false,
+                stopReason: 'exhausted',
+                graphEmpty: true,
+                build,
+            };
+        }
+        const result = reconstruct(graph, query, {
+            policy: opts.policy ?? heuristicPolicy(),
+            maxSteps: opts.maxSteps,
+            maxContext: opts.maxContext,
+        });
+        return { ...result, graphEmpty: false, build };
+    }
+    finally {
+        graph.close();
+    }
+}
+/** Decide whether this recall should rebuild the index first. */
+async function shouldRefresh(cwd, opts) {
+    if (opts.refresh === false)
+        return false;
+    if (opts.refresh !== 'if-stale')
+        return true;
+    if (!memoryGraphExists(cwd))
+        return true;
+    const graph = openMemoryGraph(cwd);
+    try {
+        const last = graph.lastRefreshedAt() ?? graph.lastIngestedAt();
+        if (!last)
+            return true;
+        // SQLite datetime('now') is UTC without a zone marker; parse it as such.
+        const lastMs = Date.parse(last.endsWith('Z') ? last : `${last.replace(' ', 'T')}Z`);
+        if (!Number.isFinite(lastMs))
+            return true;
+        const ttlMs = (opts.staleAfterSeconds ?? 900) * 1000;
+        return Date.now() - lastMs > ttlMs;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        graph.close();
+    }
+}
+/**
+ * Should a caller use active reconstruction?
+ *
+ * Both conditions must hold: the operator opted in AND the graph actually has
+ * content. Routing to an empty graph would silently return nothing where
+ * passive retrieval would have answered — a regression dressed as a feature.
+ */
+export function shouldUseActiveRecall(cwd, graph) {
+    if (!activeReconstructionEnabled())
+        return false;
+    if (!memoryGraphExists(cwd))
+        return false;
+    if (graph) {
+        try {
+            return !graph.isEmpty();
+        }
+        catch {
+            return false;
+        }
+    }
+    const owned = openMemoryGraph(cwd);
+    const graphRef = owned;
+    try {
+        // Cheap probe, not stats(): this runs on EVERY `uap memory query` and every
+        // harness-card render, and stats() is five aggregates over the triples table.
+        return !graphRef.isEmpty();
+    }
+    catch {
+        return false;
+    }
+    finally {
+        owned.close();
+    }
+}
+/**
+ * The retrieval mode actually in force, for the harness disclosure card.
+ *
+ * One implementation so the bench card and `uap harness card` cannot disagree —
+ * two call sites computing this independently is how a card starts lying.
+ */
+export function describeMemoryMode(cwd) {
+    try {
+        return shouldUseActiveRecall(cwd) ? 'active reconstruction' : 'semantic retrieval';
+    }
+    catch {
+        return 'semantic retrieval';
+    }
+}
+//# sourceMappingURL=reconstruct-store.js.map

package/dist/memory/reconstruct-store.js.map

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

package/dist/memory/reconstruct.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Active memory reconstruction over a Cue–Tag–Content graph
+ * (harness plan area E, 2026-07-31).
+ *
+ * UAP's memory retrieval is passive: embed the query, pull the top-k, reason
+ * once. "Memory is Reconstructed, Not Retrieved" (arXiv 2606.06036) shows that
+ * paradigm is strictly less expressive than letting the model traverse memory
+ * WHILE it reasons — it proves active policies solve a binary-tree
+ * needle-in-a-haystack with zero error where passive policies need an
+ * exponential budget — and measures the practical gap at up to +23% on LoCoMo
+ * with 118k tokens per query against A-Mem's 632k and LangMem's 3.26M.
+ *
+ * THE TAG LAYER IS THE CONTRIBUTION. Their ablation: cue -> content direct
+ * indexing recalls ~65%; cue -> TAG -> content with multi-turn reasoning recalls
+ * ~90%. A "graph memory" that skips the associative tag bridge gets none of the
+ * benefit, so the schema here makes tags mandatory rather than an optimisation.
+ *
+ * Off by default. The literature's numbers are theirs, not ours: this ships
+ * behind `UAP_MEMORY_ACTIVE=1` until `uap bench paired` measures the lift on our
+ * own suite (harness plan constraint 3).
+ */
+/** Which memory layer a content node lives in (MRAgent's three granularities). */
+export type MemoryLayer = 
+/** Event-specific, temporally ordered. */
+'episodic'
+/** Stable facts: preferences, attributes, decisions. */
+ | 'semantic'
+/** Topic nodes summarising recurring patterns — the top-down entry point. */
+ | 'abstraction';
+export interface ContentNode {
+    id: number;
+    layer: MemoryLayer;
+    text: string;
+    /** ISO timestamp of the source episode, when known. */
+    occurredAt?: string;
+}
+/** One (cue, tag, content) triple — the graph's only edge type. */
+export interface Triple {
+    cue: string;
+    tag: string;
+    contentId: number;
+}
+export interface ReconstructionStep {
+    /** 1-based step index. */
+    step: number;
+    /** Cues the model chose to expand this step. */
+    expandedCues: string[];
+    /** Tags reached from those cues. */
+    tags: string[];
+    /** Content ids admitted into the reconstructed context. */
+    kept: number[];
+    /** Content ids reached but judged IRRELEVANT. */
+    pruned: number[];
+    /**
+     * Content ids the policy kept but that did not fit the context budget.
+     * Separate from `pruned`: "judged irrelevant" and "budget full" are different
+     * outcomes and want different remedies.
+     */
+    dropped: number[];
+    /** Whether the model declared the evidence sufficient after this step. */
+    sufficient: boolean;
+}
+export interface ReconstructionResult {
+    /** Content, in the order it was admitted — this is what goes to the model. */
+    context: ContentNode[];
+    steps: ReconstructionStep[];
+    /** True when the loop stopped because evidence sufficed, not because it ran out of steps. */
+    converged: boolean;
+    /** Why the traversal stopped, so callers can give accurate advice. */
+    stopReason: 'sufficient' | 'context-full' | 'exhausted' | 'step-budget';
+}
+/**
+ * The reasoning seam. Injected so the traversal policy is testable without a
+ * model, and so the same graph can be driven by a local or a frontier model.
+ */
+export interface ReconstructionPolicy {
+    /**
+     * Choose which of the currently-active cues to expand next. Returning [] ends
+     * the traversal.
+     */
+    selectCues(query: string, activeCues: string[], context: ContentNode[]): string[];
+    /**
+     * Semantic routing: which reached contents are worth keeping, and is the
+     * accumulated evidence now enough to answer?
+     *
+     * `hops` carries how each candidate was reached. A router that ignores it can
+     * only judge lexical similarity to the query — and then the tag bridge, which
+     * is the whole point of the structure, buys nothing: the traversal reaches the
+     * associated memory and the router throws it away for sharing no words with
+     * the question.
+     */
+    route(query: string, candidates: ContentNode[], context: ContentNode[], hops?: HopContext): RouteDecision;
+}
+export interface RouteDecision {
+    keep: number[];
+    sufficient: boolean;
+    /**
+     * Candidates declined ONLY because a per-step cap was reached, not on the
+     * merits. The traversal keeps these reachable by a later, stronger bridge
+     * instead of blacklisting them like a genuine rejection.
+     */
+    deferred?: number[];
+}
+/** How the traversal reached this step's candidates. */
+export interface HopContext {
+    /** Candidate id -> the tags it was reached through. */
+    tagsFor: Map<number, string[]>;
+    /**
+     * Tags that have produced admitted evidence in ANY prior step — accumulated,
+     * not per-step. A bridge proves itself once; requiring it to re-prove itself
+     * every step is what stops a second hop from ever landing, since by
+     * definition the far side of a bridge does not resemble the query.
+     */
+    productiveTags: ReadonlySet<string>;
+    /**
+     * How many contents each tag links. Specificity is the honest discriminator
+     * for an associative admission: a tag on 3 memories asserts a real relation, a
+     * tag on 300 asserts almost nothing. Lexical overlap cannot serve here — the
+     * far side of a bridge shares no words with the query by construction.
+     */
+    tagSize: (tag: string) => number;
+}
+/**
+ * Zero-LLM policy: lexical overlap for routing, breadth-first for expansion.
+ *
+ * Not a toy — it is the honest default. An active traversal driven by a cheap
+ * heuristic is still active (it prunes on accumulated evidence, which is the
+ * mechanism the paper isolates); wiring an LLM in raises the ceiling but is not
+ * required for the structure to pay off, and a deterministic policy is what
+ * makes the loop unit-testable.
+ */
+export declare function heuristicPolicy(opts?: {
+    keepThreshold?: number;
+    sufficientAt?: number;
+    maxExpandPerStep?: number;
+    /** Max tag-bridged admissions per step. 0 disables associative recall. */
+    maxAssociativePerStep?: number;
+    /**
+     * A tag linking more contents than this is too broad to justify admitting a
+     * candidate that has no lexical relation to the query at all.
+     */
+    maxBridgeTagSize?: number;
+}): ReconstructionPolicy;
+/**
+ * The Cue–Tag–Content graph.
+ *
+ * Its own SQLite file rather than a table in the semantic store: the traversal
+ * is a different access pattern (many small keyed hops, no vector math) and
+ * keeping it separate means enabling the feature cannot slow the existing
+ * retrieval path.
+ */
+export declare class MemoryGraph {
+    private db;
+    constructor(dbPath: string);
+    /**
+     * Add one memory item and its (cue, tag) index entries.
+     *
+     * Tags are REQUIRED: an item indexed by cue alone is the ~65%-recall
+     * configuration the paper ablates away. Callers with no tags should supply a
+     * coarse one (the layer name) rather than none.
+     */
+    addContent(params: {
+        layer: MemoryLayer;
+        text: string;
+        occurredAt?: string;
+        cues: string[];
+        tags: string[];
+    }): number;
+    /** φ_{c→g}: the associative tags a cue activates. */
+    tagsForCue(cue: string): string[];
+    /** φ_{(c,g)→v}: contents reachable from a cue THROUGH a specific tag. */
+    contentsFor(cue: string, tag: string): ContentNode[];
+    /**
+     * Tags too broad to be bridges: attached to >= 60% of all content. Reuses the
+     * discriminativeness rule `stats()` already applies, because a tag that links
+     * everything relates nothing — and on the short-term tier EVERY item is tagged
+     * with one of ~6 type values, so without this the "bridge" is the whole store.
+     */
+    hubTags(): Set<string>;
+    private tagSizeCache;
+    /** How many distinct contents a tag links. Cached — hot in the route loop. */
+    tagSize(tag: string): number;
+    /** Cues that co-occur with a tag — how traversal discovers NEW clues. */
+    cuesForTag(tag: string): string[];
+    /** Source keys already ingested, for incremental rebuilds. */
+    ingestedKeys(): Set<string>;
+    /** Record that a refresh COMPLETED, whether or not it stored anything. */
+    markRefreshed(nowIso: string): void;
+    /** ISO timestamp of the last completed refresh, or null if never refreshed. */
+    lastRefreshedAt(): string | null;
+    /**
+     * Best-effort single-flight guard around a build.
+     *
+     * Two agents retrieving at once both see a stale graph, both build, and both
+     * insert the same items under fresh ids — permanent duplicates, since the
+     * ledger then reports them indexed. Returns false when another build holds the
+     * lock; a lock older than `staleMs` is taken over so a crashed build cannot
+     * wedge refreshes forever.
+     */
+    acquireBuildLock(nowMs: number, staleMs?: number): boolean;
+    releaseBuildLock(): void;
+    /** ISO timestamp of the most recent ingest, or null if never built. */
+    lastIngestedAt(): string | null;
+    /** Mark source keys as ingested. */
+    markIngested(keys: Iterable<string>): void;
+    /**
+     * Cheap emptiness probe. `stats()` runs five aggregates including two
+     * COUNT(DISTINCT) and a GROUP BY — far too expensive for the "should I route
+     * here" check that runs on every single query.
+     */
+    isEmpty(): boolean;
+    /** Delete everything — the truncate half of a real rebuild. */
+    clear(): void;
+    /** Shape of the graph, for `uap memory graph status` and honest reporting. */
+    stats(): {
+        contents: number;
+        cues: number;
+        tags: number;
+        triples: number;
+        bridgingTags: number;
+    };
+    /** Every cue in the graph — the seed set when the query matches nothing. */
+    allCues(): string[];
+    close(): void;
+}
+export interface ReconstructOptions {
+    /** Hard step cap. The paper's runs converge in 3–4; 5 leaves headroom. */
+    maxSteps?: number;
+    policy?: ReconstructionPolicy;
+    /** Seed cues. Omitted -> derived from the query's own tokens. */
+    seedCues?: string[];
+    /**
+     * Hard ceiling on admitted context. `sufficient` only stops FURTHER steps —
+     * everything kept in the current step is already in context — so without this
+     * one step over a well-connected graph can admit thousands of nodes and blow
+     * the token budget this whole approach exists to protect.
+     */
+    maxContext?: number;
+    /** Seed cues to draw when the query matches nothing. Default 32. */
+    maxSeeds?: number;
+    /**
+     * Hard cap on cues expanded per step, enforced HERE rather than trusted to the
+     * policy. The policy seam exists for an LLM to plug into, and an LLM will
+     * happily return 200 cues (or cues that were never active), reproducing the
+     * full-scan this bound was added to prevent.
+     */
+    maxExpandPerStep?: number;
+}
+/**
+ * Reconstruct an answer context by traversing the graph while reasoning.
+ *
+ * The loop is the paper's three-step iteration: select actions over the active
+ * set, traverse (cue -> tags -> contents), then route/prune and update state.
+ * The essential difference from retrieval is that step N+1's expansion depends
+ * on what step N actually found — cues discovered mid-traversal become new
+ * entry points, and weak paths are killed before they consume context.
+ */
+export declare function reconstruct(graph: MemoryGraph, query: string, options?: ReconstructOptions): ReconstructionResult;
+/**
+ * Seed cues = query tokens present in the graph.
+ *
+ * When nothing matches we fall back to a BOUNDED sample rather than every cue
+ * in the graph: an off-topic query would otherwise load the entire content
+ * table on step 1, which is the opposite of what this is for.
+ */
+export declare function seedCuesFromQuery(graph: MemoryGraph, query: string, maxSeeds?: number): string[];
+/**
+ * Is active reconstruction enabled? Off by default — the lift is measured on our
+ * own suite before it becomes the default retrieval path.
+ */
+export declare function activeReconstructionEnabled(): boolean;
+//# sourceMappingURL=reconstruct.d.ts.map

package/dist/memory/reconstruct.d.ts.map

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