fix(memory): persist contradictedBy through vector-store upsert

The in-memory mutation in ConsolidationPipeline.resolveConflicts was
already populating provenance.contradictedBy and provenance.lastVerifiedAt
on both winner and loser before soft-deleting the loser, but the changes
lived only in the cache and were lost on process restart.

New MemoryStore.persistTraceMetadata(traceId) re-upserts the trace's
metadata to the vector store using the cached embedding, so the audit
trail survives without paying for a re-embedding pass. resolveConflicts
calls this for both sides before the softDelete write so a future load
of either trace sees the contradiction relationship that resolved the
conflict in the original session.

Author: jddunn

src/cognition/memory/pipeline/consolidation/ConsolidationPipeline.ts

@@ -432,6 +432,12 @@ export class ConsolidationPipeline {
           const loser = trace.createdAt > other.createdAt ? other : trace;
           const winner = loser === trace ? other : trace;
           recordContradiction(winner, loser);
+          // Persist the winner's updated audit trail before the loser is
+          // dropped. The loser keeps its symmetric record in-memory; the
+          // softDelete also writes the deletion to SQL so future loads see
+          // both sides of the contradiction.
+          await this.config.store.persistTraceMetadata(winner.id);
+          await this.config.store.persistTraceMetadata(loser.id);
           await this.config.store.softDelete(loser.id);
           resolved++;
         } else {
@@ -440,6 +446,8 @@ export class ConsolidationPipeline {
             const loser = trace.provenance.confidence < other.provenance.confidence ? trace : other;
             const winner = loser === trace ? other : trace;
             recordContradiction(winner, loser);
+            await this.config.store.persistTraceMetadata(winner.id);
+            await this.config.store.persistTraceMetadata(loser.id);
             await this.config.store.softDelete(loser.id);
             resolved++;
           }

src/cognition/memory/retrieval/store/MemoryStore.ts

@@ -671,6 +671,36 @@ export class MemoryStore {
     return results;
   }
 
+  /**
+   * Re-upsert a trace's metadata to the vector store using the cached
+   * embedding. Used by consolidation when a mutation to the in-memory
+   * trace (e.g. `provenance.contradictedBy`, `provenance.lastVerifiedAt`)
+   * needs to survive a process restart without paying for re-embedding.
+   *
+   * No-ops silently when the trace or its embedding is not cached; the
+   * caller should `getTrace` first or accept that an uncached trace will
+   * not be durably updated.
+   */
+  async persistTraceMetadata(traceId: string): Promise<void> {
+    const trace = this.traceCache.get(traceId);
+    const embedding = this.embeddingCache.get(traceId);
+    if (!trace || !embedding) return;
+
+    const collection = collectionName(this.config.collectionPrefix, trace.scope, trace.scopeId);
+    const doc: VectorDocument = {
+      id: trace.id,
+      textContent: trace.content,
+      embedding,
+      metadata: traceToMetadata(trace),
+    };
+    try {
+      await this.config.vectorStore.upsert(collection, [doc]);
+    } catch {
+      // Best-effort persistence — the in-memory mutation already
+      // happened, so a vector-store failure should not kill the caller.
+    }
+  }
+
   /**
    * Soft-delete a trace.
    */