@vzn/vx 0.0.636 → 0.0.637

package/src/orchestrator/framed-output.ts

@@ -532,7 +532,8 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
   // Red, not amber: a violation fails the task, so it reads as a failure.
   // vx's note, after the evidence: the grants that would have allowed it.
   // A read the output depends on is a key input too; the sandbox never
-  // adds one (owner, 2026-10-09).
+  // adds one (owner, 2026-10-09), so the note names the reads no input
+  // glob matches and the user decides.
   const fix = outcome.sandboxFix
   const line = fix === undefined ? undefined : sandboxFixLine(fix)
   const dim = (text: string): string => paint('', text, colors, { dim: true })
@@ -541,8 +542,12 @@ function violationSection(outcome: TaskOutcome, colors: ColorSupport): string[]
       ? []
       : [
           ...(line !== undefined ? [dim(`fix: ${line}`)] : []),
-          ...(fix.read !== undefined
-            ? [dim('a read the output depends on belongs in cache.inputs.files too')]
+          ...(fix.inputs !== undefined
+            ? [
+                dim(
+                  `and, if the output depends on them, cache.inputs.files: [${fix.inputs.map((p) => `'${p}'`).join(', ')}]`,
+                ),
+              ]
             : []),
           ...(fix.withheld !== undefined
             ? [dim(`credential path, grant it only on purpose: ${fix.withheld.join(', ')}`)]

package/src/orchestrator/graph-stage.ts

@@ -2,8 +2,7 @@
 // CLI's `--affected` task selection (`vx show <task> --affected`), so both
 // select over the graph the hooks leave.
 
-import type { WorkspaceRules } from '../config.js'
-import type { TaskNode } from '../graph/index.js'
+import type { GraphRules, TaskNode } from '../graph/index.js'
 import { type ProjectMeta, validateProjectConfig } from '../workspace/index.js'
 import { applyGraphHooks } from './plugin-host.js'
 import type { VxPlugin } from './plugin.js'
@@ -17,7 +16,7 @@ export async function applyGraphStage(
     cacheDir: string
     projectMetas: readonly ProjectMeta[]
     warn: (message: string) => void
-    rules?: WorkspaceRules | undefined
+    rules?: GraphRules | undefined
   },
 ): Promise<void> {
   // A hook edits each node's config in place, as `project` does, so the
@@ -36,10 +35,11 @@ export async function applyGraphStage(
     (plugin) => {
       for (const n of nodes.values()) {
         if (isDefaultBuild(n.config)) continue
-        const where = configPaths.get(n.projectName) ?? `${n.projectName} (no config file)`
+        const own = configPaths.get(n.projectName) ?? null
         validateProjectConfig(
           { tasks: { [n.taskName]: n.config } },
-          `${where} (after plugin '${plugin.name}')`,
+          `${own ?? `${n.projectName} (no config file)`} (after plugin '${plugin.name}')`,
+          own,
         )
       }
     },

package/src/orchestrator/history.ts

@@ -12,13 +12,17 @@
 // (zero-config); the interface is the seam a plugin fills for any other.
 
 import type { Database } from 'bun:sqlite'
-import { EXECUTED_RUNS_SQL } from '../cache/index.js'
+import { branchSource, EXECUTED_RUNS_SQL } from '../cache/index.js'
+import { splitTaskId } from '../util/index.js'
 import { failureModeOf, mixedOutcomeKeysSql } from './failure-mode.js'
 import type { FailureMode } from './failure-mode.js'
 import { isPassStatus, TASK_STATUSES } from './telemetry.js'
 
 const DEFAULT_RECENT = 50
 
+/** A task's forecast is the median of this many of its newest timings. */
+const FORECAST_RUNS = 5
+
 // A hit is recorded as `cache-hit` / `cache-hit-remote` and replays a
 // success; the list is derived so a new status cannot miss it.
 /** The pass set as SQL, `(…)`: one definition, `isPassStatus`. */
@@ -86,7 +90,9 @@ export class EmptyHistoryProvider implements HistoryProvider {
 export class LocalHistoryProvider implements HistoryProvider {
   constructor(
     private readonly db: Database,
-    private readonly recent: number = DEFAULT_RECENT,
+    readonly recent: number = DEFAULT_RECENT,
+    /** The run's branch (`currentBranch`); undefined: a forecast reads every branch's timings. */
+    private readonly branch?: string | null,
   ) {}
 
   /**
@@ -107,8 +113,17 @@ export class LocalHistoryProvider implements HistoryProvider {
    * read by `run_id` and stay exact.
    */
   async loadFor(taskIds: readonly string[]): Promise<HistoryTable> {
+    if (taskIds.length === 0) return new Map()
+    return this.load(new Set(taskIds))
+  }
+
+  /** Every task the window holds, as `loadFor` answers each (`vx last --stats`). */
+  async loadAll(): Promise<HistoryTable> {
+    return this.load(null)
+  }
+
+  private load(wanted: ReadonlySet<string> | null): HistoryTable {
     const out = new Map<string, TaskHistory>()
-    if (taskIds.length === 0) return out
     const floor = this.floor()
 
     // `skipped` rows are excluded: a skip is a task the run never executed,
@@ -160,15 +175,15 @@ export class LocalHistoryProvider implements HistoryProvider {
     // Every pair in the slice is grouped (the slice is bounded, so this is
     // cheap) and the asked-for ones are picked out here — a per-row IN-list
     // probe in SQL cost more than the grouping it would have saved.
-    const wanted = new Set(taskIds)
-    const rows = (this.db.query(sql).all(floor) as Row[]).filter((r) =>
-      wanted.has(`${r.project}#${r.task}`),
+    const rows = (this.db.query(sql).all(floor) as Row[]).filter(
+      (r) => wanted === null || wanted.has(`${r.project}#${r.task}`),
     )
 
     // The flakiness signal needs per-key outcomes, which the aggregate above
     // folded away — one more pass over the slice, only for the pairs whose
     // verdict actually depends on it (failed, and no retry already proving
     // nondeterminism); a green history never pays for it.
+    const p50s = this.forecasts(new Set(rows.map((r) => `${r.project}#${r.task}`)))
     const mixed = this.mixedOutcomeKeys(
       floor,
       rows.filter((r) => r.failures > 0 && r.retried === 0),
@@ -182,7 +197,7 @@ export class LocalHistoryProvider implements HistoryProvider {
       if (durations !== undefined) durations.sort((a, b) => a - b)
       out.set(key, {
         runs: total,
-        p50DurationMs: durations ? pickPercentile(durations, 0.5) : undefined,
+        p50DurationMs: p50s.get(key),
         p99DurationMs: durations ? pickPercentile(durations, 0.99) : undefined,
         successRate: row.successes / total,
         hitRate: row.hits / total,
@@ -195,27 +210,52 @@ export class LocalHistoryProvider implements HistoryProvider {
   }
 
   /**
-   * The same window's p50s alone. `loadFor`'s rates and resource maxima
-   * read every row of the window and join each hit to its entry: 38 ms at
-   * 27,000 rows against 4 for the executed successes' durations alone.
+   * The forecasts alone. `loadFor`'s rates and resource maxima read every
+   * row of the window and join each hit to its entry: 38 ms at 27,000 rows
+   * against 4 for the executed successes' durations alone.
    */
   async p50sFor(taskIds: readonly string[]): Promise<ReadonlyMap<string, number>> {
+    if (taskIds.length === 0) return new Map()
+    return this.forecasts(new Set(taskIds))
+  }
+
+  /**
+   * Each task's duration forecast (owner, 2026-10-14): the median of its
+   * last `FORECAST_RUNS` timings on this branch, else on any branch, else
+   * none. The timings are the shared store's `task_durations`, so every
+   * worktree of the repo reads them and a new one forecasts on its first
+   * run. A point read per task on `(project, task, source, id)`: exact
+   * however old the rows, where the runs window holds only the newest
+   * invocations.
+   */
+  private forecasts(wanted: ReadonlySet<string>): Map<string, number> {
     const out = new Map<string, number>()
-    if (taskIds.length === 0) return out
-    const rows = this.db
-      .query(
-        `SELECT project, task, GROUP_CONCAT(duration_ms) AS ds FROM runs
-         WHERE id >= ? AND status = 'success' AND (cache_hit IS NULL OR cache_hit = 0)
-         GROUP BY project, task`,
+    if (wanted.size === 0) return out
+    // Tiers, first answer wins. The remote cache's default-branch timings
+    // (#3563) slot in between the two.
+    type Tier = (project: string, task: string) => Array<{ ms: number }>
+    const tiers: Tier[] = []
+    const newest = (where: string) =>
+      this.db.query(
+        `SELECT duration_ms AS ms FROM task_durations WHERE project = ? AND task = ? AND ${where}
+         ORDER BY id DESC LIMIT ${FORECAST_RUNS}`,
       )
-      .all(this.floor()) as Array<{ project: string; task: string; ds: string }>
-    const wanted = new Set(taskIds)
-    for (const row of rows) {
-      const key = `${row.project}#${row.task}`
-      if (!wanted.has(key)) continue
-      const durations = row.ds.split(',').map(Number)
-      durations.sort((a, b) => a - b)
-      out.set(key, pickPercentile(durations, 0.5))
+    if (this.branch !== undefined) {
+      const source = branchSource(this.branch)
+      const q = newest('source = ?')
+      tiers.push((p, t) => q.all(p, t, source) as Array<{ ms: number }>)
+    }
+    const any = newest(`source LIKE 'branch:%'`)
+    tiers.push((p, t) => any.all(p, t) as Array<{ ms: number }>)
+    for (const id of wanted) {
+      const [project, task] = splitTaskId(id)
+      for (const tier of tiers) {
+        const rows = tier(project, task)
+        if (rows.length === 0) continue
+        const durations = rows.map((r) => r.ms).sort((x, y) => x - y)
+        out.set(id, pickPercentile(durations, 0.5))
+        break
+      }
     }
     return out
   }
@@ -236,13 +276,12 @@ export class LocalHistoryProvider implements HistoryProvider {
     type Executed = {
       project: string
       task: string
-      ds: string
       rss: number | null
       cpu: number | null
     }
     const executed = this.db
       .query(
-        `SELECT project, task, GROUP_CONCAT(duration_ms) AS ds, MAX(peak_rss_bytes) AS rss,
+        `SELECT project, task, MAX(peak_rss_bytes) AS rss,
            MAX(CASE WHEN cpu_ms IS NOT NULL AND duration_ms > 0
                     THEN cpu_ms * 1.0 / duration_ms END) AS cpu
          FROM runs
@@ -250,13 +289,12 @@ export class LocalHistoryProvider implements HistoryProvider {
          GROUP BY project, task`,
       )
       .all(floor) as Executed[]
+    const p50s = this.forecasts(wanted)
     for (const row of executed) {
       const key = `${row.project}#${row.task}`
       if (!wanted.has(key)) continue
-      const durations = row.ds.split(',').map(Number)
-      durations.sort((a, b) => a - b)
       out.set(key, {
-        p50DurationMs: pickPercentile(durations, 0.5),
+        p50DurationMs: p50s.get(key),
         ...(row.rss !== null ? { maxPeakRssBytes: row.rss } : {}),
         ...(row.cpu !== null ? { maxCpuParallelism: row.cpu } : {}),
       })
@@ -279,11 +317,13 @@ export class LocalHistoryProvider implements HistoryProvider {
       const rss = Math.max(had?.maxPeakRssBytes ?? -Infinity, row.rss ?? -Infinity)
       const cpu = Math.max(had?.maxCpuParallelism ?? -Infinity, row.cpu ?? -Infinity)
       out.set(key, {
-        p50DurationMs: had?.p50DurationMs,
+        p50DurationMs: p50s.get(key),
         ...(rss !== -Infinity ? { maxPeakRssBytes: rss } : {}),
         ...(cpu !== -Infinity ? { maxCpuParallelism: cpu } : {}),
       })
     }
+    // A forecast reads past the window: a task with none in it still has one.
+    for (const [key, p50] of p50s) if (!out.has(key)) out.set(key, { p50DurationMs: p50 })
     return out
   }
 

package/src/orchestrator/hit-restore.ts

@@ -14,6 +14,7 @@ import {
   cleanOutputPaths,
   cleanOutputs,
   cleanWorkspaceOutputs,
+  committedFiles,
   resolveOutputs,
   resolveWorkspaceOutputs,
   WORKSPACE_OUTPUT_PREFIX,
@@ -67,8 +68,13 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
     projectDir: node.projectDir,
     outputs,
     nestedProjectDirs: args.nestedProjectDirs,
+    committed: committedFiles(args.gitFilesCache, node.projectDir),
+  }
+  const wsCleanArgs = {
+    workspaceRoot: args.workspaceRoot,
+    outputs: wsOutputs,
+    committed: committedFiles(args.gitFilesCache, args.workspaceRoot),
   }
-  const wsCleanArgs = { workspaceRoot: args.workspaceRoot, outputs: wsOutputs }
   // The two sides of an overlapping pair (item 588). An ADDITIVE task owns
   // only its recorded rows: its glob also selects the upstream's files it
   // adds beside, so "no strays" is not a claim it can make, and its clean
@@ -101,7 +107,7 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
   // output replays from the row (`hit.stdout`), and its artifact holds
   // only logs. Extracting it anyway cost an `exists` + a tar read per hit
   // — 1.7 ms each on a four-task real repo whose `link` and `element`
-  // tasks declare `outputs: []` (2026-09-10, VX_TIMING).
+  // tasks declare `outputs: []` (2026-09-10, `VX_DEBUG_TIMING`).
   let skipRestore = !anyOutputs
   // The walk that found the tree stale, handed to the clean when nothing
   // was awaited between them: the clean's own walk would only repeat it
@@ -230,7 +236,12 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
     let cleanedWsRels: string[] = []
     if (additive) {
       cleanedRels = hit.outputFiles.filter((p) => !p.startsWith(WORKSPACE_OUTPUT_PREFIX))
-      await cleanOutputPaths({ projectDir: node.projectDir, rels: cleanedRels, outputs })
+      await cleanOutputPaths({
+        projectDir: node.projectDir,
+        rels: cleanedRels,
+        outputs,
+        committed: cleanArgs.committed,
+      })
       cleanedWsRels = hit.outputFiles
         .filter((p) => p.startsWith(WORKSPACE_OUTPUT_PREFIX))
         .map((p) => p.slice(WORKSPACE_OUTPUT_PREFIX.length))
@@ -238,6 +249,7 @@ export async function restoreHit(restore: RestoreHitArgs): Promise<TaskOutcome>
         projectDir: args.workspaceRoot,
         rels: cleanedWsRels,
         outputs: wsOutputs,
+        committed: wsCleanArgs.committed,
       })
     } else {
       if (outputs.length > 0) {

package/src/orchestrator/index.ts

@@ -4,6 +4,7 @@
 export { run, planRun, nxProjectTarget, projectNamed } from './run.js'
 export { prepareRun, type PreparedRun } from './prepare.js'
 export { affectedTaskProjects } from './affected-tasks.js'
+export { applyGraphStage } from './graph-stage.js'
 export type { AffectedReason } from './affected-tasks.js'
 export {
   discoverProjects,
@@ -13,6 +14,8 @@ export {
   loadProjects,
   loadResolvedProjects,
   loadWorkspacePlugins,
+  lockOfDiscovery,
+  lockReader,
   type LoadedProjects,
   type LoadProjectsArgs,
 } from './projects.js'
@@ -21,12 +24,17 @@ export type { HeldPersistent, RunOptions, RunSummary } from './options.js'
 // Re-surface the cache policy contract (defined in the cache module) so
 // embedders constructing RunOptions.cache and the package façade can
 // reach it without importing the cache module directly.
-export { type CachePolicy, FULL_CACHE_POLICY, parseCachePolicy } from '../cache/index.js'
+export {
+  type CacheFlags,
+  type CachePolicy,
+  FULL_CACHE_POLICY,
+  parseCachePolicy,
+} from '../cache/index.js'
 // The CLI reads a recorded exit code; the runner's convention decodes it.
 // It records its own argv quoted as the runner quotes forwarded args.
 export { exitSignal, shellQuote } from '../exec/index.js'
 export { forwardedSignal } from './signals.js'
-// `vx cache prune` waits for a run on the workspace before it evicts.
+// `vx cache clean` waits for a run on the workspace before it evicts.
 export { acquireRunLock } from './run-lock.js'
 export { defaultLogger, resolveOutputView } from './logger.js'
 export { detectColors, paint, type ColorSupport } from './colors.js'
@@ -70,6 +78,7 @@ export {
   installPlugins,
   type CacheContext,
   type ExecutorContext,
+  type OutputContext,
   type CommandContext,
   type GraphHookContext,
   type KeyHookContext,
@@ -79,7 +88,7 @@ export {
   type AdmitContext,
   type WorkspaceHookContext,
   type DiscoverContext,
-  type NamedProject,
+  type DiscoveredProject,
   type InstallPluginsArgs,
   type Plugin,
   type PluginContext,
@@ -105,8 +114,9 @@ export {
   claimedAffected,
   fingerprintClaims,
   hasHook,
-  CACHE_LAYER_METHODS,
+  REMOTE_CACHE_METHODS,
   resolveCache,
+  type CacheHost,
   resolveExecutors,
 } from './plugin-host.js'
 export {
@@ -114,6 +124,7 @@ export {
   reachDigests,
   type LockfileClaimHooks,
   type LockfileClaimOptions,
+  type LockfileImporter,
   type ReachGraph,
 } from './lockfile-claim.js'
 export { subscribeTelemetry, type TelemetryHandle } from './telemetry-host.js'
@@ -147,6 +158,7 @@ export {
   captureGitContext,
   captureHostContext,
   captureWorkspaceIdentity,
+  currentBranch,
   detectCi,
 } from './run-context.js'
 export type { CiContext, GitContext, HostContext, WorkspaceIdentity } from './run-context.js'
@@ -158,6 +170,7 @@ export {
   latestRunId,
   listInvocations,
   listRuns,
+  inputWriters,
   rootCauses,
   whyDidThisRerun as whyDidThisRerunQuery,
 } from './metrics.js'
@@ -173,6 +186,7 @@ export { resolveRunId, shortRunId } from './run-id.js'
 export type {
   CacheEntryRow,
   CacheKeyDiff,
+  InputWriter,
   RootCause,
   CacheKeyExplanation,
   InputDiffEntry,

package/src/orchestrator/local-shortcircuit.ts

@@ -52,7 +52,8 @@ export interface ShortCircuitArgs {
   nodes: Map<string, TaskNode>
   cache: CacheLayer
   workspaceRoot: string
-  workspaceFingerprint: string
+  /** The root files the plugins claim (`DeriveStableKeysArgs.claimedFiles`). */
+  claimedFiles: readonly string[]
   forwardArgs?: readonly string[] | undefined
   nestedDirsByProject: Map<string, string[]>
   gitFilesCache: GitFilesCache

package/src/orchestrator/lockfile-claim.ts

@@ -25,7 +25,7 @@ import type {
 } from './plugin.js'
 
 export interface LockfileClaimOptions {
-  /** The root-relative lockfile name, one of `WORKSPACE_FINGERPRINT_FILES`. */
+  /** The lockfile's name at the workspace root. */
   readonly file: string
   /**
    * Every project's digest from the file's text: importer directory
@@ -46,8 +46,7 @@ export interface LockfileClaimOptions {
   readonly version: number
   /**
    * `'project'` (default): each task folds its own project's digest.
-   * `'workspace'`: the whole file's hash into every task — the coarse key
-   * core would fold, through the plugin.
+   * `'workspace'`: the whole file's hash into every task — the coarse key.
    */
   readonly scope?: 'project' | 'workspace'
   /**
@@ -55,18 +54,46 @@ export interface LockfileClaimOptions {
    * (`@vzn/vx-lockfile/pnpm`). Default `'deps'`.
    */
   readonly part?: string
+  /**
+   * Each importer's links to other importers, from the same text, kept in
+   * the memo beside the digests so a `discover` hook reads them without a
+   * parse. Called once per distinct content, under either scope.
+   */
+  readonly importers?: (text: string) => ReadonlyMap<string, LockfileImporter>
 }
 
-/** The two hooks a lockfile plugin spreads into `definePlugin`. */
+/**
+ * What a lockfile records of one importer's links to the workspace's other
+ * importers: dependency name → importer directory (root-relative POSIX,
+ * `.` for the root).
+ */
+export interface LockfileImporter {
+  /** The entries it installs that resolve to an importer. */
+  readonly deps: Readonly<Record<string, string>>
+  /** Its peers that resolve to an importer, each with no installed entry of the same name. */
+  readonly peers: Readonly<Record<string, string>>
+}
+
+/** What a lockfile plugin spreads into `definePlugin` (`fingerprint`, `key`), and `importers` for its own stages. */
 export interface LockfileClaimHooks {
   readonly fingerprint: FingerprintClaim
   key(task: TaskNode, ctx: KeyHookContext): Promise<Readonly<Record<string, string>> | undefined>
+  /**
+   * `importers`' answer for the file as it is now, through the same memo
+   * and gates as `key`; undefined when the file is absent. Not a hook: a
+   * plugin calls it from its own `discover` or `project`.
+   */
+  importers(ctx: {
+    readonly workspaceRoot: string
+    readonly cacheDir: string
+  }): Promise<ReadonlyMap<string, LockfileImporter> | undefined>
 }
 
 interface Digests {
   /** xxh3 of the lockfile bytes; '' when the file is absent. */
   readonly lock: string
   readonly importers: ReadonlyMap<string, string>
+  readonly edges: ReadonlyMap<string, LockfileImporter>
 }
 
 interface Memo {
@@ -76,6 +103,7 @@ interface Memo {
   /** `extraFiles` → content hash when the digests were computed. */
   extras?: Record<string, string>
   importers: Record<string, string>
+  edges?: Record<string, LockfileImporter>
 }
 
 /** A root-relative extra file's content hash, '' when absent; a path leaving the root is never read. */
@@ -125,7 +153,16 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
   // at the same number read this one's memo: one that named no extra file
   // left the other's patch edits out of its key (X-130). The functions'
   // source stands for the claimant; a rebuild that changes it is a miss.
-  const claimant = xxh3hex([part, String(digest), String(options.extraFiles ?? '')].join('\0'))
+  // The scope too: a workspace-scope memo holds no digests.
+  const claimant = xxh3hex(
+    [
+      part,
+      scope,
+      String(digest),
+      String(options.extraFiles ?? ''),
+      String(options.importers ?? ''),
+    ].join('\0'),
+  )
   if (scope !== 'project' && scope !== 'workspace') {
     throw new Error(`scope must be 'project' or 'workspace', not ${JSON.stringify(scope)}`)
   }
@@ -149,7 +186,7 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     try {
       identity = identityOf(await stat(full))
     } catch {
-      const digests: Digests = { lock: '', importers: new Map() }
+      const digests: Digests = { lock: '', importers: new Map(), edges: new Map() }
       seen.set(workspaceRoot, { identity: 'gone', extras: [], extraStats: {}, digests })
       return digests
     }
@@ -169,12 +206,14 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     let extras: Record<string, string> = {}
     let extraStats: Record<string, string> = {}
     let importers: ReadonlyMap<string, string> | undefined
+    let edges: ReadonlyMap<string, LockfileImporter> = new Map()
     if (memo !== undefined) {
       const now = await hashExtras(workspaceRoot, Object.keys(memo.extras))
       if (Object.entries(memo.extras).every(([rel, h]) => now.hashes[rel] === h)) {
         extras = memo.extras
         extraStats = now.stats
         importers = memo.importers
+        edges = memo.edges
       }
     }
     if (importers === undefined) {
@@ -186,19 +225,19 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
       importers =
         scope === 'workspace'
           ? new Map<string, string>()
-          : await computeAndMemo(
-              memoFile,
-              { version, claimant, lock: lockHash },
-              extras,
-              digest(text, new Map(Object.entries(extras))),
-            )
+          : digest(text, new Map(Object.entries(extras)))
+      edges = options.importers?.(text) ?? new Map()
+      // Workspace scope with no edges to keep has nothing a memo saves.
+      if (scope === 'project' || options.importers !== undefined) {
+        await writeMemo(memoFile, { version, claimant, lock: lockHash }, extras, importers, edges)
+      }
     }
     const rels = Object.keys(extras)
     const lock =
       rels.length === 0
         ? lockHash
         : xxh3hex([lockHash, ...rels.map((r) => `${r}\0${extras[r]}`)].join('\0'))
-    const digests: Digests = { lock, importers }
+    const digests: Digests = { lock, importers, edges }
     seen.set(workspaceRoot, { identity, extras: rels, extraStats, digests })
     return digests
   }
@@ -216,7 +255,7 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
       files: [file],
       affected(change: FingerprintChange, ctx: FingerprintContext) {
         // One side absent: the file appeared or went — every project's
-        // installed tree is in question, and core's answer (all) is right.
+        // installed tree is in question.
         if (change.before === null || change.after === null) return undefined
         if (scope === 'workspace') return undefined
         // WHICH side failed is the whole difference between "your
@@ -248,6 +287,10 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         [part]: digestFor(digests.importers, importerOf(ctx.workspaceRoot, task.projectDir)),
       }
     },
+    async importers(ctx) {
+      const digests = await load(ctx.workspaceRoot, ctx.cacheDir)
+      return digests.lock === '' ? undefined : digests.edges
+    },
   }
 }
 
@@ -280,25 +323,42 @@ async function readMemo(
   version: number,
   claimant: string,
   lock: string,
-): Promise<{ extras: Record<string, string>; importers: Map<string, string> } | undefined> {
+): Promise<
+  | {
+      extras: Record<string, string>
+      importers: Map<string, string>
+      edges: Map<string, LockfileImporter>
+    }
+  | undefined
+> {
   try {
     const memo = (await Bun.file(memoFile).json()) as Memo
     if (memo.version !== version || memo.claimant !== claimant || memo.lock !== lock) {
       return undefined
     }
-    return { extras: memo.extras ?? {}, importers: new Map(Object.entries(memo.importers)) }
+    return {
+      extras: memo.extras ?? {},
+      importers: new Map(Object.entries(memo.importers)),
+      edges: new Map(Object.entries(memo.edges ?? {})),
+    }
   } catch {
     return undefined
   }
 }
 
-async function computeAndMemo(
+async function writeMemo(
   memoFile: string,
   identity: Pick<Memo, 'version' | 'claimant' | 'lock'>,
   extras: Record<string, string>,
   importers: ReadonlyMap<string, string>,
-): Promise<ReadonlyMap<string, string>> {
-  const memo: Memo = { ...identity, extras, importers: Object.fromEntries(importers) }
+  edges: ReadonlyMap<string, LockfileImporter>,
+): Promise<void> {
+  const memo: Memo = {
+    ...identity,
+    extras,
+    importers: Object.fromEntries(importers),
+    ...(edges.size > 0 ? { edges: Object.fromEntries(edges) } : {}),
+  }
   // Write-then-rename: a reader never sees a half-written memo, and two
   // concurrent runs each land a whole one.
   const tmp = `${memoFile}.tmp-${process.pid}-${Date.now()}`
@@ -309,7 +369,6 @@ async function computeAndMemo(
     // The memo is a speed-up, never a requirement: the digests are
     // computed either way, and the next run computes them again.
   }
-  return importers
 }
 
 function decode(bytes: Uint8Array): string {