Retain metadata ownership when deleted paths are reused

Author: mchwang

core/linking.ts

@@ -146,10 +146,12 @@ export function linkHistory(plan: Plan, history: History, ledger: ReadonlyMap<st
           for (const id of line.origins) if (!removed.has(id)) removed.set(id, combine([line.evidence, current]));
         }
       }
-      const metadataEvidence = metadataChange(delta) ? combine([previous.metadata, current]) : previous.metadata;
+      const metadataEvidence = metadataChange(delta)
+        ? combine([previous.metadata, ...touched.map(path => metadata.get(path) ?? empty()), current])
+        : previous.metadata;
       const metadataPaths = unique([...previous.metadataPaths, ...touched]);
       charge(metadataPaths.length);
-      for (const path of metadataPaths) metadata.set(path, metadataEvidence);
+      for (const path of metadataPaths) metadata.set(path, combine([metadata.get(path) ?? empty(), metadataEvidence]));
       if (oldPath) files.delete(oldPath);
       if (delta.newPath) files.set(delta.newPath, { lines: next, metadata: metadataEvidence, metadataPaths });
     }

docs/implementation/build-step-1.md

@@ -100,3 +100,7 @@ Updated README import/linking examples to supply the new required context. Decli
 Reproduced seven failing fixtures covering six valid findings. Replay now rejects before cumulative line/segment/reference/text growth exceeds its budget; origin unions and hunk-sharing avoid unchecked flattening, and grouping no longer repeatedly re-splits accumulated text. Read and linking operations each use a monotonic overall deadline, with Git subprocess/diff timeouts clamped to the remaining budget. Filesystem checks are cooperative between calls; process-level containment remains the runner's job.
 
 File metadata retains the whole rename path lineage, so a later deletion includes its owner's evidence on the final original-path file card. Multiple metadata owners remain conservatively Ambiguous; foreign owners remain Unplanned. Link target validation rejects intermediate regular-file/gitlink entries, overlap in both ancestry directions, and multi-file unsafe-link repair. Repair of an unsafe existing link remains possible as its own item. Tests cover text, empty, and binary rename/deletion cards; exact line/segment boundaries; reference fanout; and deterministic deadline exhaustion.
+
+## Merged-contract review round 4
+
+The review had no inline findings, but its summary identified lost metadata after deleting and recreating a path. A real binary-file regression reproduced only the recreating owner being retained. Metadata updates now combine existing path evidence before storing/propagating it, so prior deletion owners survive reuse and subsequent renames. Owned deletion plus recreation is Ambiguous; foreign deletion plus recreation stays Unplanned. Both regressions pass.

test/history.test.ts

@@ -306,3 +306,12 @@ it('bounds linking duration and replacement-origin fanout', () => {
   try { expect(() => linkHistory(f.plan, history, f.ledger, p => p, { maxDurationMs: 3 })).toThrow(/deadline/i); }
   finally { clock.mockRestore(); }
 });
+
+it.each(['P1', undefined])('retains deletion and recreation owners on reused-path file cards (%s)', owner => {
+  const f = fixture({ 'a.txt': '\0old binary' });
+  rmSync(join(f.dir, 'a.txt')); f.commit(owner);
+  f.write('a.txt', '\0new binary'); f.commit('P2');
+  const card = f.segments().find(s => s.kind === 'file')!;
+  expect(card.owners).toEqual([owner ?? null, 'P2']);
+  expect(card.row).toBe(owner ? 'Ambiguous' : 'Unplanned');
+});