@hecer/yoke 1.18.0 → 1.19.0

package/canon/manifest.yaml

@@ -1,5 +1,5 @@
 name: yoke-canon
-version: 1.18.0
+version: 1.19.0
 agents: [claude, codex, gemini, qwen, opencode, kilo, pi, hermes]
 skills:
   - { id: tdd, path: skills/tdd, kind: methodology, invocation: auto }

package/dist/agents/process.js

@@ -6,6 +6,7 @@ import { createBoundedOutput, createTelemetryAccumulator } from './process-strea
 import { processIncarnation } from './process-incarnation.js';
 import { prepareWindowsInvocation, resolveWindowsCommand } from './windows-launch.js';
 import { createSupervision, supervisionLimits, assertPreviousProvidersStopped } from './supervision.js';
+import { prepareSolPiTemporaryConfig } from './sol-pi-runtime.js';
 function cancellationReason(signal) {
     return typeof signal.reason === 'string' && signal.reason.length > 0
         ? signal.reason
@@ -26,25 +27,48 @@ export function startProviderProcess(agent, invocation, options = {}) {
     let progress = () => { };
     const limits = supervisionLimits(invocation.cwd);
     const supervision = createSupervision(invocation.cwd, reason => failure(reason), () => progress(), options.attempt);
+    let restoreSolPiConfig = () => { };
     let prepared;
     try {
+        if (agent === 'pi')
+            restoreSolPiConfig = prepareSolPiTemporaryConfig(invocation.cwd);
         assertPreviousProvidersStopped(invocation.cwd);
         prepared = process.platform === 'win32' ? prepareWindowsInvocation(invocation) : { command: invocation.command, args: invocation.args, env: process.env };
     }
     catch (error) {
-        const message = error.message;
+        let message = error.message;
+        try {
+            restoreSolPiConfig();
+        }
+        catch (cleanupError) {
+            message = cleanupError.message;
+        }
         supervision.stop(message);
         return { pid: undefined, invocation, recordPath: '', cancel: () => false, completion: Promise.resolve({ kind: 'spawn-failed', error: message, invocation, pid: undefined, stdout: '', stderr: '', stdoutTruncated: false, stderrTruncated: false, telemetry: { usageAvailable: false } }) };
     }
     const spawnOptions = { ...prepared, cwd: invocation.cwd, shell: false, detached: process.platform !== 'win32' };
-    const child = spawn(spawnOptions.command, [...spawnOptions.args], {
-        cwd: spawnOptions.cwd,
-        shell: spawnOptions.shell,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        detached: spawnOptions.detached,
-        env: prepared.env,
-        windowsHide: true,
-    });
+    let child;
+    try {
+        child = spawn(spawnOptions.command, [...spawnOptions.args], {
+            cwd: spawnOptions.cwd,
+            shell: spawnOptions.shell,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: spawnOptions.detached,
+            env: prepared.env,
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        let message = error.message;
+        try {
+            restoreSolPiConfig();
+        }
+        catch (cleanupError) {
+            message = cleanupError.message;
+        }
+        supervision.stop(message);
+        return { pid: undefined, invocation, recordPath: '', cancel: () => false, completion: Promise.resolve({ kind: 'spawn-failed', error: message, invocation, pid: undefined, stdout: '', stderr: '', stdoutTruncated: false, stderrTruncated: false, telemetry: { usageAvailable: false } }) };
+    }
     const targetDir = resolve(invocation.cwd);
     const pid = child.pid;
     const startedAt = pid === undefined ? `unverified:${new Date().toISOString()}` : processIncarnation(pid) ?? `unverified:${new Date().toISOString()}`;
@@ -130,11 +154,18 @@ export function startProviderProcess(agent, invocation, options = {}) {
             return;
         settled = true;
         clearTimers();
-        supervision.stop(termination?.reason ?? (result.kind === 'succeeded' ? 'provider-exited' : 'provider-failed'), !termination || terminationConfirmed);
+        let completedResult = result;
+        try {
+            restoreSolPiConfig();
+        }
+        catch (error) {
+            completedResult = { ...evidence(), kind: 'spawn-failed', error: error.message };
+        }
+        supervision.stop(termination?.reason ?? (completedResult.kind === 'succeeded' ? 'provider-exited' : 'provider-failed'), !termination || terminationConfirmed);
         options.signal?.removeEventListener('abort', onAbort);
         if (!termination || terminationConfirmed)
             removeRecord();
-        resolveCompletion(result);
+        resolveCompletion(completedResult);
     };
     const evidence = () => ({
         invocation,

package/dist/agents/providers.js

@@ -1,5 +1,7 @@
 import { ModelSelectionSchema } from './contracts.js';
 import { fileURLToPath } from 'node:url';
+import { loadSolPiProjectConfig } from './sol-pi-runtime.js';
+const SOL_PI_EXTENSION = 'git:github.com/NVlabs/SoL-Pi@d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0';
 export { providerSpawnOptions, startProviderProcess, } from './process.js';
 const argsFor = (agent, permissions) => {
     if (agent === 'claude') {
@@ -76,6 +78,13 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
     if (parsedSelection.variant && !['opencode', 'kilo', 'pi', 'hermes'].includes(agent))
         throw new Error(`${agent} does not support a model variant selection`);
     const args = argsFor(agent, permissions);
+    if (agent === 'pi' && loadSolPiProjectConfig(cwd)?.solpi?.enabled) {
+        const [major, minor] = process.version.slice(1).split('.').map(Number);
+        if (major < 22 || (major === 22 && minor < 19)) {
+            throw new Error(`SoL-Pi requires Node.js 22.19 or newer; current version is ${process.version}`);
+        }
+        args.push('--extension', SOL_PI_EXTENSION);
+    }
     if (output.schemaFile !== undefined || output.jsonSchema !== undefined) {
         if (agent === 'codex' && output.schemaFile && output.jsonSchema === undefined) {
             if (/[\0\r\n]/u.test(output.schemaFile) || (process.platform === 'win32' && !/^[A-Za-z0-9_./:\\-]+$/u.test(output.schemaFile)))
@@ -119,7 +128,7 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
         else if (agent === 'pi')
             args.push('--thinking', parsedSelection.reasoningEffort);
         else if (agent === 'hermes')
-            args.push('--reasoning-effort', parsedSelection.reasoningEffort);
+            args.push('--reasoning', parsedSelection.reasoningEffort);
     }
     if (parsedSelection.variant) {
         if ((agent === 'opencode' || agent === 'kilo') && !parsedSelection.reasoningEffort)
@@ -134,7 +143,7 @@ export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe'
             if (parsedSelection.reasoningEffort && parsedSelection.reasoningEffort !== parsedSelection.variant)
                 throw new Error('Hermes reasoningEffort and variant selections must match');
             if (!parsedSelection.reasoningEffort)
-                args.push('--reasoning-effort', parsedSelection.variant);
+                args.push('--reasoning', parsedSelection.variant);
         }
     }
     if (agent === 'codex' && parsedSelection.nativeMultiAgent === false)

package/dist/agents/sol-pi-runtime.js

@@ -0,0 +1,76 @@
+import { lstatSync, mkdirSync, readFileSync, rmSync, rmdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { loadConfig, toSolPiNativeConfig } from '../retrofit/config.js';
+export function loadSolPiProjectConfig(directory) {
+    let current = resolve(directory);
+    while (true) {
+        const config = loadConfig(current);
+        if (config)
+            return config;
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function lstatIfPresent(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function assertNoConfigSymlinks(paths) {
+    for (const path of paths) {
+        if (lstatIfPresent(path)?.isSymbolicLink())
+            throw new Error('SoL-Pi refuses symbolic-link config paths: ' + path);
+    }
+}
+function removeCreatedDirectories(directories) {
+    for (const directory of [...directories].reverse()) {
+        try {
+            rmdirSync(directory);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT' && code !== 'ENOTEMPTY')
+                throw error;
+        }
+    }
+}
+export function prepareSolPiTemporaryConfig(workspace) {
+    const config = loadSolPiProjectConfig(workspace);
+    if (!config?.solpi?.enabled)
+        return () => { };
+    const piDirectory = resolve(workspace, '.pi');
+    const solPiConfigPath = join(piDirectory, 'sol-pi.json');
+    const configPaths = [piDirectory, solPiConfigPath];
+    assertNoConfigSymlinks(configPaths);
+    const existingConfig = lstatIfPresent(solPiConfigPath) ? readFileSync(solPiConfigPath) : undefined;
+    const createdDirectories = [];
+    const restore = () => {
+        assertNoConfigSymlinks(configPaths);
+        if (existingConfig === undefined)
+            rmSync(solPiConfigPath, { force: true });
+        else
+            writeFileSync(solPiConfigPath, existingConfig);
+        removeCreatedDirectories(createdDirectories);
+    };
+    try {
+        for (const directory of [piDirectory]) {
+            if (!lstatIfPresent(directory)) {
+                mkdirSync(directory);
+                createdDirectories.push(directory);
+            }
+        }
+        writeFileSync(solPiConfigPath, JSON.stringify(toSolPiNativeConfig(config)), { flag: existingConfig === undefined ? 'wx' : 'w' });
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+    return restore;
+}

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,6 +4,7 @@ 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';
@@ -99,6 +100,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 +236,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 });

package/dist/retrofit/config.js

@@ -32,6 +32,19 @@ const OutputPolicySchema = z.object({
         });
     }
 });
+const SolPiOptionsSchema = z.object({
+    actionFusion: z.boolean().default(false),
+    observationPack: z.boolean().default(false),
+    evidencePreservingReducer: z.boolean().default(false),
+    onlineContextCompact: z.boolean().default(false),
+    cacheWriteReadRatio: z.number().finite().nonnegative().default(12.5),
+});
+export const SolPiSettingsSchema = SolPiOptionsSchema.extend({ enabled: z.boolean().default(false) }).strict();
+export const SolPiNativeConfigSchema = SolPiOptionsSchema.extend({
+    version: z.literal(1),
+    evidencePreservingReducerProvider: z.string().min(1).optional(),
+    evidencePreservingReducerModel: z.string().min(1).optional(),
+}).strict();
 const RoutingWorkerSchema = z.object({
     id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
     agent: AgentSchema,
@@ -131,6 +144,7 @@ export const YokeConfigSchema = z.object({
     smoke: SmokeSchema.optional(),
     quality: ProjectQualityDefaultsSchema.optional(),
     output: OutputPolicySchema.optional(),
+    solpi: SolPiSettingsSchema.optional(),
     // Opt-in: upgrade yoke at loop START when a newer version is cached (never mid-run).
     update: z.object({ auto: z.boolean() }).optional(),
 });
@@ -143,6 +157,20 @@ export function resolveOutputPolicy(config) {
         artifactThresholdBytes: config.output?.artifactThresholdBytes ?? DEFAULT_OUTPUT_POLICY.artifactThresholdBytes,
     };
 }
+export function resolveSolPiSettings(config) {
+    return SolPiSettingsSchema.parse(config.solpi ?? {});
+}
+export function toSolPiNativeConfig(config) {
+    const settings = resolveSolPiSettings(config);
+    return SolPiNativeConfigSchema.parse({
+        version: 1,
+        actionFusion: settings.enabled && settings.actionFusion,
+        observationPack: settings.enabled && settings.observationPack,
+        evidencePreservingReducer: settings.enabled && settings.evidencePreservingReducer,
+        onlineContextCompact: settings.enabled && settings.onlineContextCompact,
+        cacheWriteReadRatio: settings.cacheWriteReadRatio,
+    });
+}
 export function configPath(targetDir) {
     return join(targetDir, '.yoke', 'config.yaml');
 }

package/docs/HARNESSES.md

@@ -77,7 +77,7 @@ runner:
   reasoningEffort: high
 ```
 
-This becomes `--provider openrouter --model anthropic/claude-sonnet-4 --reasoning-effort high`. Hermes accepts `--reasoning-effort`; configuring conflicting `variant` and `reasoningEffort` values is rejected.
+This becomes `--provider openrouter --model anthropic/claude-sonnet-4 --reasoning high`. Hermes accepts `--reasoning`; configuring conflicting `variant` and `reasoningEffort` values is rejected.
 
 The same fields are available on routing workers and quality critic/repair roles. Routing evidence is keyed by harness, provider, model, reasoning effort and variant, so a model profile does not inherit another profile's success history.
 

package/docs/SOL-PI.md

@@ -0,0 +1,41 @@
+# SoL-Pi with Yoke
+
+Yoke can add NVIDIA's SoL-Pi extension to opted-in Pi invocations. The extension is off by default. This guide records the published evidence and the limits of Yoke's integration so you can decide whether to enable it.
+
+## What the paper measured
+
+The [SoL-Pi paper](https://arxiv.org/abs/2609.20519) reports benchmark runs on fixed tasks, models, harness configurations, and API prices. “Token traffic” below is recorded model-token traffic; scores are benchmark scores. The authors tested 51 publicly released tasks from EdgeBench, a subset of its 134 tasks.
+
+On EdgeBench with GPT-5.6 Sol, the paper reports:
+
+| Configuration | Recorded token traffic | API cost | Average score |
+| --- | ---: | ---: | ---: |
+| Pi baseline | 2.1538 billion | $1,339 | 44.833 |
+| SoL-Pi Efficiency, all four mechanisms | 1.0990 billion (49.0% lower) | $894 (33.2% lower) | 42.003 (93.7% of Pi) |
+| SoL-Pi Performance, ObservationPack alone | 2.0224 billion (6.1% lower) | $1,271 | 47.208 (5.3% above Pi) |
+
+The complete efficiency configuration used fewer tokens and cost less in those runs, but scored lower than Pi. The separate performance configuration was the best-scoring single mechanism for GPT-5.6 Sol; it was not the full four-mechanism stack.
+
+The paper also ran the complete stack with Opus 5, a backend not used to search for the mechanisms. It reports 44.7% less token traffic and 33.5% lower API cost than Pi ($1,158 versus $1,741), with an average score of 42.224 versus Pi's 44.756 (94.3% of Pi's score).
+
+Results vary by benchmark. On 63 CPU-only Terminal-Bench 4 tasks, SoL-Pi solved 15 of 63 while Pi solved 18 of 63; total API cost was $211.12 versus $286.45 (26.3% lower), and cost per solved task was $14.07 versus $15.91 (11.6% lower). On six IMO 2026 problems, both systems passed three; SoL-Pi's reported cost per passed problem was $20.90 versus Pi's $25.32.
+
+These are the paper's measurements, not measurements of Yoke's pinned extension build. They are not a project-level prediction or guarantee of savings. Your tasks, models, provider prices, cache billing, and enabled mechanisms can produce different cost and capability results. Yoke does not measure or promise a savings percentage for an individual project.
+
+## Defaults and runtime
+
+The `solpi.enabled` project setting defaults to `false`. Yoke adds the pinned SoL-Pi extension only to a Pi invocation when that setting is enabled. Each mechanism—`actionFusion`, `observationPack`, `evidencePreservingReducer`, and `onlineContextCompact`—also defaults to `false`; enabling the extension does not turn those mechanisms on. `cacheWriteReadRatio` defaults to `12.5` and is an input to the compaction decision, not a live price lookup or bill estimate.
+
+Yoke pins SoL-Pi to [`d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0`](https://github.com/NVlabs/SoL-Pi/tree/d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0). The pinned upstream lists Node.js 22.19 or newer and `@earendil-works/pi-coding-agent@0.84.2` as its tested runtime baseline. Yoke checks the Node.js version but does not enforce the Pi version; other Pi releases are unverified. Yoke does not install Pi or set up provider authentication. Review the [pinned extension source](https://github.com/NVlabs/SoL-Pi/tree/d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0) before enabling it.
+
+## Trust, permissions, and data
+
+Pi project trust and extension approval remain Pi's responsibility. Yoke does not grant trust or add an automatic approval flag. If Pi requires the project to be trusted before loading project-local settings or an extension, trust it through Pi yourself.
+
+SoL-Pi runs inside the Pi process with that process's filesystem, process, network, and credential permissions. It is not a separate sandbox or permission boundary. Pi's selected tool permissions still apply: Yoke's safe Pi profile allows `read,bash,edit,write`, while its read-only profile allows `read,grep,find,ls`; the unsafe profile does not add an explicit tool allowlist. Action Fusion can run a model-requested validation command through Pi's shell tool. Review the extension at its pinned revision and choose Pi permissions appropriate for the project before enabling it.
+
+When enabled, Evidence-Preserving Reducer may send eligible diagnostic-log content to its configured reducer model using Pi-managed authentication. Logs can contain project data. Its evidence checks validate the reduced receipt against the archived source; they do not make the source private or act as a complete redaction step. Leave the reducer off for logs that must stay local, and follow the data rules for the provider that receives the request. See the upstream [SoL-Pi security policy](https://github.com/NVlabs/SoL-Pi/blob/d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0/SECURITY.md).
+
+## Configuration ownership
+
+The project's `.yoke/config.yaml` is the durable source for Yoke's SoL-Pi settings; the dashboard edits the same project settings. For an enabled Pi invocation, Yoke writes the corresponding temporary extension configuration to `.pi/sol-pi.json` in that invocation's workspace, the project-local path SoL-Pi reads. When the invocation ends, Yoke restores the file's previous contents or removes the temporary file and the `.pi` directory if Yoke created it. Pi only loads project-local extension configuration for a trusted project. Keep persistent SoL-Pi choices in Yoke's project configuration. Pi installation, project trust, and provider credentials remain owned by Pi and the user. See the pinned upstream [configuration contract](https://github.com/NVlabs/SoL-Pi/blob/d7ecfc089944f0d04b80122a0a9a6ca0d786f3d0/docs/configuration.md).

package/docs/code-intelligence-stdio-fix-2026-09-27.md

@@ -0,0 +1,8 @@
+# Code Intelligence stdio correction
+
+Acceptance criteria:
+- Serena and Graphify adapters initialize and call tools against newline-delimited JSON-RPC stdio servers.
+- Existing Graft and client tests remain green; TypeScript builds.
+- ReferDock uses explicit installed executable paths where Windows shims cannot be spawned.
+- Real read-only probes report backend failures honestly; no cloud graph processing or package upgrades are required.
+- Installed runtime changes retain backups and receive independent review before release.

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Cross-agent coding harness for eight supported CLIs: curated skill canon, mechanical safety gates, autonomous loop with proof artifacts. CLI: npm i -g @hecer/yoke",
   "contextFileName": "GEMINI-EXTENSION.md"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hecer/yoke",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "One harness, eight agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, Gemini CLI, Qwen Code, OpenCode, Kilo, Pi and Hermes: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
   "type": "module",
   "bin": {