devlyn-cli 4.3.31 → 4.3.33

package/README.md

@@ -72,7 +72,9 @@ A bare intent is planned and, when your request authorizes the work, added and d
 
 Direct work edits your current checkout; run parallel sessions in separate worktrees (for example `claude -w`). Completed, verified direct requests with changes, and
 every drained task, are delivered by project policy from their own linked worktrees. A commit request stays local and a PR request stops at the PR; otherwise accepted tasks default to
-scoped commit → push → PR → merge when the repository allows it (otherwise the PR waits for a person). After the
+scoped commit → push → PR → merge when the repository allows it (otherwise the PR waits for a person; while required
+checks or reviews have not passed it stays pending, and running the printed resume after they pass merges it, or a person
+merges it; with GitHub's Allow auto-merge on, delivery requests the merge, so it lands by itself). After the
 PR merges, the worktree and branch its session released are cleaned; anything in use is
 kept. Set `git config --local devlyn.completionMode pr` to stop at the PR; `task-complete.py complete --mode auto|pr`
 overrides one task. Local-only/no-push instructions take precedence: nothing is pushed or merged;
@@ -253,7 +255,7 @@ On native Windows, use native Node/npm and Python plus Git for Windows Bash for
 
 Drain worktrees default to `<repo parent>/.devlyn-worktrees/<repo name>/<loop-id>/<task-id>`. On Windows, a newly created shared container is marked hidden, and each worktree disables content indexing for new children; names stay indexed and Microsoft Defender scanning is unaffected. For Defender performance, use a Dev Drive via `--worktree-root` or an administrator's exclusion for the root; see [loop options](config/skills/devlyn-ideate/references/loop.md).
 
-Windows completion preserves the workspace, owned refs and recovery receipt when writer cessation cannot be proved, even after merge; resume guidance and delivery status remain separate from product verification. The portability workflow checks out the repository on native Windows and tests the POSIX-packed npm artifact there. A POSIX pass alone does not establish Windows support: acceptance requires the passing Windows job for the exact source SHA/artifact hashes.
+Windows completion keeps a merged task's workspace, with its owned refs and recovery receipt, while a program has a file open in it or runs in it, and removes it once that program lets go; a workspace a program only watches may be removed. A managed workspace is kept the same way and removed by hand as the reason says; scratch that holds files is kept too. Resume guidance and delivery status remain separate from product verification. The portability workflow checks out the repository on native Windows and tests the POSIX-packed npm artifact there. A POSIX pass alone does not establish Windows support: acceptance requires the passing Windows job for the exact source SHA/artifact hashes.
 
 ## Contributing
 

package/bin/devlyn.js

@@ -616,23 +616,46 @@ function installLocalSkill(skillName, roots, installedSkills = new Map()) {
   return true;
 }
 
-// One skill from `source` into one skill-loader directory. The copy is staged and checked first, so
-// a failed copy leaves any older copy of it in place for a plain rerun. A copy under its name
+// One skill from `source` into one skill-loader directory. The copy is staged and checked first, and
+// the older copy is moved aside into the stage before the new one is renamed in, and back if that
+// fails, so a failed copy or swap leaves the older copy in place for a plain rerun. If moving it back
+// or removing it after the swap fails, the error names where it is kept. A copy under its name
 // before the 4.0.0 rename goes only once the new one is complete.
 function installSkillInto(source, target, skillName, installedSkills) {
   const dest = path.join(target, skillName);
   const stage = fs.mkdtempSync(path.join(target, '.devlyn-skill-'));
   const stagedSkill = path.join(stage, skillName);
+  const previous = path.join(stage, 'previous');
+  let files;
+  let moved = false;
   try {
-    const files = copyRecursive(path.join(source, skillName), stagedSkill, stage);
+    files = copyRecursive(path.join(source, skillName), stagedSkill, stage);
     assertCompleteSkillInstall(source, stage, [skillName]);
-    fs.rmSync(dest, { recursive: true, force: true });
+    if (fs.lstatSync(dest, { throwIfNoEntry: false })) {
+      fs.renameSync(dest, previous);
+      moved = true;
+    }
     fs.renameSync(stagedSkill, dest);
-    installedSkills.set(dest, files.map((file) => path.join(dest, path.relative(stagedSkill, file))));
-  } finally {
+  } catch (error) {
+    if (moved) {
+      try { fs.renameSync(previous, dest); }
+      catch (rollback) {
+        throw new AggregateError([error, rollback], `${error.message}; ${rollback.message}; the previous copy is kept at ${previous}`);
+      }
+    }
+    try { fs.rmSync(stage, { recursive: true, force: true }); }
+    catch (cleanup) {
+      throw new AggregateError([error, cleanup], `${error.message}; ${dest} is as it was, but ${stage} could not be removed: ${cleanup.message}`);
+    }
+    throw new Error(`${error.message}; ${dest} is as it was`, { cause: error });
+  }
+  installedSkills.set(dest, files.map((file) => path.join(dest, path.relative(stagedSkill, file))));
+  try {
     fs.rmSync(stage, { recursive: true, force: true });
+  } catch (error) {
+    const kept = fs.lstatSync(previous, { throwIfNoEntry: false }) ? `its previous copy at ${previous}` : stage;
+    throw new Error(`${dest} is installed, but ${kept} could not be removed: ${error.message}`);
   }
-
 }
 
 // A 0.6.0-0.7.1 copy is one SKILL.md, the file that identifies it. A failed swap leaves
@@ -1440,19 +1463,78 @@ function cleanupRealParents(base, file) {
   return true;
 }
 
-let cleanupProcesses;
-// Whether a running process names `dir` on its command line (a drain started from a global copy runs
-// its queue.py and acceptance.py by absolute path). Read once per command; unreadable means unknown.
-function cleanupInUse(dir) {
-  if (cleanupProcesses === undefined) {
-    const listing = process.platform === 'win32'
-      ? spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command',
-        'Get-CimInstance Win32_Process | ForEach-Object { $_.CommandLine }'], { encoding: 'utf8', timeout: 20000 })
-      : spawnSync('ps', ['-axww', '-o', 'command='], { encoding: 'utf8', timeout: 20000 });
-    cleanupProcesses = listing.status === 0 ? listing.stdout.split(/\r?\n/).filter((line) => line && !line.includes(' cleanup --')) : null;
+// The process list that decides whether a copy is in use (a drain started from a copy runs its queue.py and
+// acceptance.py by absolute path). A path is compared only with text the lister itself printed for that very
+// path, in a list whose rows are all rendered the same way. A list that cannot be read clears nothing.
+// POSIX: under the C locale `ps` renders each byte by itself, alike in every row, and the shell it runs from
+// holds each path between random tokens in its own row, the witness. Each shell's arguments fit one page,
+// which every kernel accepts and prints whole.
+const CLEANUP_LIST_BYTES = 4096;
+// Windows: each command line travels as its UTF-16 code units in decimal, which no code page changes, and this
+// marker in PowerShell's own command line must come back intact.
+const CLEANUP_LIST_MARKER = '✓한';
+const CLEANUP_LIST_COMMAND = `Get-CimInstance Win32_Process | ForEach-Object { ([int[]][char[]]"$($_.CommandLine)") -join ',' } # ${CLEANUP_LIST_MARKER}`;
+
+// A Windows list, one command line per row; null when a row is malformed or the marker did not come back in
+// PowerShell's own row beside the command text before it (Node writes each `"` of the command there as `\"`).
+function cleanupWindowsRows(text) {
+  const rows = [];
+  for (const line of text.split(/\r?\n/)) {
+    const units = line ? line.split(',') : [];
+    if (!units.every((unit) => /^\d{1,5}$/.test(unit) && Number(unit) <= 0xffff)) return null;
+    rows.push(String.fromCharCode(...units.map(Number)));
+  }
+  const own = CLEANUP_LIST_COMMAND.slice(CLEANUP_LIST_COMMAND.lastIndexOf('"') + 1);
+  return rows.some((row) => row.includes(own)) ? rows : null;
+}
+
+// A drain started from Git Bash may name a copy C:/… or /c/…: compared lower-cased, with slashes.
+function cleanupWindowsNames(row, dir) {
+  const text = row.toLowerCase().replaceAll('\\', '/');
+  const name = `${dir}\\`.toLowerCase().replaceAll('\\', '/');
+  return text.includes(name) || (/^[a-z]:\//.test(name) && text.includes(`/${name[0]}${name.slice(2)}`));
+}
+
+// Which of `dirs` a running process names on its command line.
+function cleanupInUse(dirs) {
+  const options = { timeout: 20000, maxBuffer: 64 * 1024 * 1024 };
+  const others = (rows) => rows.filter((row) => !row.includes(' cleanup --'));
+  if (process.platform === 'win32') {
+    const listing = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', CLEANUP_LIST_COMMAND], options);
+    const rows = !listing.error && listing.status === 0 ? cleanupWindowsRows(listing.stdout.toString('latin1')) : null;
+    return new Set(dirs.filter((dir) => !rows || others(rows).some((row) => cleanupWindowsNames(row, dir))));
+  }
+  const script = 'ps -axww -o command=; exit $?';
+  // The shell's arguments with 16-letter tokens around the paths, each argument with its NUL.
+  const size = (batch) => Buffer.byteLength(['sh', '-c', script, ...batch].join('\0')) + 1 + 17 * (batch.length + 1);
+  const used = new Set();
+  const batches = [];
+  for (const name of new Set(dirs.map((dir) => dir + path.sep))) {
+    if (batches.length && size([...batches.at(-1), name]) <= CLEANUP_LIST_BYTES) batches.at(-1).push(name);
+    else if (size([name]) <= CLEANUP_LIST_BYTES) batches.push([name]);
+    else used.add(name);
+  }
+  for (const batch of batches) {
+    let tokens;
+    do {
+      tokens = [...batch, ''].map(() => crypto.randomBytes(8).toString('hex'));
+    } while (new Set(tokens).size < tokens.length || tokens.some((token) => batch.some((name) => name.includes(token))));
+    const listing = spawnSync('sh', ['-c', script, ...batch.flatMap((name, i) => [tokens[i], name]), tokens.at(-1)],
+      { ...options, env: { ...process.env, LC_ALL: 'C' } });
+    const rows = !listing.error && listing.status === 0 ? listing.stdout.toString('latin1').split('\n') : [];
+    // The witness holds every token once, in order; `ps` joins arguments with one space, dropped on each side.
+    const marks = (row) => tokens.map((token) => (row.split(token).length === 2 ? row.indexOf(token) : -1));
+    const witnesses = rows.filter((row) => marks(row).every((mark, i, all) => mark >= 0 && (i === 0 || all[i - 1] < mark)));
+    const [witness] = witnesses, at = witnesses.length === 1 && marks(witness);
+    const between = at ? batch.map((_, i) => witness.slice(at[i] + tokens[i].length, at[i + 1])) : [];
+    const framed = between.length && between.every((text) => text.length > 2 && text.startsWith(' ') && text.endsWith(' '));
+    // The witness alone is no user: any other row naming a path is one, another cleanup's lister shell included.
+    const listed = others(rows.filter((row) => row !== witness));
+    batch.forEach((name, i) => {
+      if (!framed || listed.some((row) => row.includes(between[i].slice(1, -1)))) used.add(name);
+    });
   }
-  // A list that cannot be read cannot clear anything: the roots stay until it can.
-  return cleanupProcesses === null || cleanupProcesses.some((line) => line.includes(dir + path.sep));
+  return new Set(dirs.filter((dir) => used.has(dir + path.sep)));
 }
 
 // Markers are generated, not bundled: require the exact writer format, a shipped version and
@@ -1478,7 +1560,7 @@ function cleanupMarkerOwned(file, current) {
 function cleanupSkillRoots(roots, current, callerBase = null) {
   const resolved = new Map();
   const linked = new Set();
-  const active = new Set();
+  const spellings = [];
   for (const [base, root] of roots) {
     let target = root;
     const stat = fs.lstatSync(root, { throwIfNoEntry: false });
@@ -1498,8 +1580,11 @@ function cleanupSkillRoots(roots, current, callerBase = null) {
     } else if (parents && stat?.isDirectory()) target = fs.realpathSync.native(root);
     if (!resolved.has(target)) resolved.set(target, base);
     const callerPath = (file) => callerBase ? path.join(callerBase, path.relative(base, file)) : file;
-    if (cleanupInUse(callerPath(root)) || cleanupInUse(callerPath(target))) active.add(target);
+    spellings.push([target, callerPath(root), callerPath(target)]);
   }
+  // Every path is known before the list is taken: the lister prints each of them beside the rows it is sought in.
+  const used = cleanupInUse(spellings.flatMap(([, ...names]) => names));
+  const active = new Set(spellings.filter(([, ...names]) => names.some((name) => used.has(name))).map(([target]) => target));
   return [...resolved].flatMap(([root, base]) => {
     const items = cleanupSkillRoot(base, root, current);
     const callerRoot = callerBase ? path.join(callerBase, path.relative(base, root)) : root;
@@ -2256,7 +2341,9 @@ function cleanupDeliver(scope, items, current) {
   if (!prepared.acceptance) return cleanupUpdateCheckout(scope);
   const completed = lastJson(run(['complete', '--receipt', allocated.receipt, '--acceptance', prepared.acceptance, '--writers-stopped'], scope.root).stdout);
   const status = completed?.delivery_status || completed?.status;
-  if (status === 'COMPLETE' || status === 'MERGED') return { ...cleanupUpdateCheckout(scope), delivery: { state: 'merged', url: completed.pr || null } };
+  // A merge whose workspace or scratch the helper retained (CLEANUP_PENDING) is not a clean merge: report its resume.
+  if (status === 'COMPLETE' || status === 'MERGED') return { ...cleanupUpdateCheckout(scope), delivery: completed.status === 'CLEANUP_PENDING'
+    ? { state: 'cleanup-pending', url: completed.pr || null, resume: completed.resume } : { state: 'merged', url: completed.pr || null } };
   if (completed?.pr) return { delivery: { state: 'pr-open', url: completed.pr } };
   const reason = completed?.reason || 'delivery did not complete';
   return { error: cleanupReason(failureCode(reason), { detail: reason, ...(completed?.resume ? { resume: completed.resume } : {}) }) };

package/bin/harness-activation.js

@@ -380,7 +380,10 @@ function inspectSkills(context, release, env, config, active) {
     for (const name of SKILLS) {
       const dir = path.join(root, name);
       try {
-        if (!fs.lstatSync(dir, { throwIfNoEntry: false })) continue;
+        // A lookup through a file finds no entry: POSIX says ENOTDIR where Windows says "not found".
+        let entry;
+        try { entry = fs.lstatSync(dir, { throwIfNoEntry: false }); } catch (error) { if (error.code !== 'ENOTDIR') throw error; }
+        if (!entry) continue;
         const hash = fingerprint(dir);
         if (!hashes.has(name)) hashes.set(name, fingerprint(path.join(release.root, 'config/skills', name)));
         found.push({ name, path: path.join(dir, 'SKILL.md'), owned: hash === hashes.get(name) || (history.skills[name] || []).includes(hash) });

package/bin/harness-status.js

@@ -70,16 +70,23 @@ function requirements() {
   const probes = [
     ['python', true, 'python3', ['-B', '--version']],
     ['git', true, 'git', ['--version']],
-    ['git-bash', process.platform === 'win32', 'bash', ['--version']],
-    ['gh', false, 'gh', ['--version']],
+    // Git Bash is a bash whose builtin `pwd -W` (an MSYS2 patch) prints a Windows path; its version label no longer
+    // tells it from Cygwin's. -p reads no BASH_ENV or ENV file; --norc no ~/.bashrc, which a bash at shell level 1
+    // otherwise reads when SSH_CLIENT is set or stdin is a socket (Node's pipes are). Long options come first. macOS
+    // and Linux bashes refuse -W, so there this row (never required) is unavailable.
+    ['git-bash', process.platform === 'win32', 'bash', ['--norc', '-p', '-c', 'echo "$BASH_VERSION"; cd / && pwd -W']],
+    // gh 2.91 and later writes a telemetry device id into its state folder on every command unless this is off.
+    ['gh', false, 'gh', ['--version'], { GH_TELEMETRY: 'false' }],
   ];
-  return [node, ...probes.map(([name, required, binary, argv]) => {
-    const result = spawnSync(binary, argv, { encoding: 'utf8', timeout: 5000, env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' } });
+  return [node, ...probes.map(([name, required, binary, argv, env]) => {
+    const result = spawnSync(binary, argv, { encoding: 'utf8', timeout: 5000, env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1', ...env } });
     const output = (result.stdout || result.stderr || '').trim();
-    const match = output.match(/\b(\d+)\.(\d+)(?:\.\d+)?/);
-    let available = !result.error && result.status === 0 && Boolean(match);
+    const bash = name === 'git-bash';
+    // A bash's version is its $BASH_VERSION line, never digits in the path line after it.
+    const match = output.match(bash ? /^\d+\.\d+\.\d+(?=(?:\(\d+\)-\w+)?\r?$)/m : /\b(\d+)\.(\d+)(?:\.\d+)?/);
+    let available = !result.error && result.status === 0
+      && (bash ? /^(?:[A-Za-z]:\/|\/\/)/.test(output.split('\n').pop()) : Boolean(match));
     if (name === 'python' && available) available = Number(match[1]) > 3 || (Number(match[1]) === 3 && Number(match[2]) >= 11);
-    if (name === 'git-bash' && required && available) available = /mingw|msys/i.test(output);
     return { name, required, available, version: match?.[0] || null,
       reasons: available ? [] : [{ code: 'requirement-unavailable', params: { name } }] };
   })];
@@ -168,4 +175,4 @@ function statusCommand(args) {
   return status;
 }
 
-module.exports = { harnessStatus, statusCommand, repositoryIdentity, inspectInstruction };
+module.exports = { harnessStatus, statusCommand, repositoryIdentity, inspectInstruction, requirements };

package/bin/skill-history.json

@@ -57,6 +57,7 @@
       "406b982f6ca0b9f5c0faa6cb50749b52aaf23545e06174ec39f831929dc929bd",
       "40f50f3c3c0d030d1efeb6955c0c6f32f518e737d8dd3bec6610ff02badebbdb",
       "430d156eb8c62c7edba3d660050f90b267f928976c3a3688e95d54f00dc34747",
+      "446e47fc34c81ed4cb9f4332d446a93025ae3dc1791155a4b80d6f195255958e",
       "450d578ef177a9e8f0b693940ad64b41c1d9719975ba6305f62a7c82ac3a892f",
       "45ef27af9ec27089e2861c13b882521fc6bf073dc6b7a356b326b4a27c5e6e24",
       "4685be6a94ad5587ce53785c14a60cccf9a852d9d23391dba0a5bcd0c64931cf",
@@ -120,6 +121,7 @@
       "8c80926ab03b2477e52264495b35c2116f65fc51b02e8c56e441b5705872392a",
       "8fb73c0d2472b3643ac6e3f0ad87d818694afebaf68fcad596496e703893c43d",
       "9162fc2fed6f4a611d299485be3a397080beb3304865ce59b95576ba7d00650e",
+      "92ffe78e156d8f11f666a92b26d21ae52e147ed9cad7eb79efbef334a9373281",
       "94a14a1b87df1d7297d12949a24e47a0d6c16a8fe30495ee759fcabb2e1aa398",
       "978e4210e49b42827c98cf6e40c868c87dc6e3533a2b779ca2fa05abfc16ad0f",
       "97e7ad89c74c609b15dfbf6f9f7ac61df8b50e97e4bc318f72922e058ecffba4",
@@ -130,6 +132,7 @@
       "9e4d06fd466fa896040109bac0018fcfb2f1604d55abb4180ff1f1a0b665bbc8",
       "9f14ca629e41730b1a9fb5d0ad1a39cff558fe34758d6ceccbb9de498f9f384e",
       "a11950a5880346f03257c688fd8bc6f8c29fc0b7c05c90e8f5211d5fb7665774",
+      "a1d5a9505c527af88bcac9305ec8bce0ee01d472ec383e7ffacbcccf9137565b",
       "a405a99b988f6edd2eabb0504b36309bb4cf0c3b97eab26bb7ef257e4515dbf3",
       "a463693773934b6de78f5326fb17acac34e8159f459b89c21aa66f3ac0874a57",
       "a66080b0ff25f35e8574a24ee01d87de9f579a59796977f3cc59f1865063f6f6",
@@ -197,6 +200,7 @@
       "f2bcfa0471aba81a10e3d0e6fd43bd6ec670601a4ba3a7d719e595edf9ab032a",
       "f958bfabd2e056fea911526fba2196d2ed5a48828f576e5ce1657100b466db20",
       "f9617e1034543f31ae2a3820301fbac6e4674e5d6fbc0d4b76751fe87b8e013e",
+      "fbca65e47854425acd80087e89024fb9d2f44f853d88abe582fbee107a3e8de3",
       "fd68c7a74272929a14e685e447a51058ffcdd4c1d6bef83cbba18045c07aee55",
       "fdb608b34a8600b4ce209d7f645ec5ad4475948be6ad95c941cc7ef02b5959df",
       "fe357defe8ac6efd6bbd15b3bf35f79d79761c0f56d507488d9428536d4fb5f7",
@@ -350,6 +354,7 @@
       "05e824f63a6381e02042afb1df0f1437584e25a80de8e9db0bd9456aaeb7aab8",
       "0601ee535419b7039d5da34bd9c8e1c2b3631307214e4afaf394dd47494090c7",
       "062fde2838c0edc0c20e6716948a2ae9fe9d8a98b01a8e8c544c5801641c7cdb",
+      "0c54ebc6c95f04ee0ec2f21aa4ebe34f4d2cfb9697b45a2b02999b963bbbdbca",
       "0cef055580e00f9ed439eacb2dff9d238bb11619457472016095a8915162fa4b",
       "0dc69c20434966015176d83baa6f95b3421f9e13d0b1bd608a22f0560eae1049",
       "0fe9b270d670f70da9d2535969b6117684b7c1517806b3029ebaf9624da8006c",
@@ -365,6 +370,7 @@
       "36b58dbdc26e51abc05a60872c4582faeebd67e9fe5626a3933467ba07c68dc4",
       "40237cd5259dbcf7c490f130e844a9e32eea48a8edabd50800edee5029bf95a4",
       "4213143689f7e7fe62ab8743c256a45492fafffc1757d64901b7b02725aee5c3",
+      "437659470cb978840f503c7d4a2af75c78beb2752cc3eed413bb33de346bd561",
       "472d2ad853c96651324aa9a3de00cb61c0cecacb389e850ab1b380d535d22922",
       "49d6e024b343dd77e4c0cea0e513e40fe679a7a8192953190d042b3a21bbf69c",
       "5536f8391ec4442f1b793dba8dd5d7820d45f4b6dadf1111cbac9d54469a01ca",
@@ -384,6 +390,7 @@
       "6e2b54571bfbc1fab571b81564fb0625ed83333fc12277c473fdf5a231f7d40c",
       "6e7228610628fc4bca31dc0b0aaf5eb4445e1f123f2c54bd13921c5cd01129fe",
       "75cecbce4d1f4adbba608cef498ae7e421ea75512c6bf9282b66cd94d821f672",
+      "78be1509ca8cf797f8c6e790d0d49ab608e50e0b828916c8c6ee790165ce792b",
       "7f451e48e391643b34f6249244bc47d93d6303875e7b092771e3af0718343bc1",
       "7fb3ceaf835230e1a75e510b046f4fe26e79815760354bec1949fa55515c6316",
       "83e9de10d3c439af17dc4d7a603109d35136c5c8bd468ab2be962e1fad064c3c",
@@ -407,6 +414,7 @@
       "db8d921aabf0d04811b55465a3757c62c4b39631aebaf6eecc994ca241cfbe56",
       "e25da746dc37b2e82c658a28d9481fd69741151045683eee2119582ddaf731cd",
       "e47a2ce766ae81fa0870e0a8dfbfe737311de69ce620e92217abbe4c532e3c8b",
+      "e67d3662836adf13c2e7177553bba6e7695484bd40438e8188cb9dd6d956cd2f",
       "e929f76c15349f1b9bc1e84e0a3e9e48e916168d79270e0f4a36ea8eab9b5388",
       "ebc693658da0b260c876f29cd6dfc2b12ae6690e3532622fa9c1cd4481162bd8",
       "f2243cc4150e225961825f6097b0cf38166c291dcf58127516ceee841f7ed4c8",
@@ -829,6 +837,8 @@
     "4.3.3",
     "4.3.30",
     "4.3.31",
+    "4.3.32",
+    "4.3.33",
     "4.3.4",
     "4.3.5",
     "4.3.6",

package/config/skills/_shared/bring-in.py

@@ -363,6 +363,8 @@ class BringInTests(unittest.TestCase):
         self.env = {key: value for key, value in os.environ.items()
                     if not key.startswith("GIT_")}
         self.env.update(GIT_CONFIG_NOSYSTEM="1", GIT_CONFIG_GLOBAL=str(self.root / "no-global"),
+                        # A commit's detached automatic maintenance would still write into .git while a test copies it.
+                        GIT_CONFIG_COUNT="1", GIT_CONFIG_KEY_0="maintenance.auto", GIT_CONFIG_VALUE_0="false",
                         GIT_AUTHOR_NAME="Fixture", GIT_AUTHOR_EMAIL="fixture@example.invalid",
                         GIT_COMMITTER_NAME="Fixture", GIT_COMMITTER_EMAIL="fixture@example.invalid",
                         LC_ALL="C", GIT_EDITOR=":", GIT_MERGE_AUTOEDIT="no")
@@ -415,6 +417,14 @@ class BringInTests(unittest.TestCase):
         path.write_bytes(("#!/bin/sh\n" + body).encode("utf-8"))
         path.chmod(0o755)
 
+    def test_fixture_commit_starts_no_automatic_maintenance(self):
+        # Its detached child would still write .git/objects/maintenance.lock while copytree or cleanup reads the tree.
+        trace = self.root / "trace.json"
+        self.env["GIT_TRACE2_EVENT"] = str(trace)
+        self.commit("traced", "traced\n")
+        children = [line for line in trace.read_text(encoding="utf-8").splitlines() if '"event":"child_start"' in line]
+        self.assertEqual(children, [])
+
     def test_fast_forward_and_paths_with_spaces(self):
         self.cli()
         self.assertEqual(self.g("rev-parse", "HEAD").strip(), self.target)