@hecer/yoke 1.3.0 → 1.5.0

package/dist/loop/cleanup.js

@@ -1,14 +1,17 @@
-import { existsSync, readdirSync, readFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { parseProviderProcessRecord } from '../agents/process-record.js';
+import { processIncarnation } from '../agents/process-incarnation.js';
 import { acquireTakeoverLease, acquireTakeoverRecoveryLease, lockPath, takeoverLockPath, readLock, isPidAlive, releaseTakeoverLease, releaseTakeoverRecoveryLease, takeoverRecoveryPath, } from './lock.js';
-import { killProcessTree } from './watchdog.js';
+import { killProcessForCleanup, killProcessTreeForCleanup } from './watchdog.js';
+import { cleanupClaims } from './claims.js';
 // Reap orphaned runners PROJECT-SCOPED: kill only pids recorded in this project's
 // .yoke/runner.pid files (main dir + each worktree). Never by process-name or
 // command-line pattern — that takes down runners belonging to OTHER projects,
 // which then stall mid-story. Skipped entirely while the loop lock holder is
 // alive: a live loop's runner is healthy, not an orphan.
-function reapRecordedRunners(targetDir, wtDir, isAlive, killTree) {
+export function reapRecordedRunners(targetDir, wtDir, isAlive, isTreeAlive, killChildTree, killWatchdog, currentIncarnation) {
     const pidFiles = [join(targetDir, '.yoke', 'runner.pid')];
     if (existsSync(wtDir)) {
         for (const name of readdirSync(wtDir))
@@ -18,28 +21,85 @@ function reapRecordedRunners(targetDir, wtDir, isAlive, killTree) {
     for (const file of pidFiles) {
         if (!existsSync(file))
             continue;
+        let rec;
         try {
-            const rec = JSON.parse(readFileSync(file, 'utf8'));
-            // Child (agent tree) first, then the watchdog wrapper.
-            for (const pid of [rec.childPid, rec.watchdogPid]) {
-                if (typeof pid === 'number' && Number.isInteger(pid) && pid > 0 && isAlive(pid)) {
-                    killTree(pid);
-                    killed++;
+            rec = JSON.parse(readFileSync(file, 'utf8'));
+        }
+        catch { /* malformed record — still consume the file below */ }
+        if (!rec) {
+            rmSync(file, { force: true });
+            continue;
+        }
+        // Child (agent tree) first, then the watchdog wrapper.
+        for (const [pid, incarnation, treeOwned] of [[rec.childPid, rec.childIncarnation, true], [rec.watchdogPid, rec.watchdogIncarnation, false]]) {
+            const alive = typeof pid === 'number' && Number.isInteger(pid) && pid > 0 && (isAlive(pid) || (treeOwned && isTreeAlive(pid)));
+            if (alive && typeof pid === 'number') {
+                if (isAlive(pid) && (typeof incarnation !== 'string' || currentIncarnation(pid) !== incarnation)) {
+                    throw new Error(`could not confirm legacy runner process incarnation for pid ${pid}`);
+                }
+                const terminated = treeOwned ? killChildTree(pid) : killWatchdog(pid);
+                if (!terminated && (isAlive(pid) || (treeOwned && isTreeAlive(pid)))) {
+                    throw new Error(`could not confirm legacy runner process tree termination for pid ${pid}`);
                 }
+                if (terminated)
+                    killed++;
             }
         }
-        catch { /* malformed record — still consume the file below */ }
         rmSync(file, { force: true });
     }
     return killed;
 }
+export function reapProviderProcesses(targetDir, isAlive, isTreeAlive, killTree, currentIncarnation = processIncarnation) {
+    const recordsDir = join(targetDir, '.yoke', 'provider-processes');
+    if (!existsSync(recordsDir))
+        return 0;
+    const expectedTarget = resolve(targetDir);
+    let killed = 0;
+    for (const name of readdirSync(recordsDir)) {
+        const recordPath = join(recordsDir, name);
+        let parsed = null;
+        try {
+            parsed = parseProviderProcessRecord(JSON.parse(readFileSync(recordPath, 'utf8')));
+        }
+        catch { /* malformed records are not trusted or consumed */ }
+        if (!parsed || parsed.targetDir !== expectedTarget)
+            continue;
+        if (isAlive(parsed.childPid) || isTreeAlive(parsed.childPid)) {
+            if (isAlive(parsed.childPid) && currentIncarnation(parsed.childPid) !== parsed.startedAt) {
+                throw new Error(`could not confirm provider process incarnation for pid ${parsed.childPid}`);
+            }
+            const terminated = killTree(parsed.childPid);
+            if (!terminated && (isAlive(parsed.childPid) || isTreeAlive(parsed.childPid))) {
+                throw new Error(`could not confirm provider process tree termination for pid ${parsed.childPid}`);
+            }
+            if (terminated)
+                killed++;
+        }
+        rmSync(recordPath, { force: true });
+    }
+    return killed;
+}
+export function isProviderTreeAlive(pid) {
+    if (process.platform === 'win32')
+        return isPidAlive(pid);
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // Cleans ONLY yoke-created runtime artifacts: recorded orphan runners,
 // .yoke/worktrees/*, and a stale loop.lock. Never touches user-created
 // worktrees, a lock whose holder is alive, or any process it did not record.
 export function runLoopCleanup(targetDir, opts = {}) {
     const git = opts.git ?? ((args, cwd) => { execFileSync('git', args, { cwd, stdio: 'pipe' }); });
     const isAlive = opts.isAlive ?? isPidAlive;
-    const killTree = opts.killTree ?? killProcessTree;
+    const killWatchdog = opts.killTree ?? killProcessForCleanup;
+    const killProviderTree = opts.killTree ?? killProcessTreeForCleanup;
+    const providerTreeAlive = process.platform === 'win32' ? isAlive : isProviderTreeAlive;
+    const currentIncarnation = opts.processIncarnation ?? processIncarnation;
     const wtDir = join(targetDir, '.yoke', 'worktrees');
     const recoveryFile = takeoverRecoveryPath(targetDir);
     if (opts.discardStaleRecovery && existsSync(recoveryFile)) {
@@ -112,20 +172,34 @@ export function runLoopCleanup(targetDir, opts = {}) {
             console.log(`Loop lock held by a live process (pid ${holder.pid}) — no cleanup performed.`);
             return 0;
         }
-        const killed = reapRecordedRunners(targetDir, wtDir, isAlive, killTree);
-        if (killed > 0)
-            console.log(`Killed ${killed} orphaned runner process tree(s) recorded in runner.pid files.`);
+        let killed;
+        try {
+            killed = reapRecordedRunners(targetDir, wtDir, isAlive, providerTreeAlive, killProviderTree, killWatchdog, currentIncarnation) + reapProviderProcesses(targetDir, isAlive, providerTreeAlive, killProviderTree, currentIncarnation);
+        }
+        catch (error) {
+            console.error(`Failed to reap recorded process trees: ${error.message}`);
+            return 1;
+        }
         let removed = 0;
         let failed = 0;
         if (existsSync(wtDir)) {
             for (const name of readdirSync(wtDir)) {
                 const path = join(wtDir, name);
+                try {
+                    killed += reapProviderProcesses(path, isAlive, providerTreeAlive, killProviderTree, currentIncarnation);
+                }
+                catch (error) {
+                    console.error(`Failed to reap provider processes for worktree ${path}: ${error.message}`);
+                    failed++;
+                    continue;
+                }
                 if (!opts.removeWorktrees) {
                     console.log(`Yoke worktree retained: ${path} (pass --remove-worktrees to remove it)`);
                     continue;
                 }
                 try {
                     git(['worktree', 'remove', '--force', path], targetDir);
+                    markCandidateWorktreeRemoved(targetDir, path);
                     removed++;
                 }
                 catch (e) {
@@ -140,6 +214,10 @@ export function runLoopCleanup(targetDir, opts = {}) {
                 catch { /* best-effort */ }
             }
         }
+        if (killed > 0)
+            console.log(`Killed ${killed} orphaned process tree(s) from project-scoped Yoke records.`);
+        if (opts.removeWorktrees && failed === 0)
+            cleanupClaims(targetDir);
         const lockFile = lockPath(targetDir);
         if (existsSync(lockFile)) {
             rmSync(lockFile, { force: true });
@@ -152,3 +230,27 @@ export function runLoopCleanup(targetDir, opts = {}) {
         releaseTakeoverLease(targetDir, cleanupLease.ownerToken);
     }
 }
+function markCandidateWorktreeRemoved(targetDir, worktree) {
+    const proofRoot = join(targetDir, '.yoke', 'proof');
+    if (!existsSync(proofRoot))
+        return;
+    for (const storyId of readdirSync(proofRoot)) {
+        const candidates = join(proofRoot, storyId, 'candidates');
+        if (!existsSync(candidates))
+            continue;
+        for (const candidateId of readdirSync(candidates)) {
+            const status = join(candidates, candidateId, 'status.json');
+            if (!existsSync(status))
+                continue;
+            try {
+                const parsed = JSON.parse(readFileSync(status, 'utf8'));
+                if (parsed.worktree !== worktree)
+                    continue;
+                writeFileSync(status, JSON.stringify({ ...parsed, state: 'removed', reason: 'external cleanup recovered candidate worktree' }));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+}

package/dist/loop/decision.js

@@ -72,12 +72,43 @@ export const DecisionResumeSchema = z.object({
     permissions: z.enum(['safe', 'unsafe', 'read-only']).optional(),
     parallel: z.number().int().positive().optional(),
     routing: z.boolean().optional(),
+    quality: z.boolean().optional(),
+    qualityRounds: z.number().int().positive().optional(),
+    qualityMinutes: z.number().int().positive().optional(),
+    qualityPolicy: z.enum(['blocking', 'advisory']).optional(),
+    candidates: z.number().int().positive().optional(),
     projectId: z.string().regex(/^[a-f0-9]{16}$/u).optional(),
     baseCommit: z.string().regex(/^[a-f0-9]{40,64}$/u).optional(),
     prdHash: z.string().regex(/^[a-f0-9]{64}$/u).optional(),
     decisionCommit: z.string().regex(/^[a-f0-9]{40,64}$/u).optional(),
     answerId: z.string().regex(/^[a-f0-9]{16}$/u).optional(),
 });
+export function buildTrustedDecisionResumeState(input) {
+    return DecisionResumeSchema.parse({
+        version: 1,
+        storyId: input.storyId,
+        requestId: input.requestId,
+        answered: false,
+        ...(input.maxIterations !== undefined ? { maxIterations: input.maxIterations } : {}),
+        ...(input.agent ? { agent: input.agent } : {}),
+        isolate: input.isolate,
+        ...(input.reviewer ? { reviewer: input.reviewer } : {}),
+        review: input.review,
+        allowSelfReview: input.allowSelfReview,
+        ...(input.timeoutMinutes !== undefined ? { timeoutMinutes: input.timeoutMinutes } : {}),
+        json: input.json,
+        ...(input.onAmbiguity ? { onAmbiguity: input.onAmbiguity } : {}),
+        ...(input.decisionPolicy ? { decisionPolicy: input.decisionPolicy } : {}),
+        permissions: input.permissions,
+        parallel: input.parallel,
+        routing: input.routing,
+        ...(input.quality !== undefined ? { quality: input.quality } : {}),
+        ...(input.qualityRounds !== undefined ? { qualityRounds: input.qualityRounds } : {}),
+        ...(input.qualityMinutes !== undefined ? { qualityMinutes: input.qualityMinutes } : {}),
+        ...(input.qualityPolicy ? { qualityPolicy: input.qualityPolicy } : {}),
+        ...(input.candidates !== undefined ? { candidates: input.candidates } : {}),
+    });
+}
 export function decisionRequestPath(targetDir) {
     return join(targetDir, '.yoke', 'decision-request.yaml');
 }

package/dist/loop/dispatcher.js

@@ -0,0 +1,334 @@
+import { randomUUID } from 'node:crypto';
+import { join, relative } from 'node:path';
+import { appendDecision, contextDir } from '../context/context.js';
+import { acquireClaim, heartbeatClaim, releaseClaim, requestClaimCancellation } from './claims.js';
+import { coordinateCandidates } from './candidates.js';
+import { MergeQueue } from './merge-queue.js';
+import { isAcceptanceCriterion, loadPrd, progress, savePrd } from './prd.js';
+import { readyStories } from './scheduler.js';
+import { createWorkerCleanup } from './worker-cleanup.js';
+function defaultClaims(targetDir, clock) {
+    return {
+        acquire: input => acquireClaim(targetDir, input.story.id, input.dispatcherId, {
+            dispatcherId: input.dispatcherId,
+            ownerToken: input.ownerToken,
+            ...(!input.candidateRace ? {
+                baseCommit: input.worktree.baseCommit,
+                worktree: input.worktree.path,
+                provider: input.provider.provider,
+                model: input.provider.model,
+            } : {}),
+            role: 'implementation',
+            now: clock(),
+        }) !== null,
+        heartbeat: input => { heartbeatClaim(targetDir, input.story.id, input.ownerToken, { now: clock() }); },
+        release: input => releaseClaim(targetDir, input.story.id, input.ownerToken, { now: clock() }),
+        cancel: (input, reason) => { requestClaimCancellation(targetDir, input.story.id, input.ownerToken, reason, { now: clock() }); },
+    };
+}
+async function gateResult(gates, path, worker) {
+    const { story } = worker;
+    const criteria = story.acceptance.filter(isAcceptanceCriterion);
+    if (criteria.length === 0 && gates.requireCriterionEvidence)
+        return { passed: false, summary: 'missing criterion evidence' };
+    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);
+        if (!result?.passed)
+            return { passed: false, summary: result?.summary ?? 'criterion verification failed' };
+    }
+    for (const gate of [gates.verify, gates.perf, gates.audit]) {
+        if (!gate)
+            continue;
+        const result = gate(path, story);
+        if (!result.passed)
+            return result;
+    }
+    return gates.qualityReview?.(path, story, worker) ?? { passed: true, summary: 'integrated gates passed' };
+}
+export function createDispatcher(options) {
+    const dispatcherId = options.dispatcherId ?? randomUUID();
+    const ids = options.id ?? randomUUID;
+    const clock = options.clock ?? (() => new Date());
+    const claims = options.claims ?? defaultClaims(options.targetDir, clock);
+    const queue = new MergeQueue();
+    const active = new Map();
+    const queued = new Map();
+    const areas = new Set();
+    const integrated = [];
+    const reopened = [];
+    const failed = [];
+    const failureReasons = new Map();
+    const integrationBlocks = [];
+    let iterations = 0;
+    let providerIndex = 0;
+    let paused = false;
+    let cancellationReason;
+    const reportProgress = () => options.onProgress?.({
+        dispatcherId,
+        maxConcurrency: options.maxConcurrency,
+        activeWorkers: active.size,
+        queuedCandidates: queued.size,
+        integrated: integrated.length,
+        reopened: reopened.length,
+        iteration: iterations,
+        progress: progress(options.stories),
+        workers: [...active.values()].map(worker => ({
+            story: worker.input.story.id,
+            storyTitle: worker.input.story.title,
+            provider: worker.input.provider.provider,
+            ...(worker.input.provider.model ? { model: worker.input.provider.model } : {}),
+            phase: 'implementing',
+        })),
+    });
+    const providerFor = (story) => {
+        if (story.agent) {
+            const configured = options.affinityProviders?.find(provider => provider.provider === story.agent)
+                ?? options.providers?.find(provider => provider.provider === story.agent);
+            return { ...(configured ?? { provider: story.agent }), provider: story.agent, role: 'implementation' };
+        }
+        const configured = options.providers?.[providerIndex++ % (options.providers?.length ?? 1)] ?? { provider: 'claude' };
+        return { ...configured, role: 'implementation' };
+    };
+    const cleanupWorker = createWorkerCleanup({
+        cleanupProcess: options.worktrees.cleanupProcess,
+        removeWorktree: input => options.worktrees.remove(input),
+        releaseClaim: input => {
+            if (claims.release(input) === false)
+                throw new Error('claim release failed');
+        },
+    });
+    const cleanup = (input) => {
+        if (input.story.area)
+            areas.delete(input.story.area);
+        cleanupWorker(input);
+    };
+    const releaseCandidateClaim = (input) => {
+        if (input.story.area)
+            areas.delete(input.story.area);
+        if (claims.release(input) === false)
+            throw new Error('claim release failed');
+    };
+    const persistPass = (input) => {
+        if (!options.prdPath)
+            return;
+        const path = join(input.worktree.path, relative(options.targetDir, options.prdPath));
+        const next = loadPrd(options.prdPath).map(story => story.id === input.story.id ? { ...story, passes: true } : story);
+        savePrd(path, next);
+        appendDecision(contextDir(input.worktree.path), { storyId: input.story.id, title: input.story.title, summary: `${input.story.id} integrated` });
+    };
+    const enqueue = (input, result) => {
+        let reason = 'integrated verification failed';
+        const task = queue.enqueue({
+            storyId: input.story.id,
+            rebase: async () => {
+                if (cancellationReason)
+                    throw new Error(cancellationReason);
+                if (!options.git.isClean(options.targetDir))
+                    throw new Error('target working tree is not clean');
+                const rebase = await options.git.rebase(input);
+                if (rebase.kind === 'reopen') {
+                    reason = rebase.reason;
+                    throw new Error(reason);
+                }
+                return rebase.expectedHead;
+            },
+            verify: async () => {
+                if (cancellationReason) {
+                    reason = cancellationReason;
+                    return false;
+                }
+                const gate = await gateResult(options.gates, input.worktree.path, input);
+                reason = gate.summary;
+                return gate.passed;
+            },
+            integrate: async (expectedHead) => {
+                if (cancellationReason)
+                    throw new Error(cancellationReason);
+                options.gates.integrationPhase?.(input, 'committing');
+                persistPass(input);
+                await options.git.commit(input);
+                await options.git.integrate(input, expectedHead);
+            },
+            postIntegrateVerify: () => {
+                if (!options.git.isClean(options.targetDir))
+                    throw new Error('target working tree is not clean after integration');
+            },
+        }).then(merge => {
+            switch (merge.status) {
+                case 'integrated':
+                    input.story.passes = true;
+                    integrated.push(input.story.id);
+                    result.routing.recordOutcome?.(true);
+                    return;
+                case 'integrated-but-blocked':
+                    input.story.passes = true;
+                    integrated.push(input.story.id);
+                    integrationBlocks.push(merge.reason);
+                    result.routing.recordOutcome?.(true);
+                    return;
+                case 'reopened':
+                    reopened.push(input.story.id);
+                    result.routing.recordOutcome?.(false);
+                    return;
+                default: {
+                    const unexpected = merge;
+                    throw new Error(`unexpected merge result: ${String(unexpected)}`);
+                }
+            }
+        }).finally(() => {
+            queued.delete(input.story.id);
+            options.gates.integrationPhase?.(input, undefined);
+            cleanup(input);
+            reportProgress();
+        });
+        queued.set(input.story.id, task);
+        reportProgress();
+    };
+    const launch = (story) => {
+        const provider = providerFor(story);
+        const ownerToken = ids();
+        const worktree = options.worktrees.create({ story, dispatcherId, ownerToken, provider });
+        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);
+            return;
+        }
+        iterations += 1;
+        if (story.area)
+            areas.add(story.area);
+        const candidateDispatch = candidateRace;
+        const task = (candidateDispatch && options.candidateCoordinator
+            ? Promise.resolve(options.candidateCoordinator(input)).then(coordinateCandidates).then(result => ({ source: 'candidates', result }))
+            : options.worker(input).then(result => ({ source: 'worker', result }))).then(async (outcome) => {
+            active.delete(story.id);
+            claims.heartbeat(input);
+            if (outcome.source === 'candidates') {
+                switch (outcome.result.kind) {
+                    case 'winner': {
+                        const winnerInput = {
+                            ...input,
+                            worktree: outcome.result.winner.worktree,
+                            provider: outcome.result.winner.provider,
+                        };
+                        enqueue(winnerInput, outcome.result.winner.result);
+                        return;
+                    }
+                    case 'paused':
+                        paused = true;
+                        releaseCandidateClaim(input);
+                        reportProgress();
+                        return;
+                    case 'cancelled':
+                        releaseCandidateClaim(input);
+                        reportProgress();
+                        return;
+                    case 'blocked':
+                        failed.push(story.id);
+                        failureReasons.set(story.id, outcome.result.summary);
+                        if (outcome.result.reason !== 'cleanup-error' && !outcome.result.recovery?.length)
+                            releaseCandidateClaim(input);
+                        reportProgress();
+                        return;
+                    default: {
+                        const unexpected = outcome.result;
+                        throw new Error(`unexpected candidate coordinator result: ${String(unexpected)}`);
+                    }
+                }
+            }
+            const result = outcome.result;
+            if (result.kind === 'paused') {
+                if (result.reason === 'decision')
+                    cancel(`critical decision required for story ${input.story.id}: ${result.summary}`);
+                else
+                    paused = true;
+                cleanup(input);
+                reportProgress();
+                return;
+            }
+            if (result.kind !== 'candidate') {
+                failed.push(story.id);
+                failureReasons.set(story.id, result.summary);
+                cleanup(input);
+                reportProgress();
+                return;
+            }
+            if (cancellationReason || paused || options.pause?.()) {
+                paused = true;
+                result.routing.recordOutcome?.(false);
+                cleanup(input);
+                reportProgress();
+                return;
+            }
+            enqueue(input, result);
+        }, error => {
+            active.delete(story.id);
+            failed.push(story.id);
+            failureReasons.set(story.id, error instanceof Error ? error.message : String(error));
+            try {
+                cleanup(input);
+            }
+            catch (cleanupError) {
+                reportProgress();
+                throw new AggregateError([error, cleanupError], `worker ${story.id} and cleanup failed`);
+            }
+            reportProgress();
+            if (!(error instanceof Error))
+                throw error;
+        });
+        active.set(story.id, { input, controller, task });
+        reportProgress();
+    };
+    const cancel = (reason) => {
+        if (cancellationReason)
+            return;
+        cancellationReason = reason;
+        for (const worker of active.values()) {
+            claims.cancel?.(worker.input, reason);
+            worker.controller.abort(reason);
+        }
+    };
+    const run = async () => {
+        for (;;) {
+            if (options.pause?.())
+                paused = true;
+            if (!paused && !cancellationReason && integrationBlocks.length === 0 && iterations < options.maxIterations) {
+                const busy = new Set([...active.keys(), ...queued.keys(), ...failed]);
+                const slots = Math.max(0, options.maxConcurrency - active.size);
+                const ready = readyStories(options.stories, { activeAreas: areas }).filter(story => !busy.has(story.id)).slice(0, slots);
+                for (const story of ready) {
+                    if (!story.area || !areas.has(story.area))
+                        launch(story);
+                }
+            }
+            if (active.size > 0) {
+                await Promise.race([...active.values()].map(worker => worker.task));
+                continue;
+            }
+            if (queued.size > 0) {
+                await Promise.race(queued.values());
+                continue;
+            }
+            if (cancellationReason)
+                return { status: 'cancelled', reason: cancellationReason, iterations, integrated, reopened, failed };
+            if (paused)
+                return { status: 'paused', iterations, integrated, reopened, failed };
+            if (integrationBlocks.length > 0)
+                return { status: 'blocked', reason: integrationBlocks[0], iterations, integrated, reopened, failed };
+            if (options.stories.every(story => story.passes))
+                return { status: 'complete', iterations, integrated, reopened, failed };
+            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 };
+            }
+            if (iterations >= options.maxIterations)
+                return { status: 'cap-reached', iterations, integrated, reopened, failed };
+            return { status: 'blocked', iterations, integrated, reopened, failed };
+        }
+    };
+    return { run, cancel };
+}

package/dist/loop/git.js

@@ -1,14 +1,16 @@
 import { execFileSync } from 'node:child_process';
 import { sanitizeCommitMessage } from './identity.js';
+const OUTPUT_ARTIFACT_EXCLUDE = ':(exclude).yoke/artifacts/**';
 export const realGitOps = {
     isClean(dir) {
-        const out = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString();
+        const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all', '--', '.', OUTPUT_ARTIFACT_EXCLUDE], { cwd: dir }).toString();
         return out.trim() === '';
     },
     commitAll(dir, message, identity) {
-        execFileSync('git', ['add', '-A'], { cwd: dir, stdio: 'pipe' });
-        const status = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString().trim();
-        if (status === '') {
+        execFileSync('git', ['reset', '--quiet', '--', '.yoke/artifacts'], { cwd: dir, stdio: 'pipe' });
+        execFileSync('git', ['add', '-A', '--', '.', OUTPUT_ARTIFACT_EXCLUDE], { cwd: dir, stdio: 'pipe' });
+        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: dir }).toString().trim();
+        if (staged === '') {
             throw new Error('nothing to commit after agent run');
         }
         const identityArgs = identity