@hecer/yoke 1.18.0 → 1.20.0

package/bench/results/goal-integration-probes-2026-09-29.json

@@ -0,0 +1,107 @@
+{
+  "date": "2026-09-29",
+  "auditedVersion": "1.19.0",
+  "codexVersion": "0.161.0-alpha.2",
+  "poolProbe": {
+    "fakeExecutor": true,
+    "limit": 1,
+    "executedWhilePoolFull": true,
+    "goalStatus": "complete"
+  },
+  "budgetProbe": {
+    "fakeExecutor": true,
+    "tokenBudget": 1,
+    "measuredTokens": 100,
+    "timeBudgetMs": 60,
+    "totalWallMs": 652,
+    "recordedAgentMs": 3,
+    "status": "complete"
+  },
+  "objectiveProbe": {
+    "requestedArtifact": "new-feature.txt",
+    "requestedArtifactExists": false,
+    "acceptance": "only checks old-feature.txt",
+    "executorCalled": false,
+    "attempts": 0,
+    "status": "complete"
+  },
+  "nativeProtocolProbe": {
+    "modelDevelopmentTurnRequested": false,
+    "archived": true,
+    "calls": [
+      {
+        "method": "thread/goal/set",
+        "requestedStatus": null,
+        "returnedStatus": "active",
+        "tokenBudget": 1000,
+        "tokensUsed": 0
+      },
+      {
+        "method": "thread/goal/get",
+        "requestedStatus": null,
+        "returnedStatus": "active",
+        "tokenBudget": 1000,
+        "tokensUsed": 0
+      },
+      {
+        "method": "thread/goal/set",
+        "requestedStatus": "paused",
+        "returnedStatus": "paused",
+        "tokenBudget": 1000,
+        "tokensUsed": 0
+      },
+      {
+        "method": "thread/goal/get",
+        "requestedStatus": null,
+        "returnedStatus": "paused",
+        "tokenBudget": 1000,
+        "tokensUsed": 0
+      },
+      {
+        "method": "thread/goal/clear",
+        "requestedStatus": null,
+        "returnedStatus": null,
+        "tokenBudget": null,
+        "tokensUsed": null,
+        "cleared": true
+      },
+      {
+        "method": "thread/goal/get",
+        "requestedStatus": null,
+        "returnedStatus": null,
+        "tokenBudget": null,
+        "tokensUsed": null
+      }
+    ]
+  },
+  "parallelGateProbe": [
+    {
+      "fakeAgentsAndGit": true,
+      "requiresStoryContext": false,
+      "exitCode": 0,
+      "observedContexts": [
+        "A",
+        "B",
+        "C",
+        null,
+        null,
+        null
+      ],
+      "acceptedStories": 3
+    },
+    {
+      "fakeAgentsAndGit": true,
+      "requiresStoryContext": true,
+      "exitCode": 1,
+      "observedContexts": [
+        "A",
+        "B",
+        "C",
+        null,
+        null,
+        null
+      ],
+      "acceptedStories": 0
+    }
+  ]
+}

package/bench/results/native-goal-validation-2026-09-30.json

@@ -0,0 +1,122 @@
+{
+  "schemaVersion": 1,
+  "validationDate": "2026-09-30",
+  "generatedBy": "Codex-assisted validation",
+  "codexVersion": "0.161.0-alpha.2",
+  "model": "gpt-6.1-sol",
+  "reasoningEffort": "low",
+  "evidence": "Protected executable acceptance commands, saved provider counters, and shared capacity snapshots.",
+  "cases": {
+    "nativeBareStartup": {
+      "status": "blocked",
+      "limitation": "Codex app-server does not support ignoring user config. Native bare mode is now rejected before spawn."
+    },
+    "nativeBeforeWindowsShellFix": {
+      "status": "blocked",
+      "artifactCorrect": true,
+      "limitation": "Windows Store PowerShell repeatedly failed sandbox command launch; the two-minute agent deadline interrupted the turn and its usage remained unknown."
+    },
+    "retainedThreadResume": {
+      "status": "complete",
+      "sameGoalId": true,
+      "sameNativeThread": true,
+      "attemptsBefore": 1,
+      "attemptsAfter": 1,
+      "independentCheckStatus": "passed",
+      "explicitDisposableBudgetOverride": {
+        "clearTokenBudget": true,
+        "reason": "Historical interrupted turn had unknown usage; retained as unknown, previous report preserved"
+      }
+    },
+    "nativeAfterShellFixBeforeAccountingFix": {
+      "status": "complete",
+      "independentCheckStatus": "passed",
+      "reportedLastIncrement": {
+        "inputTokens": 23419,
+        "outputTokens": 60
+      },
+      "savedProviderCumulativeTotals": {
+        "inputTokens": 133408,
+        "outputTokens": 780,
+        "cachedInputTokens": 111232,
+        "reasoningOutputTokens": 56
+      },
+      "limitation": "This historical run initially counted only the last model request. The saved provider totals exposed the error; this report preserves both measurements."
+    },
+    "nativeAfterAccountingFix": {
+      "status": "complete",
+      "attempts": 1,
+      "attemptSuccess": true,
+      "nativeThreadBound": true,
+      "artifactCorrect": true,
+      "independentCheckStatus": "passed",
+      "agentDurationMs": 82634,
+      "wallDurationMs": 89855,
+      "limits": {
+        "maxAttempts": 1,
+        "agentMinutes": 5,
+        "wallMinutes": 7,
+        "tokenBudget": 300000
+      },
+      "measuredTurnUsage": {
+        "inputTokens": 153736,
+        "outputTokens": 606,
+        "cachedInputTokens": 134528,
+        "cacheWriteInputTokens": 0,
+        "reasoningOutputTokens": 53
+      },
+      "durableUsageBaselineMatchesTurnUsage": true,
+      "nativeGoalCounter": {
+        "tokensUsed": 0,
+        "interpretation": "The paused native goal counter remains separate from measured model usage."
+      },
+      "resume": {
+        "status": "complete",
+        "attempts": 1,
+        "sameGoalId": true,
+        "sameNativeThread": true
+      },
+      "cleanup": {
+        "remainingProviderRecords": 0,
+        "activeModelUnits": 0,
+        "activeCheckUnits": 0
+      }
+    },
+    "sharedCapacity": {
+      "fakeExecutor": true,
+      "limit": 1,
+      "queuedWhilePoolFull": true,
+      "executedWhilePoolFull": false,
+      "goalStatus": "complete"
+    },
+    "budgetOverrun": {
+      "fakeExecutor": true,
+      "tokenBudget": 1,
+      "measuredTokens": 100,
+      "timeBudgetMs": 60,
+      "totalWallMs": 1208,
+      "recordedAgentMs": 30,
+      "status": "blocked"
+    },
+    "unboundObjective": {
+      "requestedArtifact": "new-feature.txt",
+      "requestedArtifactExists": false,
+      "acceptance": "only checks old-feature.txt; intentionally unbound objective",
+      "executorCalled": false,
+      "attempts": 0,
+      "status": "blocked"
+    }
+  },
+  "accounting": {
+    "source": "thread/tokenUsage/updated.tokenUsage.total",
+    "method": "Subtract the durable same-thread cumulative baseline; new threads begin at zero. Repeated absolute snapshots are not added again.",
+    "unknownUsage": "Missing or malformed snapshots remain unknown. Decreasing counters mark the reused binding untrusted until a fresh thread is explicitly selected.",
+    "reference": "https://github.com/openai/symphony/blob/main/elixir/docs/token_accounting.md"
+  },
+  "limits": [
+    "These are bounded disposable smoke cases, not a long-running recovery or provider parity benchmark.",
+    "Native Codex goals remain experimental and opt-in; method-unavailable fallback does not hide authentication, network, or provider errors.",
+    "Native goals stay paused during explicit Yoke turns; independent executable checks determine Yoke completion.",
+    "Privacy exports omit thread identifiers, local root paths, and raw transcripts."
+  ]
+}

package/bench/results/parallel-validation-2026-09-30.json

@@ -0,0 +1,86 @@
+{
+  "schemaVersion": 1,
+  "date": "2026-09-30",
+  "purpose": "Single-arm parallel acceptance smoke validation; no baseline or efficiency comparison",
+  "aiDisclosure": "AI assisted report; authenticated AI providers implemented work inside disposable benchmark fixtures.",
+  "source": {
+    "version": "1.20.0",
+    "commit": "05fac3db1a51412563005e07f80e6e5a9aab8e06",
+    "state": "Uncommitted validation worktree; built before execution"
+  },
+  "fixture": "independent-utils",
+  "model": "gpt-6.1-sol",
+  "reasoningEffort": "low",
+  "arm": "yoke-parallel",
+  "parallelWorkers": 3,
+  "maxIterations": 3,
+  "routing": false,
+  "nativeMultiAgent": false,
+  "acceptanceDigest": "3e9734e6d286b7c9d19e6ce473eea17e1adf9e30a6ee8927c7240170602f14f7",
+  "samples": [
+    {
+      "sample": "initial-runtime-claims-failure",
+      "root": "<disposable-initial-smoke>",
+      "buildContext": "Before production runtime claim exclusions were added",
+      "version": "1.20.0",
+      "exitCode": 1,
+      "status": "blocked",
+      "accepted": false,
+      "durationMs": 148237,
+      "immutableAcceptanceDurationMs": 245,
+      "stories": { "total": 3, "accepted": 0, "rejectedIntegration": 3 },
+      "immutableTests": { "total": 15, "passed": 0, "failed": 15, "cancelled": 0, "skipped": 0 },
+      "usage": {
+        "inputTokens": 646600,
+        "cachedInputTokens": 571264,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 3796,
+        "reasoningOutputTokens": 91,
+        "costUsd": null
+      },
+      "measurement": { "measuredCalls": 3, "unknownCalls": 0, "unmeasuredAttempts": 3, "costAvailable": "unknown" },
+      "failure": {
+        "classification": "Runtime claim files missing from Git cleanliness exclusions",
+        "integrationReason": "target working tree is not clean",
+        "immutableReplayReason": "No implementations integrated; original source stubs remained unimplemented",
+        "diagnostic": "Built realGitOps.isClean returned true without a claim file and false with a temporary diagnostic claim file in the completed disposable fixture.",
+        "retainedCandidates": 3,
+        "modelCandidateQuality": "Not independently established by the final root replay"
+      }
+    },
+    {
+      "sample": "corrected-runtime-claims-smoke",
+      "root": "<disposable-corrected-smoke>",
+      "buildContext": "Production claim and worktree runtime exclusions added; rebuilt before execution",
+      "version": "1.20.0",
+      "exitCode": 0,
+      "status": "complete",
+      "accepted": true,
+      "durationMs": 112949,
+      "immutableAcceptanceDurationMs": 257,
+      "stories": { "total": 3, "accepted": 3, "rejectedIntegration": 0 },
+      "immutableTests": { "total": 15, "passed": 15, "failed": 0, "cancelled": 0, "skipped": 0, "nodeTestDurationMs": 159.3043 },
+      "immutableProtectedFiles": { "total": 4, "byteIdenticalToSeedAfterReplay": true },
+      "usage": {
+        "inputTokens": 456659,
+        "cachedInputTokens": 372096,
+        "cacheWriteInputTokens": 0,
+        "outputTokens": 3217,
+        "reasoningOutputTokens": 64,
+        "costUsd": null
+      },
+      "measurement": { "measuredCalls": 3, "unknownCalls": 0, "unmeasuredAttempts": 3, "costAvailable": "unknown" }
+    }
+  ],
+  "sampleLimits": [
+    "One initial failed parallel sample and one corrected parallel sample; each executed once",
+    "No baseline or serial arm; no general efficiency conclusion",
+    "Small fixture with three independent stories and fifteen visible tests",
+    "Immutable original verification files restored and replayed after provider execution",
+    "CPU and RAM not measured; machine load not controlled",
+    "Fixed model and low effort; routing and native multi-agent delegation disabled",
+    "User config disabled; installed plugins and host skill discovery not exhaustively audited",
+    "Reported token counters retained as observed; unknown cost is not zero cost",
+    "Private prompts, transcripts, identifiers and local root paths excluded; raw logs retained outside Git"
+  ]
+}

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-record-identity.js

@@ -0,0 +1,33 @@
+import { execFile } from 'node:child_process';
+import { writeFileSync, renameSync, existsSync, rmSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { processIncarnation } from './process-incarnation.js';
+/** Resolve ownership without blocking cancellation timers on a slow CIM query. */
+export function trackProcessRecordIdentity(record, child) {
+    let cancelled = false;
+    const update = (identity) => {
+        if (!identity || cancelled || child.exitCode !== null || child.signalCode !== null || !record || !existsSync(record.path))
+            return;
+        const temporary = `${record.path}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temporary, JSON.stringify({ version: record.version, owner: record.owner, targetDir: record.targetDir, childPid: record.childPid, startedAt: identity, workerId: record.workerId }), { flag: 'wx', mode: 0o600 });
+            renameSync(temporary, record.path);
+        }
+        catch { /* unknown identity remains conservative */ }
+        finally {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch { /* stale temporary is diagnostic evidence */ }
+        }
+    };
+    if (!record || !child.pid)
+        return () => { };
+    if (process.platform !== 'win32') {
+        update(processIncarnation(child.pid));
+        return () => { cancelled = true; };
+    }
+    const query = execFile('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '(Get-CimInstance Win32_Process -Filter "ProcessId = $env:YOKE_PROCESS_PID").CreationDate'], { env: { ...process.env, YOKE_PROCESS_PID: String(child.pid) }, windowsHide: true, timeout: 5000, maxBuffer: 4096 }, (error, stdout) => update(!error && stdout.trim() ? `win32:${stdout.trim()}` : undefined));
+    return () => { cancelled = true; if (query.exitCode === null && query.signalCode === null)
+        query.kill('SIGKILL'); };
+}

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;
+}