fix(rust): drop supersede pointers outside the authority seed set

[iceteaSA]

Fixes #377.

The bug

authoritySeedRows (rust-mode-transform.ts:907) seeds every memory for a project — no status filter — and forwards superseded_by_memory_id verbatim:

db.prepare("SELECT * FROM memories WHERE project_path = ? ORDER BY id ASC").all(projectPath)

When that target is absent from the seed set, seed_memory_snapshots records a pending memory reference (crates/mc-store/src/lib.rs:14948-14958). The resolution sweep at :15068-15080 only clears pendings whose target later appears in mc_memories, so a hard-deleted target never clears. The pending survives to authority_finish_prepare (:14035-14047), which rejects the handoff:

store: storage backend: authority prepare complete rejected: 2 unresolved pending memory references
→ lkg_miss → decision=error → served_from=raw → applied=false
mc_rust_park_transition failure_passes=3 pass_count=3 park_count=1

Every pass degrades with materialized = 0, so m[0]/m[1] are never built — empty sidebar, "reconnecting" notification, and rust mode is unreachable. It is permanent: nothing repairs supersede pointers and the targets are gone.

The pointers come from ordinary merge/curate activity — the losing row records superseded_by_memory_id, the winner is later archived then deleted, the pointer outlives it. Nothing in the TS path dereferences it, so it stays inert and invisible until the module's store resolves it.

Why host-side and not a gate relaxation

My first instinct (and the original text of #377) was to relax the Rust gate — treat unresolvable as resolved-to-null in seed_memory_snapshots. After finding the resolution sweep, I think that's wrong: it would also swallow a genuine ingest failure, where the host sent the target and the module failed to store it. The store cannot tell those apart.

The host can, because it knows the seed set it just sent:

• target absent from the seed set → dead link, can never resolve → drop it here
• target present in the seed set but missing module-side → real failure → pending fires, gate correctly rejects

So the gate keeps its protective value and only the provably-dead links are dropped.

The change

const seededIds = new Set(memoryRows.map((row) => Number(row.id)));
...
const resolvedSnapshot =
    domain === "memories" &&
    snapshot.superseded_by_memory_id != null &&
    !seededIds.has(Number(snapshot.superseded_by_memory_id))
        ? { ...snapshot, superseded_by_memory_id: null }
        : snapshot;

Note the seed set is project-scoped, so a target belonging to another project is equally unresolvable — covered by the same check and by a test.

Verification

Red-checked (reverted the fix, confirmed both new tests fail for the right reason, restored):

fix reverted   82 pass / 2 fail
fix restored   84 pass / 0 fail

Gates:

                    this PR      clean master
plugin suite        4165 / 1     4163 / 1      (+2 = the new tests; same 1 pre-existing failure)
tsc                 0
lint                6 errors     6 errors      identical, none in touched files

Simulated against a real 3,101-memory store, on the project that hit this:

BEFORE   unresolvable pointers sent: 2     id=25 → 265 (archived)
                                           id=26 → 265 (archived)
AFTER    unresolvable pointers sent: 0
         resolvable pointers preserved: 61 of 63

61-of-63 is the number that matters — the change is surgical, not a blanket null of the column.

Scope in the wild

Measured on one long-lived install, per project (blocking rows / seeded rows):

25/363 · 17/302 · 13/448 · 10/148 · 4/179 · 2/245 · 2/122
7 of 40 projects affected

A fresh install has none, which is likely why this hasn't surfaced — it needs merge/curate history plus an eventual hard delete. Detection query is in #377 if you want to check other installs.

Tests

Two regression tests in rust-mode-transform.test.ts, both red-checked:

1. drops a pointer whose target is absent from the seed set, and preserves a resolvable one in the same seed — guards against a blanket-null regression
2. drops a pointer whose target belongs to another project

authoritySeedRows is added to the existing __rustModeTransformTest export surface; no other production surface changed. In-memory DB, no mock.module (avoiding the process-global bleed of #279).

---

^{Need help on this PR? Tag @codesmith-bot with what you need. Autofix is disabled.}

---

Summary by cubic

Fixes rust mode being permanently unreachable when a memory's superseded_by_memory_id points to a row that was hard-deleted after being archived. The seed set no longer includes that target, so the Rust store records an unresolvable pending reference and rejects the handoff. Host now drops such dead pointers before seeding, while keeping resolvable ones intact.

• Drops any supersede pointer whose target is absent from the seed set, including cross-project targets.
• Preserves resolvable pointers; verified to drop only the dead links (61 of 63 preserved on an affected project).
• Adds two regression tests covering both cases.
• Fixes rust mode: supersede pointers outside the authority seed set permanently block prepare (memories domain) #377.

^{Written for commit a0f548c. Summary will update on new commits.}

Greptile Summary

The PR prevents permanently unresolved Rust authority references by clearing supersession pointers whose targets are absent from the complete project-scoped seed set.

• Builds the set of memory IDs included in each authority handoff.
• Preserves resolvable supersession relationships while nulling only out-of-seed targets.
• Adds regression coverage for deleted/missing and cross-project targets.

Confidence Score: 5/5

The PR appears safe to merge, with no actionable correctness or security issues identified.

The project-scoped seed is complete before transport batching, valid in-seed supersession references are preserved, and host and module checksums operate on the same transformed snapshots.

Important Files Changed

Filename	Overview
packages/plugin/src/hooks/magic-context/rust-mode-transform.ts	Filters unresolvable supersession pointers at the host boundary while preserving targets included in the complete project seed.
packages/plugin/src/hooks/magic-context/rust-mode-transform.test.ts	Covers missing and cross-project targets and verifies that valid same-seed pointers remain intact.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart LR
  A[Load all project memories] --> B[Build seeded ID set]
  B --> C{Supersession target included?}
  C -->|Yes| D[Preserve pointer]
  C -->|No| E[Set pointer to null]
  D --> F[Seed Rust authority]
  E --> F
  F --> G[Complete authority handoff]

Loading

_{Reviews (1): Last reviewed commit: "fix(rust): drop supersede pointers outsi..." | Re-trigger Greptile}

Context used:

• Knowledge Base — Memory storage and decay

[cubic-dev-ai]

No issues found across 2 files

_{Re-trigger cubic}

[magic-alfonso]

Ready-to-post review comment for PR #378

Approved. I verified that authority seeding includes archived rows, while the module keeps a project-scoped pending reference when a supplied target never arrives and rejects prepare completion. This patch removes only targets outside the complete project seed, so it preserves the important failure signal for a target the host did send but the module did not ingest.

The two new host-seed tests pass, including the same-seed preservation and cross-project cases; I also ran the matching Rust-store pending-reference gate test and the plugin typecheck. No blocker found.

One wording-only suggestion: the implementation comment says an out-of-set target was hard-deleted, but the cross-project case can still exist outside this project. “Outside this project's seed” would describe both cases precisely.