@hecer/yoke 1.19.0 → 1.21.1

package/dist/loop/dispatcher.js

@@ -34,18 +34,32 @@ async function gateResult(gates, path, worker) {
     if (criteria.length > 0 && !gates.verifyCriterion)
         return { passed: false, summary: 'criterion verifier is not configured' };
     for (const criterion of criteria) {
-        const result = gates.verifyCriterion?.(path, story, criterion);
+        const result = withStoryContext(story.id, () => gates.verifyCriterion?.(path, story, criterion));
         if (!result?.passed)
             return { passed: false, summary: result?.summary ?? 'criterion verification failed' };
     }
     for (const gate of [gates.verify, gates.design, gates.perf, gates.audit]) {
         if (!gate)
             continue;
-        const result = gate(path, story);
+        const result = withStoryContext(story.id, () => gate(path, story));
         if (!result.passed)
             return result;
     }
-    return gates.qualityReview?.(path, story, worker) ?? { passed: true, summary: 'integrated gates passed' };
+    return withStoryContext(story.id, () => gates.qualityReview?.(path, story, worker)) ?? { passed: true, summary: 'integrated gates passed' };
+}
+// All gate APIs are synchronous: never leave ambient story context set across an await.
+function withStoryContext(storyId, gate) {
+    const previous = process.env.YOKE_STORY;
+    process.env.YOKE_STORY = storyId;
+    try {
+        return gate();
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.YOKE_STORY;
+        else
+            process.env.YOKE_STORY = previous;
+    }
 }
 export function createDispatcher(options) {
     const dispatcherId = options.dispatcherId ?? randomUUID();
@@ -125,6 +139,11 @@ export function createDispatcher(options) {
         if (claims.release(input) === false)
             throw new Error('claim release failed');
     };
+    const cleanupRetained = createWorkerCleanup({
+        cleanupProcess: options.worktrees.cleanupProcess,
+        removeWorktree: () => undefined,
+        releaseClaim: releaseCandidateClaim,
+    });
     const persistPass = (input) => {
         if (!options.prdPath)
             return;
@@ -135,6 +154,8 @@ export function createDispatcher(options) {
     };
     const enqueue = (input, result) => {
         let reason = 'integrated verification failed';
+        let retained = false;
+        let recoveryBaseCommit = input.worktree.baseCommit;
         const integrationQueuedAt = Date.now();
         let integrationStartedAt;
         const integrationController = new AbortController();
@@ -160,6 +181,7 @@ export function createDispatcher(options) {
                     reason = rebase.reason;
                     throw new Error(reason);
                 }
+                recoveryBaseCommit = rebase.expectedHead;
                 return rebase.expectedHead;
             },
             verify: async () => {
@@ -169,7 +191,9 @@ export function createDispatcher(options) {
                 }
                 const gate = await gateResult(options.gates, input.worktree.path, input);
                 reason = gate.summary;
-                return gate.passed;
+                if (!gate.passed)
+                    throw new Error(gate.summary);
+                return true;
             },
             integrate: async (expectedHead) => {
                 if (cancellationReason)
@@ -200,6 +224,15 @@ export function createDispatcher(options) {
                     return;
                 case 'reopened':
                     reopened.push(input.story.id);
+                    reason = merge.reason;
+                    if (options.worktrees.retain) {
+                        // Retain first, then report/release. Recovery evidence must precede cleanup.
+                        retained = true;
+                        options.worktrees.retain({ ...input, worktree: { ...input.worktree, baseCommit: recoveryBaseCommit } }, reason);
+                        failed.push(input.story.id);
+                        failureReasons.set(input.story.id, `${reason}; candidate retained at ${input.worktree.path}`);
+                    }
+                    options.onReopened?.(input.story, { reason, worktree: input.worktree.path, baseCommit: recoveryBaseCommit, ownerToken: input.ownerToken });
                     result.routing.recordOutcome?.(false);
                     return;
                 default: {
@@ -217,7 +250,10 @@ export function createDispatcher(options) {
                 options.onIntegrationMetrics?.(input, Date.now() - integrationQueuedAt, integrationStartedAt === undefined ? undefined : Date.now() - integrationStartedAt);
             }
             finally {
-                cleanup(input);
+                if (retained)
+                    cleanupRetained(input);
+                else
+                    cleanup(input);
                 reportProgress();
             }
         });
@@ -227,12 +263,22 @@ export function createDispatcher(options) {
     const launch = (story) => {
         const provider = providerFor(story);
         const ownerToken = ids();
-        const worktree = options.worktrees.create({ story, dispatcherId, ownerToken, provider });
+        let worktree;
+        try {
+            worktree = options.worktrees.create({ story, dispatcherId, ownerToken, provider });
+        }
+        catch (error) {
+            failed.push(story.id);
+            failureReasons.set(story.id, `worktree setup failed: ${error instanceof Error ? error.message : String(error)}`);
+            reportProgress();
+            return;
+        }
         const controller = new AbortController();
         const candidateRace = Boolean(options.candidateCount && options.candidateCount > 1 && options.candidateCoordinator);
         const input = { story, worktree, provider, cancellation: { signal: controller.signal }, dispatcherId, ownerToken, ...(candidateRace ? { candidateRace: true } : {}) };
         if (!claims.acquire(input)) {
-            options.worktrees.remove(input);
+            if (!worktree.recovered)
+                options.worktrees.remove(input);
             return;
         }
         iterations += 1;
@@ -241,6 +287,19 @@ export function createDispatcher(options) {
             areas.add(story.area);
         const candidateDispatch = candidateRace;
         const activeWorker = { input, controller, task: Promise.resolve(), phase: options.acquireResource ? 'waiting-resource' : 'implementing' };
+        // Durable admission reporting must succeed before the worker microtask can start.
+        active.set(story.id, activeWorker);
+        try {
+            reportProgress();
+        }
+        catch (error) {
+            active.delete(story.id);
+            if (worktree.recovered)
+                cleanupRetained(input);
+            else
+                cleanup(input);
+            throw error;
+        }
         const task = Promise.resolve().then(async () => {
             const workerLease = options.acquireResource
                 ? await options.acquireResource({ story, provider, role: 'implementation', units: candidateRace ? options.candidateCount : 1, signal: controller.signal })
@@ -248,6 +307,13 @@ export function createDispatcher(options) {
             activeWorker.phase = 'implementing';
             reportProgress();
             try {
+                if (worktree.recovered)
+                    options.worktrees.cleanupProcess?.(input);
+                if (worktree.recovered)
+                    return { source: 'worker', result: {
+                            kind: 'candidate', storyId: story.id, worktree: worktree.path, baseCommit: worktree.baseCommit,
+                            provider, summary: 'retained candidate recovered for independent integration checks', evidence: { criteria: [] }, routing: { outcome: 'pending-integration' },
+                        } };
                 return await (candidateDispatch && options.candidateCoordinator
                     ? Promise.resolve(options.candidateCoordinator(input)).then(coordinateCandidates).then(result => ({ source: 'candidates', result }))
                     : options.worker(input).then(result => ({ source: 'worker', result })));
@@ -312,7 +378,10 @@ export function createDispatcher(options) {
             if (cancellationReason || paused || options.pause?.()) {
                 paused = true;
                 result.routing.recordOutcome?.(false);
-                cleanup(input);
+                if (input.worktree.recovered)
+                    cleanupRetained(input);
+                else
+                    cleanup(input);
                 reportProgress();
                 return;
             }
@@ -322,7 +391,10 @@ export function createDispatcher(options) {
             failed.push(story.id);
             failureReasons.set(story.id, error instanceof Error ? error.message : String(error));
             try {
-                cleanup(input);
+                if (input.worktree.recovered)
+                    cleanupRetained(input);
+                else
+                    cleanup(input);
             }
             catch (cleanupError) {
                 reportProgress();
@@ -387,7 +459,7 @@ export function createDispatcher(options) {
             if (failed.length > 0) {
                 const storyId = failed[0];
                 const detail = storyId ? failureReasons.get(storyId) : undefined;
-                return { status: 'blocked', ...(storyId && detail ? { reason: `worker ${storyId} failed: ${detail}` } : {}), iterations, integrated, reopened, failed };
+                return { status: 'blocked', ...(storyId && detail ? { reason: `${reopened.includes(storyId) ? `story ${storyId} integration rejected` : `worker ${storyId} failed`}: ${detail}` } : {}), iterations, integrated, reopened, failed };
             }
             if (iterations >= options.maxIterations)
                 return { status: 'cap-reached', iterations, integrated, reopened, failed };

package/dist/loop/git.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { sanitizeCommitMessage } from './identity.js';
-export const RUNTIME_PATHS = [".yoke/supervision", ".yoke/provider-processes", '.yoke/artifacts', '.yoke/events', '.yoke/history', '.yoke/routing', '.yoke/checks', '.yoke/goal.json', '.yoke/goal.pause', '.yoke/loop.pause', '.yoke/loop-status.json', '.yoke/loop.lock', '.yoke/loop.lock.takeover', '.yoke/loop.lock.takeover.recovery', '.yoke/runner.pid', '.yoke/story-durations.json'];
+export const RUNTIME_PATHS = [".yoke/supervision", ".yoke/provider-processes", '.yoke/claims', '.yoke/worktrees', '.yoke/artifacts', '.yoke/events', '.yoke/history', '.yoke/routing', '.yoke/checks', '.yoke/integration-recovery', '.yoke/run-state.json', '.yoke/run-state.*.tmp', '.yoke/goal.json', '.yoke/goal.pause', '.yoke/loop.pause', '.yoke/loop-status.json', '.yoke/loop.lock', '.yoke/loop.lock.takeover', '.yoke/loop.lock.takeover.recovery', '.yoke/runner.pid', '.yoke/story-durations.json'];
 // Directory pathspecs include descendants and also exclude the directory entry.
 export const RUNTIME_EXCLUDES = RUNTIME_PATHS.map(path => `:(exclude)${path}`);
 export function stageImplementation(dir) {

package/dist/loop/parallel-adapters.js

@@ -1,11 +1,14 @@
 import { execFileSync, spawnSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { isProviderTreeAlive, reapProviderProcesses } from './cleanup.js';
 import { realGitOps, stageImplementation } from './git.js';
 import { isPidAlive } from './lock.js';
 import { storyPathSegment } from './prd.js';
 import { killProcessTreeForCleanup } from './watchdog.js';
+import { parallelAcceptanceDigest, recoverParallelWorktree, retainParallelWorktree } from './recovery.js';
+import { statePath } from '../workspace/state.js';
 export function makeParallelAdapters(targetDir, identity, injectedGit) {
     return injectedGit
         ? injectedAdapters(targetDir, identity, injectedGit)
@@ -37,18 +40,40 @@ function injectedAdapters(targetDir, identity, git) {
 function productionAdapters(targetDir, identity) {
     const owned = new Set();
     const removed = new Set();
+    const acceptanceDigests = new Map();
+    const ownershipTokens = new Map();
     return {
         worktrees: {
             create: input => {
+                acceptanceDigests.set(input.story.id, parallelAcceptanceDigest(targetDir));
                 const path = worktreePath(targetDir, input);
+                const recovered = recoverParallelWorktree(targetDir, recoveryPath(targetDir, input.story.id), input.story.id);
+                if (recovered) {
+                    owned.add(recovered.path);
+                    ownershipTokens.set(recovered.path, recovered.ownerToken);
+                    return recovered;
+                }
                 const baseCommit = gitText(targetDir, ['rev-parse', 'HEAD']);
+                preflightWorktreePath(targetDir, path);
                 mkdirSync(dirname(path), { recursive: true });
                 realGitOps.addWorktree(targetDir, path);
                 owned.add(path);
+                ownershipTokens.set(path, input.ownerToken);
                 return { path, baseCommit };
             },
             cleanupProcess: cleanupProviderProcesses,
-            remove: input => removeOwnedWorktree(targetDir, input, owned, removed, realGitOps),
+            retain: (input, reason) => {
+                const file = recoveryPath(targetDir, input.story.id);
+                // Preserve the path's original ownership identity when a retry is rejected again.
+                const ownerToken = ownershipTokens.get(input.worktree.path) ?? input.ownerToken;
+                retainParallelWorktree(targetDir, file, { storyId: input.story.id, worktree: input.worktree.path, baseCommit: input.worktree.baseCommit, prdHash: acceptanceDigests.get(input.story.id), ownerToken, reason });
+            },
+            remove: input => {
+                removeOwnedWorktree(targetDir, input, owned, removed, realGitOps);
+                const file = recoveryPath(targetDir, input.story.id);
+                if (input.worktree.recovered && existsSync(file))
+                    unlinkSync(file);
+            },
         },
         git: {
             isClean: dir => realGitOps.isClean(dir),
@@ -56,23 +81,27 @@ function productionAdapters(targetDir, identity) {
             commit: input => realGitOps.commitAll(input.worktree.path, `yoke: complete ${input.story.id} ${input.story.title}`, identity),
             integrate: (input, expectedHead) => integrateCandidate(targetDir, input, expectedHead),
         },
-        candidates: primary => makeCandidateLifecycle(targetDir, primary, owned, removed, realGitOps),
+        candidates: primary => makeCandidateLifecycle(targetDir, primary, owned, removed, realGitOps, ownershipTokens),
     };
 }
 function cleanupProviderProcesses(input) {
     reapProviderProcesses(input.worktree.path, isPidAlive, isProviderTreeAlive, killProcessTreeForCleanup);
 }
-function makeCandidateLifecycle(targetDir, primary, owned, removed, git) {
+function makeCandidateLifecycle(targetDir, primary, owned, removed, git, ownershipTokens) {
     return {
         reserve: input => {
             const worktree = input.candidateId === 'candidate-1'
                 ? primary.worktree
                 : { path: candidateWorktreePath(targetDir, input), baseCommit: primary.worktree.baseCommit };
+            if (input.candidateId !== 'candidate-1')
+                ownershipTokens?.set(worktree.path, input.ownerToken);
             writeCandidateStatus(targetDir, input, worktree.path, 'reserved');
             return worktree;
         },
         materialize: ownership => {
             if (ownership.worktree.path !== primary.worktree.path) {
+                if (git === realGitOps)
+                    preflightWorktreePath(targetDir, ownership.worktree.path);
                 mkdirSync(dirname(ownership.worktree.path), { recursive: true });
                 git.addWorktree(targetDir, ownership.worktree.path);
                 owned.add(ownership.worktree.path);
@@ -92,7 +121,7 @@ function makeCandidateLifecycle(targetDir, primary, owned, removed, git) {
     };
 }
 function worktreePath(targetDir, input) {
-    return join(targetDir, '.yoke', 'worktrees', `${storyPathSegment(input.story.id)}-${input.ownerToken}`);
+    return shortWorktreePath(targetDir, input.story.id, input.ownerToken);
 }
 function removeOwnedWorktree(targetDir, input, owned, removed, git) {
     if (removed.has(input.worktree.path))
@@ -105,7 +134,24 @@ function removeOwnedWorktree(targetDir, input, owned, removed, git) {
     removed.add(input.worktree.path);
 }
 function candidateWorktreePath(targetDir, input) {
-    return join(targetDir, '.yoke', 'worktrees', `${storyPathSegment(input.storyId)}-${input.ownerToken}`);
+    return shortWorktreePath(targetDir, input.storyId, input.ownerToken);
+}
+function shortWorktreePath(targetDir, storyId, ownerToken) {
+    // 96 bits derived from the complete ownership identity; Git refuses an existing path.
+    const name = createHash('sha256').update(JSON.stringify([storyId, ownerToken])).digest('hex').slice(0, 24);
+    return join(targetDir, '.yoke', 'worktrees', name);
+}
+function recoveryPath(targetDir, storyId) {
+    return statePath(targetDir, 'integration-recovery', `${storyPathSegment(storyId)}.json`);
+}
+function preflightWorktreePath(targetDir, path) {
+    if (process.platform !== 'win32')
+        return;
+    const common = resolve(targetDir, gitText(targetDir, ['rev-parse', '--git-common-dir']));
+    const administrativePath = join(common, 'worktrees', basename(path));
+    if ([resolve(path, '.git'), administrativePath].some(value => value.length >= 240)) {
+        throw new Error(`Parallel worktree path exceeds the Windows Git path budget: ${path}. Move the project to a shorter root and retry; implementation has not started.`);
+    }
 }
 function writeCandidateStatus(targetDir, input, worktree, state, reason) {
     const file = join(targetDir, '.yoke', 'proof', storyPathSegment(input.storyId), 'candidates', input.candidateId, 'status.json');

package/dist/loop/parallel-command.js

@@ -50,7 +50,13 @@ export async function runParallelLoopCommand(input) {
                 units: request.units,
                 signal: request.signal,
             });
-            input.reporter.resourceWait?.({ id: request.story.id, title: request.story.title }, request.role, request.units, Date.now() - started, request.provider.provider);
+            try {
+                input.reporter.resourceWait?.({ id: request.story.id, title: request.story.title }, request.role, request.units, Date.now() - started, request.provider.provider);
+            }
+            catch (error) {
+                await lease.release();
+                throw error;
+            }
             return lease;
         },
         resourceStatus: () => sharedPoolStatus(),
@@ -71,6 +77,7 @@ export async function runParallelLoopCommand(input) {
         pause,
         onProgress: status => input.reporter.parallel?.(status),
         onAccepted: story => input.reporter.accepted?.(story),
+        onReopened: (story, evidence) => input.reporter.reopened?.(story, evidence),
         gates: {
             verify: input.verify,
             design: input.design,

package/dist/loop/recovery.js

@@ -1,8 +1,11 @@
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, realpathSync as filesystemRealpathSync, writeFileSync } from 'node:fs';
-import { dirname, join, relative, resolve, isAbsolute } from 'node:path';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync as filesystemRealpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+import { statePath } from '../workspace/state.js';
+import { loadPrd } from './prd.js';
 const Recovery = z.object({ version: z.literal(1), root: z.string(), worktree: z.string(), base: z.string(), prdHash: z.string() }).strict();
 const digest = (file) => createHash('sha256').update(readFileSync(file)).digest('hex');
 const pathIdentity = (path) => process.platform === 'win32' ? path.toLowerCase() : path;
@@ -49,3 +52,79 @@ export function prepareIsolatedWorktree(directory, worktree, resume) {
     // Record is outside the worker checkout and binds reuse to its source state.
     writeFileSync(record, JSON.stringify({ version: 1, root, worktree: wt, base, prdHash }), { mode: 0o600 });
 }
+const ParallelRecovery = z.object({
+    version: z.literal(1), root: z.string().max(4096), storyId: z.string().max(1024), worktree: z.string().max(4096), baseCommit: z.string().max(128),
+    prdHash: z.string().length(64), ownerToken: z.string().min(1).max(256), reason: z.string().max(16384), state: z.literal('retained'), recordedAt: z.string().datetime(),
+}).strict();
+export function parallelAcceptanceDigest(directory) {
+    // Accepted sibling stories change only passes. Their acceptance contracts remain protected.
+    const contract = loadPrd(join(directory, '.yoke', 'prd.yaml')).map(({ passes: _passes, ...story }) => story);
+    return createHash('sha256').update(JSON.stringify(contract)).digest('hex');
+}
+function parallelRecordPath(directory, file) {
+    const safe = statePath(directory, 'integration-recovery', basename(file));
+    if (pathIdentity(resolve(file)) !== pathIdentity(resolve(safe)))
+        throw new Error('Invalid parallel recovery record path');
+    return safe;
+}
+export function discardParallelRecoveryRecords(directory) {
+    const parent = statePath(directory, 'integration-recovery');
+    if (!existsSync(parent))
+        return;
+    for (const name of readdirSync(parent)) {
+        if (!name.endsWith('.json') && !name.endsWith('.tmp'))
+            continue;
+        const file = statePath(directory, 'integration-recovery', name);
+        if (!lstatSync(file).isFile())
+            throw new Error('Parallel recovery record is not a file');
+        rmSync(file);
+    }
+}
+/** Records are outside the candidate and bind reuse to unchanged target acceptance. */
+export function retainParallelWorktree(directory, file, input) {
+    const root = realpathSync(directory);
+    const worktree = realpathSync(input.worktree);
+    const record = ParallelRecovery.parse({ version: 1, root, ...input, reason: input.reason.slice(0, 16384), worktree, state: 'retained', recordedAt: new Date().toISOString() });
+    const safe = parallelRecordPath(directory, file);
+    mkdirSync(dirname(safe), { recursive: true });
+    const temp = statePath(directory, 'integration-recovery', `${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temp, JSON.stringify(record), { flag: 'wx', mode: 0o600 });
+        parallelRecordPath(directory, file);
+        renameSync(temp, safe);
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+}
+export function recoverParallelWorktree(directory, file, storyId) {
+    const safe = parallelRecordPath(directory, file);
+    if (!existsSync(safe))
+        return undefined;
+    const stat = lstatSync(safe);
+    if (!stat.isFile())
+        throw new Error('Parallel recovery record is not a file');
+    if (stat.size > 65536)
+        throw new Error('Parallel recovery record is too large');
+    const saved = ParallelRecovery.parse(JSON.parse(readFileSync(safe, 'utf8')));
+    if (!existsSync(saved.worktree))
+        throw new Error(`Retained candidate is missing: ${saved.worktree}; resolve its recovery record before retrying`);
+    const root = realpathSync(directory);
+    const actual = realpathSync(saved.worktree);
+    const parent = realpathSync(join(root, '.yoke', 'worktrees'));
+    const rel = relative(parent, actual);
+    const expectedName = createHash('sha256').update(JSON.stringify([storyId, saved.ownerToken])).digest('hex').slice(0, 24);
+    if (saved.storyId !== storyId || pathIdentity(saved.root) !== pathIdentity(root) || pathIdentity(actual) !== pathIdentity(saved.worktree) || isAbsolute(rel) || rel !== expectedName)
+        throw new Error('Retained candidate ownership or path binding is invalid');
+    const git = (args, cwd = root) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: 'pipe' }).trim();
+    if (saved.baseCommit !== git(['rev-parse', 'HEAD']) || saved.prdHash !== parallelAcceptanceDigest(root))
+        throw new Error(`Retained candidate is stale against target or PRD: ${actual}; reconcile it before retrying`);
+    const common = realpathSync(resolve(root, git(['rev-parse', '--git-common-dir'])));
+    if (pathIdentity(realpathSync(resolve(actual, git(['rev-parse', '--git-common-dir'], actual)))) !== pathIdentity(common))
+        throw new Error('Retained candidate belongs to another repository');
+    const registered = git(['worktree', 'list', '--porcelain']).split(/\r?\n/u).filter(line => line.startsWith('worktree ')).map(line => realpathSync(resolve(line.slice(9))));
+    if (!registered.some(path => pathIdentity(path) === pathIdentity(actual)))
+        throw new Error('Retained candidate is not a registered worktree');
+    git(['merge-base', '--is-ancestor', saved.baseCommit, 'HEAD'], actual);
+    return { path: actual, baseCommit: saved.baseCommit, recovered: true, ownerToken: saved.ownerToken };
+}

package/dist/loop/reporter.js

@@ -303,6 +303,9 @@ export function makeReporter(dir, opts = {}, now = () => new Date()) {
         integrationDuration(story, durationMs, provider) {
             appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'phase-ended', storyId: story.id, phase: 'integration', provider, durationMs: Math.max(0, durationMs) });
         },
+        reopened(story, evidence) {
+            appendEvent(dir, { runId, timestamp: now().toISOString(), type: 'status', storyId: story.id, data: { status: 'reopened', ...evidence } });
+        },
         parallelWorker(status) {
             const base = current;
             const parallel = base?.parallel;

package/dist/loop/resource-pool.js

@@ -51,12 +51,12 @@ export function globalWorkerLimit(environment = process.env) {
         cachedGlobalLimit = value;
     return value;
 }
-function poolDir() {
+function poolDir(resource) {
     const base = process.env.LOCALAPPDATA || process.env.XDG_STATE_HOME || join(homedir(), '.yoke');
-    return join(resolve(base), 'Yoke', 'parallel-pool');
+    return join(resolve(base), 'Yoke', resource === 'check' ? 'check-pool' : 'parallel-pool');
 }
-function ensurePoolDir() {
-    const dir = poolDir();
+function ensurePoolDir(resource) {
+    const dir = poolDir(resource);
     mkdirSync(dir, { recursive: true });
     const stat = lstatSync(dir);
     if (!stat.isDirectory() || stat.isSymbolicLink())
@@ -119,8 +119,8 @@ function staleDead(record, now) {
     const created = Date.parse(record.createdAt);
     return !Number.isFinite(created) || now - created > STALE_OWNER_MS;
 }
-function withPoolLock(operation) {
-    const dir = ensurePoolDir();
+function withPoolLock(operation, resource) {
+    const dir = ensurePoolDir(resource);
     const lockFile = join(dir, 'pool');
     return withClaimOperations(lockFile, { now: new Date(), staleMs: STALE_OWNER_MS, isAlive: isPidAlive }, () => readRecords(dir), () => [], records => {
         const now = Date.now();
@@ -184,7 +184,7 @@ function writeRecord(dir, record) {
 }
 export async function acquireSharedWorker(request) {
     const units = request.units ?? 1;
-    const limit = globalWorkerLimit();
+    const limit = request.resource === 'check' ? globalCheckLimit() : globalWorkerLimit();
     if (!Number.isInteger(units) || units < 1 || units > MAX_PROJECT_WORKERS)
         throw new Error(`Worker reservation units must be an integer from 1 to ${MAX_PROJECT_WORKERS}`);
     if (units > limit)
@@ -213,7 +213,7 @@ export async function acquireSharedWorker(request) {
     while (!published) {
         if (request.signal?.aborted)
             throw new Error(abortReason(request.signal));
-        const result = withPoolLock((_records, dir) => { writeRecord(dir, waiting); return true; });
+        const result = withPoolLock((_records, dir) => { writeRecord(dir, waiting); return true; }, request.resource);
         if (result === true)
             published = true;
         else
@@ -237,7 +237,7 @@ export async function acquireSharedWorker(request) {
                     replaceRecord(dir, { ...head, overtakes: head.overtakes + 1 });
                 replaceRecord(dir, { ...own, state: 'active' });
                 return true;
-            });
+            }, request.resource);
             if (granted === true) {
                 const acquiredAt = new Date().toISOString();
                 let released = false;
@@ -254,7 +254,7 @@ export async function acquireSharedWorker(request) {
                                     return false;
                                 rmSync(recordPath(dir, id), { force: true });
                                 return true;
-                            });
+                            }, request.resource);
                             if (result !== null) {
                                 released = true;
                                 return result;
@@ -274,7 +274,7 @@ export async function acquireSharedWorker(request) {
                 if (own)
                     rmSync(recordPath(dir, id), { force: true });
                 return true;
-            });
+            }, request.resource);
             if (removed !== null)
                 break;
             await waitForCapacity();
@@ -347,10 +347,10 @@ export function withSharedWorkerSync(request, operation) {
         }
     }
 }
-export function sharedPoolStatus() {
-    const limit = globalWorkerLimit();
-    const snapshot = withPoolLock(records => records.map(record => ({ ...record })));
-    const records = snapshot ?? readRecords(ensurePoolDir()).filter(record => !staleDead(record, Date.now()));
+export function sharedPoolStatus(resource) {
+    const limit = resource === 'check' ? globalCheckLimit() : globalWorkerLimit();
+    const snapshot = withPoolLock(records => records.map(record => ({ ...record })), resource);
+    const records = snapshot ?? readRecords(ensurePoolDir(resource)).filter(record => !staleDead(record, Date.now()));
     const sharedLimit = effectiveLimit(records, limit);
     const active = records.filter(record => record.state === 'active');
     const waiting = records.filter(record => record.state === 'waiting');
@@ -367,3 +367,9 @@ export function sharedPoolStatus() {
         oldestWaitMs: Number.isFinite(oldest) ? Math.max(0, Date.now() - oldest) : 0,
     };
 }
+export function globalCheckLimit(environment = process.env) {
+    const raw = environment.YOKE_MAX_PARALLEL_CHECKS ?? '1';
+    if (!/^[1-8]$/u.test(raw))
+        throw new Error('YOKE_MAX_PARALLEL_CHECKS must be an integer from 1 to 8');
+    return Number(raw);
+}