@hecer/yoke 1.19.0 → 1.20.0

package/dist/check/command.js

@@ -8,11 +8,159 @@ import { defaultConfig, loadConfig, resolveVerifyCommand } from '../retrofit/con
 import { commandVerifier } from '../loop/verify.js';
 import { workspaceFingerprint } from '../workspace/fingerprint.js';
 import { statePath } from '../workspace/state.js';
+import { spawn } from 'node:child_process';
+import { acquireSharedWorker } from '../loop/resource-pool.js';
+import { compactCommandOutput } from '../output/compact.js';
+import { writeOutputArtifact } from '../output/artifact.js';
+import { DEFAULT_OUTPUT_POLICY } from '../output/types.js';
+import { createProviderProcessRecord, filesystemProviderProcessRecordAdapter } from '../agents/process-record.js';
+import { trackProcessRecordIdentity } from '../agents/process-record-identity.js';
 const Criterion = z.object({ id: z.string().min(1).max(120), text: z.string().min(1).max(8000), commands: z.array(z.string().min(1).max(8000)).max(30) }).strict();
 const Acceptance = z.object({ version: z.literal(1), criteria: z.array(Criterion).max(200), protected: z.array(z.string().min(1)).max(500).default([]) }).strict().superRefine((value, ctx) => {
     if (new Set(value.criteria.map(c => c.id)).size !== value.criteria.length)
         ctx.addIssue({ code: 'custom', message: 'Duplicate acceptance criterion id' });
 });
+export async function checkProjectAsync(directory, options = {}) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal?.reason ?? 'Verification cancelled');
+    if (options.signal?.aborted)
+        abort();
+    else
+        options.signal?.addEventListener('abort', abort, { once: true });
+    const remaining = options.deadline === undefined ? undefined : options.deadline - Date.now();
+    if (remaining !== undefined && remaining <= 0)
+        controller.abort('Verification deadline reached');
+    const timer = remaining === undefined || remaining <= 0 ? undefined : setTimeout(() => controller.abort('Verification deadline reached'), remaining);
+    let lease;
+    let report;
+    let cleanupUnconfirmed = false;
+    try {
+        try {
+            lease = await acquireSharedWorker({ targetDir: directory, storyId: 'project-check', provider: 'codex', role: 'integration', resource: 'check', signal: controller.signal });
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                throw error;
+            // Persist failed evidence even when cancellation happens while queued.
+        }
+        if (options.deadline !== undefined && Date.now() >= options.deadline)
+            controller.abort('Verification deadline reached');
+        report = await checkProjectAsyncAdmitted(directory, { ...options, signal: controller.signal, onCleanupUnconfirmed: confirmed => { cleanupUnconfirmed = true; if (confirmed)
+                void confirmed.then(() => lease?.release()).catch(() => { }); } });
+        return report;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        options.signal?.removeEventListener('abort', abort);
+        if (!cleanupUnconfirmed)
+            await lease?.release();
+    }
+}
+function verifyCommandAsync(command, root, signal) {
+    if (signal?.aborted)
+        return Promise.resolve({ passed: false, summary: 'Verification cancelled or deadline reached' });
+    return new Promise(resolveResult => {
+        const child = spawn(command, { cwd: root, shell: true, detached: process.platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const record = child.pid ? createProviderProcessRecord(realpathSync(root), child.pid, 'verification', `unverified:${new Date().toISOString()}`) : undefined;
+        let publishFailed = false;
+        if (record) {
+            try {
+                filesystemProviderProcessRecordAdapter.publish(record);
+            }
+            catch {
+                publishFailed = true;
+            }
+        }
+        const cancelIdentity = trackProcessRecordIdentity(record, child);
+        let stdout = '', stderr = '', captured = 0, stopped = '', settled = false, exited = false, treeStopped = process.platform !== 'win32';
+        let resolveConfirmed = () => { };
+        const cleanupConfirmed = new Promise(resolveValue => { resolveConfirmed = resolveValue; });
+        const confirm = () => { if (exited && (!stopped || treeStopped)) {
+            cancelIdentity();
+            if (record)
+                filesystemProviderProcessRecordAdapter.remove(record.path);
+            resolveConfirmed();
+        } };
+        const finish = (passed, reason = '', cleanupUnconfirmed = false) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (cleanupTimer)
+                clearTimeout(cleanupTimer);
+            signal?.removeEventListener('abort', abort);
+            cancelIdentity();
+            if (record && exited && !cleanupUnconfirmed)
+                filesystemProviderProcessRecordAdapter.remove(record.path);
+            if (passed) {
+                resolveResult({ passed: true, summary: `verify passed: ${command}` });
+                return;
+            }
+            const raw = `=== stdout ===\n${stdout}\n=== stderr ===\n${stderr}`;
+            const compacted = compactCommandOutput(raw, { previewBytes: DEFAULT_OUTPUT_POLICY.previewBytes });
+            const parts = [`verify failed: ${command}${reason ? ` (${reason})` : ''}`, compacted.preview];
+            if (compacted.originalBytes > DEFAULT_OUTPUT_POLICY.artifactThresholdBytes) {
+                try {
+                    parts.push(writeOutputArtifact(root, raw, { phase: 'verify', storyId: process.env.YOKE_STORY }).marker);
+                }
+                catch {
+                    parts.push('[artifact unavailable]');
+                }
+            }
+            resolveResult({ passed: false, summary: parts.filter(Boolean).join('\n'), ...(cleanupUnconfirmed ? { cleanupUnconfirmed: true, cleanupConfirmed } : {}) });
+        };
+        let cleanupTimer;
+        const stop = (reason) => {
+            if (stopped || settled)
+                return;
+            stopped = reason;
+            if (child.pid) {
+                if (process.platform === 'win32') {
+                    const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+                    killer.on('error', () => { });
+                    killer.on('close', code => { treeStopped = code === 0; confirm(); if (exited && treeStopped)
+                        finish(false, stopped); });
+                    killer.unref();
+                }
+                else {
+                    try {
+                        process.kill(-child.pid, 'SIGKILL');
+                    }
+                    catch {
+                        child.kill('SIGKILL');
+                    }
+                }
+            }
+            if (process.platform !== 'win32')
+                child.kill('SIGKILL');
+            cleanupTimer = setTimeout(() => { if (process.platform !== 'win32')
+                child.kill('SIGKILL'); finish(false, `${stopped}; process cleanup could not be confirmed`, !exited || !treeStopped); }, 4000);
+        };
+        const abort = () => stop('cancelled or deadline reached');
+        const timer = setTimeout(() => stop('timed out'), 600_000);
+        const append = (stream, data) => {
+            const room = Math.max(0, 16 * 1024 * 1024 - captured);
+            captured += data.length;
+            if (stream === 'stdout')
+                stdout += data.subarray(0, room).toString('utf8');
+            else
+                stderr += data.subarray(0, room).toString('utf8');
+            if (captured > 16 * 1024 * 1024)
+                stop('capture limit exceeded');
+        };
+        child.stdout.on('data', data => append('stdout', data));
+        child.stderr.on('data', data => append('stderr', data));
+        child.on('error', () => finish(false, 'command could not start'));
+        child.on('close', code => { exited = true; confirm(); if (!stopped || treeStopped)
+            finish(!stopped && code === 0, stopped); });
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        if (publishFailed)
+            stop('process ownership record could not be published');
+    });
+}
 export function loadAcceptance(root) {
     const file = statePath(root, 'acceptance.yaml');
     return existsSync(file) ? Acceptance.parse(parse(readFileSync(file, 'utf8'))) : null;
@@ -112,3 +260,73 @@ export function checkProject(directory, options = {}) {
     return report;
 }
 export function checkExitCode(report) { return report.status === 'passed' ? 0 : report.status === 'failed' ? 1 : 2; }
+async function checkProjectAsyncAdmitted(directory, options) {
+    const root = realpathSync(directory);
+    const started = Date.now();
+    const before = workspaceFingerprint(root);
+    const problem = acceptanceProtectionProblem(root);
+    const criteria = [];
+    let cleanupUnconfirmed = false;
+    const rawExecute = options.execute ?? ((command, cwd) => verifyCommandAsync(command, cwd, options.signal));
+    const execute = async (command, cwd, signal) => {
+        if (cleanupUnconfirmed)
+            return { passed: false, summary: 'Previous verification cleanup unconfirmed; no further commands admitted', cleanupUnconfirmed: true };
+        const result = await rawExecute(command, cwd, signal);
+        if (result.cleanupUnconfirmed) {
+            cleanupUnconfirmed = true;
+            options.onCleanupUnconfirmed?.(result.cleanupConfirmed);
+        }
+        return result;
+    };
+    if (problem)
+        criteria.push({ id: 'protected-acceptance', text: 'Acceptance infrastructure unchanged', commands: [], status: 'failed', summary: problem });
+    else {
+        const manifest = loadAcceptance(root);
+        for (const criterion of manifest?.criteria ?? []) {
+            const results = [];
+            for (const command of criterion.commands) {
+                results.push(await (async () => {
+                    try {
+                        if (options.signal?.aborted)
+                            throw new Error('Verification cancelled or deadline reached');
+                        return await execute(command, root, options.signal);
+                    }
+                    catch (error) {
+                        return { passed: false, summary: error.message };
+                    }
+                })());
+            }
+            criteria.push({ ...criterion, status: results.length === 0 ? 'unverified' : results.every(r => r.passed) ? 'passed' : 'failed', summary: results.map(r => r.summary).join('\n') || 'No executable acceptance mapped' });
+        }
+        const command = resolveVerifyCommand(root, loadConfig(root) ?? defaultConfig('1.6.2'));
+        if (command) {
+            let result;
+            try {
+                if (options.signal?.aborted)
+                    throw new Error('Verification cancelled or deadline reached');
+                result = await execute(command, root, options.signal);
+            }
+            catch (error) {
+                result = { passed: false, summary: error.message };
+            }
+            criteria.push({ id: 'project-suite', text: 'Configured project verification', commands: [command], status: result.passed ? 'passed' : 'failed', summary: result.summary });
+        }
+        if (options.requirement)
+            criteria.push({ id: 'requested-outcome', text: options.requirement, commands: [], status: 'unverified', summary: 'Map this outcome to executable criteria in .yoke/acceptance.yaml; a green suite alone is not proof of this requirement.' });
+        if (criteria.length === 0)
+            criteria.push({ id: 'acceptance', text: 'Project acceptance', commands: [], status: 'unverified', summary: 'No acceptance manifest or project verification command found' });
+    }
+    const changed = workspaceFingerprint(root) !== before;
+    const afterProblem = acceptanceProtectionProblem(root);
+    if (changed || afterProblem)
+        criteria.push({ id: 'source-integrity', text: 'Checked source remained stable', commands: [], status: 'failed', summary: afterProblem ?? 'Source changed during verification; run check again on a stable tree' });
+    if (options.signal?.aborted)
+        criteria.push({ id: 'verification-cancelled', text: 'Verification completed within its allowed run', commands: [], status: 'failed', summary: 'Verification cancelled or deadline reached' });
+    const status = criteria.some(c => c.status === 'failed') ? 'failed' : criteria.some(c => c.status === 'unverified') ? 'unverified' : 'passed';
+    const id = randomUUID();
+    const evidencePath = statePath(root, 'checks', `${id}.json`);
+    const report = { ...(cleanupUnconfirmed ? { cleanupUnconfirmed: true } : {}), version: 1, id, generatedAt: new Date().toISOString(), fingerprint: before, status, summary: changed ? 'Source changed during verification' : `${criteria.filter(c => c.status === 'passed').length}/${criteria.length} checks passed; ${status}`, criteria, durationMs: Date.now() - started, evidencePath };
+    mkdirSync(dirname(evidencePath), { recursive: true });
+    writeFileSync(evidencePath, JSON.stringify(report, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+    return report;
+}

package/dist/cli.js

@@ -5,7 +5,7 @@ import { realpathSync } from 'node:fs';
 import { checkProject, checkExitCode, protectAcceptance } from './check/command.js';
 import { registerProject, listProjects, unregisterProject } from './dashboard/registry.js';
 import { startDashboard } from './dashboard/server.js';
-import { createProjectGoal, readProjectGoal, runProjectGoal, pauseProjectGoal, goalHandoff, budgetProjectGoal } from './goals/command.js';
+import { createProjectGoal, readProjectGoal, runProjectGoal, pauseProjectGoal, goalHandoff, budgetProjectGoal, bindProjectGoal } from './goals/command.js';
 import { validateCanon } from './canon/validate.js';
 import { runRetrofit } from './retrofit/command.js';
 import { setLoopEnabled, loopStatus, runLoopCommand } from './loop/run-command.js';
@@ -250,7 +250,7 @@ export function main(argv) {
                     const objective = value('objective');
                     if (!objective)
                         throw new Error('Use goal set [dir] --objective="..." with executable .yoke/acceptance.yaml criteria');
-                    const goal = createProjectGoal(targetDir, objective, { maxAttempts: value('attempts') ? Number(value('attempts')) : undefined, maxMinutes: value('minutes') ? Number(value('minutes')) : undefined, tokenBudget: value('tokens') ? Number(value('tokens')) : undefined });
+                    const goal = createProjectGoal(targetDir, objective, { maxAttempts: value('attempts') ? Number(value('attempts')) : undefined, maxMinutes: value('minutes') ? Number(value('minutes')) : undefined, maxWallMinutes: value('wall-minutes') ? Number(value('wall-minutes')) : undefined, tokenBudget: value('tokens') ? Number(value('tokens')) : undefined, acceptanceIds: value('criteria')?.split(',') });
                     console.log(JSON.stringify(goal));
                     return 0;
                 }
@@ -258,8 +258,12 @@ export function main(argv) {
                     console.log(JSON.stringify(readProjectGoal(targetDir)));
                     return 0;
                 }
+                if (sub === 'bind') {
+                    console.log(JSON.stringify(bindProjectGoal(targetDir, value('criteria')?.split(',') ?? [])));
+                    return 0;
+                }
                 if (sub === 'budget') {
-                    console.log(JSON.stringify(budgetProjectGoal(targetDir, { maxAttempts: value('attempts') ? Number(value('attempts')) : undefined, maxMinutes: value('minutes') ? Number(value('minutes')) : undefined, tokenBudget: value('tokens') ? Number(value('tokens')) : undefined, clearTokenBudget: rest.includes('--clear-token-budget') })));
+                    console.log(JSON.stringify(budgetProjectGoal(targetDir, { maxAttempts: value('attempts') ? Number(value('attempts')) : undefined, maxMinutes: value('minutes') ? Number(value('minutes')) : undefined, maxWallMinutes: value('wall-minutes') ? Number(value('wall-minutes')) : undefined, tokenBudget: value('tokens') ? Number(value('tokens')) : undefined, clearTokenBudget: rest.includes('--clear-token-budget') })));
                     return 0;
                 }
                 if (sub === 'handoff') {
@@ -272,15 +276,15 @@ export function main(argv) {
                     return 0;
                 }
                 if (sub === 'run' || sub === 'resume') {
-                    const provider = value('runner') ?? 'codex';
-                    if (!SUPPORTED_AGENTS.includes(provider))
+                    const provider = value('runner');
+                    if (provider && !SUPPORTED_AGENTS.includes(provider))
                         throw new Error('Unknown runner');
-                    return runProjectGoal(targetDir, { provider: provider, selection: { model: value('model') } }).then(goal => {
+                    return runProjectGoal(targetDir, { provider: provider, selection: { model: value('model'), reasoningEffort: value('effort'), bare: rest.includes('--bare') ? true : undefined }, native: rest.includes('--native-goal') ? true : rest.includes('--no-native-goal') ? false : undefined }).then(goal => {
                         console.log(JSON.stringify(goal));
                         return goal.status === 'complete' ? 0 : 1;
                     }).catch(error => { console.error(`Goal: ${error.message}`); return 2; });
                 }
-                throw new Error('Use goal set|status|run|resume|pause|handoff');
+                throw new Error('Use goal set|bind|status|run|resume|pause|handoff|budget');
             }
             catch (error) {
                 console.error(`Goal: ${error.message}`);

package/dist/dashboard/server.js

@@ -10,7 +10,8 @@ import { dashboardPage } from './page.js';
 import { readEvents } from '../observability/events.js';
 import { estimateSchedule } from '../estimation/schedule.js';
 import { pauseProjectGoal, runProjectGoal } from '../goals/command.js';
-import { runLoopCommand } from '../loop/run-command.js';
+import { runLoopCommand, resumeLoopCommand } from '../loop/run-command.js';
+import { readRunState } from '../loop/run-state.js';
 import { isPidAlive, readLock } from '../loop/lock.js';
 import { appendEvent } from '../observability/events.js';
 import { queueChange } from '../change/inbox.js';
@@ -331,9 +332,11 @@ export async function startDashboard(options = {}) {
                         send(409, { error: project.error });
                         return;
                     }
-                    if (current.goal)
+                    const saved = readRunState(project.root);
+                    if (current.goal && (!saved || saved.mode === 'goal'))
                         pauseProjectGoal(project.root);
-                    writePauseSignal(project.root);
+                    if (!saved || saved.mode !== 'goal')
+                        writePauseSignal(project.root);
                     const response = { status: 'pause-requested' };
                     send(200, response);
                     return;
@@ -355,13 +358,30 @@ export async function startDashboard(options = {}) {
                         send(409, { status: 'already-running', error: 'Project is already running' });
                         return;
                     }
-                    const goal = current.goal !== null && current.goal.status !== 'complete';
+                    let saved;
+                    try {
+                        saved = readRunState(project.root);
+                    }
+                    catch {
+                        send(409, { error: 'Saved execution state is invalid; start a fresh run from the CLI' });
+                        return;
+                    }
+                    const goal = saved ? saved.mode === 'goal' : current.goal !== null && current.goal.status !== 'complete';
+                    if (saved?.mode === 'goal') {
+                        const rawGoal = safeFile(project.root, '.yoke/goal.json');
+                        if (!rawGoal || JSON.parse(rawGoal).id !== saved.goalId) {
+                            send(409, { error: 'Saved goal identity no longer matches this project' });
+                            return;
+                        }
+                    }
                     activeResumes.add(project.root);
                     void Promise.resolve().then(async () => {
                         if (goal)
-                            await runProjectGoal(project.root);
+                            await runProjectGoal(project.root, saved?.mode === 'goal' ? { ...saved.options, provider: saved.options.agent, expectedGoalId: saved.goalId } : {});
+                        else if (saved)
+                            await resumeLoopCommand(project.root);
                         else
-                            await runLoopCommand(project.root, {});
+                            await runLoopCommand(project.root, { permissions: 'safe' });
                     }).catch(() => undefined).finally(() => { activeResumes.delete(project.root); });
                     const response = { status: 'resume-requested' };
                     send(202, response);