@spinabot/brigade 0.1.2 → 1.0.1

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

@@ -0,0 +1,617 @@
+/**
+ * Structured memory records — an append-only JSONL file
+ * (`<workspace>/memory/facts.jsonl`). Single-user, so reads scan the whole
+ * file and writes are read-modify-write — no concurrency budget to fight.
+ *
+ * A "memory" here is a structured fact, NOT a raw note: one declarative
+ * sentence tagged with a `segment` (what kind of fact) and a `tier` +
+ * `importance` + `decayRate` derived from that segment. This is what the
+ * post-turn extraction subagent emits and what `write_memory` persists; the
+ * lexical recall layer (storage.ts) searches these alongside MEMORY.md +
+ * daily notes.
+ *
+ * Conflict resolution: `supersedes` archives older records, the
+ * `correction` segment overturns a prior belief, and a decay GC ages out
+ * neglected facts. (A heavier 3-LLM consolidation debate is intentionally
+ * NOT done in v1 — supersede + decay cover the common cases.)
+ */
+import { type ScoreBreakdown } from "./scoring.js";
+import { type MemoryLink } from "./links.js";
+import { type MemoryEvent } from "./event-log.js";
+/** What kind of fact this is — drives tier/importance/decay defaults. */
+export type MemorySegment = "identity" | "preference" | "correction" | "relationship" | "project" | "knowledge" | "context";
+/** How durable a record is. `permanent` is never decayed out. */
+export type MemoryTier = "short" | "long" | "permanent";
+/** Active = live, archived = superseded/decayed-but-kept, pruned = dead. */
+export type MemoryLifecycle = "active" | "archived" | "pruned";
+/**
+ * Where a fact CAME FROM — distinct from `createdBy` (the principal/origin).
+ * Drives the write-gate (Step 12): low-trust sources (`tool_output`,
+ * `retrieved_document`, `compaction`) can't supersede owner-authored facts or
+ * write procedural records. `undefined` ⇔ legacy / owner-authored (trusted).
+ */
+export type MemorySourceType = "user_instruction" | "owner_message" | "channel_message" | "tool_output" | "retrieved_document" | "compaction" | "extraction" | "dream";
+/** Runtime list of every {@link MemorySourceType} — for validating
+ *  externally-loaded data (e.g. the real-data gold path, where a typo'd source
+ *  would otherwise be silently treated as TRUSTED by the write-gate). The
+ *  `satisfies` clause makes a typo/extra value a COMPILE error; keep in sync with
+ *  the type above if a source is ever added. */
+export declare const MEMORY_SOURCE_TYPES: readonly ["user_instruction", "owner_message", "channel_message", "tool_output", "retrieved_document", "compaction", "extraction", "dream"];
+/**
+ * Epistemic state of a fact — distinct from {@link MemoryLifecycle} (which is
+ * STORAGE state: active/archived/pruned). Dormant in v1 (the field persists but
+ * nothing sets/reads it); Phase-2 cognition (trust, contradiction) drives it.
+ */
+export type MemoryStatus = "asserted" | "provisional" | "confirmed" | "disputed" | "retracted";
+/** Modality of a fact's underlying content (Step 17 cold-pointer). The stored
+ *  `content` is ALWAYS text (a transcript/caption) so recall is uniform; the
+ *  media itself lives at `mediaPointer`. `undefined` ⇒ text. */
+export type MemoryModality = "text" | "audio" | "image" | "video" | "document";
+/**
+ * Who wrote this memory record — used by the recall path to keep peer
+ * memories isolated from the operator's view (and isolated per-session
+ * from each other). Mirrors the `CronJobOrigin` shape from the cron tool
+ * so the audit trail vocabulary stays consistent across primitives.
+ *
+ *   - `{ kind: "owner" }` — workspace owner (TUI / `connect` / CLI).
+ *     Recallable by the owner across every owner session. NOT recalled
+ *     by channel peers so the operator's private notes can't leak into
+ *     an approved peer's chat.
+ *   - `{ kind: "channel", channelId, conversationId, sessionKey }` —
+ *     written from an approved channel peer's chat. Recallable ONLY
+ *     when the calling turn matches all three (channel + conversation
+ *     + session). Different chats from the same peer don't see each
+ *     other; the operator never sees them in auto-recall.
+ *
+ * `accountId` is captured opportunistically for multi-account channels.
+ *
+ * Records persisted before this field existed have `createdBy: undefined`
+ * — the recall path treats them as owner-origin for back-compat.
+ */
+export type MemoryRecordOrigin = {
+    kind: "owner";
+} | {
+    kind: "channel";
+    channelId: string;
+    conversationId: string;
+    sessionKey: string;
+    accountId?: string;
+};
+export interface MemoryRecord {
+    memoryId: string;
+    /** One clear declarative sentence. */
+    content: string;
+    segment: MemorySegment;
+    tier: MemoryTier;
+    /** 0..1 — segment default unless the writer overrides. */
+    importance: number;
+    /** Per-segment decay multiplier (higher = forgets faster). */
+    decayRate: number;
+    /** Bumped each time recall surfaces this record (decay reinforcement). */
+    accessCount: number;
+    /** Epoch ms of the last recall hit (or creation). */
+    lastAccessedAt: number;
+    /** Epoch ms when first written. */
+    createdAt: number;
+    /** Run/turn id that produced this fact, when known. */
+    sourceTurn?: string;
+    /** memoryIds this record archives (corrections/updates). */
+    supersedes?: string[];
+    lifecycle: MemoryLifecycle;
+    /**
+     * Origin of this record (see {@link MemoryRecordOrigin}). `undefined`
+     * ⇔ legacy record persisted before ownership tracking shipped —
+     * treated as `{ kind: "owner" }` by the recall path so existing
+     * facts keep their previous owner-visible behaviour.
+     */
+    createdBy?: MemoryRecordOrigin;
+    /** Where this fact came from (see {@link MemorySourceType}) — drives the
+     *  write-gate. `undefined` ⇔ legacy / owner-authored (trusted). */
+    sourceType?: MemorySourceType;
+    /** Typed edges to other facts (the graph substrate, Step 7). `supersedes[]`
+     *  is mirrored at READ time by `linksFrom` — not stored here. */
+    links?: MemoryLink[];
+    /** Bi-temporal VALID-time interval (Step 7 cognition) — when the fact is true
+     *  in the world, distinct from `createdAt` (transaction time it was recorded).
+     *  Phase-2 contradiction handling closes `validTo` on a bi-temporal supersede.
+     *  Dormant in v1. */
+    validFrom?: number;
+    validTo?: number;
+    /** Confidence in the fact, [0, 1]. Phase-2 trust folds this into ranking. Dormant in v1. */
+    confidence?: number;
+    /** Epistemic state (distinct from `lifecycle`, the storage state). Dormant in v1. */
+    status?: MemoryStatus;
+    /** Ids of the source material this fact was derived from (message ids, doc
+     *  ids, parent memoryIds). Phase-3 `purge` cascades along these. Dormant in v1. */
+    sourcePointers?: string[];
+    /** Dense vector for the HYBRID recall lane — populated on write in BOTH modes
+     *  (convex ANN-indexes it via `by_embedding`; fs cosine-scans it in-app). */
+    embedding?: number[];
+    /** Modality of the underlying content (Step 17 cold-pointer). `undefined` ⇒ text. */
+    modality?: MemoryModality;
+    /** Path/URI to the source media this fact was distilled from — the "cold
+     *  pointer" that keeps media OUT of the hot text index. */
+    mediaPointer?: string;
+    /** Optional JSON sidecar, e.g. {"corrects":"the prior belief"}. */
+    metadata?: Record<string, unknown>;
+    /** Single-valued ATTRIBUTE SLOT this fact sets (normalized snake_case, e.g.
+     *  `deploy_day`, `home_city`, `ui_theme`). When present, writing a NEW fact with
+     *  the SAME subjectKey + SAME origin auto-supersedes this one (the prior value is
+     *  archived, bi-temporally closed, and `contradicts`-linked) — so a correction
+     *  replaces the stale belief instead of piling up beside it. Omit for ADDITIVE
+     *  facts (pets, skills) that should coexist. Segment-independent by design. */
+    subjectKey?: string;
+}
+/**
+ * Per-segment defaults. `identity` is the most durable (permanent, slow
+ * decay); `context` the most ephemeral (short tier, fast decay).
+ */
+export declare const SEGMENT_DEFAULTS: Record<MemorySegment, {
+    tier: MemoryTier;
+    importance: number;
+    decayRate: number;
+}>;
+export declare const MEMORY_SEGMENTS: MemorySegment[];
+/** Relative path of the structured fact store within a workspace. */
+export declare const FACTS_RELATIVE_PATH: string;
+/**
+ * Hard cap on a single fact's content. A fact is meant to be one sentence;
+ * this stops a misbehaving model (or pasted blob) from writing a megabyte
+ * "fact" that then bloats the always-read JSONL AND every auto-recall
+ * injection. Generous enough for any legitimate fact.
+ */
+export declare const MAX_FACT_CONTENT_CHARS = 1000;
+/**
+ * Jaccard-similarity threshold above which two facts are treated as the same
+ * at write time (dedup). Deliberately HIGH (0.85) so only near-identical
+ * restatements collapse — distinct facts that merely share words (e.g. two
+ * different facts about the same topic) are kept separate.
+ */
+export declare const DEDUP_SIMILARITY = 0.85;
+/**
+ * Idempotency bars for "is this extracted fact ALREADY known?" — looser than the
+ * write-time {@link DEDUP_SIMILARITY} because post-turn extraction REWORDS a fact
+ * the operator already taught (a paraphrase scores well below 0.85 on both lanes:
+ * measured ≈0.4–0.64 cosine / ≈0.2–0.6 Jaccard for real restatements). These bars
+ * apply ONLY when the existing candidate is SUBJECT-BEARING — the single-valued
+ * facts (`diet`, `ui_theme`, …) extraction must not churn a subject-less twin
+ * beside — so the looseness can't suppress an ADDITIVE fact (pets, skills: no
+ * subjectKey ⇒ they fall back to the strict {@link DEDUP_SIMILARITY} near-exact
+ * bar). Empirically these cleanly separate real restatements from distinct facts.
+ */
+export declare const IDEMPOTENT_COSINE_BAR = 0.45;
+export declare const IDEMPOTENT_JACCARD_BAR = 0.4;
+/** Token-set Jaccard over two raw contents (the dedup/idempotency basis — same
+ *  tokenizer as recall). Exposed so the extraction-idempotency check (extract.ts)
+ *  measures "already-known" with the IDENTICAL near-duplicate basis the write-time
+ *  dedup uses, instead of re-deriving a divergent one. */
+export declare function contentSimilarity(a: string, b: string): number;
+/**
+ * Compare two records by metadata RICHNESS (NOT recency). Returns >0 when `a` is
+ * richer, <0 when `b` is, 0 when equal on every richness field. This is the
+ * survivor-selection ordering for every dedup / supersede / consolidation merge:
+ * the SURVIVING record must be the richest one, so a subject-less reworded copy
+ * never archives a subject-bearing `identity`/`preference` original.
+ */
+export declare function compareRichness(a: MemoryRecord, b: MemoryRecord): number;
+/**
+ * Of two near-identical records, the one that should SURVIVE a merge: the richer
+ * by {@link compareRichness}; an exact richness tie breaks to the NEWER record
+ * (a genuine restatement refreshes the belief). Pure — picks, never mutates.
+ */
+export declare function richerSurvivor(a: MemoryRecord, b: MemoryRecord): MemoryRecord;
+/**
+ * Fold the RICHER metadata of `loser` into `survivor`, in place — so collapsing a
+ * near-duplicate pair never DROPS hard-won metadata even when the survivor was the
+ * sparser record. Each field takes the more-informative value across BOTH records:
+ * a present `subjectKey` is never lost to none; the more-specific segment is kept;
+ * importance / confidence / accessCount take the max; `sourceTurn` / `validFrom`
+ * backfill if missing; links union (deduped). Provenance (`sourceType`, `createdBy`)
+ * is NOT merged — those are identity/trust, not richness, and the survivor keeps its
+ * own. Returns `survivor` for chaining. Mutates `survivor` only.
+ */
+export declare function inheritRicherMetadata(survivor: MemoryRecord, loser: MemoryRecord): MemoryRecord;
+/** `mem_<base36 time>_<rand>` — a time-sortable id shape. */
+export declare function makeMemoryId(): string;
+/**
+ * Treat a missing origin as owner (back-compat with records persisted
+ * before ownership tracking shipped). All recall + dedup logic should
+ * route through this helper rather than reading `createdBy` directly so
+ * the legacy default stays in one place.
+ */
+export declare function resolveRecordOrigin(origin: MemoryRecordOrigin | undefined): MemoryRecordOrigin;
+/** Origin-isolation bucket key. Owner (and legacy/undefined-origin) facts share
+ *  one bucket; each channel peer (channelId+conversationId+sessionKey) is its
+ *  OWN bucket — so any cross-fact operation (consolidation, dream merges) can
+ *  group by this and never mix origins. The canonical key; consolidate.ts +
+ *  dream.ts + FactStore.distinctOrigins all route through it. */
+export declare function originBucketKey(r: Pick<MemoryRecord, "createdBy">): string;
+/** Two origins are the same when both fields-by-fields match. */
+export declare function sameOrigin(a: MemoryRecordOrigin | undefined, b: MemoryRecordOrigin | undefined): boolean;
+/**
+ * Recall-side filter. Per the design:
+ *   - An owner caller's filter is `{ kind: "owner" }` — they recall ONLY
+ *     owner-written records (and legacy `undefined`-origin records, which
+ *     resolve to owner). The operator's view stays clean of peer-written
+ *     state.
+ *   - A channel-peer caller's filter is `{ kind: "channel", … }` matching
+ *     their channelId + conversationId + sessionKey. They recall ONLY
+ *     records whose origin matches exactly. Different sessions from the
+ *     same peer don't see each other; the operator's records are
+ *     invisible to them too.
+ *
+ * `undefined` filter = no filtering (used by maintenance paths like
+ * decay GC, consolidation, doctor diagnostics — anything that legitimately
+ * needs the whole store).
+ */
+export type RecordOriginFilter = MemoryRecordOrigin | undefined;
+/** True if the record matches the filter. `undefined` filter matches every record. */
+export declare function recordMatchesOriginFilter(record: {
+    createdBy?: MemoryRecordOrigin;
+}, filter: RecordOriginFilter): boolean;
+/** Clamp to [0,1], falling back to `fallback` when not a finite number. */
+export declare function clampImportance(value: unknown, fallback: number): number;
+export interface NewFact {
+    content: string;
+    segment: MemorySegment;
+    importance?: number;
+    tier?: MemoryTier;
+    sourceTurn?: string;
+    supersedes?: string[];
+    metadata?: Record<string, unknown>;
+    /**
+     * Stamped by the `write_memory` per-call gate (owner default; channel
+     * peer = their session origin). The store persists it verbatim onto
+     * the resulting record so the recall path can filter by it.
+     */
+    createdBy?: MemoryRecordOrigin;
+    /** Source type for the write-gate (owner_message, tool_output, …). Omit ⇒
+     *  owner-authored/trusted. */
+    sourceType?: MemorySourceType;
+    /** Typed edges to other facts (the graph substrate, Step 7). */
+    links?: MemoryLink[];
+    /** Cognition fields (Step 7) — bi-temporal valid interval, confidence,
+     *  epistemic status, and source pointers. All dormant in v1 (persisted for
+     *  Phase-2 use); omit them and the record behaves exactly as before. */
+    validFrom?: number;
+    validTo?: number;
+    confidence?: number;
+    status?: MemoryStatus;
+    sourcePointers?: string[];
+    /** Cold-pointer multimodal (Step 17): `content` = the transcript/caption text. */
+    modality?: MemoryModality;
+    mediaPointer?: string;
+    /** Single-valued attribute slot (e.g. `deploy_day`) — a new value for the same
+     *  slot + origin auto-supersedes the prior one. Omit for additive facts. */
+    subjectKey?: string;
+}
+export interface ListFilter {
+    segment?: MemorySegment;
+    lifecycle?: MemoryLifecycle;
+    /** Cap the number returned (most-recent-first). */
+    limit?: number;
+    /**
+     * Restrict to records matching this origin. Omit to return EVERY
+     * record regardless of origin (the maintenance default — used by
+     * decay GC, consolidation, doctor diagnostics). Tool-facing callers
+     * (`read_memory` / `recall_memory` / auto-recall) MUST pass an
+     * explicit filter so peer + operator state stay isolated.
+     */
+    origin?: RecordOriginFilter;
+}
+/**
+ * Append-only-ish JSONL fact store. "Mutations" (markAccessed / supersede /
+ * setLifecycle / decay) are read-modify-write of the whole file — fine at
+ * single-user scale, and atomic via tmp+rename so a crash never leaves a
+ * half-written store.
+ */
+export declare class FactStore {
+    private readonly file;
+    /** Injectable wall-clock. Defaults to `Date.now`; the eval pins it (e.g. `() => 0`)
+     *  so write-time `createdAt` AND score-time `now` share ONE deterministic clock —
+     *  otherwise decay over the (load-dependent) gap between seeding and recall makes
+     *  the hybrid/decay lanes non-reproducible. Production passes nothing → `Date.now`. */
+    private readonly clock;
+    private eventLogCache?;
+    /** Did the most recent readAll SKIP any non-empty line (unparseable JSON or an
+     *  invalid record shape)? Such content — a hand-edit, a torn/concurrent write, a
+     *  partial sync — would be silently DROPPED by the next writeAll (which rewrites
+     *  only the parsed records). When set, writeAll snapshots the file to a `.bak`
+     *  first so the skipped content stays recoverable. */
+    private lastReadHadUnparseable;
+    constructor(workspaceDir: string, opts?: {
+        now?: () => number;
+    });
+    /** Absolute path to the JSONL file (for diagnostics). */
+    get filePath(): string;
+    /** The append-only event log (sibling `events.jsonl` of the facts file). */
+    private eventLog;
+    /** Emit a provenance event. Filesystem mode appends to `events.jsonl`; convex mode
+     *  appends to the convex audit trail via the OPTIONAL `appendMemoryEvent` store hook
+     *  (best-effort + fire-and-forget — an audit-log write must never fail a memory
+     *  write, and the log is additive, never affecting recall). When the hook is absent
+     *  (a backend without the convex events table yet) it degrades to no audit trail. */
+    private emit;
+    /** The append-only provenance history. SYNC — filesystem only (convex reads are
+     *  async; use {@link readEventsAsync}). Empty in convex mode. Ordered oldest-first. */
+    readEvents(): MemoryEvent[];
+    /** The append-only provenance history, working in BOTH modes — fs reads
+     *  `events.jsonl`; convex reads the audit trail via the optional `listMemoryEvents`
+     *  store hook (empty when the hook is absent). Ordered oldest-first. */
+    readEventsAsync(): Promise<MemoryEvent[]>;
+    /** Read every record. Malformed lines are skipped (never throws on a bad line). */
+    readAll(): MemoryRecord[];
+    /** Active records, optionally filtered, most-recent-first, capped by `limit`. */
+    list(filter?: ListFilter): MemoryRecord[];
+    /**
+     * Persist a new fact. Derives tier/importance/decay from the segment
+     * defaults (writer may override tier/importance). Archives any `supersedes`
+     * targets. Returns the stored record.
+     */
+    write(fact: NewFact): MemoryRecord;
+    /**
+     * Extraction-idempotency probe (Fix 1). Given a candidate fact's content +
+     * origin, return an ALREADY-STORED active same-origin record that the
+     * candidate is merely a RESTATEMENT of — or `undefined` if it's genuinely new.
+     * The post-turn distiller calls this BEFORE writing so it never re-creates a
+     * fact the operator already taught (which would pile a subject-less `knowledge`
+     * churn copy beside a rich `identity`/`preference` original and then let
+     * consolidation archive the wrong one).
+     *
+     * Two match lanes (a candidate that hits EITHER is "already known"):
+     *   1. SUBJECT-ANCHORED restatement — the existing record is SUBJECT-BEARING
+     *      (the single-valued kind extraction must not churn a twin beside) and the
+     *      candidate is a paraphrase of it: embedding cosine ≥ {@link IDEMPOTENT_COSINE_BAR}
+     *      OR content Jaccard ≥ {@link IDEMPOTENT_JACCARD_BAR}. The loose bar is safe
+     *      here BECAUSE it's gated on an existing subjectKey — an ADDITIVE fact (no
+     *      subjectKey: pets, skills) can't trip it.
+     *   2. NEAR-EXACT restatement of ANY existing fact — content Jaccard ≥
+     *      {@link DEDUP_SIMILARITY} (the write-time dedup bar), so even an additive
+     *      fact's verbatim re-extraction is recognised.
+     *
+     * Origin-isolated (only same-origin candidates) and embedder-guarded (a thrown/
+     * async embedder degrades to the Jaccard lanes). The richest of several matches
+     * is returned so a reinforcement lands on the best record.
+     */
+    findEquivalentActive(content: string, origin: MemoryRecordOrigin | undefined): MemoryRecord | undefined;
+    /**
+     * Reinforce an existing record by id WITHOUT writing a new one (the
+     * idempotency no-op's "optionally reinforce" path). Bumps access (recall-
+     * reinforcement) and lifts confidence toward `minConfidence` if given — so a
+     * re-seen fact gets MORE durable rather than spawning a churn duplicate. No-op
+     * (undefined) if the id isn't an active record. Emits a `reinforced` event.
+     */
+    reinforce(memoryId: string, opts?: {
+        minConfidence?: number;
+    }): MemoryRecord | undefined;
+    /**
+     * Lexical recall over active facts — Okapi BM25 × `effectiveScore`
+     * (decay + importance), origin-filtered (the shared scorer, scoring.ts).
+     * The SAME scorer runs in fs (these `readAll` records) and convex mode
+     * (the hydrated cache) ⇒ cross-mode parity by construction. Marks every
+     * returned record accessed (recall reinforcement) unless `markAccessed:
+     * false`. Returns at most `limit` hits (default 8), each with its score.
+     */
+    search(query: string, opts?: {
+        limit?: number;
+        markAccessed?: boolean;
+        origin?: RecordOriginFilter;
+    }): Array<MemoryRecord & {
+        score: number;
+    }>;
+    /**
+     * Hybrid recall (Tideline v2) — BM25 ⊕ vector (cosine over each record's
+     * `embedding`), fused via `recallHybrid`. Embeddings are populated on write in
+     * BOTH modes (see embed-on-write in `write`), so the vector lane contributes
+     * IDENTICALLY in fs and convex mode — that's the cross-mode-parity guarantee.
+     * Convex additionally ANN-serves the SAME vectors via the built-in
+     * `by_embedding` vectorIndex at scale; this in-app cosine is the identical
+     * ranking over the hydrated cache. A record misses the vector lane only if its
+     * embedder threw on write (graceful BM25-only for that fact) or it predates
+     * embed-on-write (legacy). Same active+origin candidate filter + reinforcement
+     * semantics as `search`.
+     */
+    searchHybrid(query: string, opts?: {
+        limit?: number;
+        markAccessed?: boolean;
+        origin?: RecordOriginFilter;
+    }): Array<MemoryRecord & {
+        score: number;
+    }>;
+    /**
+     * The recall entry point live callers (auto-recall, recall_memory) use →
+     * the HYBRID lane (BM25 ⊕ vector, {@link searchHybrid}) in BOTH modes, so
+     * recall is identical fs ↔ convex (parity by construction, same as v1). The
+     * lower-level `search` stays a pure-lexical primitive for callers that want
+     * just BM25 (the eval floor, transparency).
+     */
+    recall(query: string, opts?: {
+        limit?: number;
+        markAccessed?: boolean;
+        origin?: RecordOriginFilter;
+    }): Array<MemoryRecord & {
+        score: number;
+    }>;
+    /**
+     * ASYNC hybrid recall — identical to {@link searchHybrid} but pre-embeds the
+     * query via {@link recallHybridAsync}, so it works with a LEARNED (async)
+     * embedder (OpenAI / local node-llama-cpp) as well as the sync HRR default
+     * (awaiting a sync embed is a no-op). This is the path that delivers true-
+     * synonymy recall when a learned embedder is selected; the sync `searchHybrid`/
+     * `recall` stay for callers that aren't async (and degrade to BM25-primary
+     * under a learned embedder — never crash). Same candidate filter + reinforcement.
+     */
+    searchHybridAsync(query: string, opts?: {
+        limit?: number;
+        markAccessed?: boolean;
+        origin?: RecordOriginFilter;
+    }): Promise<Array<MemoryRecord & {
+        score: number;
+    }>>;
+    /** Async recall entry point (the learned-embedder-aware {@link searchHybridAsync}). */
+    recallAsync(query: string, opts?: {
+        limit?: number;
+        markAccessed?: boolean;
+        origin?: RecordOriginFilter;
+    }): Promise<Array<MemoryRecord & {
+        score: number;
+    }>>;
+    /**
+     * Recall transparency (Tideline Step 11) — like `search` but returns each
+     * hit's {@link ScoreBreakdown} and does NOT reinforce decay (diagnostic +
+     * passive). Same candidate filtering (active + origin) and the same scorer,
+     * so the ranking matches `search` exactly — this just exposes the arithmetic
+     * (bm25 × modulator) behind each rank, for "why did this surface?" tooling.
+     */
+    explainRecall(query: string, opts?: {
+        limit?: number;
+        origin?: RecordOriginFilter;
+    }): Array<MemoryRecord & {
+        score: number;
+        breakdown: ScoreBreakdown;
+    }>;
+    /** Bump accessCount + lastAccessedAt for the given ids (recall reinforcement). */
+    markAccessed(ids: string[]): void;
+    /**
+     * Write embeddings onto existing records by id (the re-embed pass's apply-step).
+     * Used to fill vectors that embed-on-write SKIPPED because the selected embedder
+     * is async (a learned model) — see {@link reembedPending}. Read-mutate-write,
+     * so it flows through the convex write-through cache like any other mutation.
+     */
+    applyEmbeddings(updates: ReadonlyArray<{
+        memoryId: string;
+        embedding: number[];
+    }>): void;
+    /**
+     * Feedback-driven self-learning (the continual-learning loop's signal). `up`
+     * nudges importance (+ confidence if set) UP and reinforces decay; `down`
+     * nudges them DOWN — ASYMMETRIC (+0.05 / −0.10), so a
+     * few bad recalls outweigh many lukewarm ones. Persisted + logged to the event
+     * track (telemetry). Recall's trust/importance modulation then adapts, closing
+     * the loop: recall → feedback → better recall. Returns the updated record.
+     */
+    applyFeedback(memoryId: string, signal: "up" | "down"): MemoryRecord | undefined;
+    /**
+     * Metadata-preservation on reconcile (Fix 2). Fold the RICHER metadata of the
+     * `loserId` record into the `survivorId` record, in place — so a supersede /
+     * consolidation merge that ARCHIVES the loser doesn't DROP its hard-won metadata
+     * (a `subjectKey`, a more-specific segment, a higher importance/confidence). The
+     * caller invokes this on the KEEPER right before archiving the duplicate, so the
+     * survivor inherits from BOTH. No-op (false) if either id is missing or the
+     * survivor isn't active. Persists + returns whether anything changed.
+     *
+     * This is the store-level counterpart to {@link inheritRicherMetadata} (which
+     * the in-`write` reinforce paths call on their in-memory `all` array); the
+     * consolidation passes (dream / LLM consolidation) call THIS because their
+     * survivor lives in the store, not in a write-local array.
+     */
+    mergeMetadataInto(survivorId: string, loserId: string): boolean;
+    /**
+     * Bi-temporally INVALIDATE a fact (Tideline v2, step 15) — close its valid
+     * interval (`validTo = now`) + archive it, so recall drops it while HISTORY
+     * keeps it (transaction time `createdAt` untouched). If `supersededBy` is
+     * given, records a `contradicts` link on the superseder → the stale fact.
+     * Persisted + logged. Returns the invalidated record, or `undefined` if it's
+     * missing / already inactive.
+     */
+    invalidate(staleId: string, opts?: {
+        supersededBy?: string;
+        now?: number;
+    }): MemoryRecord | undefined;
+    /**
+     * Step 19 — persist TYPED association edges between fact pairs (where the
+     * relationship extractor's typed taxonomy AND the dream's synonymy/relatedness
+     * edges land). Bidirectional, deduped per (kind,target), and capped per record per
+     * kind (a hub-fact fan-out guard); only ACTIVE facts are linked. Each edge carries
+     * the edge `kind` (default `relates` for legacy synonymy callers), an optional
+     * `reason` (the model's justification, for explainable rendering) and `strength`.
+     * Idempotent — re-running adds nothing already present (a later write may BACKFILL a
+     * reason onto a prior reason-less edge of the same kind, which is not counted as a
+     * new edge). Goes through readAll/writeAll like every mutation, so it is fs↔convex
+     * parity by construction. Returns the number of NEW link entries written.
+     *
+     * Callers MUST pass only SAME-ORIGIN pairs (the dream computes synonymy per origin
+     * bucket; the extractor pre-filters to one origin) — a cross-principal edge would
+     * leak one peer's facts into another principal's graph-recall walk.
+     *
+     * The edge is written DIRECTED on the kind the caller supplies, and the REVERSE
+     * endpoint records the INVERSE kind (causes↔caused_by, precedes↔follows,
+     * enables/blocks→caused_by/blocks, part_of→part_of, …) so the graph reads
+     * correctly from either note; symmetric kinds (co_constrains/contrasts_with/
+     * same_topic/relates/relates_to/uses/works_on/located_at) mirror unchanged.
+     */
+    linkRelated(pairs: ReadonlyArray<{
+        a: string;
+        b: string;
+        kind?: MemoryLink["kind"];
+        reason?: string;
+        strength?: number;
+    }>, opts?: {
+        maxPerRecord?: number;
+    }): number;
+    /**
+     * Lane B (Step 25) — REVERSE a retraction: re-activate an `archived` fact and
+     * clear its valid-time bound so it surfaces again. The reversible counterpart
+     * to {@link invalidate} — the operator's "restore" after an over-eager
+     * retraction. Persisted + logged (a `reinforced` event: the fact is reasserted
+     * as valid). Returns the record, or `undefined` if it's missing / not archived.
+     */
+    reactivate(id: string, opts?: {
+        now?: number;
+    }): MemoryRecord | undefined;
+    /**
+     * Records whose VAULT note must be preserved: every ACTIVE fact PLUS any ARCHIVED
+     * fact that is still RESTORABLE — i.e. retracted/decayed, NOT superseded/consolidated
+     * by an active successor (same edge test as {@link reactivate}). The vault prune
+     * deletes notes outside this set, so a reversibly-retracted fact — and the operator's
+     * hand-pinned edits on it — survives a re-render; only a hard-purged fact's note
+     * (gone from the store entirely) is removed.
+     */
+    listForVault(origin?: RecordOriginFilter): MemoryRecord[];
+    /**
+     * Dream/curator lane (Step 22) — REVERSIBLE: patch cognition fields on an
+     * ACTIVE record, used to PROMOTE a repeatedly-corrected belief to a confirmed
+     * preference. Returns the PRIOR {confidence,status,importance} (also recorded
+     * in the "confirmed" event) so a dream pass can be undone — Lane A is
+     * reversible by design. No-op (undefined) if `memoryId` isn't an active record.
+     */
+    promote(memoryId: string, patch: {
+        status?: MemoryStatus;
+        confidence?: number;
+        importance?: number;
+    }, opts?: {
+        now?: number;
+    }): {
+        confidence?: number;
+        status?: MemoryStatus;
+        importance?: number;
+    } | undefined;
+    /**
+     * Dream/curator lane (Step 22): archive low-value decayed facts, emitting an
+     * "evicted" event per fact. Returns the ids actually archived (skips already
+     * non-active ones). Distinct from decay GC's `setLifecycle` in that it logs.
+     */
+    evict(ids: readonly string[], opts?: {
+        now?: number;
+    }): string[];
+    /**
+     * Governance (Step 24) — HARD-delete records (crypto-shred: the sealed
+     * content is REMOVED, not archived, so it's unrecoverable even with the key).
+     * Returns the ids actually removed. Filesystem rewrites the JSONL without
+     * them; convex mode realises the deletion through the write-through diff.
+     * Distinct from evict/setLifecycle, which only flip lifecycle.
+     */
+    purge(ids: readonly string[]): string[];
+    /**
+     * The DISTINCT origins present in the active store (owner + each channel
+     * peer). The per-origin fan-out seam: the curator/dream run one pass per
+     * origin so a cross-fact operation never mixes principals. Deduped by
+     * {@link originBucketKey}; owner first, then channels in stable key order.
+     */
+    distinctOrigins(): MemoryRecordOrigin[];
+    /** Set the lifecycle of specific records (used by decay GC). */
+    setLifecycle(ids: string[], lifecycle: MemoryLifecycle): void;
+    /** Atomic whole-file rewrite (tmp + rename) so a crash can't corrupt the store. */
+    private writeAll;
+}
+//# sourceMappingURL=records.d.ts.map

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

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