agentic-workflow-manager 9.22.0 → 9.22.1

package/dist/tests/commands/changes/list.test.js

@@ -57,20 +57,46 @@ afterEach(() => expect(listReal()).toEqual(realBefore));
 const UNSAFE = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
 let repo;
 let template;
-beforeAll(() => { template = (0, helpers_1.makeRepo)(); });
-afterAll(() => template.cleanup());
+/** The template plus `buildHistory`, built once: `history()` starts a test from a copy of it (no git process). */
+let historic;
+beforeAll(() => {
+    template = (0, helpers_1.makeRepo)();
+    historic = (0, helpers_1.cloneRepo)(template);
+    buildHistory(historic);
+});
+afterAll(() => { historic.cleanup(); template.cleanup(); });
 beforeEach(() => { repo = (0, helpers_1.cloneRepo)(template); });
 afterEach(() => { jest.restoreAllMocks(); repo.cleanup(); });
 const FIRST = '2026-10-16-first';
+function buildHistory(into) {
+    into.commit({ 'old.ts': '1' }, 'feat: before adoption', '2026-10-16T09:00:00Z');
+    into.commit({ [(0, list_fixtures_1.recordPath)(FIRST)]: (0, list_fixtures_1.record)(FIRST), 'a.ts': '1' }, 'feat: first (#10)', '2026-10-16T20:00:00Z');
+    into.commit({ 'b.ts': '1' }, 'fix: no record', '2026-10-16T21:00:00Z');
+    into.commit({ 'c.ts': '1' }, 'chore(release): v1.0.0 [skip ci]\n\nChange-Record: none', '2026-10-16T22:00:00Z');
+    into.commit({ [(0, list_fixtures_1.recordPath)('2026-10-17-bad')]: '---\nschema: nope\n---\n' }, 'feat: bad record', '2026-10-17T01:00:00Z');
+    into.gitAt('2026-10-17T02:00:00Z', 'tag', '-a', 'v1.0.0', '-m', 'v1.0.0');
+}
+/** The repository after `buildHistory` (a copy of the prebuilt one). */
 function history() {
-    repo.commit({ 'old.ts': '1' }, 'feat: before adoption', '2026-10-16T09:00:00Z');
-    repo.commit({ [(0, list_fixtures_1.recordPath)(FIRST)]: (0, list_fixtures_1.record)(FIRST), 'a.ts': '1' }, 'feat: first (#10)', '2026-10-16T20:00:00Z');
-    repo.commit({ 'b.ts': '1' }, 'fix: no record', '2026-10-16T21:00:00Z');
-    repo.commit({ 'c.ts': '1' }, 'chore(release): v1.0.0 [skip ci]\n\nChange-Record: none', '2026-10-16T22:00:00Z');
-    repo.commit({ [(0, list_fixtures_1.recordPath)('2026-10-17-bad')]: '---\nschema: nope\n---\n' }, 'feat: bad record', '2026-10-17T01:00:00Z');
-    repo.gitAt('2026-10-17T02:00:00Z', 'tag', '-a', 'v1.0.0', '-m', 'v1.0.0');
+    repo.cleanup();
+    repo = (0, helpers_1.cloneRepo)(historic);
 }
 const run = (opts = {}, deps = {}) => (0, changes_1.runChangesList)(repo.root, opts, { now: list_fixtures_1.now, ...deps });
+const sharedRuns = new Map();
+/**
+ * `run(opts)` on the untouched prebuilt history. The command is read-only (R5.7, asserted below), so each distinct run is made once
+ * and its result shared by the tests that only read it.
+ */
+function onHistory(opts) {
+    const key = JSON.stringify(Object.entries(opts).sort(([a], [b]) => a.localeCompare(b)));
+    let r = sharedRuns.get(key);
+    if (r === undefined) {
+        r = (0, changes_1.runChangesList)(historic.root, opts, { now: list_fixtures_1.now });
+        sharedRuns.set(key, r);
+    }
+    return r;
+}
+const historyJson = () => JSON.parse(onHistory({ since: '48h', format: 'json' }).stdout);
 const json = (opts = {}, deps = {}) => JSON.parse(run({ since: '48h', format: 'json', ...opts }, deps).stdout);
 const failure = (r, code) => {
     expect(r.code).toBe(2);
@@ -209,8 +235,7 @@ describe('awm changes list: adoption (R5.4)', () => {
 });
 describe('awm changes list: classification and derived fields (R5.1, R5.3, R5.4, R5.5)', () => {
     test('classifies and derives', () => {
-        history();
-        const out = json();
+        const out = historyJson();
         const byClass = Object.fromEntries(out.changes.map((c) => [c.subject, c.classification]));
         expect(byClass).toEqual({ 'feat: first (#10)': 'recorded', 'fix: no record': 'missing', 'chore(release): v1.0.0 [skip ci]': 'exempt', 'feat: bad record': 'invalid-record' });
         const first = out.changes.find((c) => c.subject === 'feat: first (#10)');
@@ -219,8 +244,7 @@ describe('awm changes list: classification and derived fields (R5.1, R5.3, R5.4,
         expect(out.repo).toBeNull();
     });
     test('pre-adoption commits are omitted', () => {
-        history();
-        expect(JSON.stringify(json())).not.toContain('before adoption');
+        expect(JSON.stringify(historyJson())).not.toContain('before adoption');
     });
     test('repo identity strips credentials', () => {
         history();
@@ -291,28 +315,24 @@ describe('awm changes list: mixed invalid commits, odd dates and shallow clones
 });
 describe('awm changes list: formats (R5.6)', () => {
     test('json is one document on one line', () => {
-        history();
-        const r = run({ since: '48h', format: 'json' });
+        const r = onHistory({ since: '48h', format: 'json' });
         expect(r.stdout.split('\n')).toHaveLength(2);
         expect(Object.keys(JSON.parse(r.stdout))).toEqual(['schema', 'repo', 'base', 'since', 'adopted', 'truncated', 'omitted', 'changes']);
         expect(JSON.parse(r.stdout).adopted).toBe(true);
     });
     test('voice speaks recorded changes and counts the rest', () => {
-        history();
-        const r = run({ since: '48h', format: 'voice' });
+        const r = onHistory({ since: '48h', format: 'voice' });
         expect(r.stdout).toContain('Primer cambio. feat, verificado, 2 validaciones manuales pendientes.');
         expect(r.stdout).toMatch(/1 cambio\(s\) sin record y 1 con record inválido/);
     });
     test('text is a table with the classification of each change', () => {
-        history();
-        const out = run({ since: '48h' }).stdout;
+        const out = onHistory({ since: '48h' }).stdout;
         for (const word of ['recorded', 'missing', 'exempt', 'invalid-record', 'v1.0.0', '#10'])
             expect(out).toContain(word);
         expect(out.split('\n')[0]).toMatch(/^WHEN\s+CLASSIFICATION/);
     });
     test('text is the default format', () => {
-        history();
-        expect(run({ since: '48h' }).stdout).toBe(run({ since: '48h', format: 'text' }).stdout);
+        expect(onHistory({ since: '48h' }).stdout).toBe(onHistory({ since: '48h', format: 'text' }).stdout);
     });
     test('an empty window says so in text', () => {
         history();
@@ -328,9 +348,8 @@ describe('awm changes list: formats (R5.6)', () => {
         expect(run({ since: '48h', format: 'voice' }, deps).stdout).toMatch(/Hay 2 cambio\(s\) más antiguo\(s\) sin mostrar/);
     });
     test('no format prints anything on stderr when it succeeds', () => {
-        history();
         for (const format of ['text', 'json', 'voice'])
-            expect(run({ since: '48h', format }).stderr).toBe('');
+            expect(onHistory({ since: '48h', format }).stderr).toBe('');
     });
 });
 describe('awm changes list: read-only (R5.7)', () => {

package/dist/tests/commands/job/gate-reconcile.test.js

@@ -425,9 +425,20 @@ describe('reap — limpieza explicita con identidad validada (R2.2)', () => {
         expect(m.aliveWithIdentity).toBe(false);
     });
     test('planReap reporta aliveWithIdentity: true para un proceso genuinamente vivo', () => {
-        const { spawnStructured } = require('../../../src/core/journal/process');
+        // Same full-spawn retry as process.test.ts: on windows-11-arm (and
+        // historically windows-latest) a freshly spawned `node -e` can die
+        // before OpenProcess/pidExistsNative sees it. Re-polling the same pid
+        // never helps; a fresh instance can. Three failures still fail loudly.
+        const { spawnStructured, refIsAlive } = require('../../../src/core/journal/process');
         const s = (0, types_1.emptyState)('r');
-        const { child, ref } = spawnStructured(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nLive');
+        let { child, ref } = spawnStructured(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nLive');
+        for (let attempt = 1; attempt < 3 && !refIsAlive(ref); attempt++) {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* already gone */ }
+            ({ child, ref } = spawnStructured(['node', '-e', 'setTimeout(()=>{}, 5000)'], process.cwd(), 'nLive'));
+        }
         s.jobs['vivo'] = job({ id: 'vivo', executionState: 'running', processRef: ref });
         try {
             const plan = (0, reap_1.planReap)(s);

package/dist/tests/commands/registry-sync-honesty.test.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// #238 S2 / SG-7 — soft (add/list) vs hard (sync/update/init/registry add) sync failure UX.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const registry_sync_report_1 = require("../../src/core/registry-sync-report");
+describe('registry-sync-report pure helpers (#238 S2)', () => {
+    it('formatClassifiedRegistryFailure includes name, remote, class, fatal, remedy — never URL userinfo', () => {
+        const token = 'ghp_TESTSECRET_DO_NOT_ECHO';
+        const text = (0, registry_sync_report_1.formatClassifiedRegistryFailure)({
+            name: 'baseline',
+            remote: `https://${token}@example.test/baseline.git`,
+            err: new Error(`fatal: could not read Username for 'https://${token}@example.test': terminal prompts disabled`),
+        });
+        expect(text).toContain('baseline');
+        expect(text).toContain('example.test/baseline.git');
+        expect(text).toMatch(/authentication/i);
+        expect(text).toMatch(/terminal prompts disabled/i);
+        expect(text).toMatch(/credential\.helper/);
+        expect(text).not.toContain(token);
+        expect(text).not.toMatch(/ghp_/);
+    });
+    it('formatRegistrySyncSoftFailure states cached version plus SG-6 cause/remedy', () => {
+        const classified = (0, registry_sync_report_1.formatClassifiedRegistryFailure)({
+            name: 'docs',
+            remote: 'https://example.test/docs.git',
+            err: new Error('fatal: unable to access: Could not resolve host: example.test'),
+        });
+        const soft = (0, registry_sync_report_1.formatRegistrySyncSoftFailure)({
+            name: 'docs',
+            cachedVersion: '1.4.0',
+            classifiedMessage: classified,
+        });
+        expect(soft).toMatch(/cached version v1\.4\.0/i);
+        expect(soft).toContain('docs');
+        expect(soft).toMatch(/network/i);
+        expect(soft).toMatch(/Could not resolve host/i);
+        expect(soft).toMatch(/remedy:/);
+        // B3: soft line must not say "sync failed" twice before the classified clause.
+        expect(soft.match(/sync failed/gi)?.length ?? 0).toBe(1);
+    });
+    it('formatRegistrySyncSoftFailure uses unknown when cachedVersion is null', () => {
+        const soft = (0, registry_sync_report_1.formatRegistrySyncSoftFailure)({
+            name: 'docs',
+            cachedVersion: null,
+            classifiedMessage: 'registry docs sync failed (class=network); remedy: check connectivity',
+        });
+        expect(soft).toMatch(/cached version unknown/i);
+    });
+    it('hardFailOnAnyRegistrySyncError is true when any result is action:error', () => {
+        const ok = [{ name: 'baseline', action: 'pulled', version: 'v1.0.0' }];
+        const mixed = [
+            { name: 'baseline', action: 'pulled', version: 'v1.0.0' },
+            { name: 'docs', action: 'error', error: 'network unreachable' },
+        ];
+        expect((0, registry_sync_report_1.hardFailOnAnyRegistrySyncError)(ok)).toBe(false);
+        expect((0, registry_sync_report_1.hardFailOnAnyRegistrySyncError)(mixed)).toBe(true);
+    });
+    it('formatSoftRegistrySyncFailures emits only usable errored registries with cached version', async () => {
+        const results = [
+            { name: 'ok', action: 'pulled', version: 'v1.0.0' },
+            { name: 'stale', action: 'error', error: 'registry stale sync failed (class=network); remedy: check connectivity' },
+            { name: 'gone', action: 'error', error: 'registry gone sync failed (class=not-found); remedy: verify the remote URL' },
+        ];
+        const lines = await (0, registry_sync_report_1.formatSoftRegistrySyncFailures)(results, {
+            isUsable: (name) => name === 'stale',
+            cachedVersion: (name) => (name === 'stale' ? '2.0.0' : null),
+        });
+        expect(lines).toHaveLength(1);
+        expect(lines[0]).toMatch(/stale/);
+        expect(lines[0]).toMatch(/cached version v2\.0\.0/i);
+        expect(lines[0]).toMatch(/class=network/);
+        expect(lines.join('\n')).not.toMatch(/\bgone\b/);
+    });
+});
+describe('awm sync / update hard-exit on sync error (#238 S2 / SG-7)', () => {
+    const realHome = process.env.HOME;
+    const realAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sync-honesty-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        fs_1.default.mkdirSync(process.env.AWM_HOME, { recursive: true });
+        jest.resetModules();
+        jest.doMock('@clack/prompts', () => ({
+            confirm: jest.fn(),
+            isCancel: jest.fn(),
+            intro: jest.fn(),
+            outro: jest.fn(),
+            spinner: jest.fn(() => ({ start: jest.fn(), stop: jest.fn() })),
+        }));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (realHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = realHome;
+        if (realAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = realAwmHome;
+        jest.resetModules();
+        jest.dontMock('@clack/prompts');
+    });
+    function writePrefs() {
+        const { savePreferences } = require('../../src/utils/config');
+        savePreferences({
+            defaultAgent: 'claude-code',
+            enabledAgents: ['claude-code'],
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
+    }
+    function seedUsableDocsRegistry() {
+        const registriesDir = path_1.default.join(process.env.AWM_HOME, 'registries');
+        fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs', 'skills'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registriesDir, 'docs', 'skills', 'x.md'), '# x\n');
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'docs', remote: 'https://example.test/docs.git' }]));
+    }
+    it('runSyncCore returns code !== 0 when any registry result is action:error (even if usable on disk)', async () => {
+        writePrefs();
+        seedUsableDocsRegistry();
+        const project = path_1.default.join(tmpHome, 'proj');
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'profile.json'), JSON.stringify({ version: 1, extensions: [], agents: ['claude-code'] }));
+        const reconcile = jest.fn(() => []);
+        const { runSyncCore } = require('../../src/commands/sync');
+        const result = await runSyncCore({ cwd: project }, {
+            syncRegistries: async () => [
+                { name: 'docs', action: 'error', error: 'network unreachable' },
+            ],
+            verifyMinCliVersions: () => [],
+            verifyProjectPins: async () => [],
+            syncProfile: () => ({ extensions: [], installed: [], skipped: [], transactionIds: [] }),
+            reconcileProjectSkillLinks: reconcile,
+        });
+        expect(result.code).not.toBe(0);
+        // A1: later stages still run when usable content remains.
+        expect(reconcile).toHaveBeenCalled();
+    });
+    it('runUpdateCore returns code !== 0 when a registry fails even with usable on-disk content', async () => {
+        writePrefs();
+        seedUsableDocsRegistry();
+        const regenerate = jest.fn(() => []);
+        const planReconciliation = jest.fn(() => ({ operations: [], records: [], reports: [] }));
+        const applyInstallPlan = jest.fn(() => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }));
+        const offerSelfUpdate = jest.fn(async () => { });
+        const { runUpdateCore, updateOutro } = require('../../src/commands/update');
+        const result = await runUpdateCore({}, {
+            syncRegistries: async () => [
+                { name: 'docs', action: 'error', error: 'network unreachable' },
+            ],
+            verifyMinCliVersions: () => [],
+            regenerateGlobalContext: regenerate,
+            planReconciliation,
+            applyInstallPlan,
+            resyncInstalledHooks: () => [],
+            offerSelfUpdate,
+        });
+        expect(result.code).not.toBe(0);
+        expect(result.registries.failed).toEqual(['docs']);
+        // A1: pipeline continues after sync error when content is usable.
+        expect(regenerate).toHaveBeenCalled();
+        expect(planReconciliation).toHaveBeenCalled();
+        expect(applyInstallPlan).toHaveBeenCalled();
+        expect(offerSelfUpdate).toHaveBeenCalled();
+        expect(updateOutro(result)).toMatch(/Finished with registry sync errors|Update failed/i);
+    });
+});

package/dist/tests/commands/sensors/exec.test.js

@@ -44,6 +44,7 @@ const exec_1 = require("../../../src/commands/sensors/exec");
 const result_1 = require("../../../src/commands/sensors/result");
 const baseline_1 = require("../../../src/commands/sensors/baseline");
 const prepare_1 = require("../../../src/commands/sensors/prepare");
+const fixture_cleanup_1 = require("../../helpers/fixture-cleanup");
 const sensor = (overrides = {}) => ({
     name: 'lint',
     command: { kind: 'legacy', value: 'node -e "setTimeout(() => {}, 1000)"' },
@@ -401,7 +402,8 @@ describe('runStructuredCommand — Windows local native binaries', () => {
             delete process.env.PATHEXT;
         else
             process.env.PATHEXT = savedPathExt;
-        fs_1.default.rmSync(dir, { recursive: true, force: true });
+        // Windows keeps a just-executed copy of node locked for a moment (EBUSY on unlink).
+        (0, fixture_cleanup_1.removeFixtureTree)(dir);
     });
     it('executes a contained native executable with literal shell-sensitive argv', async () => {
         const executable = path_1.default.join(dir, 'node_modules', '.bin', 'fixture.exe');

package/dist/tests/commands/update.test.js

@@ -164,9 +164,9 @@ describe('awm update — honest outcome', () => {
         expect(result.code).toBe(1);
         expect(result.registries.failed).toEqual(['baseline']);
     });
-    it('un registry que falló pero conserva contenido sigue, y el cierre lo nombra en vez de anunciar éxito parejo', async () => {
-        // `unusableSyncedRegistries` mira contenido EN DISCO: se siembra el content root
-        // y el registries.json para que `docs` cuente como stale, no como roto.
+    it('un registry que falló falla cerrado aunque conserve contenido en disco (SG-7)', async () => {
+        // Pre-SG-7 update warn-and-continued on usable cache; #238 SG-7 requires
+        // non-zero exit for init/update/sync/registry add on any sync failure.
         const registriesDir = path_1.default.join(process.env.AWM_HOME, 'registries');
         fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs', 'skills'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'docs', remote: 'https://example.test/docs.git' }]));
@@ -177,12 +177,12 @@ describe('awm update — honest outcome', () => {
                 { name: 'docs', action: 'error', error: 'network unreachable' },
             ],
         }));
-        expect(result.code).toBe(0);
+        expect(result.code).toBe(1);
         expect(result.registries).toEqual({ configured: 2, synced: 1, failed: ['docs'] });
-        const outro = updateOutro(result);
-        expect(outro).toMatch(/stale/i);
-        expect(outro).toMatch(/docs/);
-        expect(outro).not.toMatch(/^✅/);
+        expect(updateOutro(result)).toMatch(/Finished with registry sync errors/);
+        expect(updateOutro(result)).toMatch(/1\/2/);
+        expect(updateOutro(result)).toMatch(/docs/);
+        expect(errSpy.mock.calls.flat().join('\n')).toMatch(/docs/);
     });
 });
 describe('awm update — nunca se cuelga esperando a un humano que no está', () => {

package/dist/tests/commands/watch/supervisor-loop.test.js

@@ -758,21 +758,37 @@ describe('supervisor loop', () => {
     // subagent kept an idle leader while the work ran in processes outside its
     // process group, and the supervisor entered a false custody. Work in the
     // descendant tree is activity: observe, never custody, while it moves.
+    // The tree must move deterministically between the two ticks. A `while :; do
+    // sleep 0.02; done` loop leaves instants with no `sleep` child, so under CPU
+    // load two samples 150 ms apart could read identical (~1% of pairs) and the
+    // supervisor entered a real custody: a flaky red on linux-arm64. Each worker
+    // child lives 30 s, and the test itself makes the tree grow by one between ticks.
     itPosix('espera sana: lider ocioso + descendiente fuera del grupo trabajando => observa, no custodia (R4.2)', async () => {
         initUnattendedFixture(repo);
         (0, generations_1.beginGeneration)(repo, 'main');
-        const worker = "require('child_process').spawn('sh', ['-c', 'while :; do sleep 0.02; done'], { detached: true, stdio: 'ignore' }).unref(); setTimeout(()=>{}, 20000)";
-        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', worker], process.cwd(), 'nWait');
+        const trigger = path_1.default.join(repo, 'grow-descendant');
+        const worker = [
+            "const { spawn } = require('child_process'); const fs = require('fs');",
+            "const grow = () => spawn('sleep', ['30'], { detached: true, stdio: 'ignore' }).unref();",
+            'grow();',
+            'const poll = setInterval(() => { if (fs.existsSync(process.argv[1])) { clearInterval(poll); grow(); } }, 10);',
+            'setTimeout(() => {}, 20000);',
+        ].join(' ');
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', worker, trigger], process.cwd(), 'nWait');
         try {
             let s = (0, store_1.readJournal)(repo, 'main').state;
             (0, generations_1.activeGeneration)(s).processRef = ref;
             s.controllerHeartbeatAt = new Date(Date.now() - 3600000).toISOString(); // heartbeat vencido: bloqueado en la espera
             (0, store_1.writeJournal)(repo, 'main', s);
-            await until(() => ((0, process_1.activitySnapshot)(ref)?.descendants ?? '0:none') !== '0:none');
+            const descendants = () => (0, process_1.activitySnapshot)(ref)?.descendants ?? '0:none';
+            await until(() => descendants().startsWith('1:'));
             const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 1, activityWindowMs: 50, tickMs: 20 };
             const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted);
             await sup.tick();
-            await new Promise((r) => setTimeout(r, 150)); // mas que la ventana, pero el arbol se movio
+            const firstTick = Date.now();
+            fs_1.default.writeFileSync(trigger, ''); // el arbol crece: trabajo real fuera del grupo
+            await until(() => descendants().startsWith('2:'));
+            await new Promise((r) => setTimeout(r, Math.max(0, 150 - (Date.now() - firstTick)))); // mas que la ventana, pero el arbol se movio
             expect(await sup.tick()).not.toBe('custody');
             const after = (0, store_1.readJournal)(repo, 'main').state;
             expect(after.cycle.status).toBe('IN_PROGRESS');
@@ -780,7 +796,7 @@ describe('supervisor loop', () => {
             expect(child.killed).toBe(false);
         }
         finally {
-            // The detached shell leads its own group: kill that group, never a pattern match.
+            // Each detached child leads its own group: kill that group, never a pattern match.
             let shells = [];
             try {
                 shells = (0, child_process_1.execFileSync)('pgrep', ['-P', String(ref.pid)], { encoding: 'utf8' }).split('\n').filter(Boolean).map(Number);

package/dist/tests/core/changes/helpers.js

@@ -67,19 +67,25 @@ function emptyGitConfig(home) {
     fs_1.default.writeFileSync(file, '');
     return file;
 }
+/**
+ * Every test git child: no signing, and no automatic maintenance after a commit. A newer git runs that maintenance detached in
+ * the background, where its lock file under `.git/objects` appears and vanishes while a test copies or removes the repository
+ * (`cloneRepo` failed with ENOENT on macOS with git 2.55).
+ */
+const GIT_TEST_CONFIG = ['-c', 'commit.gpgsign=false', '-c', 'maintenance.auto=false', '-c', 'gc.auto=0'];
 /** The git runner of a repository: identity and config isolation in an explicit environment, optional explicit dates. */
 function gitApi(root, home) {
     const env = {
         ...process.env, HOME: home, GIT_CONFIG_GLOBAL: path_1.default.join(home, 'gitconfig'), GIT_CONFIG_NOSYSTEM: '1',
         GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t',
     };
-    const run = (extra, args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env: { ...env, ...extra } }).trim();
+    const run = (extra, args) => (0, child_process_1.execFileSync)('git', [...GIT_TEST_CONFIG, ...args], { cwd: root, encoding: 'utf8', env: { ...env, ...extra } }).trim();
     const dates = (date) => {
         const stamp = `${Math.floor(Date.parse(date) / 1000)} +0000`;
         return { GIT_AUTHOR_DATE: stamp, GIT_COMMITTER_DATE: stamp };
     };
     const git = (...args) => run({}, args);
-    const gitInput = (input, ...args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env, input }).trim();
+    const gitInput = (input, ...args) => (0, child_process_1.execFileSync)('git', [...GIT_TEST_CONFIG, ...args], { cwd: root, encoding: 'utf8', env, input }).trim();
     const gitAt = (date, ...args) => run(dates(date), args);
     const commit = (files, message, date) => {
         for (const [rel, content] of Object.entries(files)) {
@@ -144,7 +150,13 @@ Object.defineProperty(exports, "posixOnly", { enumerable: true, get: function ()
  */
 function cloneRepo(template) {
     const root = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-chg-')));
-    fs_1.default.cpSync(template.root, root, { recursive: true });
+    try {
+        fs_1.default.cpSync(template.root, root, { recursive: true });
+    }
+    catch (error) {
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        throw error;
+    }
     const { git, gitInput, gitAt, commit } = gitApi(root, template.home);
     return { root, home: template.home, git, gitInput, gitAt, commit, cleanup: () => fs_1.default.rmSync(root, { recursive: true, force: true }) };
 }