@lumy-pack/line-lore 0.0.7 → 0.0.9

package/README.md

@@ -25,9 +25,12 @@ yarn add @lumy-pack/line-lore
 ### CLI Usage
 
 ```bash
-# Trace a single line to its PR
+# Trace a single line to its originating PR
 npx @lumy-pack/line-lore trace src/auth.ts -L 42
 
+# Trace the last meaningful change to a line
+npx @lumy-pack/line-lore trace src/auth.ts -L 42 --mode change
+
 # Trace a line range
 npx @lumy-pack/line-lore trace src/config.ts -L 10,50
 
@@ -61,14 +64,21 @@ npx @lumy-pack/line-lore trace src/auth.ts -L 42 --quiet
 ```typescript
 import { trace, graph, health, clearCache } from '@lumy-pack/line-lore';
 
-// Trace a line to its PR
-const result = await trace({
+// Trace a line to its originating PR (default mode)
+const originResult = await trace({
+  file: 'src/auth.ts',
+  line: 42,
+});
+
+// Trace the last meaningful change to a line
+const changeResult = await trace({
   file: 'src/auth.ts',
   line: 42,
+  mode: 'change',
 });
 
 // Find the PR node
-const prNode = result.nodes.find(n => n.type === 'pull_request');
+const prNode = originResult.nodes.find(n => n.type === 'pull_request');
 if (prNode) {
   console.log(`PR #${prNode.prNumber}: ${prNode.prTitle}`);
 }
@@ -89,9 +99,11 @@ console.log(`Git version: ${report.gitVersion}`);
 
 ## How It Works
 
-@lumy-pack/line-lore executes a 4-stage deterministic pipeline:
+@lumy-pack/line-lore executes a deterministic pipeline with two trace modes:
 
-1. **Line → Commit (Blame)**: Git blame with `-C -C -M` flags to detect renames and copies
+1. **Line → Commit (Blame)**:
+   - `origin`: `git blame -w -C -C -M` — follows copy/move history across renames; whitespace-only changes ignored
+   - `change`: `git blame -w` — finds the last meaningful local change; ignores whitespace but does **not** track renames/copies, so a rename commit itself is attributed as the change
 2. **Cosmetic Detection**: AST structural comparison to skip formatting-only changes
 3. **Commit → Merge Commit**: Ancestry-path traversal + patch-id matching to resolve merge commits
 4. **Merge Commit → PR**: Commit message parsing + platform API lookup (filters unmerged PRs)
@@ -111,19 +123,21 @@ Strategy 1 — Cache ─────────────────── c
   │ hit? → return cached PRInfo
   │ miss + --cache-only? → return null (skip all fallbacks)
   ▼
-Strategy 2 — Ancestry-path + Message ─ cost: 1 git-log
-  │ 1st: git log --merges --ancestry-path --first-parent sha..HEAD
-  │ 2nd: (fallback) full ancestry-path without --first-parent
+Strategy 2 — Platform API ──────────── cost: 1 HTTP request
+  │ gh api repos/{owner}/{repo}/commits/{sha}/pulls
+  │ Filter: merged PRs only (mergedAt != null)
+  │ found? → return PRInfo
+  ▼
+Strategy 3 — Ancestry-path + Message ─ cost: 1-2 git-log traversals
+  │ Search verified merge candidates:
+  │   • first-parent ancestry path first
+  │   • full ancestry path second
   │ Parse merge subject with 3 regex patterns:
   │   • /Merge pull request #(\d+)/  — GitHub merge commit
   │   • /\(#(\d+)\)\s*$/             — Squash merge convention
-  │   • /!(\d+)\s*$/                 — GitLab merge commit
-  │ If PR# found + adapter available → enrich via API
-  │ found? → return PRInfo
-  ▼
-Strategy 3 — Platform API ──────────── cost: 1 HTTP request
-  │ gh api repos/{owner}/{repo}/commits/{sha}/pulls
-  │ Filter: merged PRs only (mergedAt != null)
+  │   • /See merge request ...!(\d+)$/ — GitLab merge commit
+  │ If message has no PR number and API is available:
+  │   query the merge commit SHA directly
   │ found? → return PRInfo
   ▼
 Strategy 4 — Patch-ID matching ─────── cost: streaming 500+ commits
@@ -136,7 +150,7 @@ Strategy 4 — Patch-ID matching ─────── cost: streaming 500+ comm
 All failed → null
 ```
 
-**Why this order?** The chain is sorted by cost. Most repositories use merge or squash workflows, so Strategy 2 resolves >90% of lookups with zero API calls. Strategy 3 (single HTTP) is cheaper than Strategy 4 (streaming hundreds of commit diffs), so API is tried before patch-id scanning.
+**Why this order?** Direct API lookup is the strongest Level 2 signal, so it runs before local ancestry heuristics. Verified ancestry is still cheaper than patch-id scanning and resolves most merge-based workflows without diff streaming.
 
 **Patch-ID explained**: `git patch-id --stable` generates a content-based hash from a commit's diff, ignoring all metadata (author, date, message). When a commit is rebased, its SHA changes but the patch-id stays the same — enabling deterministic matching of rebased commits.
 
@@ -170,7 +184,7 @@ interface TraceNode {
 
 | Type | Symbol | Meaning | When it appears |
 |------|--------|---------|-----------------|
-| `original_commit` | `●` | The commit that introduced or last modified this line | Always (at least one) |
+| `original_commit` | `●` | The commit selected by the active trace mode | Always (at least one) |
 | `cosmetic_commit` | `○` | A formatting-only change (whitespace, imports) | When AST detects no logic change |
 | `merge_commit` | `◆` | The merge commit on the base branch | Merge-based workflows |
 | `rebased_commit` | `◇` | A rebased version of the original commit | Rebase workflows with patch-id match |
@@ -206,6 +220,13 @@ interface TraceNode {
   └─ https://github.com/org/repo/pull/42
 ```
 
+**Last meaningful change mode (`--mode change`):**
+```
+● Commit e4f5a6b [exact] via blame
+▸ PR #55 refactor: update validation logic
+  └─ https://github.com/org/repo/pull/55
+```
+
 **Squash merge (Level 2):**
 ```
 ● Commit e4f5a6b [exact] via blame-CMw
@@ -334,7 +355,7 @@ import { trace, graph, health, clearCache, LineLoreError } from '@lumy-pack/line
 
 ### `trace(options): Promise<TraceFullResult>`
 
-Trace a code line to its originating PR.
+Trace a code line to its originating or last-change PR, depending on the selected mode.
 
 **Options (`TraceOptions`):**
 
@@ -344,6 +365,7 @@ Trace a code line to its originating PR.
 | `line` | `number` | yes | — | Starting line number (1-indexed) |
 | `endLine` | `number` | no | — | Ending line for range queries |
 | `remote` | `string` | no | `'origin'` | Git remote name |
+| `mode` | `'origin' \| 'change'` | no | `'origin'` | `origin` uses `git blame -w -C -C -M` (follows copy/move history across renames), `change` uses `git blame -w` (finds the last meaningful local change, ignoring whitespace but not copy/move) |
 | `deep` | `boolean` | no | `false` | Expand patch-id scan range (500→2000), continue search after merge commit match |
 | `noAst` | `boolean` | no | `false` | Disable AST analysis |
 | `noCache` | `boolean` | no | `false` | Disable cache reads and writes |
@@ -389,6 +411,7 @@ const result = await trace({
   file: 'src/config.ts',
   line: 10,
   endLine: 50,
+  mode: 'origin',
   deep: true,    // search harder for squash merges
   noCache: true, // skip cache for fresh results
 });
@@ -631,8 +654,9 @@ import type {
 
 | Command | Purpose |
 |---------|---------|
-| `npx @lumy-pack/line-lore trace <file>` | Trace a line to its PR |
+| `npx @lumy-pack/line-lore trace <file>` | Trace a line to its origin or last-change PR |
 | `-L, --line <num>` | Starting line (required) |
+| `--mode <origin\|change>` | Choose between content origin and last meaningful change |
 | `--end-line <num>` | Ending line for range |
 | `--deep` | Deep trace (squash merges) |
 | `--output <format>` | Output as json, llm, or human |

package/dist/cli.mjs

@@ -367,25 +367,6 @@ var init_executor = __esm({
 
 // src/core/ancestry/ancestry.ts
 import { filter as filter4, isTruthy as isTruthy4 } from "@winglet/common-utils";
-async function findMergeCommit(commitSha, options) {
-  const ref = options?.ref ?? "HEAD";
-  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
-  const startTime = Date.now();
-  const firstParentResult = await findMergeCommitWithArgs(
-    commitSha,
-    ref,
-    ["--first-parent"],
-    { ...options, timeout: budget }
-  );
-  if (firstParentResult) return firstParentResult;
-  const elapsed = Date.now() - startTime;
-  const remaining = budget - elapsed;
-  if (remaining <= 0) return null;
-  return findMergeCommitWithArgs(commitSha, ref, [], {
-    ...options,
-    timeout: remaining
-  });
-}
 async function verifyMergeIntroducesCommit(targetSha, mergeResult, options) {
   if (mergeResult.parentShas.length < 2) return true;
   const firstParent = mergeResult.parentShas[0];
@@ -415,7 +396,7 @@ async function isAncestor(commitA, commitB, options) {
     return null;
   }
 }
-async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
+async function findMergeCommitsWithArgs(commitSha, ref, extraArgs, options) {
   try {
     const result = await gitExec(
       [
@@ -431,28 +412,29 @@ async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
       { cwd: options?.cwd, timeout: options?.timeout }
     );
     const lines = filter4(result.stdout.trim().split("\n"), isTruthy4);
-    if (lines.length === 0) return null;
+    if (lines.length === 0) return [];
+    const verifiedCandidates = [];
     const candidateCount = Math.min(lines.length, MAX_CANDIDATES);
-    let verifiedCount = 0;
+    let attemptedCount = 0;
     for (let i = 0; i < candidateCount; i++) {
       const candidate = parseMergeLogLine(lines[i]);
       if (!candidate) continue;
-      verifiedCount++;
+      attemptedCount++;
       const verified = await verifyMergeIntroducesCommit(
         commitSha,
         candidate,
         options
       );
-      if (verified) return candidate;
+      if (verified) verifiedCandidates.push(candidate);
     }
-    if (verifiedCount > 0 && options?.warnings) {
+    if (attemptedCount > 0 && verifiedCandidates.length === 0 && options?.warnings) {
       options.warnings.push(
-        `ancestry: all ${verifiedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
+        `ancestry: all ${attemptedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
       );
     }
-    return null;
+    return verifiedCandidates;
   } catch {
-    return null;
+    return [];
   }
 }
 function parseMergeLogLine(line) {
@@ -472,6 +454,38 @@ function parseMergeLogLine(line) {
   const subject = parts.slice(subjectStart).join(" ");
   return { mergeCommitSha, parentShas, subject };
 }
+async function findMergeCommits(commitSha, options) {
+  const ref = options?.ref ?? "HEAD";
+  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
+  const startTime = Date.now();
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushUnique = (candidates) => {
+    for (const candidate of candidates) {
+      if (seen.has(candidate.mergeCommitSha)) continue;
+      seen.add(candidate.mergeCommitSha);
+      results.push(candidate);
+      if (results.length >= MAX_CANDIDATES) break;
+    }
+  };
+  const firstParent = await findMergeCommitsWithArgs(
+    commitSha,
+    ref,
+    ["--first-parent"],
+    { ...options, timeout: budget }
+  );
+  pushUnique(firstParent);
+  const elapsed = Date.now() - startTime;
+  const remaining = budget - elapsed;
+  if (remaining > 0 && results.length < MAX_CANDIDATES) {
+    const full = await findMergeCommitsWithArgs(commitSha, ref, [], {
+      ...options,
+      timeout: remaining
+    });
+    pushUnique(full);
+  }
+  return results;
+}
 async function getCommitSubject(sha, options) {
   try {
     const result = await gitExec(["log", "-1", "--format=%s", sha], {
@@ -670,16 +684,17 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
     }
   }
   let mergeBasedPR = null;
-  const mergeResult = await findMergeCommit(commitSha, options);
-  if (mergeResult) {
+  const mergeCandidates = await findMergeCommits(commitSha, options);
+  const hasAncestryMerges = mergeCandidates.length > 0;
+  for (const candidate of mergeCandidates) {
     const prNumber = extractPRFromMergeMessage(
-      mergeResult.subject,
+      candidate.subject,
       options?.platform
     );
     if (prNumber) {
       if (adapter) {
         const prInfo = await adapter.getPRForCommit(
-          mergeResult.mergeCommitSha,
+          candidate.mergeCommitSha,
           prSelectOptions
         );
         if (prInfo?.mergedAt) {
@@ -689,23 +704,32 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       if (!mergeBasedPR) {
         mergeBasedPR = {
           number: prNumber,
-          title: mergeResult.subject,
+          title: candidate.subject,
           author: "",
           url: "",
-          mergeCommit: mergeResult.mergeCommitSha,
+          mergeCommit: candidate.mergeCommitSha,
           baseBranch: "",
           resolvedVia: "ancestry"
         };
       }
-      if (!options?.deep || mergeBasedPR.mergedAt) {
-        await cache.set(commitSha, toCachedPR(mergeBasedPR));
-        return mergeBasedPR;
+      break;
+    }
+    if (adapter) {
+      const mergeCommitPR = await adapter.getPRForCommit(
+        candidate.mergeCommitSha,
+        prSelectOptions
+      );
+      if (mergeCommitPR?.mergedAt) {
+        mergeBasedPR = { ...mergeCommitPR, resolvedVia: "ancestry" };
+        break;
       }
     }
   }
   if (mergeBasedPR) {
-    await cache.set(commitSha, toCachedPR(mergeBasedPR));
-    return mergeBasedPR;
+    if (!options?.deep || mergeBasedPR.mergedAt) {
+      await cache.set(commitSha, toCachedPR(mergeBasedPR));
+      return mergeBasedPR;
+    }
   }
   const commitSubject = await getCommitSubject(commitSha, options);
   if (commitSubject) {
@@ -727,7 +751,7 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       return subjectPR;
     }
   }
-  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH) {
+  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH && (!hasAncestryMerges || options?.deep)) {
     const patchIdMatch = await findPatchIdMatch(commitSha, {
       ...options,
       scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
@@ -745,6 +769,10 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       }
     }
   }
+  if (mergeBasedPR) {
+    await cache.set(commitSha, toCachedPR(mergeBasedPR));
+    return mergeBasedPR;
+  }
   return null;
 }
 function resetPRCache() {
@@ -781,7 +809,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = "0.0.7";
+    VERSION = "0.0.9";
   }
 });
 
@@ -2094,6 +2122,7 @@ function parsePorcelainOutput(output) {
     }
     let commitHash = headerMatch[1];
     const originalLine = parseInt(headerMatch[2], 10);
+    const finalLine = parseInt(headerMatch[3], 10) || 0;
     const isBoundary = commitHash.startsWith("^");
     if (isBoundary) {
       commitHash = commitHash.slice(1).padStart(40, "0");
@@ -2137,6 +2166,7 @@ function parsePorcelainOutput(output) {
       authorEmail: cleanEmail,
       date,
       lineContent,
+      finalLine,
       originalFile,
       originalLine: originalFile ? originalLine : void 0
     });
@@ -2147,14 +2177,112 @@ function parsePorcelainOutput(output) {
 // src/core/blame/blame.ts
 async function executeBlame(file, lineRange, options) {
   const lineSpec = `${lineRange.start},${lineRange.end}`;
-  const result = await gitExec(
-    ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file],
-    options
-  );
+  const args = options?.mode === "change" ? ["blame", "-w", "--porcelain", "-L", lineSpec, file] : ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file];
+  const result = await gitExec(args, options);
   return parsePorcelainOutput(result.stdout);
 }
-async function analyzeBlameResults(results, filePath, options) {
-  const uniqueShas = [...new Set(map6(results, (r) => r.commitHash))];
+async function executeDualBlame(file, lineRange, options) {
+  if (options?.mode === "change") {
+    const results = await executeBlame(file, lineRange, options);
+    return { blame: results, changeBlame: [] };
+  }
+  const [originResult, changeResult] = await Promise.allSettled([
+    executeBlame(file, lineRange, options),
+    executeBlame(file, lineRange, { ...options, mode: "change" })
+  ]);
+  const blame = originResult.status === "fulfilled" ? originResult.value : [];
+  const changeBlame = changeResult.status === "fulfilled" ? changeResult.value : [];
+  if (originResult.status === "rejected") {
+    throw originResult.reason;
+  }
+  return { blame, changeBlame };
+}
+async function verifyRename(originalFile, currentFile, options) {
+  try {
+    const result = await gitExec(
+      [
+        "log",
+        "--diff-filter=R",
+        "--find-renames",
+        "--format=%H",
+        "--",
+        originalFile,
+        currentFile
+      ],
+      options
+    );
+    return result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function crossValidateBlame(originResults, changeResults) {
+  const changeMap = /* @__PURE__ */ new Map();
+  for (const r of changeResults) {
+    changeMap.set(r.finalLine, r);
+  }
+  const validated = [];
+  const crossValidatedFlags = [];
+  const changeFallbackFlags = [];
+  const renameChecks = [];
+  for (let i = 0; i < originResults.length; i++) {
+    const origin = originResults[i];
+    const change = changeMap.get(origin.finalLine);
+    if (!change) {
+      validated.push(origin);
+      crossValidatedFlags.push(false);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.commitHash === change.commitHash) {
+      validated.push(origin);
+      crossValidatedFlags.push(true);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.originalFile) {
+      renameChecks.push({
+        originalFile: origin.originalFile,
+        lineIndex: i
+      });
+    }
+    validated.push(change);
+    crossValidatedFlags.push(true);
+    changeFallbackFlags.push(true);
+  }
+  return { validated, renameChecks, crossValidatedFlags, changeFallbackFlags };
+}
+async function analyzeBlameResults(results, filePath, options, changeResults) {
+  let effectiveResults = results;
+  let crossValidatedFlags;
+  let changeFallbackFlagsResult;
+  if (changeResults && changeResults.length > 0) {
+    const { validated, renameChecks, crossValidatedFlags: cvFlags, changeFallbackFlags } = crossValidateBlame(results, changeResults);
+    if (renameChecks.length > 0) {
+      const pendingChecks = /* @__PURE__ */ new Map();
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (!pendingChecks.has(cacheKey)) {
+          pendingChecks.set(cacheKey, verifyRename(check.originalFile, filePath, options));
+        }
+      }
+      const renameResults = /* @__PURE__ */ new Map();
+      for (const [key, promise] of pendingChecks) {
+        renameResults.set(key, await promise);
+      }
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (renameResults.get(cacheKey)) {
+          validated[check.lineIndex] = results[check.lineIndex];
+          changeFallbackFlags[check.lineIndex] = false;
+        }
+      }
+    }
+    effectiveResults = validated;
+    crossValidatedFlags = cvFlags;
+    changeFallbackFlagsResult = changeFallbackFlags;
+  }
+  const uniqueShas = [...new Set(map6(effectiveResults, (r) => r.commitHash))];
   const cosmeticMap = /* @__PURE__ */ new Map();
   const zeroSha = "0".repeat(40);
   const tasks = [];
@@ -2163,7 +2291,7 @@ async function analyzeBlameResults(results, filePath, options) {
     tasks.push(
       (async () => {
         try {
-          const blameResult = results.find((r) => r.commitHash === sha);
+          const blameResult = effectiveResults.find((r) => r.commitHash === sha);
           if (!blameResult) return;
           const file = blameResult.originalFile ?? filePath;
           const diff = await getCosmeticDiff(sha, file, options);
@@ -2175,12 +2303,14 @@ async function analyzeBlameResults(results, filePath, options) {
     );
   });
   await Promise.all(tasks);
-  return map6(results, (blame) => {
+  return map6(effectiveResults, (blame, i) => {
     const cosmetic = cosmeticMap.get(blame.commitHash);
     return {
       blame,
       isCosmetic: cosmetic?.isCosmetic ?? false,
-      cosmeticReason: cosmetic?.reason
+      cosmeticReason: cosmetic?.reason,
+      crossValidated: crossValidatedFlags?.[i],
+      usedChangeFallback: changeFallbackFlagsResult?.[i]
     };
   });
 }
@@ -2357,8 +2487,11 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   const lineRange = parseLineRange(
     options.endLine ? `${options.line},${options.endLine}` : `${options.line}`
   );
-  const blameChain = executeBlame(options.file, lineRange, execOptions).then(
-    (results) => analyzeBlameResults(results, options.file, execOptions)
+  const blameChain = executeDualBlame(options.file, lineRange, {
+    ...execOptions,
+    mode: options.mode
+  }).then(
+    ({ blame, changeBlame }) => analyzeBlameResults(blame, options.file, execOptions, changeBlame.length > 0 ? changeBlame : void 0)
   );
   const [authResult, blameResult] = await Promise.allSettled([
     adapter ? adapter.checkAuth() : Promise.resolve({ authenticated: false }),
@@ -2380,12 +2513,24 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   }
   return { analyzed: blameResult.value, operatingLevel, warnings };
 }
-async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+function resolveTraceMode(mode) {
+  return mode ?? "origin";
+}
+function deduplicatedLookupPR(sha, adapter, options, inflight) {
+  const existing = inflight.get(sha);
+  if (existing) return existing;
+  const promise = lookupPR(sha, adapter, options);
+  inflight.set(sha, promise);
+  promise.finally(() => inflight.delete(sha));
+  return promise;
+}
+async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, inflightPR, skipPatchIdScan, preferredBase) {
   const nodes = [];
+  const traceMode = resolveTraceMode(options.mode);
   const commitNode = {
     type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
     sha: entry.blame.commitHash,
-    trackingMethod: "blame-CMw",
+    trackingMethod: traceMode === "change" || entry.usedChangeFallback ? "blame" : "blame-CMw",
     confidence: "exact",
     note: entry.cosmeticReason ? `Cosmetic change: ${entry.cosmeticReason}` : void 0
   };
@@ -2407,17 +2552,18 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
     }
   }
   const targetSha = nodes[nodes.length - 1].sha;
+  const prLookupOptions = {
+    ...execOptions,
+    noCache: options.noCache,
+    cacheOnly: options.cacheOnly,
+    deep: featureFlags.deepTrace,
+    repoId,
+    skipPatchIdScan,
+    preferredBase,
+    platform: adapter?.platform
+  };
   if (targetSha) {
-    const prInfo = await lookupPR(targetSha, adapter, {
-      ...execOptions,
-      noCache: options.noCache,
-      cacheOnly: options.cacheOnly,
-      deep: featureFlags.deepTrace,
-      repoId,
-      skipPatchIdScan,
-      preferredBase,
-      platform: adapter?.platform
-    });
+    const prInfo = await deduplicatedLookupPR(targetSha, adapter, prLookupOptions, inflightPR);
     if (prInfo) {
       nodes.push({
         type: "pull_request",
@@ -2434,6 +2580,7 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
   return nodes;
 }
 async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+  const inflightPR = /* @__PURE__ */ new Map();
   const results = await Promise.allSettled(
     map8(
       analyzed,
@@ -2444,6 +2591,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
         options,
         execOptions,
         repoId,
+        inflightPR,
         skipPatchIdScan,
         preferredBase
       )
@@ -2453,6 +2601,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
 }
 var legacyCacheCleaned = false;
 async function trace(options) {
+  const mode = resolveTraceMode(options.mode);
   const { file, cwd } = await resolveFileContext(options.file, options.cwd);
   const warnings = [];
   const execOptions = { cwd, warnings };
@@ -2474,7 +2623,7 @@ async function trace(options) {
   }
   const blameAuth = await runBlameAndAuth(
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions
   );
   const operatingLevel = blameAuth.operatingLevel || platform.operatingLevel;
@@ -2517,7 +2666,7 @@ async function trace(options) {
     blameAuth.analyzed,
     featureFlags,
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions,
     repoId,
     cloneStatus.partialClone || void 0,
@@ -2728,7 +2877,11 @@ function formatNodeHuman(node) {
 init_normalizer();
 init_errors();
 function registerTraceCommand(program2) {
-  program2.command("trace <file>").description("Trace a file line to its originating PR").requiredOption("-L, --line <range>", 'Line number or range (e.g., "42" or "10,50")').option("--deep", "Enable deep trace for squash PRs").option("--no-ast", "Disable AST diff analysis").option("--no-cache", "Disable cache").option("--cache-only", "Return cached results only (no API calls)").option("--json", "Output in JSON format").option("-q, --quiet", "Output PR number only").option("--output <format>", "Output format: human, json, llm", "human").option("--no-color", "Disable colored output").action(async (file, opts) => {
+  program2.command("trace <file>").description("Trace a file line to its originating or last-change PR").requiredOption("-L, --line <range>", 'Line number or range (e.g., "42" or "10,50")').option("--mode <mode>", "Trace mode: change (default) or origin (includes copy/move source)", "change").option("--deep", "Enable deep trace for squash PRs").option("--no-ast", "Disable AST diff analysis").option("--no-cache", "Disable cache").option("--cache-only", "Return cached results only (no API calls)").option("--json", "Output in JSON format").option("-q, --quiet", "Output PR number only").option("--output <format>", "Output format: human, json, llm", "human").option("--no-color", "Disable colored output").action(async (file, opts) => {
+    const mode = opts.mode;
+    if (mode !== "origin" && mode !== "change") {
+      throw new Error(`Invalid trace mode: ${String(mode)}`);
+    }
     const lineStr = opts.line;
     const parts = lineStr.split(",");
     const line = parseInt(parts[0], 10);
@@ -2737,6 +2890,7 @@ function registerTraceCommand(program2) {
       file,
       line,
       endLine,
+      mode,
       deep: opts.deep,
       noAst: opts.ast === false,
       noCache: opts.cache === false,
@@ -2777,7 +2931,7 @@ init_errors();
 // src/utils/command-registry.ts
 var TRACE_COMMAND = {
   name: "trace",
-  description: "Trace a file line to its originating PR",
+  description: "Trace a file line to its originating or last-change PR",
   usage: "line-lore trace <file> [options]",
   arguments: [
     {
@@ -2792,6 +2946,12 @@ var TRACE_COMMAND = {
       description: 'Line number or range (e.g., "42" or "10,50")',
       type: "string"
     },
+    {
+      flag: "--mode <mode>",
+      description: "Trace mode: origin or change",
+      type: "string",
+      default: "origin"
+    },
     {
       flag: "--deep",
       description: "Enable deep trace for squash PRs",