mixdog 1.4.1 → 1.4.2

package/src/runtime/shared/worktrees/manager.mjs

@@ -40,6 +40,7 @@ import {
 } from './file-recovery.mjs';
 import { lstat, mkdir, readdir, readFile, rm, rmdir, stat } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
+import { isPidAlive } from '../pid-liveness.mjs';
 import {
   managedWorktreePath,
   managedWorktreeRoot,
@@ -86,7 +87,7 @@ import {
 } from './include.mjs';
 import { linkWorktreeDependencies } from './dependencies.mjs';
 import { withRepoLock as withRepoMutationLock } from './lock.mjs';
-import { holdWorkspaceActivity } from './activity-gate.mjs';
+import { holdWorkspaceActivityAsync } from './activity-gate.mjs';
 import { withAdvisoryLocks } from '../../agent/orchestrator/tools/builtin/advisory-lock.mjs';
 import { mergeBranchIntoCheckout, operationInProgress } from './merge.mjs';
 import { readOwnerLease, removeOwnerLease, sameOwner, writeOwnerLease } from './owner.mjs';
@@ -124,17 +125,7 @@ function sessionRootOf(record) {
 // ---------------------------------------------------------------------------
 // Host configuration (settings source, free-space probe); tests override it.
 
-/** pid probe (signal 0); EPERM means the process exists. */
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code === 'EPERM';
-  }
-}
-
-const DEFAULT_CONFIG = Object.freeze({ settings: null, freeBytes: freeBytesAt, processAlive });
+const DEFAULT_CONFIG = Object.freeze({ settings: null, freeBytes: freeBytesAt, processAlive: isPidAlive });
 let config = { ...DEFAULT_CONFIG };
 
 /**
@@ -979,6 +970,174 @@ async function snapshotHolderLive(record, live) {
   return !!lease && lease.pid !== process.pid && leaseProcessAlive(lease);
 }
 
+/** The project folder's uncommitted changes under the requested `carryChanges` mode; `ask` refuses while there are any. */
+async function judgePendingChanges(repo, projectSubdir, carryChanges) {
+  // A carry is judged by the same status read that counts the changes.
+  let pendingChanges = [];
+  if (carryChanges === 'carry') pendingChanges = await assertCarryable(repo.topLevel, projectSubdir);
+  else if (carryChanges) pendingChanges = await uncommittedChanges(repo.topLevel, projectSubdir);
+  if (pendingChanges.length && carryChanges === 'ask') {
+    throw worktreeError('WORKTREE_DIRTY_CHOICE', undefined, {
+      count: pendingChanges.length,
+      paths: pendingChanges.slice(0, DIRTY_CHOICE_PREVIEW),
+    });
+  }
+  return pendingChanges;
+}
+
+/** The commit a new worktree starts from and the branch a merge targets by default. */
+async function resolveStartPoint(repo, { baseBranch, startCommit, signal }) {
+  let baseCommit = repo.headCommit;
+  let mergeTarget = repo.currentBranch;
+  if (baseBranch) {
+    baseCommit = await branchCommit(repo.projectPath, baseBranch, { signal });
+    if (!baseCommit) {
+      throw worktreeError('WORKTREE_UNSUPPORTED_REPO', `Base branch ${baseBranch} does not exist.`, { baseBranch });
+    }
+    mergeTarget = baseBranch;
+  }
+  // A new branch at an explicit start point (`git worktree add -b <b> <path> <commit-ish>`).
+  if (startCommit) baseCommit = await resolveCommit(repo.projectPath, startCommit, signal);
+  return { baseCommit, mergeTarget };
+}
+
+/** The record a creation reserves before git is asked to add the checkout. */
+function newCreationRecord({
+  slug,
+  branch,
+  repo,
+  owner,
+  txId,
+  baseCommit,
+  mergeTarget,
+  existingBranch,
+  exactBranch,
+  tracked,
+  includePlan,
+}) {
+  return {
+    id: slug,
+    txId,
+    repoCommonDir: repo.repoCommonDir,
+    projectPath: repo.projectPath,
+    projectSubdir: projectSubdirOf(repo.topLevel, repo.projectPath),
+    path: managedWorktreePath(repo.repoCommonDir, slug),
+    branch,
+    baseCommit,
+    // An existing branch has no base it branched from: it merges where a
+    // merge first takes it (recorded then), and until that its own work is
+    // what it gained here since baseCommit.
+    mergeTarget: existingBranch ? null : mergeTarget,
+    createdAt: Date.now(),
+    ownerSessionId: owner.sessionId,
+    existingBranch,
+    exactBranch,
+    state: 'creating',
+    disposable: false,
+    warnings: [...(tracked.submodules ? ['submodules'] : []), ...includePlan.warnings],
+    resources: { worktree: null, lock: null, owner: null, includes: [] },
+    deleting: null,
+    recovery: null,
+  };
+}
+
+/**
+ * Locks the fresh checkout, binds its owner lease, moves or leaves the
+ * project folder's changes, applies the includes and links dependencies.
+ * `carry.moved` is set as soon as changes were carried, so a later failure
+ * can put them back.
+ */
+async function populateCheckout({
+  record,
+  owner,
+  repo,
+  projectSubdir,
+  signal,
+  pendingChanges,
+  carryChanges,
+  baseCommit,
+  includePlan,
+  carry,
+}) {
+  await setResource(record, 'worktree', 'created');
+  throwIfAborted(signal);
+  await setResource(record, 'lock', 'pending');
+  await runGit(repo.projectPath, ['worktree', 'lock', '--reason', `mixdog session=${owner.sessionId}`, record.path]);
+  await setResource(record, 'lock', 'created');
+  await setResource(record, 'owner', 'pending');
+  await writeOwnerLease(record, owner);
+  await setResource(record, 'owner', 'created');
+  // Carried before the include entries are copied, so an include never
+  // stands in the way of a carried file; the status is read again here,
+  // right before acting.
+  let changes = pendingChanges.length ? { mode: 'left', count: pendingChanges.length } : null;
+  if (carryChanges === 'carry') {
+    carry.moved = await carryUncommittedChanges({
+      topLevel: repo.topLevel,
+      projectSubdir,
+      worktreePath: record.path,
+      baseCommit,
+      label: record.id,
+    });
+    // The recovery ref stays until the caller has committed the move
+    // (dropCarryRecoveryRef) or put the changes back (restoreCarriedChanges).
+    changes = carry.moved.count
+      ? { mode: 'carried', count: carry.moved.count, recoveryRef: carry.moved.recoveryRef }
+      : null;
+  }
+  const applied = await applyIncludes(includePlan, record.path, (ledger) => recordInclude(record, ledger));
+  throwIfAborted(signal);
+  // After the includes: one that already brought a node_modules wins.
+  const linkedDependencies = await linkWorktreeDependencies({
+    mainDir: repo.projectPath,
+    worktreeDir: projectSubdir ? join(record.path, ...projectSubdir.split('/')) : record.path,
+    worktreeRel: projectSubdir,
+    signal,
+    record: (ledger) => recordInclude(record, ledger),
+  });
+  throwIfAborted(signal);
+  record.warnings = [...record.warnings, ...applied.warnings];
+  const made = (record.resources.includes || []).filter((item) => item.status === 'created');
+  const rels = (predicate) => made.filter(predicate).map((item) => item.rel);
+  // What creation did, for the agent's note at the first turn there (transitions.mjs).
+  const prepared = {
+    root: repo.topLevel,
+    copied: rels((item) => item.mode === 'copy'),
+    linked: rels((item) => item.mode === 'link' && !item.dependency),
+    dependencies: linkedDependencies,
+    skipped: [...includePlan.warnings, ...applied.warnings],
+  };
+  // Whichever path made it (a worktree task, a branch selection, `git
+  // worktree add`), the first turn a session runs here prepares its
+  // dependencies (claimWorktreeSetup).
+  record.setup = { pending: true, prepared };
+  record.state = 'ready';
+  await putRecord(record);
+  return { ...entryView(record), prepared, ...(changes ? { changes } : {}) };
+}
+
+/** The error a failed creation throws, after its carried changes and partial checkout are undone. */
+async function failCreation(error, { record, carried, repo, projectSubdir, needed, root }) {
+  // Carried already: the changes go back to the project folder before the
+  // worktree that holds them is rolled back (the recovery ref keeps them
+  // either way).
+  let carryRestore = null;
+  if (carried?.recoveryRef) {
+    carryRestore = await restoreFromRecoveryRef(repo.topLevel, projectSubdir, carried.recoveryRef)
+      .then(() => ({ restored: true, recoveryRef: carried.recoveryRef }))
+      .catch((restoreError) => ({
+        restored: false,
+        recoveryRef: carried.recoveryRef,
+        error: String(restoreError?.message || restoreError),
+      }));
+  }
+  const rollback = await rollbackCreation(record, error);
+  const failure = isDiskFullError(error) ? await diskFullFailure(error, { needed, root }) : error;
+  if (!rollback.complete) failure.rollback = rollback;
+  if (carryRestore) failure.carryRestore = carryRestore;
+  return failure;
+}
+
 /**
  * `carryChanges` decides the project folder's uncommitted changes (tracked
  * and untracked, ignored excluded), judged under the repository lock:
@@ -1034,29 +1193,10 @@ export async function createManagedWorktree({
     throwIfAborted(signal);
 
     const projectSubdir = projectSubdirOf(repo.topLevel, repo.projectPath);
-    // A carry is judged by the same status read that counts the changes.
-    let pendingChanges = [];
-    if (carryChanges === 'carry') pendingChanges = await assertCarryable(repo.topLevel, projectSubdir);
-    else if (carryChanges) pendingChanges = await uncommittedChanges(repo.topLevel, projectSubdir);
-    if (pendingChanges.length && carryChanges === 'ask') {
-      throw worktreeError('WORKTREE_DIRTY_CHOICE', undefined, {
-        count: pendingChanges.length,
-        paths: pendingChanges.slice(0, DIRTY_CHOICE_PREVIEW),
-      });
-    }
+    const pendingChanges = await judgePendingChanges(repo, projectSubdir, carryChanges);
 
     const settings = await currentWorktreeSettings();
-    let baseCommit = repo.headCommit;
-    let mergeTarget = repo.currentBranch;
-    if (baseBranch) {
-      baseCommit = await branchCommit(repo.projectPath, baseBranch, { signal });
-      if (!baseCommit) {
-        throw worktreeError('WORKTREE_UNSUPPORTED_REPO', `Base branch ${baseBranch} does not exist.`, { baseBranch });
-      }
-      mergeTarget = baseBranch;
-    }
-    // A new branch at an explicit start point (`git worktree add -b <b> <path> <commit-ish>`).
-    if (startCommit) baseCommit = await resolveCommit(repo.projectPath, startCommit, signal);
+    const { baseCommit, mergeTarget } = await resolveStartPoint(repo, { baseBranch, startCommit, signal });
 
     // The main checkout's local env files come along on their own;
     // `.worktreeinclude` applies on top.
@@ -1099,7 +1239,7 @@ export async function createManagedWorktree({
         }
       );
     let record = await reserve();
-    let carried = null;
+    const carry = { moved: null };
 
     try {
       await mkdir(root, { recursive: true });
@@ -1120,84 +1260,20 @@ export async function createManagedWorktree({
         await setResource(record, 'worktree', 'pending');
         await addCheckout(record);
       }
-      await setResource(record, 'worktree', 'created');
-      throwIfAborted(signal);
-      await setResource(record, 'lock', 'pending');
-      await runGit(repo.projectPath, [
-        'worktree',
-        'lock',
-        '--reason',
-        `mixdog session=${owner.sessionId}`,
-        record.path,
-      ]);
-      await setResource(record, 'lock', 'created');
-      await setResource(record, 'owner', 'pending');
-      await writeOwnerLease(record, owner);
-      await setResource(record, 'owner', 'created');
-      // Carried before the include entries are copied, so an include never
-      // stands in the way of a carried file; the status is read again here,
-      // right before acting.
-      let changes = pendingChanges.length ? { mode: 'left', count: pendingChanges.length } : null;
-      if (carryChanges === 'carry') {
-        carried = await carryUncommittedChanges({
-          topLevel: repo.topLevel,
-          projectSubdir,
-          worktreePath: record.path,
-          baseCommit,
-          label: record.id,
-        });
-        // The recovery ref stays until the caller has committed the move
-        // (dropCarryRecoveryRef) or put the changes back (restoreCarriedChanges).
-        changes = carried.count ? { mode: 'carried', count: carried.count, recoveryRef: carried.recoveryRef } : null;
-      }
-      const applied = await applyIncludes(includePlan, record.path, (ledger) => recordInclude(record, ledger));
-      throwIfAborted(signal);
-      // After the includes: one that already brought a node_modules wins.
-      const linkedDependencies = await linkWorktreeDependencies({
-        mainDir: repo.projectPath,
-        worktreeDir: projectSubdir ? join(record.path, ...projectSubdir.split('/')) : record.path,
-        worktreeRel: projectSubdir,
+      return await populateCheckout({
+        record,
+        owner,
+        repo,
+        projectSubdir,
         signal,
-        record: (ledger) => recordInclude(record, ledger),
+        pendingChanges,
+        carryChanges,
+        baseCommit,
+        includePlan,
+        carry,
       });
-      throwIfAborted(signal);
-      record.warnings = [...record.warnings, ...applied.warnings];
-      const made = (record.resources.includes || []).filter((item) => item.status === 'created');
-      const rels = (predicate) => made.filter(predicate).map((item) => item.rel);
-      // What creation did, for the agent's note at the first turn there (transitions.mjs).
-      const prepared = {
-        root: repo.topLevel,
-        copied: rels((item) => item.mode === 'copy'),
-        linked: rels((item) => item.mode === 'link' && !item.dependency),
-        dependencies: linkedDependencies,
-        skipped: [...includePlan.warnings, ...applied.warnings],
-      };
-      // Whichever path made it (a worktree task, a branch selection, `git
-      // worktree add`), the first turn a session runs here prepares its
-      // dependencies (claimWorktreeSetup).
-      record.setup = { pending: true, prepared };
-      record.state = 'ready';
-      await putRecord(record);
-      return { ...entryView(record), prepared, ...(changes ? { changes } : {}) };
     } catch (error) {
-      // Carried already: the changes go back to the project folder before the
-      // worktree that holds them is rolled back (the recovery ref keeps them
-      // either way).
-      let carryRestore = null;
-      if (carried?.recoveryRef) {
-        carryRestore = await restoreFromRecoveryRef(repo.topLevel, projectSubdir, carried.recoveryRef)
-          .then(() => ({ restored: true, recoveryRef: carried.recoveryRef }))
-          .catch((restoreError) => ({
-            restored: false,
-            recoveryRef: carried.recoveryRef,
-            error: String(restoreError?.message || restoreError),
-          }));
-      }
-      const rollback = await rollbackCreation(record, error);
-      const failure = isDiskFullError(error) ? await diskFullFailure(error, { needed, root }) : error;
-      if (!rollback.complete) failure.rollback = rollback;
-      if (carryRestore) failure.carryRestore = carryRestore;
-      throw failure;
+      throw await failCreation(error, { record, carried: carry.moved, repo, projectSubdir, needed, root });
     }
 
     async function reserveName() {
@@ -1213,30 +1289,19 @@ export async function createManagedWorktree({
       if (!(await validBranchName(repo.projectPath, branch))) {
         throw worktreeError('WORKTREE_UNSUPPORTED_REPO', `Branch name ${branch} is not valid.`, { branch });
       }
-      const candidate = {
-        id: slug,
-        txId,
-        repoCommonDir: repo.repoCommonDir,
-        projectPath: repo.projectPath,
-        projectSubdir: projectSubdirOf(repo.topLevel, repo.projectPath),
-        path: managedWorktreePath(repo.repoCommonDir, slug),
+      const candidate = newCreationRecord({
+        slug,
         branch,
+        repo,
+        owner,
+        txId,
         baseCommit,
-        // An existing branch has no base it branched from: it merges where a
-        // merge first takes it (recorded then), and until that its own work is
-        // what it gained here since baseCommit.
-        mergeTarget: existingBranch ? null : mergeTarget,
-        createdAt: Date.now(),
-        ownerSessionId: owner.sessionId,
+        mergeTarget,
         existingBranch,
         exactBranch: requestedBranch !== null,
-        state: 'creating',
-        disposable: false,
-        warnings: [...(tracked.submodules ? ['submodules'] : []), ...includePlan.warnings],
-        resources: { worktree: null, lock: null, owner: null, includes: [] },
-        deleting: null,
-        recovery: null,
-      };
+        tracked,
+        includePlan,
+      });
       return (await insertRecord(candidate)) ? candidate : null;
     }
   });
@@ -1362,9 +1427,12 @@ export async function createSnapshotWorktree({
  * one is admitted there until the returned release. A folder no longer a
  * checkout admits no consumer (activity-gate tracks git checkouts only).
  */
-function holdSnapshotFolder(record) {
+async function holdSnapshotFolder(record) {
   if (!existsSync(join(record.path, '.git'))) return () => {};
-  return holdWorkspaceActivity([record.path]);
+  const release = await holdWorkspaceActivityAsync([record.path]);
+  // Settles once the removal was attempted. It fails only when workspace
+  // admission stopped (reported there), which keeps the folder held.
+  return () => release().catch(() => {});
 }
 
 /** A refusal that only says "something still runs there" (retry once it ends). */
@@ -1871,11 +1939,11 @@ async function removeLocked(current, { force, sessionId, preserveBranch = false,
   }
   // Every deletion attempt of a snapshot, a resumed one included, waits
   // for (refuses on) its consumers.
-  const release = current.kind === WORKTREE_SNAPSHOT_KIND ? holdSnapshotFolder(current) : () => {};
+  const release = current.kind === WORKTREE_SNAPSHOT_KIND ? await holdSnapshotFolder(current) : () => {};
   try {
     return await decideAndFinishDeletion(current, { force, preserveBranch, safeOnly });
   } finally {
-    release();
+    await release();
   }
 }
 
@@ -2044,7 +2112,7 @@ export async function reconcileManagedWorktrees({
               // surviving folder since still keeps it.
               let release;
               try {
-                release = holdSnapshotFolder(record);
+                release = await holdSnapshotFolder(record);
               } catch (error) {
                 if (!snapshotInUse(error)) throw error;
                 report.kept.push({ id: record.id, reason: 'snapshot-in-use' });
@@ -2053,7 +2121,7 @@ export async function reconcileManagedWorktrees({
               try {
                 reportDeletion(record, await finishDeletion(record));
               } finally {
-                release();
+                await release();
               }
               continue;
             }
@@ -2069,7 +2137,7 @@ export async function reconcileManagedWorktrees({
               let release = null;
               if (!(await snapshotHolderLive(record, live))) {
                 try {
-                  release = holdSnapshotFolder(record);
+                  release = await holdSnapshotFolder(record);
                 } catch (error) {
                   if (!snapshotInUse(error)) throw error;
                 }
@@ -2085,7 +2153,7 @@ export async function reconcileManagedWorktrees({
                 await putRecord(record);
                 reportDeletion(record, await finishDeletion(record));
               } finally {
-                release();
+                await release();
               }
               continue;
             }

package/src/runtime/tidy/install.mjs

@@ -4,12 +4,22 @@
 // Policy gating happens BEFORE any network call: 'never' refuses, 'ask' returns
 // needsApproval unless the call carried approveDownloads:true, 'auto' proceeds.
 // Toolchain engines (rustfmt, gofmt, zig fmt, ...) are never downloadable.
-import { chmodSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from 'node:fs';
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 import { MAX_NATIVE_BINARY_DOWNLOAD_BYTES, streamResponseToFile } from '../shared/bounded-download.mjs';
-import { platformEntryKey, platformKey, sha256File } from '../shared/native-asset.mjs';
-import { fileHasData } from '../shared/file-has-data.mjs';
+import { platformEntryKey, platformKey, sha256File, validSha256 } from '../shared/native-asset.mjs';
+import { fileHasDataAsync } from '../shared/file-has-data.mjs';
 import { readJsonSafe } from '../shared/json-file.mjs';
 import { ENGINE_CATALOG } from './engines.mjs';
 import { extractArchive } from './extract.mjs';
@@ -45,14 +55,73 @@ export function manifestAsset(manifest, id, pkey = platformEntryKey(manifest?.en
   return { entry, asset, version: String(entry.version || '0'), pkey: entry?.assets?.[pkey] ? pkey : 'any' };
 }
 
-/** An already-installed managed binary for `id`, or null. Sync, no network. */
-export function managedEngineBinary({ id, manifest, pluginData }) {
+// The installer records the extracted binary's sha256 beside it; a reuse
+// re-hashes the binary against that record. Like the other managed binaries
+// (mixdog-spawn / patch / graph resolve their path once per process), the hash
+// runs once per process per binary, again only when its size or mtime changes.
+// An install from before the record existed has no digest file: its first use
+// records the digest (trust on first use). An existing record that is invalid
+// or does not match is never overwritten; that binary is tampered or corrupt.
+export const ENGINE_DIGEST_FILE = '.engine.sha256';
+const verifiedEngineBins = new Map();
+
+function recordEngineDigest(digestFile, digest) {
+  const tmp = `${digestFile}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(tmp, digest);
+    renameSync(tmp, digestFile);
+  } catch {
+    /* unrecorded: this install is trusted for this process only */
+  } finally {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+      /* a leftover temp file never matches the digest path */
+    }
+  }
+}
+
+// The recorded digest decides whether a binary is intact. Only an install from
+// before the record existed has none; there alone the content probe keeps a
+// crash-torn (empty or NUL-filled) binary from becoming the digest it is
+// trusted by. A binary that cannot be statted, read or hashed cannot be
+// verified, so it is not reused.
+async function engineBinaryIntact(dir, full) {
+  try {
+    const stamp = statSync(full);
+    const key = `${stamp.size}:${stamp.mtimeMs}`;
+    if (verifiedEngineBins.get(full) === key) return true;
+    const digestFile = join(dir, ENGINE_DIGEST_FILE);
+    let recorded = null;
+    try {
+      recorded = readFileSync(digestFile, 'utf8').trim().toLowerCase();
+    } catch (error) {
+      if (error?.code !== 'ENOENT') return false;
+    }
+    if (recorded === null && !(await fileHasDataAsync(full))) return false;
+    const actual = await sha256File(full);
+    if (recorded === null) {
+      recordEngineDigest(digestFile, actual);
+      recorded = actual;
+    }
+    if (!validSha256(recorded) || actual !== recorded) return false;
+    verifiedEngineBins.set(full, key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** An already-installed managed binary for `id`, or null. No network; the
+ *  binary probe is async so a slow (scanned) open never stalls the event loop. */
+export async function managedEngineBinary({ id, manifest, pluginData }) {
   const found = manifestAsset(manifest, id);
   if (!found || !pluginData) return null;
   const binPath = String(found.asset.binPath || '');
   if (!binPath) return null;
-  const full = join(managedEngineDir(pluginData, id, found.version), binPath);
-  return fileHasData(full) ? { path: full, version: found.version } : null;
+  const dir = managedEngineDir(pluginData, id, found.version);
+  const full = join(dir, binPath);
+  return (await engineBinaryIntact(dir, full)) ? { path: full, version: found.version } : null;
 }
 
 /** Throws unless `filePath` hashes to `expected`. */
@@ -72,7 +141,13 @@ export async function verifyDownloadDigest(filePath, expected, label = LABEL) {
  * Decide what an install call may do, without touching the network.
  * Returns { targets, present, needsApproval, errors }.
  */
-export function planInstall({ ids = [], manifest, pluginData = '', policy = 'auto', approveDownloads = false } = {}) {
+export async function planInstall({
+  ids = [],
+  manifest,
+  pluginData = '',
+  policy = 'auto',
+  approveDownloads = false,
+} = {}) {
   const targets = [];
   const present = [];
   const errors = [];
@@ -101,7 +176,7 @@ export function planInstall({ ids = [], manifest, pluginData = '', policy = 'aut
       });
       continue;
     }
-    const installed = managedEngineBinary({ id, manifest, pluginData });
+    const installed = await managedEngineBinary({ id, manifest, pluginData });
     if (installed) {
       present.push({ id, version: installed.version, path: installed.path });
       continue;
@@ -242,8 +317,9 @@ export async function installEngine(
   const engineRoot = join(managedToolsDir(pluginData), target.id);
   const finalDir = managedEngineDir(pluginData, target.id, target.version);
   const binFull = join(finalDir, target.binPath);
-  // An engine binary a crash left NUL-filled is not present: it is installed again.
-  if (fileHasData(binFull)) {
+  // An engine binary a crash left NUL-filled, or that no longer matches its
+  // recorded digest, is not present: it is installed again.
+  if (await engineBinaryIntact(finalDir, binFull)) {
     return { id: target.id, version: target.version, path: binFull, bytes: 0, status: 'present' };
   }
   mkdirSync(engineRoot, { recursive: true });
@@ -272,12 +348,16 @@ export async function installEngine(
         /* best-effort */
       }
     }
+    writeFileSync(join(stageDir, ENGINE_DIGEST_FILE), await sha256File(stagedBin));
     try {
-      if (existsSync(finalDir) && !fileHasData(binFull)) rmSync(finalDir, { recursive: true, force: true });
+      if (existsSync(finalDir) && !(await engineBinaryIntact(finalDir, binFull))) {
+        verifiedEngineBins.delete(binFull);
+        rmSync(finalDir, { recursive: true, force: true });
+      }
       renameSync(stageDir, finalDir);
     } catch (error) {
-      // A concurrent install won the race; its verified copy is equivalent.
-      if (!existsSync(binFull)) throw error;
+      // A concurrent install won the race only if the surviving copy verifies.
+      if (!(await engineBinaryIntact(finalDir, binFull))) throw error;
     }
     return { id: target.id, version: target.version, path: binFull, bytes, status: 'installed' };
   } finally {
@@ -305,7 +385,7 @@ export async function installEngines({
   stallTimeoutMs = undefined,
 } = {}) {
   const loaded = manifest || readEnginesManifest();
-  const plan = planInstall({ ids, manifest: loaded, pluginData, policy, approveDownloads });
+  const plan = await planInstall({ ids, manifest: loaded, pluginData, policy, approveDownloads });
   const installed = [...plan.present];
   const errors = [...plan.errors];
   if (!pluginData && plan.targets.length > 0) {

package/src/runtime/tidy/languages.mjs

@@ -6,6 +6,7 @@
 // on the id. AUX_LANGUAGE_EXTENSIONS adds the config/markup languages the graph
 // never parses but formatters do (PowerShell, JSON, TOML, ...).
 import { extname } from 'node:path';
+import { startGit } from '../shared/git-launch.mjs';
 import { runProcess } from './process.mjs';
 
 export const CODE_LANGUAGE_EXTENSIONS = Object.freeze({
@@ -156,21 +157,22 @@ export function parseGraphLangs(stdout) {
 
 /** git-tracked files under `cwd`, filtered to the requested scope paths. */
 async function listScopedFiles({ cwd, paths = [], signal = null, timeoutMs = 20_000 } = {}) {
-  const result = await runProcess(
-    'git',
-    [
-      '-c',
-      'core.quotepath=false',
-      '--literal-pathspecs',
-      'ls-files',
-      '--cached',
-      '--others',
-      '--exclude-standard',
-      '-z',
-      '--',
-      ...paths,
-    ],
-    { cwd, signal, timeoutMs }
+  const args = [
+    '-c',
+    'core.quotepath=false',
+    '--literal-pathspecs',
+    'ls-files',
+    '--cached',
+    '--others',
+    '--exclude-standard',
+    '-z',
+    '--',
+    ...paths,
+  ];
+  const result = await startGit(
+    process.env,
+    (command, env) => runProcess(command, args, { cwd, signal, timeoutMs, env }),
+    (outcome) => ({ code: outcome.errorCode })
   );
   if (result.code !== 0) {
     return {