@spinabot/brigade 0.1.2 → 1.0.1

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

@@ -0,0 +1,203 @@
+/**
+ * Tideline — Brigade's long-term memory framework. Public FACADE + adapter SPI
+ * (build Step 5: freeze the surface).
+ *
+ * This is the single, stable entry the rest of Brigade (and any future OSS
+ * adopter) imports. The internal pieces — `FactStore` (storage + cross-mode
+ * dispatch), `scoring` (the shared BM25 scorer), `write-gate` (the poisoning
+ * guard), `links` (the graph substrate) — sit behind it. The facade adds no
+ * recall logic of its own: it delegates to one {@link StorageAdapter} so the
+ * write-gate, the shared scorer, and the fs ↔ convex dispatch all apply
+ * uniformly and exactly once.
+ *
+ * SPI = four adapters the facade composes:
+ *   - {@link StorageAdapter}  — the persistence backend (v1: `FactStore`, which
+ *     itself dispatches fs ↔ convex). The one adapter that's fully live in v1.
+ *   - {@link ClockAdapter}    — injectable time (default = system clock). RESERVED:
+ *     the facade does not yet route reads/writes through it in v1.
+ *   - {@link EmbedderAdapter} — a RESERVED learned-embedder seam. Recall in v1 is
+ *     always served by the bundled zero-dep HRR vector lane inside `FactStore`;
+ *     passing an embedder to the facade records the wiring but does NOT change
+ *     recall (the facade never calls it in v1). A future version routes the lane
+ *     through it to upgrade to true synonymy. Optional.
+ *   - {@link LlmAdapter}      — LLM for reflection/synthesis. Optional seam,
+ *     used by Phase-3 dream/consolidation; unused in v1.
+ *
+ * "Extraction would be a publish": nothing here imports Brigade-specific
+ * modules — only the sibling memory primitives — so Tideline can be lifted into
+ * a standalone package by re-exporting this file + its deps.
+ */
+import type { ListFilter, MemoryLifecycle, MemoryRecord, NewFact, RecordOriginFilter } from "./records.js";
+import type { ScoreBreakdown } from "./scoring.js";
+import type { MemoryLink, MemoryLinkKind } from "./links.js";
+/** A recalled fact with its relevance score (the ranked recall result). */
+export type RecalledFact = MemoryRecord & {
+    score: number;
+};
+/** A recalled fact plus the {@link ScoreBreakdown} explaining its rank. */
+export type ExplainedFact = MemoryRecord & {
+    score: number;
+    breakdown: ScoreBreakdown;
+};
+export type RecallOpts = {
+    limit?: number;
+    markAccessed?: boolean;
+    origin?: RecordOriginFilter;
+};
+export type ExplainOpts = {
+    limit?: number;
+    origin?: RecordOriginFilter;
+};
+export type ContextOpts = ExplainOpts & {
+    maxChars?: number;
+};
+/** Feedback signal on a recalled fact (the continual-learning loop). Asymmetric:
+ *  `up` nudges importance/confidence +0.05 and reinforces decay; `down` nudges
+ *  −0.10 (a few bad recalls outweigh many lukewarm ones). Both persist + log. */
+export type FeedbackSignal = "up" | "down";
+/** Injectable time source. Default = the system clock. */
+export interface ClockAdapter {
+    now(): number;
+}
+/** Recall-time CONTENT-safety seam. **Optional**: when wired, every "recall →
+ *  drop into a prompt" surface on the facade ({@link Tideline.context}) runs each
+ *  recalled fact's text through it and, on a non-empty result, substitutes a
+ *  non-actionable `[BLOCKED]` placeholder instead of surfacing the fact verbatim
+ *  (the markup-escape stays as defense-in-depth on top). This is the SAME
+ *  injection/exfil/C2 net the in-process auto-recall loop applies; defining it as
+ *  an injectable adapter (rather than importing a scanner) keeps the facade free
+ *  of host-specific imports so it stays extractable. `scan(content)` returns the
+ *  matched threat-pattern ids (empty = clean). Default = no scan (returns `[]`),
+ *  preserving the markup-escape-only behavior. */
+export interface ThreatScanAdapter {
+    scan(content: string): string[];
+}
+/** The persistence backend. `FactStore` is the v1 realization (it dispatches
+ *  fs ↔ convex internally); an alternative backend or an OSS adopter targets
+ *  this. Invariants every adapter MUST uphold (the bundled FactStore does):
+ *   - `write` applies the write-gate + dedup; a blocked write throws and
+ *     persists nothing.
+ *   - `search`/`explainRecall` enforce origin isolation BEFORE scoring and use
+ *     the shared scorer; `explainRecall` never reinforces decay. */
+export interface StorageAdapter {
+    write(fact: NewFact): MemoryRecord;
+    search(query: string, opts?: RecallOpts): RecalledFact[];
+    /** Optional HYBRID recall (BM25 ⊕ vector). When present, `recall`/`context`
+     *  prefer it over pure-lexical `search` (the bundled FactStore implements it in
+     *  both fs + convex mode); a backend that omits it transparently falls back to
+     *  `search`. */
+    searchHybrid?(query: string, opts?: RecallOpts): RecalledFact[];
+    explainRecall(query: string, opts?: ExplainOpts): ExplainedFact[];
+    list(filter?: ListFilter): MemoryRecord[];
+    readAll(): MemoryRecord[];
+    markAccessed(ids: string[]): void;
+    setLifecycle(ids: string[], lifecycle: MemoryLifecycle): void;
+    applyFeedback(memoryId: string, signal: "up" | "down"): MemoryRecord | undefined;
+}
+/** Learned-embedder seam. **RESERVED — unused by the facade in v1**: recall is
+ *  served by the bundled zero-dep HRR vector lane inside `FactStore`, not by an
+ *  embedder passed here. A future version plugs a learned model in to upgrade
+ *  that lane to true synonymy. Defined now so the column/contract isn't designed
+ *  twice. */
+export interface EmbedderAdapter {
+    readonly dims: number;
+    embed(texts: string[]): Promise<number[][]>;
+}
+/** LLM seam for reflection/synthesis (Phase-3 dream/consolidation). Optional;
+ *  unused in v1. */
+export interface LlmAdapter {
+    complete(prompt: string): Promise<string>;
+}
+/** A fact with its graph neighbourhood — the `inspect` result. */
+export interface FactInspection {
+    record: MemoryRecord;
+    links: MemoryLink[];
+    backlinks: Array<{
+        from: string;
+        kind: MemoryLinkKind;
+    }>;
+}
+/**
+ * The Tideline facade — the public entry point. Verbs:
+ * `add · search · explain · context · feedback · purge · inspect · export`
+ * (plus `remember`/`recall`/`list` aliases for existing call sites). Origin is
+ * first-class on every read/write that touches recall.
+ */
+export declare class Tideline {
+    private readonly store;
+    private readonly clock;
+    private readonly threatScan;
+    private readonly embedder?;
+    private readonly llm?;
+    private constructor();
+    /** Open Tideline for a workspace directory (the common case). The optional
+     *  adapters default to: system clock, no recall-time threat scan (markup-escape
+     *  only), no embedder (v1 = FTS5-only), no LLM. */
+    static open(workspaceDir: string, adapters?: {
+        clock?: ClockAdapter;
+        threatScan?: ThreatScanAdapter;
+        embedder?: EmbedderAdapter;
+        llm?: LlmAdapter;
+    }): Tideline;
+    /** Wrap an existing {@link StorageAdapter} (DI / shared store / a swapped backend). */
+    static over(store: StorageAdapter, adapters?: {
+        clock?: ClockAdapter;
+        threatScan?: ThreatScanAdapter;
+        embedder?: EmbedderAdapter;
+        llm?: LlmAdapter;
+    }): Tideline;
+    /** Whether a learned embedder is WIRED into the facade — reflects wiring only,
+     *  not recall behavior. In v1 recall is always served by the bundled HRR vector
+     *  lane regardless of this flag; a wired embedder is recorded but unused. */
+    get hasVectors(): boolean;
+    /** Persist a fact (write-gate + dedup applied). Throws `WriteGateError` on a
+     *  blocked poisoning write. */
+    add(fact: NewFact): MemoryRecord;
+    remember(fact: NewFact): MemoryRecord;
+    /** Ranked recall over active, origin-matching facts (reinforces decay unless
+     *  `markAccessed: false`). */
+    search(query: string, opts?: RecallOpts): RecalledFact[];
+    /** The recall entry point callers should prefer — HYBRID (BM25 ⊕ vector) when
+     *  the backend offers it, else pure-lexical `search`. `search` stays a
+     *  lexical-only primitive (the eval floor / transparency). */
+    recall(query: string, opts?: RecallOpts): RecalledFact[];
+    /** Passive recall transparency — same ranking as `search`, each hit with its
+     *  score breakdown, and NO decay reinforcement. */
+    explain(query: string, opts?: ExplainOpts): ExplainedFact[];
+    /** A budgeted, origin-scoped recall block ready to drop into a prompt — the
+     *  facts joined into a capped string (relevance-ranked (decay-weighted),
+     *  highest first, truncated to `maxChars`, default 1200). Passive (no decay
+     *  reinforcement). Content-safety: when a {@link ThreatScanAdapter} is wired,
+     *  any fact whose text matches an injection/exfil/C2 pattern is replaced by a
+     *  non-actionable `[BLOCKED]` placeholder (the SAME recall-time net the
+     *  in-process auto-recall loop applies); `<`/`>` in the surfaced fact text are
+     *  ALSO defanged so a fact can't inject markup (defense-in-depth, always on).
+     *  Returns `undefined` when nothing relevant is stored. */
+    context(query: string, opts?: ContextOpts): string | undefined;
+    /** Apply the wired threat-scan to a piece of content (empty array = clean).
+     *  Exposes the injected {@link ThreatScanAdapter} so recall surfaces built on
+     *  this facade (e.g. the MCP `memory_search` tool, which returns per-hit results
+     *  rather than a `context()` block) enforce the SAME recall-time content-safety
+     *  net `context()` applies — without importing a concrete scanner here (the
+     *  facade stays Brigade-import-free + OSS-extractable). */
+    scanThreats(content: string): string[];
+    /** Record relevance feedback on a recalled fact. Asymmetric importance/
+     *  confidence update (`up` +0.05 / `down` −0.10), persisted + logged. Recall's
+     *  trust/importance modulation then adapts, closing the loop: recall →
+     *  feedback → better recall. */
+    feedback(memoryId: string, signal: FeedbackSignal): void;
+    /** SOFT purge (reversible): lifecycle → `pruned` (excluded from recall, record
+     *  retained). This is the facade's gentle retract. For the DESTRUCTIVE Step-24
+     *  crypto-shred (hard-delete + cascade along `sourcePointers`), use
+     *  `governance.purge` / `FactStore.purge` — a different, irreversible verb. */
+    purge(memoryIds: string[]): void;
+    /** Fact-level diagnostic: a single record with its outbound {@link MemoryLink}
+     *  edges and inbound backlinks (the graph neighbourhood). `undefined` if the
+     *  id isn't found. */
+    inspect(memoryId: string): FactInspection | undefined;
+    /** Full store dump (all lifecycles) for backup/portability. */
+    export(): MemoryRecord[];
+    /** List active (or `filter.lifecycle`) facts, most-recent-first. */
+    list(filter?: ListFilter): MemoryRecord[];
+}
+//# sourceMappingURL=tideline.d.ts.map

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

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

package/dist/agents/memory/tideline.js

@@ -0,0 +1,189 @@
+/**
+ * Tideline — Brigade's long-term memory framework. Public FACADE + adapter SPI
+ * (build Step 5: freeze the surface).
+ *
+ * This is the single, stable entry the rest of Brigade (and any future OSS
+ * adopter) imports. The internal pieces — `FactStore` (storage + cross-mode
+ * dispatch), `scoring` (the shared BM25 scorer), `write-gate` (the poisoning
+ * guard), `links` (the graph substrate) — sit behind it. The facade adds no
+ * recall logic of its own: it delegates to one {@link StorageAdapter} so the
+ * write-gate, the shared scorer, and the fs ↔ convex dispatch all apply
+ * uniformly and exactly once.
+ *
+ * SPI = four adapters the facade composes:
+ *   - {@link StorageAdapter}  — the persistence backend (v1: `FactStore`, which
+ *     itself dispatches fs ↔ convex). The one adapter that's fully live in v1.
+ *   - {@link ClockAdapter}    — injectable time (default = system clock). RESERVED:
+ *     the facade does not yet route reads/writes through it in v1.
+ *   - {@link EmbedderAdapter} — a RESERVED learned-embedder seam. Recall in v1 is
+ *     always served by the bundled zero-dep HRR vector lane inside `FactStore`;
+ *     passing an embedder to the facade records the wiring but does NOT change
+ *     recall (the facade never calls it in v1). A future version routes the lane
+ *     through it to upgrade to true synonymy. Optional.
+ *   - {@link LlmAdapter}      — LLM for reflection/synthesis. Optional seam,
+ *     used by Phase-3 dream/consolidation; unused in v1.
+ *
+ * "Extraction would be a publish": nothing here imports Brigade-specific
+ * modules — only the sibling memory primitives — so Tideline can be lifted into
+ * a standalone package by re-exporting this file + its deps.
+ */
+import { FactStore } from "./records.js";
+import { backlinksTo, linksFrom } from "./links.js";
+const SYSTEM_CLOCK = { now: () => Date.now() };
+/** Default recall-time scan = no-op (markup-escape only). A host wires a real
+ *  scanner via the `threatScan` adapter to enforce the full content-safety net. */
+const NO_THREAT_SCAN = { scan: () => [] };
+// ───────────────────────────── the facade ────────────────────────────
+/**
+ * The Tideline facade — the public entry point. Verbs:
+ * `add · search · explain · context · feedback · purge · inspect · export`
+ * (plus `remember`/`recall`/`list` aliases for existing call sites). Origin is
+ * first-class on every read/write that touches recall.
+ */
+export class Tideline {
+    store;
+    clock;
+    threatScan;
+    embedder;
+    llm;
+    constructor(store, clock, threatScan, embedder, llm) {
+        this.store = store;
+        this.clock = clock;
+        this.threatScan = threatScan;
+        this.embedder = embedder;
+        this.llm = llm;
+    }
+    /** Open Tideline for a workspace directory (the common case). The optional
+     *  adapters default to: system clock, no recall-time threat scan (markup-escape
+     *  only), no embedder (v1 = FTS5-only), no LLM. */
+    static open(workspaceDir, adapters = {}) {
+        return new Tideline(new FactStore(workspaceDir), adapters.clock ?? SYSTEM_CLOCK, adapters.threatScan ?? NO_THREAT_SCAN, adapters.embedder, adapters.llm);
+    }
+    /** Wrap an existing {@link StorageAdapter} (DI / shared store / a swapped backend). */
+    static over(store, adapters = {}) {
+        return new Tideline(store, adapters.clock ?? SYSTEM_CLOCK, adapters.threatScan ?? NO_THREAT_SCAN, adapters.embedder, adapters.llm);
+    }
+    /** Whether a learned embedder is WIRED into the facade — reflects wiring only,
+     *  not recall behavior. In v1 recall is always served by the bundled HRR vector
+     *  lane regardless of this flag; a wired embedder is recorded but unused. */
+    get hasVectors() {
+        return this.embedder !== undefined;
+    }
+    // ── add ──
+    /** Persist a fact (write-gate + dedup applied). Throws `WriteGateError` on a
+     *  blocked poisoning write. */
+    add(fact) {
+        return this.store.write(fact);
+    }
+    remember(fact) {
+        return this.add(fact);
+    }
+    // ── search ──
+    /** Ranked recall over active, origin-matching facts (reinforces decay unless
+     *  `markAccessed: false`). */
+    search(query, opts = {}) {
+        return this.store.search(query, opts);
+    }
+    /** The recall entry point callers should prefer — HYBRID (BM25 ⊕ vector) when
+     *  the backend offers it, else pure-lexical `search`. `search` stays a
+     *  lexical-only primitive (the eval floor / transparency). */
+    recall(query, opts = {}) {
+        return this.store.searchHybrid ? this.store.searchHybrid(query, opts) : this.store.search(query, opts);
+    }
+    /** Passive recall transparency — same ranking as `search`, each hit with its
+     *  score breakdown, and NO decay reinforcement. */
+    explain(query, opts = {}) {
+        return this.store.explainRecall(query, opts);
+    }
+    // ── context ──
+    /** A budgeted, origin-scoped recall block ready to drop into a prompt — the
+     *  facts joined into a capped string (relevance-ranked (decay-weighted),
+     *  highest first, truncated to `maxChars`, default 1200). Passive (no decay
+     *  reinforcement). Content-safety: when a {@link ThreatScanAdapter} is wired,
+     *  any fact whose text matches an injection/exfil/C2 pattern is replaced by a
+     *  non-actionable `[BLOCKED]` placeholder (the SAME recall-time net the
+     *  in-process auto-recall loop applies); `<`/`>` in the surfaced fact text are
+     *  ALSO defanged so a fact can't inject markup (defense-in-depth, always on).
+     *  Returns `undefined` when nothing relevant is stored. */
+    context(query, opts = {}) {
+        const { maxChars = 1200, ...recallOpts } = opts;
+        const recallOptsPassive = { ...recallOpts, markAccessed: false };
+        const hits = this.store.searchHybrid
+            ? this.store.searchHybrid(query, recallOptsPassive)
+            : this.store.search(query, recallOptsPassive);
+        if (hits.length === 0)
+            return undefined;
+        const lines = [];
+        let used = 0;
+        for (const h of hits) {
+            // Recall-time content scan FIRST: a fact carrying an injection/exfil/C2
+            // payload is surfaced as a non-actionable `[BLOCKED]` line — never its
+            // raw text — mirroring auto-recall's renderRecalledFact. The markup-
+            // escape below is the second, always-on layer (the no-angle-bracket
+            // natural-language class the scan catches has no `<`/`>` to escape).
+            const threats = this.threatScan.scan(h.content);
+            const safe = threats.length > 0
+                ? `[BLOCKED] this ${h.segment} fact matched threat pattern(s): ${threats.join(", ")} — omitted from context`
+                : h.content.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+            const line = `- [${h.segment}] ${safe}`;
+            // `+ 1` per line accounts for the "\n" separator. This is a conservative
+            // upper bound: the final line carries no trailing separator, so the
+            // budget over-counts by one — the emitted block is never longer than the
+            // accounting assumes (the block.length <= maxChars guarantee holds).
+            if (used + line.length + 1 > maxChars && lines.length > 0)
+                break;
+            lines.push(line);
+            used += line.length + 1;
+        }
+        return lines.join("\n");
+    }
+    /** Apply the wired threat-scan to a piece of content (empty array = clean).
+     *  Exposes the injected {@link ThreatScanAdapter} so recall surfaces built on
+     *  this facade (e.g. the MCP `memory_search` tool, which returns per-hit results
+     *  rather than a `context()` block) enforce the SAME recall-time content-safety
+     *  net `context()` applies — without importing a concrete scanner here (the
+     *  facade stays Brigade-import-free + OSS-extractable). */
+    scanThreats(content) {
+        return this.threatScan.scan(content);
+    }
+    // ── feedback ──
+    /** Record relevance feedback on a recalled fact. Asymmetric importance/
+     *  confidence update (`up` +0.05 / `down` −0.10), persisted + logged. Recall's
+     *  trust/importance modulation then adapts, closing the loop: recall →
+     *  feedback → better recall. */
+    feedback(memoryId, signal) {
+        // The continual-learning loop's signal: asymmetric importance/confidence
+        // update (+0.05 / −0.10), persisted + logged. Recall's trust/importance
+        // modulation then adapts → recall improves from use.
+        this.store.applyFeedback(memoryId, signal);
+    }
+    // ── purge ──
+    /** SOFT purge (reversible): lifecycle → `pruned` (excluded from recall, record
+     *  retained). This is the facade's gentle retract. For the DESTRUCTIVE Step-24
+     *  crypto-shred (hard-delete + cascade along `sourcePointers`), use
+     *  `governance.purge` / `FactStore.purge` — a different, irreversible verb. */
+    purge(memoryIds) {
+        this.store.setLifecycle(memoryIds, "pruned");
+    }
+    // ── inspect ──
+    /** Fact-level diagnostic: a single record with its outbound {@link MemoryLink}
+     *  edges and inbound backlinks (the graph neighbourhood). `undefined` if the
+     *  id isn't found. */
+    inspect(memoryId) {
+        const all = this.store.readAll();
+        const record = all.find((r) => r.memoryId === memoryId);
+        if (!record)
+            return undefined;
+        return { record, links: linksFrom(record), backlinks: backlinksTo(all, memoryId) };
+    }
+    // ── export ──
+    /** Full store dump (all lifecycles) for backup/portability. */
+    export() {
+        return this.store.readAll();
+    }
+    /** List active (or `filter.lifecycle`) facts, most-recent-first. */
+    list(filter = {}) {
+        return this.store.list(filter);
+    }
+}
+//# sourceMappingURL=tideline.js.map

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

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

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

@@ -0,0 +1,142 @@
+import { type MemoryRecord } from "./records.js";
+/**
+ * Render a fact to a full markdown note: frontmatter (with tags) + the system
+ * sentinel + body + an optional topic-hub backlink + `## Related` wikilinks +
+ * empty pin region. `names` resolves link targets (and this fact's own topic
+ * hub) to readable filenames; OMITTING it (e.g. a bare `renderNote(rec)`) means
+ * no edges can be resolved, so the `## Related` / hub-backlink sections are
+ * simply absent — the frontmatter + body + pin region still render. `bridges`
+ * (optional) is this fact's set of semantic-bridge target ids from
+ * {@link buildBridges}.
+ */
+export declare function renderNote(r: MemoryRecord, names?: Map<string, string>, bridges?: ReadonlySet<string>): string;
+/**
+ * Render a TOPIC-HUB note for `subject`: a system note whose body `[[wikilinks]]`
+ * to every member fact (DOWN, the cluster anchor) AND — so the hubs form one
+ * connected web rather than disconnected stars — UP to the root Map and ACROSS to
+ * its sibling hubs in the SAME segment.
+ *
+ * `opts.linkMap` adds `Part of: [[Memory Map]]` (the UP edge to the graph centre);
+ * the caller sets it only when a Map note is actually being written, so the
+ * wikilink never dangles. `opts.siblingSubjects` are the OTHER subjects sharing
+ * this hub's segment — rendered as a `Related topics:` list of `[[topic — …]]`
+ * (the ACROSS edges that turn a segment into a visible cluster). Both are purely
+ * structural: they link only to hubs/notes that exist. Members are listed in the
+ * order given (the caller passes them subject-stable).
+ */
+export declare function renderHubNote(subject: string, memberIds: readonly string[], names: Map<string, string>, opts?: {
+    linkMap?: boolean;
+    siblingSubjects?: readonly string[];
+}): string;
+/**
+ * Render the root MAP / Map-of-Content note — the graph's CENTER node. It links to
+ * EVERY topic hub (`[[topic — <subject>]]`), GROUPED under a per-segment heading
+ * (`## identity`, `## preference`, …) so each segment reads as a cluster, with the
+ * active-fact count shown per topic. This is what turns N disconnected hub-stars
+ * into one connected web (Map → hubs → facts, plus the hubs' sibling interlinks).
+ *
+ * STRUCTURAL ONLY: it lists subjects/segments that ACTUALLY occur in the record
+ * set — it never invents a topic, a fact, or a count. `segments` maps each segment
+ * → its subjects (insertion-stable from the caller); `activeCounts` maps subject →
+ * its ACTIVE-fact tally (archived facts are excluded from the headline number,
+ * matching what the operator thinks of as "live" facts on a topic). Carries the
+ * map sentinel so a STALE Map is pruned/rewritten like a hub, and the usual pinned
+ * region so a human can annotate the map and have it survive a re-render.
+ */
+export declare function renderMapNote(segments: ReadonlyMap<string, readonly string[]>, activeCounts: ReadonlyMap<string, number>): string;
+/**
+ * Build conservative SEMANTIC bridges between facts — `memoryId → set of target
+ * memoryIds` to additionally link as `relates (bridge)` edges. Purely ADDITIVE
+ * connective tissue so the graph reads as one web instead of isolated stars: it
+ * connects ONLY facts that genuinely co-occur, and only ones that already exist as
+ * notes. It NEVER fabricates content — it only draws edges between real records.
+ *
+ * Conditions for a bridge between facts A and B:
+ *   - both are in `names` (i.e. both have an on-disk note to link);
+ *   - SAME origin (`originBucketKey`) — never bridge an owner fact to a peer's, or
+ *     two different peers' facts (mirrors every other cross-fact op's isolation);
+ *   - NOT already joined by a typed edge in EITHER direction (no duplicate);
+ *   - embedding cosine ≥ {@link BRIDGE_COSINE_BAR} (a HIGH bar — bridges fire only
+ *     on genuinely-near content).
+ * Each fact keeps at most {@link MAX_BRIDGES_PER_FACT} bridges (highest cosine
+ * first) so one fact can't fan out into a hairball. Edges are SYMMETRIC (both
+ * endpoints record the bridge) so the link renders from either note.
+ *
+ * EMBEDDER GUARD — the whole feature is opt-in on a usable embedder. A vector is
+ * the record's stored `embedding` when present, else the fact's `content` embedded
+ * on demand. If the embedder is async (returns a Promise), throws, or yields a
+ * wrong-width vector, that record simply has NO vector and forms no bridges; if NO
+ * record ends up with a vector, the function returns an empty map and the vault
+ * renders with typed edges only. Nothing crosses the bar ⇒ empty map ⇒ no bridges.
+ */
+export declare function buildBridges(records: readonly MemoryRecord[], names: ReadonlyMap<string, string>): Map<string, Set<string>>;
+/**
+ * Extract the pinned region's INNER text. LINE-ANCHORED: the open marker is the
+ * LAST line that is exactly `%% pinned %%`, the close is the first subsequent line
+ * exactly `%% /pinned %%` — so a marker token embedded MID-LINE in the human's own
+ * prose (or in a fact body that discusses the `%%` comment syntax) is NOT treated as
+ * a delimiter and cannot truncate/hijack the region. Missing close → captures
+ * OPEN→EOF rather than discarding edits. `undefined` when there is no open-marker line.
+ */
+export declare function extractPinned(md: string): string | undefined;
+/**
+ * 3-way merge: take the `proposed` render but splice the EXISTING note's pinned
+ * region back in, so a human edit survives a re-render. Line-anchored (matches
+ * extractPinned). No existing note / no pin region → `proposed` unchanged.
+ */
+export declare function mergeNote(existing: string | undefined, proposed: string): string;
+export interface VaultWriteResult {
+    written: number;
+    /** Notes whose pinned region was preserved from a prior hand edit. */
+    mergedPinned: number;
+    /** Topic-hub notes written this pass (one per distinct subject). */
+    hubs?: number;
+    /** Notes that could not be written this pass (locked/unwritable — best effort).
+     *  A non-zero count means the vault render is degraded but the pass still
+     *  completed (remaining notes + the integrity prune were not abandoned). */
+    writeFailed?: number;
+    /** Stale notes removed (only when `prune` is set). */
+    pruned?: number;
+}
+/**
+ * Write/refresh the vault for `records` under `dir`, preserving pinned edits.
+ *
+ * Produces a CONNECTED, CLUSTERED graph with the topology of a well-built
+ * hand-crafted Obsidian vault — a root MAP → per-segment CLUSTERS → topic HUBS →
+ * fact LEAVES, plus cross-links so it reads as one web, not disconnected stars:
+ *   - one note per fact (readable filename), each with `## Related` `[[wikilinks]]`
+ *     to its typed neighbours (all seven edge kinds) PLUS conservative semantic
+ *     bridges, a `topic/<subject>` tag, and a backlink to its topic hub;
+ *   - one TOPIC-HUB note per distinct subject — links DOWN to its facts, UP to the
+ *     Map, and ACROSS to its same-segment sibling hubs (the cluster interlinks);
+ *   - one root MAP note (`Memory Map.md`) — the graph's centre — linking to EVERY
+ *     hub grouped under per-segment headings, with each topic's active-fact count.
+ *
+ * `prune` (default OFF) removes any SYSTEM note (fact, hub, OR the Map — detected
+ * by the sentinel, NOT by filename) in `dir` NOT in the current render set — so an
+ * evicted/PURGED fact's note can't linger as plaintext on disk after a
+ * crypto-shred (the integrity counterpart to {@link FactStore.purge}), a hub for a
+ * now-empty subject is cleaned up, and a stale Map (all subjects gone) is removed
+ * rather than orphaned with dangling hub links. A human's own vault notes (their
+ * OWN Index/MOC/daily) carry no sentinel and are NEVER pruned. Callers that pass
+ * the FULL set for a vault (e.g. the whole owner origin) should enable it; callers
+ * passing a partial set must not.
+ *
+ * DURABILITY: each note is written via a sibling temp + atomic rename (the same
+ * tmp+rename pattern {@link FactStore} uses), so a crash mid-write leaves the
+ * OLD note — and the human-pinned region that lives ONLY in the .md (the fact
+ * body is recoverable from facts.jsonl; the pin is not) — intact rather than
+ * truncated. `renameWithRetry` rides over the Windows EPERM/EBUSY window an
+ * indexer/Obsidian briefly opens on the destination.
+ *
+ * BEST-EFFORT PER NOTE: a single unwritable/locked note (EACCES on a read-only
+ * note, EBUSY while held) is isolated so it neither skips the remaining notes
+ * nor — critically — skips the prune. The prune is the integrity step (it
+ * removes a just-shredded fact's plaintext note); `keep` is computed before any
+ * write, so it stays correct regardless of which renders succeeded, and so the
+ * prune runs unconditionally after the loop.
+ */
+export declare function writeVault(dir: string, records: readonly MemoryRecord[], opts?: {
+    prune?: boolean;
+}): VaultWriteResult;
+//# sourceMappingURL=vault.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vault.d.ts","sourceRoot":"","sources":["../../../src/agents/memory/vault.ts"],"names":[],"mappings":"AAiCA,OAAO,EAAmB,KAAK,YAAY,EAAsB,MAAM,cAAc,CAAC;AA2RtF;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAiB9G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC5B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1B,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACnE,MAAM,CAgBR;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EAChD,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,CAiBR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAkF1B;AAQD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY5D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBhF;AASD,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;gFAE4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,UAAU,CACzB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5B,gBAAgB,CAkKlB"}