@hecer/yoke 1.19.0 → 1.21.1

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';
@@ -17,7 +17,7 @@ import { runNew } from './new/command.js';
 import { runPrdDraft, runPrdCheck } from './prd/command.js';
 import { runPrdAssess } from './prd/assess.js';
 import { runPrdDecompose } from './prd/decompose.js';
-import { runLoopCleanup } from './loop/cleanup.js';
+import { runLoopCleanup, pruneWorktrees, pruneFleetWorktrees, listWorktrees, listFleetWorktrees } from './loop/cleanup.js';
 import { runFlowSmoke } from './smoke/command.js';
 import { maybeNotifyUpdate, currentYokeVersion } from './update/check.js';
 import { runUpgrade } from './update/upgrade.js';
@@ -62,6 +62,22 @@ export function runDesignScan(targetDir, opts) {
     console.log(`${label} — ✓`);
     return 0;
 }
+export function parseKeyValueFlags(args, flagName) {
+    const result = {};
+    for (const arg of args) {
+        if (arg.startsWith(`--${flagName}=`)) {
+            const raw = arg.slice(flagName.length + 3);
+            const eqIdx = raw.indexOf(':');
+            if (eqIdx > 0) {
+                const key = raw.slice(0, eqIdx).trim();
+                const val = raw.slice(eqIdx + 1).trim();
+                if (key && val)
+                    result[key] = val;
+            }
+        }
+    }
+    return result;
+}
 export function parseQualityFlags(args) {
     const quality = args.includes('--quality') ? true : args.includes('--no-quality') ? false : undefined;
     const qualityUnbounded = args.includes('--quality-unbounded') || undefined;
@@ -185,9 +201,16 @@ export function main(argv) {
                 console.error('Invalid --model-provider (expected deepseek,kimi)');
                 return 1;
             }
+            const runnerModel = rest.find(a => a.startsWith('--runner-model='))?.slice('--runner-model='.length);
+            const runnerReasoning = rest.find(a => a.startsWith('--runner-reasoning='))?.slice('--runner-reasoning='.length);
+            const agentModels = parseKeyValueFlags(rest, 'model');
+            const agentReasoning = parseKeyValueFlags(rest, 'reasoning');
+            const cleanWorktrees = rest.includes('--clean-worktrees');
             return runSetup(targetDir, {
                 modelProviders: modelProviders,
                 host: hostArg, agents, runner: runnerArg,
+                runnerModel, runnerReasoning, agentModels, agentReasoning, cleanWorktrees,
+                configureModels: rest.includes('--configure-models'),
                 codeGraph: graphArg,
                 codeIntelligence: intelligenceArg,
                 loop, routing, decisionPolicy: policyArg,
@@ -218,6 +241,47 @@ export function main(argv) {
                 return 2;
             }
         }
+        case 'worktrees': {
+            const sub = rest[0] ?? 'list';
+            const targetDir = rest.slice(1).find(a => !a.startsWith('-')) ?? '.';
+            const all = rest.includes('--all');
+            const force = rest.includes('--force');
+            if (sub === 'list') {
+                if (all) {
+                    const fleet = listFleetWorktrees();
+                    for (const [name, list] of Object.entries(fleet)) {
+                        console.log(`[${name}] ${list.length} worktree(s):`);
+                        for (const wt of list)
+                            console.log(`  ${wt}`);
+                    }
+                    return 0;
+                }
+                const list = listWorktrees(targetDir);
+                console.log(`Worktrees in ${targetDir} (${list.length}):`);
+                for (const wt of list)
+                    console.log(`  ${wt}`);
+                return 0;
+            }
+            if (sub === 'prune') {
+                if (all) {
+                    const fleet = pruneFleetWorktrees({ force });
+                    let totalRemoved = 0;
+                    for (const [name, res] of Object.entries(fleet)) {
+                        if (res.removed.length > 0 || res.failed.length > 0) {
+                            console.log(`[${name}] Removed: ${res.removed.length}, Failed: ${res.failed.length}`);
+                            totalRemoved += res.removed.length;
+                        }
+                    }
+                    console.log(`Fleet prune complete: ${totalRemoved} worktree(s) removed.`);
+                    return 0;
+                }
+                const res = pruneWorktrees(targetDir, { force });
+                console.log(`Pruned ${res.removed.length} worktree(s) in ${targetDir}${res.failed.length > 0 ? ` (${res.failed.length} failed)` : ''}.`);
+                return res.failed.length === 0 ? 0 : 1;
+            }
+            console.log('usage: yoke worktrees <list|prune> [dir] [--all] [--force]');
+            return 1;
+        }
         case 'dashboard': {
             const port = rest.find(a => a.startsWith('--port='))?.slice('--port='.length);
             if (port !== undefined && (!Number.isInteger(Number(port)) || Number(port) < 0 || Number(port) > 65535)) {
@@ -250,7 +314,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 +322,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 +340,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}`);
@@ -315,6 +383,11 @@ export function main(argv) {
         case 'retrofit': {
             const targetDir = rest.find(a => !a.startsWith('-')) ?? '.';
             const loop = rest.includes('--loop');
+            const cleanWorktrees = rest.includes('--clean-worktrees');
+            const runnerModel = rest.find(a => a.startsWith('--runner-model='))?.slice('--runner-model='.length);
+            const runnerReasoning = rest.find(a => a.startsWith('--runner-reasoning='))?.slice('--runner-reasoning='.length);
+            const agentModels = parseKeyValueFlags(rest, 'model');
+            const agentReasoning = parseKeyValueFlags(rest, 'reasoning');
             const agentArg = rest.find(a => a.startsWith('--agent='))?.slice('--agent='.length);
             const all = [...SUPPORTED_AGENTS];
             const agents = !agentArg || agentArg === 'all'
@@ -334,7 +407,7 @@ export function main(argv) {
                 console.error(`Invalid --code-intelligence value: ${ciArg} (expected off|shadow|active)`);
                 return 1;
             }
-            return runRetrofit(targetDir, { loop, agents, codeGraph, codeIntelligence: ciArg });
+            return runRetrofit(targetDir, { loop, agents, codeGraph, codeIntelligence: ciArg, cleanWorktrees, runnerModel, runnerReasoning, agentModels, agentReasoning });
         }
         case 'change': {
             const sub = rest[0];
@@ -383,7 +456,7 @@ export function main(argv) {
                 return 0;
             }
             if (sub === 'status') {
-                console.log(loopStatus(targetDir));
+                console.log(loopStatus(targetDir, undefined, { compact: rest.includes('--compact') }));
                 return 0;
             }
             if (sub === 'pause') {
@@ -614,7 +687,7 @@ export function main(argv) {
                 }
                 return runLoopCommand(targetDir, { maxIterations: rawMax, agent, isolate, resumeWorktree: rest.includes('--resume-worktree'), parallel, parallelAuto: parallelArg === '--parallel=auto', reviewer, review, allowSelfReview, timeoutMinutes, json, routing, onAmbiguity: oaArg, decisionPolicy: dpArg, permissions, ...(explore ? { explore: true } : {}), ...(exploreIntervalMinutes !== undefined ? { exploreIntervalMinutes } : {}), ...(exploreLimit.milliseconds !== undefined ? { exploreLimitMs: exploreLimit.milliseconds } : {}), ...qualityFlags.options });
             }
-            console.log(`usage: yoke loop <on|off|status|pause|decision|answer|resume [--discard] [--explore] [--explore-interval=<minutes>] [--explore-limit=<Nh|Nd|Nw>] [--quality|--no-quality] [--quality-rounds=N] [--quality-minutes=N] [--quality-policy=<blocking|advisory>] [--quality-unbounded] [--candidates=N]|cleanup [--remove-worktrees] [--discard-stale-recovery]|run [--max=N] [--explore] [--explore-interval=<minutes>] [--explore-limit=<Nh|Nd|Nw>] [--parallel=<auto|N>] [--runner=<${AGENT_LIST}>] [--reviewer=<${AGENT_LIST}>] [--review] [--allow-self-review] [--routing|--no-routing] [--isolate|--no-isolate] [--unsafe] [--timeout=<minutes>] [--decision-policy=<auto|critical>] [--quality|--no-quality] [--quality-rounds=N] [--quality-minutes=N] [--quality-policy=<blocking|advisory>] [--quality-unbounded] [--candidates=N] [--json]> [targetDir]`);
+            console.log(`usage: yoke loop <on|off|status [--compact]|pause|decision|answer|resume [--discard] [--explore] [--explore-interval=<minutes>] [--explore-limit=<Nh|Nd|Nw>] [--quality|--no-quality] [--quality-rounds=N] [--quality-minutes=N] [--quality-policy=<blocking|advisory>] [--quality-unbounded] [--candidates=N]|cleanup [--remove-worktrees] [--discard-stale-recovery]|run [--max=N] [--explore] [--explore-interval=<minutes>] [--explore-limit=<Nh|Nd|Nw>] [--parallel=<auto|N>] [--runner=<${AGENT_LIST}>] [--reviewer=<${AGENT_LIST}>] [--review] [--allow-self-review] [--routing|--no-routing] [--isolate|--no-isolate] [--unsafe] [--timeout=<minutes>] [--decision-policy=<auto|critical>] [--quality|--no-quality] [--quality-rounds=N] [--quality-minutes=N] [--quality-policy=<blocking|advisory>] [--quality-unbounded] [--candidates=N] [--json]> [targetDir]`);
             return 1;
         }
         case 'new': {
@@ -760,7 +833,7 @@ export function main(argv) {
             return runUpgrade();
         default:
             console.log('Project workflows: yoke check [dir] [--json|--protect] | goal set|run|resume|pause|status|handoff|budget [dir] | projects add|list|remove | dashboard [dir] [--port=N]');
-            console.log(`usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=${AGENT_LIST}|all] [--code-graph=graphify|serena] [--code-intelligence=off|shadow|active] [--loop] | change <add|status> [dir] | code-intelligence-server --workspace=<dir> --mode=<mode> | prd <draft|check|assess|decompose> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] | design-scan [dir] | flow-smoke [dir] | upgrade>`);
+            console.log(`usage: yoke <setup [dir] | new <dir> [--idea="..."] | validate [canonDir] | retrofit [targetDir] [--agent=${AGENT_LIST}|all] [--code-graph=graphify|serena] [--code-intelligence=off|shadow|active] [--clean-worktrees] [--runner-model=<model>] [--runner-reasoning=<effort>] [--model=<agent>:<model>] [--reasoning=<agent>:<effort>] [--loop] | worktrees <list|prune> [dir] [--all] [--force] | change <add|status> [dir] | code-intelligence-server --workspace=<dir> --mode=<mode> | prd <draft|check|assess|decompose> [dir] | loop <on|off|status|decision|answer|resume|run|cleanup> | context <init|status> | review [dir] | design-scan [dir] | flow-smoke [dir] | upgrade>`);
             return cmd ? 1 : 0;
     }
 }

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);