@sema-ai/core 1.275.1

package/dist/core/memory-engine/types.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Structured header fields of one memory entry (the CC frontmatter shape: `name`/`description`/
+ * `metadata.type`). `extra` preserves any additional frontmatter lines VERBATIM (round-trip safety:
+ * the engine must never destroy model-authored frontmatter it doesn't understand — same posture as
+ * the file store's unknown-op replay skip).
+ */
+export interface MemoryEntryFrontmatter {
+    /** Short kebab-case slug (CC `name:`). Defaults to the file slug when the model omits it. */
+    name?: string;
+    /** One-line summary used for recall relevance (CC `description:`). */
+    description?: string;
+    /** CC `metadata.type`: user | feedback | project | reference (unknown strings degrade, design/65). */
+    type?: string;
+    /** design/138 §2.4 删除防线 — the EXPLICIT tombstone. A file that merely disappears is NEVER a
+     *  delete; only `deleted: true` in frontmatter produces a delete patch. */
+    deleted?: boolean;
+    /** Unknown frontmatter lines preserved verbatim (order kept), re-serialized on projection. */
+    extra?: string[];
+}
+/** design/138 §2.1 — one memory entry (the unit the backend stores and the engine projects to a file). */
+export interface MemoryEntry {
+    /** IMMUTABLE uuid — survives slug renames (consolidation cursors/vectors/dedup all key on it).
+     *  Hidden in the file's frontmatter as `id:`; minted at harvest for id-less new files. */
+    id: string;
+    /** File-name identity (the path relative to its scope dir, without `.md`) — model-visible, renameable. */
+    slug: string;
+    frontmatter: MemoryEntryFrontmatter;
+    /** The markdown body (everything after the frontmatter block). */
+    body: string;
+    /** CAS baseline — a content hash over (id, frontmatter, body). See {@link computeEntryRev}. */
+    rev: string;
+    /** Owning scope (tenant/layer key, same vocabulary as `TaskSpec.memory.scopes`). */
+    scope: string;
+}
+/** Manifest-level header: enough to judge relevance / build the derived index, never the body. */
+export interface MemoryEntryHeader {
+    id: string;
+    slug: string;
+    scope: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    /** Last content change (ms epoch) — drives the natural-language age rendering in the derived index. */
+    mtimeMs: number;
+    rev: string;
+    /** Approximate stored size (bytes of body+frontmatter) — drives the per-scope materialization budget. */
+    sizeBytes: number;
+}
+/** A scored search hit (FileBackend = lexical floor; PgBackend = design/81 vector rungs, S3). */
+export interface ScoredMemoryEntry extends MemoryEntryHeader {
+    /** Cosine-DISTANCE ∈ [0,2], 0 = identical (same contract as {@link import("../memory.js").ScoredMemory}). */
+    score: number;
+}
+/**
+ * design/138 §2.1 — one entry transaction. `add`/`delete` are naturally commutative; `update` carries
+ * a per-id CAS baseline (`baseRev`): when the backend's current rev differs, the patch is reported as a
+ * CONFLICT (never blind-written) and the next task re-materializes fresh state (§2.4 并发).
+ */
+export interface NotePatch {
+    op: "add" | "update" | "delete";
+    /** The immutable entry id this patch addresses. */
+    id: string;
+    /** The full new entry state (`add`/`update`). Absent for `delete`. */
+    entry?: MemoryEntry;
+    /** CAS baseline for `update`/`delete`: the rev this patch was computed against. Absent (a brand-new
+     *  add) ⇒ no CAS. */
+    baseRev?: string;
+    /** ADD-ONLY guard (design/142 S2.5, E-02). Meaningful only on `op: "add"`:
+     *  - `"absent"` ⇒ add-if-absent: if the target id already exists, the backend compares revs —
+     *    same rev AND same projection (scope+slug) = idempotent apply; DIFFERENT rev, or same rev at a
+     *    DIFFERENT projection (三轮复查: rev hashes id/frontmatter/body, not slug/scope — a same-content
+     *    copy at another slug/scope is no no-op, "applying" it would mint a duplicate file for the id) =
+     *    a REPORTED conflict (`add_guard_absent_conflict`, carrying `currentRev`), NEVER a blind
+     *    overwrite or a duplicate. This is for sync's first-round pull adds, where a concurrent local
+     *    create during the RTT must not be clobbered.
+     *  A plain add WITHOUT this guard keeps its existing idempotent-overwrite semantics (the
+     *  `same-scope re-add of an existing id is the idempotent overwrite` contract clause is unchanged).
+     *  Ignored on `update`/`delete`. */
+    guard?: "absent";
+}
+/** Result of {@link MemoryBackend.applyPatches} — applied ops + per-id CAS conflicts (reported, not thrown). */
+export interface PatchReport {
+    applied: Array<{
+        op: NotePatch["op"];
+        id: string;
+        slug?: string;
+    }>;
+    conflicts: Array<{
+        op: NotePatch["op"];
+        id: string;
+        reason: string;
+        baseRev?: string;
+        currentRev?: string;
+    }>;
+}
+/**
+ * design/138 §2.1 — the storage seam under the MemoryEngine. NOT a MemoryStore replacement shim: this
+ * is the S1 new-architecture surface (the legacy `MemoryStore` path is untouched and switched off it).
+ */
+export interface MemoryBackend {
+    /** Headers for every entry in the given scopes (manifest surface — bodies excluded). */
+    listHeaders(scopes: readonly string[]): Promise<MemoryEntryHeader[]>;
+    /** Full entries for the selected ids (unknown ids silently skipped). */
+    getByIds(ids: readonly string[]): Promise<MemoryEntry[]>;
+    /** Scored retrieval (FileBackend = lexical floor; vector rungs live in the S3 PgBackend). */
+    search(query: string, scopes: readonly string[], opts?: {
+        limit?: number;
+    }): Promise<ScoredMemoryEntry[]>;
+    /**
+     * Apply entry transactions (add/update/delete) against the backend's CURRENT state (per-id CAS).
+     *
+     * Behavior clauses a conforming implementation MUST honor (ext-dogfood F1 — each is asserted by
+     * `memoryBackendContract`, listed here so a third party doesn't have to discover them case by case):
+     * - a repeated id WITHIN one batch: first op wins, later ones conflict with reason matching
+     *   /duplicate id in batch/;
+     * - `entry.id !== patch.id` (either op) is refused with reason matching /malformed patch refused/
+     *   — never silently rekeyed;
+     * - an `add` whose slug is taken by a DIFFERENT id in the same scope gets a deterministic `-n`
+     *   suffix (`taken` → `taken-2`); the id stays the identity anchor;
+     * - re-`add` of an EXISTING id is the idempotent overwrite (and into another scope = the MOVE:
+     *   the old scope loses the entry) — not a conflict;
+     * - an `add` carrying `guard: "absent"` is add-if-absent: onto a MISSING id it is a plain add;
+     *   onto an EXISTING id it is idempotent when the rev AND the projection (scope+slug) match, else a
+     *   REPORTED conflict with reason matching /add_guard_absent_conflict/ carrying `currentRev` —
+     *   NEVER a blind overwrite, never a second file for one id (E-02 + 三轮复查投影校验);
+     * - `update` MAY move an entry across scopes; a stale `baseRev` is a REPORTED conflict, never
+     *   thrown, never blind-written;
+     * - conflicts are per-patch and non-fatal: the rest of the batch still applies.
+     */
+    applyPatches(patches: readonly NotePatch[]): Promise<PatchReport>;
+    /** design/84 Seam B cursor pair, migrated verbatim onto the entry-id plane (S2 rewires consolidation). */
+    getConsolidationCursor(scope: string): Promise<string | undefined>;
+    setConsolidationCursor(scope: string, cursor: string): Promise<void>;
+}
+/** One file the engine materialized into the session memory directory. */
+export interface MaterializedFile {
+    /** Absolute canonical path of the projected file. */
+    path: string;
+    /** Path relative to the memory dir root (the link target used in the derived MEMORY.md index). */
+    relPath: string;
+    scope: string;
+    id: string;
+    slug: string;
+    /** Rev of the ON-DISK content at materialize time (for a stub: the stub content's rev). */
+    rev: string;
+    /** True when this file is a budget stub (frontmatter+description only, body archived — §2.3). */
+    stub: boolean;
+    /** True when the file belongs to a read-only inherited layer (chmod-protected, never harvested as a write). */
+    readonly: boolean;
+}
+/**
+ * design/138 §2.2 — the session handle `materialize` returns and `harvest`/`rebaseline` consume.
+ * `materialized` IS the harvest diff domain (plus session-new files under `writableRoot`): an entry
+ * that was never materialized can never be deleted by its absence (镜头 G).
+ */
+export interface MemorySessionHandle {
+    /** The memory directory root. PURE CONFIG (§2.7 r2.1): a project scope may live IN-REPO
+     *  (git-tracked `memory/`), a user/personal scope OUTSIDE — the engine never asserts either.
+     *  TODO(S1b): per-scope PHYSICAL roots (project scope in-repo + user scope in the home mount in ONE
+     *  session) — `fileToScope` already keys absolute paths, so only the layout mapping needs the split. */
+    memoryDir: string;
+    /** The single directory the model may write memory into (the writeScope's home). Equals `memoryDir`
+     *  when the writeScope owns the root (the standard TOC layout). */
+    writableRoot: string;
+    writeScope: string | null;
+    scopes: string[];
+    /** The materialized manifest = the harvest diff domain. */
+    materialized: MaterializedFile[];
+    /** Absolute file path → owning scope. */
+    fileToScope: Map<string, string>;
+    /** Absolute file path → materialize-time rev (the per-id CAS baseline harvest sends with updates). */
+    baseRevs: Map<string, string>;
+    /** Absolute file path → entry id at materialize time (rename/id-restore bookkeeping). */
+    baseIds: Map<string, string>;
+    /** Lines of the derived MEMORY.md at materialize time (the index-cleared fuse baseline). */
+    indexBaselineLines: number;
+    /** 评审 M6 — the derived index TEXT as of materialize. `inject` reads THIS when no on-disk
+     *  MEMORY.md exists (a read-only layering never writes one), so first-session read-only injection
+     *  works without a disk round-trip. */
+    indexText: string;
+}
+/** Stable rejection codes a harvest gate can produce (model-visible gate events — 镜头 I). */
+export type HarvestRejectionCode = "outside_root" | "symlink" | "secret" | "injection" | "filename" | "too_large" | "file_cap" | "readonly_layer" | "stub_modified" | "nested_too_deep" | "quarantine_failed" | "invalid";
+/** One rejected file: path (relative to the memory dir), stable code, and a model-readable reason. */
+export interface HarvestRejection {
+    path: string;
+    code: HarvestRejectionCode;
+    reason: string;
+}
+/**
+ * design/138 S2-C — one finding from the shared write-time/harvest scan rule set
+ * (`scan.ts` `scanMemoryWrite`/`scanMemoryFileName`; ONE rule set, TWO mount points).
+ */
+export interface ScanFinding {
+    /** The subset of {@link HarvestRejectionCode} the scan can produce. */
+    code: "secret" | "injection" | "filename" | "too_large";
+    /** Engine-composed, model-readable reason fragment (for `secret`: the pattern LABEL, never the value). */
+    reason: string;
+}
+/**
+ * design/138 S2-B — one queued memory-change announcement, drained into the NEXT session's first
+ * injection (时机① only; there is no in-run delivery lane — O-F2/C-F4 裁撤). Queued via the
+ * journaled control-plane queue ({@link import("./layout.js").enqueueMemoryAnnouncement}) so
+ * concurrent writers never overwrite each other (O-F6/C-F5).
+ */
+export interface MemoryAnnouncement {
+    /** `gate` = engine gate/harvest events (rejections, quarantine, incidents, restores, conflicts,
+     *  degradation, applied-patch summary); `external` = out-of-session changes the backend's read-side
+     *  detected (disk rev ≠ ledger: adopted external edits + inbound-gate rejects). */
+    kind: "gate" | "external";
+    /** ms epoch at enqueue. */
+    at: number;
+    /** Optional producing-session id (repo-level event stream — Q-G: no worktree attribution in S2). */
+    sessionId?: string;
+    /** Engine-composed single-line items. O-F1/C-F8: every model/collaborator-controllable identifier
+     *  (path/slug/name/description) is neutralized (inlineUntrusted) AND JSON-quoted at ENQUEUE time —
+     *  the stored strings are already render-safe; the render step only adds the trusted lead/frame. */
+    items: string[];
+}
+/**
+ * design/138 §2.4 — the harvest outcome. Rejections are MODEL-VISIBLE gate events: S1 delivers the
+ * structure; the runner's boundary-announcement wiring (attachments member) lands in S2 (TODO(S2)).
+ */
+export interface HarvestReport {
+    /** False ⇔ the whole harvest was refused (deletion fuse / missing dir / corrupt sidecar incident). */
+    ok: boolean;
+    /** Set when a fuse tripped (§2.4 删除防线 / B3 fail-closed): the harvest is refused wholesale, NO
+     *  patches (especially no deletes) are produced, and the report is surfaced as an alert. */
+    incident?: {
+        kind: "mass_deletion" | "index_cleared" | "dir_missing" | "sidecar_corrupt";
+        detail: string;
+    };
+    /** Patch counts actually APPLIED by the backend. */
+    patches: {
+        add: number;
+        update: number;
+        delete: number;
+    };
+    /** Per-id CAS conflicts from the backend (reported, never blind-written). */
+    conflicts: PatchReport["conflicts"];
+    rejections: HarvestRejection[];
+    /** Non-`.md` / non-structural files found in the diff domain — listed, never persisted (they stay
+     *  on disk: they may be the model's working files). Files REMOVED from the model-visible plane go
+     *  in {@link movedToQuarantine}. */
+    quarantined: string[];
+    /** Gate-rejected files physically MOVED into the control plane's `quarantine/` (out of the scan
+     *  domain and off the model-visible disk — B2/验收 L4: secret-bearing files never linger). */
+    movedToQuarantine: string[];
+    /** C-F9 (S2-0) — quarantine escalations: any deviation from the clean capture+remove path is
+     *  REPORT-VISIBLE here (never a debug-only downgrade). `contained` = the suspect content no longer
+     *  sits raw on the model-visible plane (deleted / cleared in place / overwritten with the committed
+     *  copy); `contained: false` is the worst case — residue remains and a human/runner must act. */
+    quarantineFailures?: Array<{
+        path: string;
+        contained: boolean;
+        detail: string;
+    }>;
+    /** Materialized files absent at harvest. NOT deletes (§2.4: 文件缺失≠删除). Files whose entry id
+     *  re-appears at another path (a RENAME) are NOT counted here (验收 M1 — a rename is an id-keyed
+     *  update, never a missing file, and never feeds the deletion fuse). */
+    missing: string[];
+    /** B1 committed-shadow recovery: missing (non-tombstoned) files RESTORED onto disk from the
+     *  committed copy (backend/shadow). Disclosed here (the restore is an engine action, never silent).
+     *  Restored paths also appear in {@link missing} (the honest record of what vanished). */
+    restored: string[];
+    /** Index self-heal notes (L8): suspected-duplicate index lines kept-with-warning, cleared orphans. */
+    warnings: string[];
+    /** M7 harvest budget: set when the deadline/file budget cut the harvest short. `pending` files were
+     *  NOT processed this round (no patches, still on disk) — the next boundary harvest picks them up. */
+    degraded?: {
+        reason: "deadline" | "file_budget";
+        pending: string[];
+    };
+    /** B2 §2.7 r2.1 inbound gate: findings from scanning changes that did NOT originate in this session
+     *  (e.g. a git-pull-borne edit of an in-repo memory dir — a write channel that bypasses the harvest
+     *  gate). Populated by the backend's read-side sync gate and drained into the report at harvest. */
+    inboundFindings?: HarvestRejection[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/memory-engine/types.d.ts.map

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

package/dist/core/memory-engine/types.js

@@ -0,0 +1,9 @@
+// design/138 S1 — MemoryEngine contract types (§2.1: 条目为本体,文件为投影).
+//
+// The ENTRY is the unit of truth; files are the engine's projection of entries into a directory the
+// model manipulates with its ordinary file skills (CC file-based-memory parity, live capture §12).
+// The backend seam below is deliberately CONDITION-FREE across deployments: FileBackend (TOC 权威盘,
+// this slice) and PgBackend (TOB, S3) implement the SAME entry-transactional surface, so the engine —
+// and therefore the model-facing behavior — never forks on the storage tier.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/memory-engine/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/memory-engine/types.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,EAAE;AACF,oGAAoG;AACpG,mGAAmG;AACnG,kGAAkG;AAClG,sGAAsG;AACtG,6EAA6E"}

package/dist/core/memory-recall.d.ts

@@ -0,0 +1,261 @@
+import type { MemoryNoteHeader, MemoryNoteRecord, MemoryStore } from "./memory.js";
+import type { ModelRef, TaskSpec, TaskResult } from "./types.js";
+/**
+ * Selective memory recall (design/65 §2.2 — port of CC `findRelevantMemories`). For a LARGE memory scope,
+ * instead of injecting the whole `<user_memory>` block (inject-all), we inject a compact **manifest** (one
+ * header line per note) + a side-query that picks the ≤K relevant note ids + only those bodies. Small
+ * scopes keep inject-all (the common case after consolidation) — this path is threshold-gated, so most
+ * tasks pay nothing.
+ *
+ * The model side-query is an injected **seam** ({@link MemorySelector}); core provides a brain-backed
+ * default ({@link createBrainMemorySelector}) and a deployment can override it. The pipeline here is pure +
+ * deterministic given a selector: it validates the returned ids against the manifest (rejects hallucinated
+ * ids, council #5), caps at K, applies a hard timeout (council #12), and on ANY selector failure/timeout
+ * DEGRADES to inject-all (council #4 — never silently drop knowledge). Output goes in the variable tail
+ * (manifest + selected bodies are per-user/volatile, like the current memory block).
+ */
+/** Default max notes the side-query may select (CC `findRelevantMemories` ≤5). */
+export declare const DEFAULT_MAX_SELECTED = 5;
+/** Default max 1-hop link-followed notes appended after the selected ones (design/65 P3). */
+export declare const DEFAULT_MAX_LINKED = 3;
+/** Default side-query hard timeout (ms) — council #12; on timeout we degrade to inject-all. */
+export declare const DEFAULT_SELECT_TIMEOUT_MS = 5000;
+/**
+ * Render a memory note's age as a natural-language phrase (CC-parity P0-1, design/65). CC's eval found
+ * models reason about memory age much better from natural language ("3 days ago") than from a boolean
+ * "older note" flag (verify-claims 0/2 → 3/3 once the age was spelled out), because the model can weigh
+ * staleness proportionally instead of as a single cliff. This is the relative phrase only; the
+ * point-in-time / verify-before-trust discipline still lives in {@link RECALL_CAVEAT} + the per-note
+ * "verify it's still current" hint (the age is ADDITIONAL signal, not a replacement).
+ *
+ * Buckets (each chooses the coarsest unit that's ≥1): `today` (<1 day, incl. future mtime / clock skew →
+ * clamped to today, never a negative age), `yesterday` (1–2 days), `N days ago` (2–7 days),
+ * `N weeks ago` (1 week – ~1 month), `N months ago` (≥ ~1 month). N is floored to the whole unit.
+ */
+export declare function formatMemoryAge(ageMs: number): string;
+/**
+ * Read-side recall caveat (design/65 §8#2 / §9#1 — ported from CC's MEMORY_DRIFT_CAVEAT +
+ * TRUSTING_RECALL_SECTION). The council found CC's two-section form is **eval-validated** (verify-claims
+ * 0/2→3/3) and that the structure carries the effect: the precise decision-point heading
+ * "## Before recommending from memory" scored 3/3 while an abstract heading or a buried bullet scored 0/3.
+ * So this is deliberately TWO sections — a drift bullet + a titled action section with the frame-shift
+ * sentence and concrete verify actions — NOT one merged paragraph (same semantics, 3× worse eval).
+ * MEMORY_SAFETY already carries the authority hierarchy; this adds the point-in-time / verify-before-trust
+ * discipline selective recall specifically needs.
+ */
+export declare const RECALL_CAVEAT: string;
+export interface MemorySelectRequest {
+    /** The task objective the recall is for. */
+    objective: string;
+    /** The manifest the selector chooses from (id + description [+ type]). */
+    manifest: MemoryNoteHeader[];
+    /** Tools the task will use — for these, keep gotchas/warnings, skip pure usage notes (design/65 §2.2). */
+    recentTools?: string[];
+}
+/** The side-query seam: pick the relevant note ids from the manifest. MUST be fail-fast (throw → degrade). */
+export type MemorySelector = (req: MemorySelectRequest, signal?: AbortSignal) => Promise<string[]>;
+export interface SelectiveRecallOptions {
+    store: MemoryStore;
+    scope: string;
+    objective: string;
+    selector: MemorySelector;
+    recentTools?: string[];
+    /** Absolute time for the freshness caveat (default Date.now()). */
+    nowMs?: number;
+    maxSelected?: number;
+    /** Max 1-hop `[[name]]` link-followed notes appended after the selected ones (design/65 P3).
+     *  `0` disables link-following. Default {@link DEFAULT_MAX_LINKED}. */
+    maxLinked?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /**
+     * CC-parity P1 (durable cross-worker recall de-dup). Note ids ALREADY surfaced to this logical
+     * conversation in earlier turns/runs (CC's in-process `alreadySurfaced`/readFileState filter, lifted
+     * to a **durable, caller-owned** set so it survives task hops, resume, and multi-worker fan-out). When
+     * provided, these ids are **filtered out of the manifest BEFORE the selector sees it** — the selector
+     * never sees an already-shown note, so it cannot re-select it, so a long/resumed/multi-worker session
+     * does not re-inject the same bodies. core does NOT store this set (like {@link CheckpointStore}, the
+     * durable store is the caller's): the caller persists {@link surfacedIds} from one call and feeds it
+     * back here as `priorSurfacedIds` on the next. Omitted ⇒ no filtering (the prior, non-de-duped behavior).
+     */
+    priorSurfacedIds?: ReadonlySet<string>;
+}
+/**
+ * Result of {@link selectAndComposeMemory}. `surfacedIds` (CC-parity P1) is the set of note ids whose
+ * BODIES this call injected into the prompt — the caller appends them to its durable surfaced-set and
+ * feeds that back as {@link SelectiveRecallOptions.priorSurfacedIds} next time, so a long/resumed/
+ * multi-worker session does not re-inject the same notes. THREE shapes (all carry `surfacedIds`):
+ *
+ *  - **block branch** (`{ block: string }`): a selective-recall block was rendered. `surfacedIds` = the
+ *    validated selection + the 1-hop linked notes (everything whose body was rendered). The caller injects
+ *    `block` verbatim.
+ *
+ *  - **no-new branch** (`{ block: undefined }`): a SUCCESS, NOT a degrade. Every selectable candidate was
+ *    already surfaced earlier (filtered out by {@link SelectiveRecallOptions.priorSurfacedIds}), so there is
+ *    NOTHING NEW to inject. The caller injects NOTHING (no block) — it must NOT fall back to inject-all,
+ *    because inject-all would re-dump the WHOLE scope including the already-shown notes, defeating the
+ *    de-dup. `surfacedIds` is `[]` (this call added no new note to the durable set; the prior ids are
+ *    already in the caller's store). Distinguished from `degrade` precisely so the caller does not
+ *    re-inject (the bug this branch fixes). `"block" in result` is TRUE here (the key is present, value
+ *    `undefined`), so the caller's `"degrade" in result` narrow routes this to the non-degrade path.
+ *
+ *  - **degrade branch** (`{ degrade: true }`): a true FALLBACK — the store can't do selective recall
+ *    (missing manifest/getByIds), the scope is empty, OR the selector failed/timed out. The caller falls
+ *    back to inject-all (never drops knowledge, council #4), a best-effort FULL DUMP that
+ *    `composeMemoryBlock` hard-truncates to a head slice (so it does NOT reliably render every body), and
+ *    the caller already holds the prior surfaced ids. Degrade is therefore not a precise per-id surface that
+ *    can be de-duped: `surfacedIds` is ALWAYS `[]` and degrade does **not** advance the durable surfaced-set.
+ *    (Reporting the full header id list here would over-claim the truncated tail as surfaced → permanent
+ *    silent under-recall on the next turn.) See {@link selectAndComposeMemory}.
+ */
+export type SelectiveRecallResult = {
+    block: string;
+    surfacedIds: string[];
+} | {
+    block: undefined;
+    surfacedIds: string[];
+} | {
+    degrade: true;
+    surfacedIds: string[];
+};
+/**
+ * Resolve the `[[name]]` references in the selected notes' bodies to manifest headers — ONE hop
+ * (design/65 P3: "recall one note → bring its [[links]]"; linked bodies are NOT re-scanned, so a link
+ * chain can't pull in the whole graph). Pure-text convention: names resolve against the manifest's
+ * `name` field; an unresolved name is silently skipped (a `[[link]]` to a not-yet-written note is legal
+ * authoring, design/65 §2.1); a name collision resolves to the newest note (strict mtime `>`; on a
+ * tie the first-encountered header wins). Already-selected targets are excluded (they're injected
+ * anyway). Returns at most `max` ids, in first-mention order.
+ */
+export declare function resolveLinkedIds(headers: MemoryNoteHeader[], selected: MemoryNoteRecord[], max: number): string[];
+/** Render the manifest as compact lines, double-capped (council #7). One line per note, guaranteed. */
+export declare function buildManifestText(headers: MemoryNoteHeader[]): string;
+/** Keep only ids present in the manifest (reject hallucinated, council #5), de-duped, capped at `max`. */
+export declare function validateSelectedIds(headers: MemoryNoteHeader[], ids: string[], max: number): string[];
+/**
+ * Render the BODY of a selective-recall block: the optional `recall` manifest index + the selected note
+ * bodies (+ 1-hop linked notes), WITHOUT the outer `<user_memory>` wrapper and WITHOUT {@link RECALL_CAVEAT}.
+ * The wrapper + caveat are the caller's job — `composeSelectiveMemoryBlock` (single-scope) places ONE caveat
+ * inside ONE `<user_memory scope=… mode="selective">`, and the layered renderer places ONE caveat inside ONE
+ * `<user_memory mode="selective">` ahead of N `<scope>` subsections (MAJOR fix: no nested fences, no per-scope
+ * caveat duplication).
+ *
+ * `recallable` controls the "Memory index — call recall …" affordance (MAJOR fix): the on-demand `recall` tool
+ * is bound to a SINGLE scope, so the "load in full via recall" instruction is only TRUE for that scope. Pass
+ * `false` for non-recallable layers — the selected bodies are already rendered inline, so the index is just a
+ * false affordance that wastes a tool call (model searches the wrong scope → "No memory matches").
+ *
+ * Notes are tagged with their natural-language age (CC-parity P0-1, design/65; >1-day-old ones keep the
+ * "verify it's still current" hint, council #8). `linked` (design/65 P3) are 1-hop `[[name]]`-followed notes,
+ * rendered in their own clearly-labeled subsection AFTER the selected ones — expanded as DATA under the same
+ * fence/sanitize/byte-cap discipline (design/65 §8#9: a followed link must not become markup or escalate authority).
+ */
+export declare function composeSelectiveBody(manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[], recallable?: boolean): string;
+/** Render the single-scope selective block: ONE `<user_memory scope=… mode="selective">` with ONE
+ *  {@link RECALL_CAVEAT} at the top and the {@link composeSelectiveBody} (manifest + selected bodies + links).
+ *  `recall` is bound to this single scope, so the manifest affordance is recallable. *
+ * @deprecated design/138 S4 — served ONLY the retired legacy memoryStore injection path; the Runner no
+ * longer calls this. Kept exported one major for direct/standalone store-level use; removal is the next major.
+ */
+export declare function composeSelectiveMemoryBlock(scope: string, manifestText: string, selected: MemoryNoteRecord[], nowMs: number, linked?: MemoryNoteRecord[]): string;
+/**
+ * Run the selective-recall pipeline. Returns the composed block (+ {@link SelectiveRecallResult.surfacedIds}),
+ * or `{ degrade: true, surfacedIds: [] }` when the selector fails/times out (caller falls back to inject-all —
+ * never drops knowledge, council #4). Degrade always reports `surfacedIds: []`: inject-all is a best-effort
+ * full dump (head-truncated at the cap), so it cannot honestly attribute a precise per-id surface, and the
+ * caller already holds the prior ids — degrade does NOT advance the durable surfaced-set.
+ *
+ * CC-parity P1 (durable cross-worker de-dup): when {@link SelectiveRecallOptions.priorSurfacedIds} is given,
+ * those ids are dropped from the candidate headers BEFORE the manifest is built and BEFORE the selector runs,
+ * so an already-shown note is invisible to the selector (and therefore cannot be re-selected, re-link-followed,
+ * or re-rendered). `surfacedIds` reports what THIS call rendered, for the caller's durable surfaced-set.
+ *
+ * @deprecated design/138 S4 — served ONLY the retired legacy memoryStore injection path; the Runner no
+ * longer calls this. Kept exported one major for direct/standalone store-level use; removal is the next major.
+ */
+export declare function selectAndComposeMemory(opts: SelectiveRecallOptions): Promise<SelectiveRecallResult>;
+/** A `(scope, id)` composite key for the multi-scope durable de-dup (design/84 Seam A decision 5). Note ids
+ *  are only unique WITHIN a scope, so the cross-scope `priorSurfacedKeys`/`surfacedKeys` set MUST be keyed on
+ *  both. Core owns the FORMAT so a caller can't drift the wire format (decision 7) — the encoding is OPAQUE
+ *  and length-prefixes the scope so a scope/id containing the separator cannot forge a collision.
+ *
+ *  ONE-WAY by design (codex MINOR (d)): the key is only ever PRODUCED here (`surfacedKeys`) and compared by
+ *  STRING EQUALITY against the caller's persisted set ({@link LayeredRecallOptions.priorSurfacedKeys}, applied
+ *  at memory-recall.ts via `priorSurfacedKeys.has(encodeSurfacedKey(h.scope, h.id))`). Nothing ever needs the
+ *  `(scope, id)` BACK out of a key, so there is intentionally NO `decodeSurfacedKey` — adding a decode would
+ *  widen the public surface (and invite callers to parse the opaque format) for zero consumer. Treat the key
+ *  as an opaque token: persist it, feed it back, compare for equality — never split it. */
+export declare function encodeSurfacedKey(scope: string, id: string): string;
+/** A manifest header tagged with the scope it came from (design/84 Seam A decision 5). */
+export interface ScopedNoteHeader extends MemoryNoteHeader {
+    scope: string;
+}
+/** A full record tagged with its scope (for cross-scope getByIds). */
+export interface ScopedNoteRecord extends MemoryNoteRecord {
+    scope: string;
+}
+export interface LayeredRecallOptions {
+    store: MemoryStore;
+    /** Ordered scopes (design/84 Seam A): list order = priority; the last is highest. */
+    scopes: ReadonlyArray<string>;
+    objective: string;
+    selector: MemorySelector;
+    recentTools?: string[];
+    nowMs?: number;
+    maxSelected?: number;
+    maxLinked?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /** CC-parity P1, multi-scope: `(scope,id)` composite keys ({@link encodeSurfacedKey}) already surfaced to
+     *  this logical conversation. Filtered out of the merged manifest BEFORE the selector sees it. */
+    priorSurfacedKeys?: ReadonlySet<string>;
+}
+/** Result of {@link selectAndComposeLayeredMemory}. `surfacedKeys` are `(scope,id)` composite keys
+ *  ({@link encodeSurfacedKey}) — the caller appends them to its durable set and feeds them back as
+ *  {@link LayeredRecallOptions.priorSurfacedKeys}. Mirrors {@link SelectiveRecallResult}'s three shapes. */
+export type LayeredRecallResult = {
+    block: string;
+    surfacedKeys: string[];
+} | {
+    block: undefined;
+    surfacedKeys: string[];
+} | {
+    degrade: true;
+    surfacedKeys: string[];
+};
+/**
+ * Multi-scope (layered) selective recall (design/84 Seam A decision 5). Merges each scope's
+ * {@link MemoryStore.listStructuredNotes} into ONE manifest (each header tagged with its scope), lets the
+ * selector pick ids from the merged manifest, then fetches the selected bodies per-scope via
+ * {@link MemoryStore.getByIds} and renders ONE `<user_memory>` block with the selected notes grouped under a
+ * `<scope …>` subsection IN LIST ORDER (stable layers first = cacheable prefix, volatile last = tail). The
+ * `(scope,id)` composite de-dup ({@link LayeredRecallOptions.priorSurfacedKeys}) is applied at the manifest
+ * layer so an already-shown note in ANY scope is invisible to the selector.
+ *
+ * v1 (decision 6): accepts the N-small (3–4 layer) fan-out of one `listStructuredNotes`/`getByIds` per scope
+ * — no pre-built batch getByIds. Degrades to inject-all (the caller's job, like the single-scope path) on
+ * store-incapability / empty / selector failure. Threshold-gated by the caller, so a small layering pays nothing.
+ *
+ * @deprecated design/138 S4 — served ONLY the retired legacy memoryStore injection path; the Runner no
+ * longer calls this. Kept exported one major for direct/standalone store-level use; removal is the next major.
+ */
+export declare function selectAndComposeLayeredMemory(opts: LayeredRecallOptions): Promise<LayeredRecallResult>;
+/** Minimal structural view of the Runner needed by {@link createBrainMemorySelector} (avoids a circular
+ *  import of the Runner class). */
+export interface MemorySelectorRunner {
+    runTask(spec: TaskSpec): Promise<TaskResult>;
+}
+/**
+ * Default brain-backed {@link MemorySelector} (design/65 §6.2 / council #1: the side-query uses the MAIN
+ * brain — a cheap model is our unproven ABOVE assumption, not a CC port). Runs a tiny isolated sub-task
+ * with an `{ids}` output schema, no tools, a short budget. Returns the selected ids (validated downstream).
+ *
+ * @deprecated design/138 S4 — served ONLY the retired legacy memoryStore injection path; the Runner no
+ * longer calls this. Kept exported one major for direct/standalone store-level use; removal is the next major.
+ */
+export declare function createBrainMemorySelector(runner: MemorySelectorRunner, opts?: {
+    model?: ModelRef;
+    timeoutSec?: number;
+    release?: (sessionId: string) => Promise<void> | void;
+}): MemorySelector;
+//# sourceMappingURL=memory-recall.d.ts.map

package/dist/core/memory-recall.d.ts.map

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