@remnic/core 9.69.49 → 9.69.50

package/dist/who-knows-cli.js

@@ -4,14 +4,15 @@ import {
   renderWhoKnows,
   renderWhoKnowsJson,
   renderWhoKnowsText
-} from "./chunk-KHLNIDWB.js";
-import "./chunk-LX32KV2C.js";
-import "./chunk-AJLQH4RO.js";
-import "./chunk-46WM6JX2.js";
+} from "./chunk-DNO6QWCB.js";
+import "./chunk-KOEDSRF5.js";
+import "./chunk-D2XUSZ24.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-46WM6JX2.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-T3F2HWIG.js";
-import "./chunk-C3YEB7CR.js";
+import "./chunk-TZ44E732.js";
+import "./chunk-JOP7W24J.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-G6NQ3L4T.js";
 import "./chunk-WPGR3RW4.js";
 import "./chunk-6KTXE6A3.js";
@@ -19,13 +20,12 @@ import "./chunk-D7MAYFQP.js";
 import "./chunk-KVO2BTA4.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-DNAD57VY.js";
+import "./chunk-PQWICTRO.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";

package/dist/who-knows.d.ts

@@ -1,6 +1,6 @@
-export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-70VHaltr.js';
-import './types-DQ2H8gAC.js';
-import './orchestrator-Kx5zwNUm.js';
+export { bA as WHO_KNOWS_AUTHORSHIP_BONUS, bB as WHO_KNOWS_DEFAULT_LIMIT, bC as WHO_KNOWS_MAX_EVIDENCE, bD as WHO_KNOWS_MAX_LIMIT, bE as WHO_KNOWS_MCP_TOOLS, bF as WhoKnowsEntity, bG as WhoKnowsEvidence, bH as WhoKnowsHit, bI as WhoKnowsHttpOutcome, W as WhoKnowsResult, bJ as WhoKnowsStorage, bT as computeWhoKnows, bZ as handleWhoKnowsHttpQuery, c2 as loadWhoKnowsEntities, c9 as tokenizeTopic, ca as validateWhoKnowsInput } from './access-service-BZaC-RZw.js';
+import './types-DCB90q3g.js';
+import './orchestrator-BTqT3F6X.js';
 import './recall-state.js';
 import './utils/serialize-mutations.js';
 import './search/port.js';
@@ -14,6 +14,7 @@ import './graph-path-scoring-config.js';
 import './background-generation-config.js';
 import './deep-recall-config.js';
 import './recall-navigation-config.js';
+import './recall-recognition-tier.js';
 import './causal-trajectory.js';
 import './objective-state.js';
 import './active-context-config.js';
@@ -22,7 +23,7 @@ import './semantic-merge-config.js';
 import './types-continuity.js';
 import './included-memories.js';
 import './briefing.js';
-import './storage-BS7ux8F7.js';
+import './storage-DNQWtOSM.js';
 import './corpus-read-cancellation.js';
 import './artifact-search.js';
 import './active-context-transform.js';
@@ -38,7 +39,7 @@ import './write-envelope.js';
 import './structured-attributes.js';
 import './buffer.js';
 import './extraction-faithfulness.js';
-import './local-llm-B0vd_rp9.js';
+import './local-llm-BXYC-mbU.js';
 import './model-registry.js';
 import './fallback-llm.js';
 import './fallback-llm-codex-subscription.js';
@@ -47,8 +48,8 @@ import './resolve-provider-secret.js';
 import './transcript.js';
 import './session-integrity.js';
 import './summarizer.js';
-import './maintenance-DJgQkoLh.js';
-import './catalog-Byi9prz9.js';
+import './maintenance-zJiLsKBY.js';
+import './catalog-DK2eHhax.js';
 import './namespaces/search.js';
 import './compounding/engine.js';
 import './shared-context/manager.js';
@@ -58,7 +59,7 @@ import './utility-runtime.js';
 import './tier-routing.js';
 import './lifecycle.js';
 import './orchestration/compression-guideline-coordinator.js';
-import './semantic-consolidation-DMzhKRYl.js';
+import './semantic-consolidation-DEzRyeyn.js';
 import './connectors/codex-materialize.js';
 import './logger.js';
 import './embedding-fallback.js';
@@ -80,17 +81,17 @@ import './conversation-index/chunker.js';
 import './conversation-index/backend.js';
 import './faiss-adapter-BHecI1fF.js';
 import './runtime/child-process.js';
-import './dependency-propagation-delivery-BgHy44WX.js';
+import './dependency-propagation-delivery-BMkR4gmY.js';
 import './namespaces/storage.js';
 import './threading.js';
-import './scope-profiles-DPegZtRf.js';
+import './scope-profiles-Bg1rB-Dp.js';
 import './graph-DRkl22KE.js';
 import './graph-write-lock.js';
 import './recall-xray.js';
 import './memory-provenance.js';
 import './user-model.js';
 import './recall-context-composition.js';
-import './generic-recall-paths-BoueWXYr.js';
+import './generic-recall-paths-BCRtXU32.js';
 import './live-connectors-runner.js';
 import './framework-CNDn2164.js';
 import './relevance.js';
@@ -98,7 +99,7 @@ import './negative.js';
 import './session-observer-state.js';
 import './semantic-BalR6EXU.js';
 import './replay/types.js';
-import './service-E99KuPvi.js';
+import './service-DGEIDOeD.js';
 import './extraction-judge.js';
 import './lcm/engine.js';
 import './lcm/archive.js';
@@ -121,7 +122,7 @@ import './types-B1VHaf2w.js';
 import './transfer/capsule-import.js';
 import './transfer/types.js';
 import './recall-navigation.js';
-import './access-namespace-preflight-DqRw_g-8.js';
+import './access-namespace-preflight-C1q3XuAc.js';
 import './access-token-capabilities.js';
 import 'node:async_hooks';
 import './recall-explain-renderer.js';
@@ -129,7 +130,7 @@ import './access-citation.js';
 import './access-health-types.js';
 import './corpus-watermark.js';
 import './replica-divergence.js';
-import './tagging-BhOEcSXP.js';
+import './tagging-CPVwgadt.js';
 import './explicit-capture.js';
 import './access-wearables-meetings-surface.js';
 import './deep-recall.js';

package/dist/who-knows.js

@@ -9,13 +9,14 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-LX32KV2C.js";
-import "./chunk-AJLQH4RO.js";
-import "./chunk-46WM6JX2.js";
+} from "./chunk-KOEDSRF5.js";
+import "./chunk-D2XUSZ24.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-46WM6JX2.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-T3F2HWIG.js";
-import "./chunk-C3YEB7CR.js";
+import "./chunk-TZ44E732.js";
+import "./chunk-JOP7W24J.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-G6NQ3L4T.js";
 import "./chunk-WPGR3RW4.js";
 import "./chunk-6KTXE6A3.js";
@@ -23,13 +24,12 @@ import "./chunk-D7MAYFQP.js";
 import "./chunk-KVO2BTA4.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
-import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-DNAD57VY.js";
+import "./chunk-PQWICTRO.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { u as MemoryCategory, N as MemorySubject } from './types-DQ2H8gAC.js';
+import { u as MemoryCategory, N as MemorySubject } from './types-DCB90q3g.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
@@ -9,6 +9,7 @@ import './graph-path-scoring-config.js';
 import './background-generation-config.js';
 import './deep-recall-config.js';
 import './recall-navigation-config.js';
+import './recall-recognition-tier.js';
 import './causal-trajectory.js';
 import './objective-state.js';
 import './active-context-config.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.49",
+  "version": "9.69.50",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3307,7 +3307,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.49"
+    "@remnic/coding-graph": "^9.69.50"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/config.ts

@@ -46,6 +46,7 @@ import {
   parseStandingBlockFreshDays,
   parseStandingBlockMaxChars,
 } from "./standing-memory-block.js";
+import { parseRecognitionIndexMaxEntries, parseRecallRecognitionTier } from "./recall-recognition-tier.js";
 import { parseRecallConcurrencyConfig } from "./recall-concurrency-config.js";
 import { parseExtractionFields } from "./extraction-span-config.js";
 import { parseReplicaPeersConfig } from "./replica-peers-config.js";
@@ -1967,6 +1968,10 @@ export function parseConfig(
     recallStandingBlock: parseRecallStandingBlock(cfg.recallStandingBlock),
     standingBlockFreshDays: parseStandingBlockFreshDays(cfg.standingBlockFreshDays),
     standingBlockMaxChars: parseStandingBlockMaxChars(cfg.standingBlockMaxChars),
+    // Full-index recognition tier (issue #2975). Default false; nothing on the
+    // recall path reads these keys until the wiring slice lands.
+    recallRecognitionTier: parseRecallRecognitionTier(cfg.recallRecognitionTier),
+    recognitionIndexMaxEntries: parseRecognitionIndexMaxEntries(cfg.recognitionIndexMaxEntries),
     // Disclosure auto-escalation (issue #677 PR 4/4).  Default `manual`
     // so pre-#677 callers see unchanged behavior.  Reject anything
     // outside the allow-list rather than silently defaulting (CLAUDE.md

package/src/index.ts

@@ -50,6 +50,7 @@ export * from "./model-registry.js";
 export * from "./contradiction/index.js";
 export * from "./recall-state-view.js";
 export * from "./standing-memory-block.js";
+export * from "./recall-recognition-tier.js";
 
 export {
   buildEvidencePack,

package/src/lifecycle/seed-graduation.test.ts

@@ -0,0 +1,424 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { test } from "node:test";
+
+import { StorageManager } from "../storage.js";
+import {
+  SEED_GRADUATION_DEFAULTS,
+  evaluateSeedGraduation,
+  parseSeedGraduationConfig,
+  runSeedGraduationPass,
+  type SeedGraduationConfig,
+} from "./seed-graduation.js";
+import type { MemoryFile, MemoryFrontmatter } from "../types.js";
+
+const ENABLED: SeedGraduationConfig = { enabled: true, minCorroborations: 1 };
+
+const SEED_TEXT = "The launch moved to September twelfth after the vendor call.";
+// Restates the seed in similar wording (the wearable support-corpus pair).
+const RESTATE_TEXT = "Launch moved to September twelfth after the vendor call.";
+const UNRELATED_TEXT = "Quarterly budget planning covered the new office lease.";
+
+function fakeMemory(overrides: {
+  id: string;
+  content: string;
+  created: string;
+  source?: string;
+  status?: MemoryFrontmatter["status"];
+  structuredAttributes?: Record<string, string>;
+  lineage?: string[];
+}): MemoryFile {
+  return {
+    path: `facts/${overrides.id}.md`,
+    content: overrides.content,
+    frontmatter: {
+      id: overrides.id,
+      category: "fact",
+      created: overrides.created,
+      updated: overrides.created,
+      source: overrides.source ?? "extraction",
+      confidence: 0.7,
+      confidenceTier: "inferred",
+      tags: [],
+      status: overrides.status,
+      structuredAttributes: overrides.structuredAttributes,
+      lineage: overrides.lineage,
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+test("seedGraduation defaults to disabled with minCorroborations 2", () => {
+  assert.deepEqual(SEED_GRADUATION_DEFAULTS, { enabled: false, minCorroborations: 2 });
+  assert.deepEqual(parseSeedGraduationConfig(undefined), SEED_GRADUATION_DEFAULTS);
+  assert.deepEqual(parseSeedGraduationConfig({}), SEED_GRADUATION_DEFAULTS);
+  assert.deepEqual(parseSeedGraduationConfig({ enabled: "true", minCorroborations: "3" }), {
+    enabled: true,
+    minCorroborations: 3,
+  });
+});
+
+test("seedGraduation rejects invalid values instead of defaulting", () => {
+  assert.throws(() => parseSeedGraduationConfig("yes"), /seedGraduation must be an object/);
+  assert.throws(() => parseSeedGraduationConfig([1]), /seedGraduation must be an object/);
+  assert.throws(
+    () => parseSeedGraduationConfig({ enabled: "maybe" }),
+    /seedGraduation\.enabled must be a boolean/,
+  );
+  assert.throws(
+    () => parseSeedGraduationConfig({ minCorroborations: 0 }),
+    /minCorroborations must be an integer in \[1, 50\]/,
+  );
+  assert.throws(
+    () => parseSeedGraduationConfig({ minCorroborations: 1.5 }),
+    /minCorroborations must be an integer in \[1, 50\]/,
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Gate — echo suppression (pure)
+// ---------------------------------------------------------------------------
+
+test("evidence from the seed's own session never corroborates (self-echo)", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  const echo = fakeMemory({
+    id: "echo-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  const decision = evaluateSeedGraduation(seed, [echo], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.corroborationCount, 0);
+  assert.equal(decision.echoSuppressedCount, 1);
+});
+
+test("identical source without session anchors is never independent (fail closed)", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "extraction",
+  });
+  const lookalike = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "extraction",
+  });
+  const decision = evaluateSeedGraduation(seed, [lookalike], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.echoSuppressedCount, 1);
+});
+
+test("a session that recalled the seed cannot corroborate it (quoted-back echo)", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  // Different session AND different source — passes the anchor rules, but the
+  // session's recall history shows the seed was injected there: pure echo.
+  const readback = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "extraction",
+    structuredAttributes: { sessionKey: "session-b" },
+  });
+  const decision = evaluateSeedGraduation(seed, [readback], {
+    config: ENABLED,
+    recalledBySession: (sessionKey) =>
+      sessionKey === "session-b" ? [["seed-1", "other-mem"]] : [],
+  });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.echoSuppressedCount, 1);
+  // Same evidence, but the session never recalled the seed → real corroboration.
+  const clean = evaluateSeedGraduation(seed, [readback], {
+    config: ENABLED,
+    recalledBySession: () => [],
+  });
+  assert.equal(clean.decision, "promote");
+});
+
+test("a lineage descendant of the seed is derivation, not corroboration", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+  });
+  const derived = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "extraction",
+    lineage: ["seed-1"],
+  });
+  const decision = evaluateSeedGraduation(seed, [derived], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.echoSuppressedCount, 1);
+});
+
+test("independent later evidence from a different provenance corroborates", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+  });
+  const independent = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [independent], { config: ENABLED });
+  assert.equal(decision.decision, "promote");
+  assert.deepEqual(decision.corroborating, [
+    { memoryId: "ev-1", source: "wearable:limitless" },
+  ]);
+});
+
+test("minCorroborations counts distinct corroborating memories", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+  });
+  const evidence = [
+    fakeMemory({
+      id: "ev-1",
+      content: RESTATE_TEXT,
+      created: "2026-08-02T10:00:00.000Z",
+      source: "wearable:limitless",
+    }),
+    fakeMemory({
+      id: "ev-2",
+      content: `Noted separately: ${RESTATE_TEXT}`,
+      created: "2026-08-03T10:00:00.000Z",
+      source: "extraction",
+    }),
+  ];
+  const one = evaluateSeedGraduation(seed, evidence, {
+    config: { enabled: true, minCorroborations: 2 },
+  });
+  // ev-2 restates via a superset of tokens; both count → promotes at 2.
+  assert.equal(one.decision, "promote");
+  assert.equal(one.corroborationCount, 2);
+
+  const short = evaluateSeedGraduation(seed, [evidence[0]], {
+    config: { enabled: true, minCorroborations: 2 },
+  });
+  assert.equal(short.decision, "hold");
+  assert.ok(short.reasons.includes("corroboration-below-min:1/2"));
+});
+
+test("low token coverage is not corroboration and is not echo", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+  });
+  const unrelated = fakeMemory({
+    id: "ev-1",
+    content: UNRELATED_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [unrelated], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.corroborationCount, 0);
+  assert.equal(decision.echoSuppressedCount, 0);
+});
+
+test("evidence written at or before the seed does not corroborate", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+  });
+  const earlier = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const sameMoment = fakeMemory({
+    id: "ev-2",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "extraction",
+  });
+  const decision = evaluateSeedGraduation(seed, [earlier, sameMoment], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.corroborationCount, 0);
+});
+
+test("disabled config holds with the disabled reason (zero-value semantics)", () => {
+  const seed = fakeMemory({
+    id: "seed-1",
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+  });
+  const decision = evaluateSeedGraduation(seed, [], { config: SEED_GRADUATION_DEFAULTS });
+  assert.equal(decision.decision, "hold");
+  assert.deepEqual(decision.reasons, ["seed-graduation-disabled"]);
+});
+
+// ---------------------------------------------------------------------------
+// Pass — against a real StorageManager (acceptance cases)
+// ---------------------------------------------------------------------------
+
+function makeStorage(): { storage: StorageManager; dir: string } {
+  const dir = mkdtempSync(path.join(tmpdir(), "remnic-seed-graduation-"));
+  return { storage: new StorageManager(dir), dir };
+}
+
+test("pass: self-echo evidence does not promote a pending_review seed", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "extraction",
+      status: "pending_review",
+      structuredAttributes: { sessionKey: "session-a" },
+    });
+    await storage.writeMemory("fact", RESTATE_TEXT, {
+      source: "extraction",
+      structuredAttributes: { sessionKey: "session-a" },
+    });
+    const memories = await storage.readAllMemories();
+    const summary = await runSeedGraduationPass({
+      memories,
+      storage,
+      config: ENABLED,
+    });
+    assert.equal(summary.evaluated, 1);
+    assert.equal(summary.promoted, 0, "same-session echo must not graduate the seed");
+    assert.equal(summary.echoSuppressed, 1);
+    const seed = (await storage.readAllMemories()).find(
+      (memory) => memory.frontmatter.status === "pending_review",
+    );
+    assert.ok(seed, "seed stays pending_review");
+    assert.equal(seed.frontmatter.structuredAttributes?.graduatedBy, undefined);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pass: independent corroboration promotes the seed in place with audit attributes", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "wearable:bee",
+      status: "pending_review",
+    });
+    await storage.writeMemory("fact", RESTATE_TEXT, {
+      source: "wearable:limitless",
+    });
+    const memories = await storage.readAllMemories();
+    const summary = await runSeedGraduationPass({
+      memories,
+      storage,
+      config: ENABLED,
+    });
+    assert.equal(summary.promoted, 1);
+    const rows = await storage.readAllMemories();
+    const seed = rows.find((memory) => memory.frontmatter.source === "wearable:bee");
+    assert.ok(seed);
+    assert.equal(seed.frontmatter.status, "active", "graduated by corroboration");
+    const attrs = seed.frontmatter.structuredAttributes ?? {};
+    assert.equal(attrs.graduatedBy, "independent-corroboration");
+    assert.equal(attrs.corroborationCount, "1");
+    const evidence = rows.find((memory) => memory.frontmatter.source === "wearable:limitless");
+    assert.ok(evidence);
+    assert.equal(attrs.corroboratingMemoryIds, evidence.frontmatter.id);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pass: a non-corroborated seed stays in its prior state", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "wearable:bee",
+      status: "pending_review",
+    });
+    await storage.writeMemory("fact", UNRELATED_TEXT, {
+      source: "wearable:limitless",
+    });
+    const memories = await storage.readAllMemories();
+    const summary = await runSeedGraduationPass({
+      memories,
+      storage,
+      config: ENABLED,
+    });
+    assert.equal(summary.promoted, 0);
+    assert.equal(summary.held, 1);
+    const seed = (await storage.readAllMemories()).find(
+      (memory) => memory.frontmatter.source === "wearable:bee",
+    );
+    assert.ok(seed);
+    assert.equal(seed.frontmatter.status, "pending_review", "no corroboration, no change");
+    assert.equal(seed.frontmatter.structuredAttributes?.graduatedBy, undefined);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("pass: disabled config touches nothing", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "wearable:bee",
+      status: "pending_review",
+    });
+    await storage.writeMemory("fact", RESTATE_TEXT, {
+      source: "wearable:limitless",
+    });
+    const memories = await storage.readAllMemories();
+    const summary = await runSeedGraduationPass({
+      memories,
+      storage,
+      config: SEED_GRADUATION_DEFAULTS,
+    });
+    assert.deepEqual(summary, {
+      evaluated: 0,
+      promoted: 0,
+      held: 0,
+      echoSuppressed: 0,
+      disabled: true,
+    });
+    const seed = (await storage.readAllMemories()).find(
+      (memory) => memory.frontmatter.source === "wearable:bee",
+    );
+    assert.equal(seed?.frontmatter.status, "pending_review");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});