@hecer/yoke 1.18.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/code-intelligence/adapters/graphify.js

@@ -2,7 +2,7 @@ import { McpBackendAdapter } from './mcp.js';
 export const GRAPHIFY_VERSION = '0.9.56';
 export function createGraphifyAdapter(cwd, override) {
     return new McpBackendAdapter({
-        name: 'graphify', version: GRAPHIFY_VERSION, cwd, command: override?.command ?? 'python', args: override?.args ?? ['-m', 'graphify.serve'], framing: 'content-length', semantic: false, documents: true,
+        name: 'graphify', version: GRAPHIFY_VERSION, cwd, command: override?.command ?? 'python', args: override?.args ?? ['-m', 'graphify.serve'], framing: 'line', semantic: false, documents: true,
         aliases: { context: 'query_graph', symbol: 'get_node', neighbors: 'get_neighbors', trace: 'shortest_path', impact: 'get_pr_impact' },
     });
 }

package/dist/code-intelligence/adapters/mcp.js

@@ -2,16 +2,37 @@ import { McpStdioClient } from '../mcp-client.js';
 function valueFromResult(value) {
     if (!value || typeof value !== 'object')
         return value;
-    if (value.structuredContent !== undefined)
-        return value.structuredContent;
+    if (value.isError === true)
+        throw new Error('MCP backend tool returned an error');
+    if (value.structuredContent !== undefined) {
+        const structured = value.structuredContent;
+        if (structured && typeof structured === 'object' && Object.keys(structured).length === 1 && typeof structured.result === 'string') {
+            try {
+                return JSON.parse(structured.result);
+            }
+            catch {
+                return structured.result;
+            }
+        }
+        return structured;
+    }
     const text = Array.isArray(value.content) ? value.content.find((item) => item?.type === 'text')?.text : undefined;
     if (typeof text !== 'string')
         return value;
     try {
-        return JSON.parse(text);
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === 'object' && Object.keys(parsed).length === 1 && typeof parsed.result === 'string') {
+            try {
+                return JSON.parse(parsed.result);
+            }
+            catch {
+                return parsed.result;
+            }
+        }
+        return parsed;
     }
     catch {
-        return { text };
+        return text;
     }
 }
 export class McpBackendAdapter {

package/dist/code-intelligence/adapters/serena.js

@@ -2,7 +2,7 @@ import { McpBackendAdapter } from './mcp.js';
 export const SERENA_VERSION = '1.7.1-dev';
 export function createSerenaAdapter(cwd, override) {
     return new McpBackendAdapter({
-        name: 'serena-lsp', version: SERENA_VERSION, cwd, command: override?.command ?? 'serena', args: override?.args ?? ['start-mcp-server', '--project-from-cwd', '--context', 'codex'], framing: 'content-length', semantic: true, documents: false,
+        name: 'serena-lsp', version: SERENA_VERSION, cwd, command: override?.command ?? 'serena', args: override?.args ?? ['start-mcp-server', '--project-from-cwd', '--context', 'codex'], framing: 'line', semantic: true, documents: false,
         aliases: {
             symbol: 'find_symbol', references: 'find_referencing_symbols', implementations: 'find_implementations', overview: 'get_symbols_overview', diagnostics: 'get_diagnostics_for_file',
             rename: 'rename_symbol', replace_symbol_body: 'replace_symbol_body', insert_before_symbol: 'insert_before_symbol', insert_after_symbol: 'insert_after_symbol', safe_delete: 'safe_delete_symbol',

package/dist/code-intelligence/coordinator.js

@@ -185,9 +185,10 @@ export class CodeIntelligenceCoordinator {
         const name = input.symbol_id ?? input.query;
         const reference = symbolArgs(name, input.path ?? '');
         const graft = await this.call('graft', 'context', { query: name, limit: 10, ...(input.path ? { in: input.path } : {}) }, input.timeout_ms, state);
+        // Graft returns search prose, not structured symbol definitions. Preserve
+        // its provenance without inventing a symbol from the response heading.
         if (graft !== null) {
             const normalized = normalizeItems(graft, this.evidenceOptions(snapshot, 'graft'), 'symbol', 20);
-            symbols.push(...normalized.items.map(item => ({ symbol_id: `graft:${item.item_id}`, name: item.excerpt.split(/\s|\(|\{/u)[0] ?? name, path: item.path, kind: 'unknown', signature: item.excerpt.slice(0, 500), evidence_ids: item.evidence_ids })));
             provenance.push(...normalized.provenance);
         }
         const symbol = await this.call('serena-lsp', 'symbol', { name_path_pattern: reference.name_path, depth: 0, relative_path: reference.relative_path, include_body: false, max_matches: 20 }, input.timeout_ms, state);

package/dist/code-intelligence/evidence.js

@@ -12,7 +12,7 @@ function textOf(raw) {
     }
 }
 function locate(text, root) {
-    const match = /(?:^|[\s("'`])((?:[A-Za-z0-9_.@-]+[\\/])*[A-Za-z0-9_.@-]+\.[A-Za-z0-9]+):(\d+)/u.exec(text);
+    const match = /(?:^|[\s("'`])((?:[A-Za-z0-9_.@-]+[\\/])*[A-Za-z0-9_.@-]+\.[A-Za-z0-9]+):L?(\d+)/u.exec(text);
     if (!match)
         return { path: null, line: null };
     try {
@@ -44,6 +44,17 @@ export function normalizeItems(raw, options, kind = 'code', limit = 100) {
         if (!excerpt)
             continue;
         const p = makeProvenance(options, excerpt, excerpt.toLowerCase().includes('ambiguous') ? 'ambiguous' : 'resolved');
+        if (candidate && typeof candidate === 'object' && typeof candidate.relative_path === 'string') {
+            try {
+                p.source_path = assertSafePath(options.root, candidate.relative_path);
+                p.content_hash = options.snapshot.files.find(file => file.path === p.source_path)?.hash ?? null;
+            }
+            catch {
+                p.source_path = null;
+                p.content_hash = null;
+                p.resolution = 'unresolved';
+            }
+        }
         const id = evidenceId(p, excerpt);
         provenance.push(p);
         items.push({ item_id: `item-${hash(excerpt).slice(0, 24)}`, kind, path: p.source_path, excerpt, evidence_ids: [id], rank: items.length });

package/dist/code-intelligence/mcp-client.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-/** Small, bounded stdio MCP client. It supports Graft's newline JSON-RPC and the
- * Content-Length framing used by the Python MCP SDK (Graphify and Serena). */
+/** Small, bounded stdio MCP client. Supports newline JSON-RPC used by the
+ * backend SDKs and optional Content-Length framing for legacy peers. */
 export class McpStdioClient {
     command;
     args;

package/dist/dashboard/page.js

@@ -33,7 +33,7 @@ function validDate(value){if(!/^\\d{4}-\\d{2}-\\d{2}$/u.test(value))return false
 function parseNavigationHash(hash){
   const params=new URLSearchParams(String(hash||'').replace(/^#/u,''));const screen=params.get('screen')||'overview',project=params.get('project'),view=params.get('view')||'now',period=Number(params.get('period')||30),group=params.get('group')||'day',from=params.get('from')||'',to=params.get('to')||'',query=params.get('query')||'',status=params.get('status')||'all',sort=params.get('sort')||'attention';
   const datesValid=(!from&&!to)||(validDate(from)&&validDate(to)&&from<=to&&Date.parse(to+'T00:00:00Z')-Date.parse(from+'T00:00:00Z')<=365*86400000);
-  if(!['overview','workspace','project'].includes(screen)||!['now','usage','results','history'].includes(view)||![1,7,30,90,365].includes(period)||!['day','week','month'].includes(group)||!['all','active','attention'].includes(status)||!['attention','activity','tokens','cost','acceptance','name'].includes(sort)||query.length>200||!datesValid||(screen==='project'&&!/^[a-f0-9]{32}$/u.test(project||'')))return {...defaultNavigation};
+  if(!['overview','workspace','project'].includes(screen)||!['now','usage','results','history','settings'].includes(view)||![1,7,30,90,365].includes(period)||!['day','week','month'].includes(group)||!['all','active','attention'].includes(status)||!['attention','activity','tokens','cost','acceptance','name'].includes(sort)||query.length>200||!datesValid||(screen==='project'&&!/^[a-f0-9]{32}$/u.test(project||'')))return {...defaultNavigation};
   const state={screen,project:screen==='project'?project:null,view,period,group,from,to};if(params.has('query'))state.query=query;if(params.has('status'))state.status=status;if(params.has('sort'))state.sort=sort;return state;
 }
 function serializeNavigationHash(state){const params=new URLSearchParams({screen:state.screen||'overview',view:state.view||'now',period:String(state.period||30),group:state.group||'day'});if(state.project)params.set('project',state.project);if(state.from&&state.to){params.set('from',state.from);params.set('to',state.to)}if(state.query)params.set('query',state.query);if(state.status&&state.status!=='all')params.set('status',state.status);if(state.sort&&state.sort!=='attention')params.set('sort',state.sort);return '#'+params.toString()}

package/dist/dashboard/panels.js

@@ -125,25 +125,47 @@ function renderUsageHistory(current,previous,project={}){
 }
 function renderResults(p,a){const t=a.total;content.append(append(el('div',undefined,'metrics'),metric('Accepted in period',t.accepted,'Recorded acceptance events'),metric('Repair phases',t.repairs,'Routing escalations: '+t.escalations),metric('Tokens / acceptance',rate(t.tokensPerAccepted),'Reported input + output, including failed work')));const attempts=panel('Measured outcomes');attempts.append(el('p','Ended attempts: '+t.attempts+' · explicitly successful attempts: '+t.successfulAttempts+' · average summed attempt time per acceptance: '+duration(t.timePerAcceptedMs)));attempts.append(el('p','Worker termination alone is not counted as successful acceptance. Rates only describe recorded activity in the selected period.','muted'));attempts.append(table(['Task','Attempts','Accepted','Repairs','Escalations','Tokens / acceptance'],a.tasks.map(v=>[v.storyId,v.attempts,v.accepted,v.repairs,v.escalations,rate(v.tokensPerAccepted)])));content.append(attempts);const checks=panel('Latest saved acceptance evidence');if(p.check){checks.append(el('p',p.check.summary));for(const c of p.check.criteria){const item=row(c.text,c.id,c.status);item.firstChild.append(append(el('details'),el('summary','View evidence'),el('p',c.summary)));checks.append(item)}checks.append(el('p','Checked '+p.check.generatedAt+' · historical evidence; independent of the selected statistics period.','muted'))}else checks.append(el('p','No saved independent check.','empty'));content.append(checks);const goals=panel('Saved goal attempts');for(const attempt of p.goal?.attempts||[])goals.append(row(attempt.provider||'Agent',(attempt.summary||'')+' · '+duration(attempt.durationMs)+' · input '+tokenText(attempt.inputTokens)+' / output '+tokenText(attempt.outputTokens),attempt.success?'finished':'failed'));content.append(goals)}
 function renderHistoryExplorer(project,history){const state=projectStatus(project),view=panel('History explorer');view.append(el('p','Recorded events and completed runs in the selected UTC window. The list is bounded to the latest 100 events.','muted'));const events=timelineEvents(history.events||[]);if(!events.length)view.append(el('p','No recorded history in this period.','empty'));else{const list=el('div',undefined,'timeline');for(const event of events)list.append(timelineItem(event));view.append(list)}const runs=panel('Run history');if(!(history.runs||[]).length)runs.append(el('p','No recorded runs in this period.','empty'));else runs.append(table(['Run','Started','Ended','Agent','Provider','Model','Tokens','Accepted','Outcome'],history.runs.map(run=>[dimensionLabel(run.runId),run.startedAt||'Not reported',run.endedAt||'Not reported',dimensionLabel(run.agent),dimensionLabel(run.provider),dimensionLabel(run.model),rankingText(run.total?.tokens?.total),rankingText(run.total?.outcomes?.accepted),rankingText(run.total?.outcomes?.successfulAttempts)])));content.append(renderCoverage(history,{stale:state.stale,unavailable:false}),runs,view)}
+function solPiRatioError(value){const text=String(value);const ratio=Number(text);return text.trim()===''||!Number.isFinite(ratio)||ratio<0?'Enter a finite cache write/read ratio of 0 or more.':null}
+async function saveSolPiSettings(projectId,settings,feedback){
+  const error=solPiRatioError(settings.cacheWriteReadRatio);if(error){feedback.className='settings-feedback notice';feedback.textContent=error;return}
+  feedback.className='settings-feedback muted';feedback.textContent='Saving settings…';
+  try{await api('/api/projects/'+projectId+'/settings',{method:'POST',headers:{'content-type':'application/json','x-yoke-token':sessionToken},body:JSON.stringify({...settings,cacheWriteReadRatio:Number(settings.cacheWriteReadRatio)})});feedback.className='settings-feedback muted';feedback.textContent='Settings saved.'}
+  catch(error){feedback.className='settings-feedback notice';feedback.textContent='Could not save settings: '+error.message}
+}
+function renderSolPiSettings(project,settings){
+  const view=panel('SoL-Pi settings');view.append(el('p','SoL-Pi is off by default. Change the master switch and any mechanism switches, then save.','muted'));
+  const controls={},toggles=[['enabled','Enable SoL-Pi (off by default)'],['actionFusion','Action fusion'],['observationPack','Observation packing'],['evidencePreservingReducer','Evidence-preserving reducer'],['onlineContextCompact','Online context compaction']];
+  for(const [key,label] of toggles){const input=el('input');input.type='checkbox';input.checked=settings[key]===true;input.setAttribute('role','switch');input.setAttribute('aria-label',label);controls[key]=input;view.append(append(el('label',undefined,'setting-toggle'),input,el('span',label)))}
+  const ratioLabel=el('label',undefined,'field'),ratio=el('input');ratio.type='number';ratio.min='0';ratio.step='any';ratio.value=String(settings.cacheWriteReadRatio);ratio.setAttribute('aria-label','Cache write/read ratio');ratioLabel.append(el('span','Cache write/read ratio','label'),ratio);view.append(ratioLabel);
+  view.append(el('p','The pinned SoL-Pi extension executes inside Pi. Review the pinned SoL-Pi extension before enabling it.','muted'));
+  view.append(el('p','SoL-Pi needs a compatible Pi runtime installed and configured; Yoke does not install or authenticate Pi. For headless runs, Pi requires explicit project trust before it loads project-local settings. Open Pi, run /trust, then restart. Yoke does not grant trust.','muted'));
+  view.append(el('p','The evidence-preserving reducer may make a model call using diagnostic logs; those logs can contain project data. Review the selected provider and model before enabling it.','muted'));
+  const feedback=el('p','Save your changes to apply them.','settings-feedback muted');feedback.setAttribute('role','status');feedback.setAttribute('aria-live','polite');view.append(feedback);
+  view.append(button('Save settings',()=>saveSolPiSettings(project.id,{enabled:controls.enabled.checked,actionFusion:controls.actionFusion.checked,observationPack:controls.observationPack.checked,evidencePreservingReducer:controls.evidencePreservingReducer.checked,onlineContextCompact:controls.onlineContextCompact.checked,cacheWriteReadRatio:ratio.value},feedback),true));
+  return view
+}
 async function showProject(id){
   const request=beginRequest();selected=id;nav();
   try{
     const bounds=periodWindows(Date.now(),periodDays,customFrom,customTo),detailRequest=api('/api/projects/'+id,{},request.signal);
-    let project,current=null,previous=null,history=null;
+    let project,current=null,previous=null,history=null,settings=null;
     if(projectView==='usage'){
       [project,current,previous]=await Promise.all([detailRequest,api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.current),{},request.signal),api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.previous),{},request.signal)]);
     }else if(projectView==='results'){
       [project,current]=await Promise.all([detailRequest,api('/api/projects/'+id+'/analytics?'+queryPeriod(bounds.current),{},request.signal)]);
     }else if(projectView==='history'){
       [project,history]=await Promise.all([detailRequest,api('/api/projects/'+id+'/history?'+queryPeriod(bounds.current)+'&limit=100',{},request.signal)]);
+    }else if(projectView==='settings'){
+      [project,settings]=await Promise.all([detailRequest,api('/api/projects/'+id+'/settings',{},request.signal)]);
     }else project=await detailRequest;
     if(!currentRequest(request.version)||navigationState.screen!=='project'||selected!==id)return;
     lastSuccessfulSync=new Date().toISOString();heading(project.name,project.goal?.objective||'Saved project work');content.append(el('p',project.root,'path'));for(const error of project.errors)content.append(el('p',error,'notice'));
-    const tabs=el('div',undefined,'actions');for(const [view,label] of [['now','Now'],['usage','Usage & time'],['results','Results'],['history','History']]){const control=button(label,()=>setNavigation({view}),projectView===view);control.setAttribute('aria-pressed',String(projectView===view));tabs.append(control)}
+    const tabs=el('div',undefined,'actions');for(const [view,label] of [['now','Now'],['usage','Usage & time'],['results','Results'],['history','History'],['settings','Settings']]){const control=button(label,()=>setNavigation({view}),projectView===view);control.setAttribute('aria-pressed',String(projectView===view));tabs.append(control)}
     content.append(tabs);
     if(projectView==='now'){
       const tasks=project.stories||[],state=projectStatus(project);content.append(append(el('div',undefined,'metrics'),metric('Accepted tasks',tasks.filter(task=>task.passes).length+' / '+tasks.length,'Saved acceptance state'),metric('Remaining time',project.estimate?.available?duration(project.estimate.lowerMs)+' – '+duration(project.estimate.upperMs):'Unknown',project.estimate?.available?project.estimate.sampleCount+' samples · empirical range':'No reliable duration history'),metric('Project status',state.primary,state.goal&&state.loop&&state.goal!==state.loop?'Goal '+state.goal+' · loop '+(state.stale?'unconfirmed':state.loop):'Latest reported state')));renderNow(project);
-    }else{periodControls(id);if(projectView==='usage')renderUsageHistory(current,previous,projectStatus(project));else if(projectView==='history')renderHistoryExplorer(project,history);else renderResults(project,current)}
+    }else if(projectView==='settings')content.append(renderSolPiSettings(project,settings));
+    else{periodControls(id);if(projectView==='usage')renderUsageHistory(current,previous,projectStatus(project));else if(projectView==='history')renderHistoryExplorer(project,history);else renderResults(project,current)}
   }catch(error){if(currentRequest(request.version)&&navigationState.screen==='project'&&selected===id&&!isAbort(error)){heading('Project unavailable','Offline or unavailable: '+error.message);content.append(renderCoverage({errors:[],coverage:'Historical analytics are unavailable for this project.'},{unavailable:true}))}}
 }
 if(typeof setInterval==='function')setInterval(()=>{if(selected&&projectView==='now'&&typeof document.hidden!=='undefined'&&!document.hidden&&!['INPUT','SELECT','TEXTAREA'].includes(document.activeElement?.tagName)&&!document.activeElement?.matches?.(':focus-visible'))showProject(selected)},5000);

package/dist/dashboard/server.js

@@ -4,12 +4,14 @@ import { lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from '
 import { join } from 'node:path';
 import { parse } from 'yaml';
 import { z } from 'zod';
+import { configPath, defaultConfig, loadConfig, resolveSolPiSettings, saveConfig, SolPiSettingsSchema } from '../retrofit/config.js';
 import { listProjects } from './registry.js';
 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';
@@ -99,6 +101,28 @@ function writePauseSignal(root) {
             throw error;
     }
 }
+function assertSafeConfigTarget(root) {
+    const directory = join(root, '.yoke');
+    const file = configPath(root);
+    try {
+        const stat = lstatSync(directory);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw new Error('Unsafe project settings target');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    try {
+        const stat = lstatSync(file);
+        if (stat.isSymbolicLink() || !stat.isFile())
+            throw new Error('Unsafe project settings target');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
 function projectIsRunning(root) {
     if (activeResumes.has(root))
         return true;
@@ -213,13 +237,51 @@ export async function startDashboard(options = {}) {
                 send(200, workspaceAnalytics(listProjects(), period, sort));
                 return;
             }
-            const match = /^\/api\/projects\/([a-f0-9]{32})(\/pause|\/resume|\/notes|\/changes|\/analytics|\/history|\/events)?$/u.exec(path);
+            const match = /^\/api\/projects\/([a-f0-9]{32})(\/pause|\/resume|\/notes|\/changes|\/settings|\/analytics|\/history|\/events)?$/u.exec(path);
             if (match) {
                 const project = listProjects().find(project => project.id === match[1]);
                 if (!project) {
                     send(404, { error: 'Unknown project' });
                     return;
                 }
+                if (req.method === 'GET' && match[2] === '/settings') {
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    assertSafeConfigTarget(project.root);
+                    const config = loadConfig(project.root) ?? defaultConfig('0.0.0');
+                    send(200, resolveSolPiSettings(config));
+                    return;
+                }
+                if (req.method === 'POST' && match[2] === '/settings') {
+                    let settings;
+                    try {
+                        settings = SolPiSettingsSchema.parse(await requestBody(req, {}));
+                    }
+                    catch (error) {
+                        send(error.message === 'Dashboard request body too large' ? 413 : 400, { error: error.message === 'Dashboard request body too large' ? error.message : 'Invalid project settings payload' });
+                        return;
+                    }
+                    if (project.error) {
+                        send(409, { error: project.error });
+                        return;
+                    }
+                    try {
+                        assertSafeConfigTarget(project.root);
+                        const config = loadConfig(project.root) ?? defaultConfig('0.0.0');
+                        saveConfig(project.root, { ...config, solpi: settings });
+                    }
+                    catch (error) {
+                        if (error.message === 'Unsafe project settings target') {
+                            send(409, { error: error.message });
+                            return;
+                        }
+                        throw error;
+                    }
+                    send(200, settings);
+                    return;
+                }
                 if (req.method === 'GET' && match[2] === '/analytics') {
                     if (project.error) {
                         send(409, { error: project.error });
@@ -270,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;
@@ -294,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);