@hecer/yoke 1.19.0 → 1.20.0

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "yoke",
   "displayName": "Yoke",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Cross-agent coding harness for Claude, Codex, Gemini, Qwen, OpenCode, Kilo, Pi and Hermes: one curated skill canon plus mechanical safety gates and an autonomous loop via the yoke CLI.",
   "author": { "name": "HECer", "url": "https://github.com/HECer" },
   "homepage": "https://github.com/HECer/yoke#readme",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "yoke",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "description": "Cross-agent coding discipline, mechanical gates, and release workflows for eight supported harnesses",
   "skills": "./canon/skills/",
   "hooks": "./hooks/hooks.json"

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.20.0 — 2026-09-30
+
+### Added
+- Add explicit goal-to-acceptance binding with `goal set --criteria=...` and `goal bind --criteria=...`; preserve the objective and manifest digest across continuation.
+- Add opt-in native Codex goal threads through `goal run --native-goal` or `goals.nativeCodex`. Yoke pauses native automatic continuation, runs explicit bounded turns, and synchronizes completion only after independent acceptance.
+- Add cumulative `goal set|budget --wall-minutes=N` and a separate shared asynchronous goal-check pool, controlled by `YOKE_MAX_PARALLEL_CHECKS` (1–8, default 1).
+- Add reproducible direct-Codex comparison tooling, deterministic resource/goal probes and dated evidence reports.
+
+### Fixed
+- Preserve story context through integrated verification, design, performance, audit and quality gates, and restore it after exceptions.
+- Retain rejected parallel candidates and exact rejection reasons; validate recovery before rerunning integration gates without another implementation model call.
+- Shorten generated worktree names and reject unsupported Windows paths before setup.
+- Exclude active claims and nested worker worktrees from cleanliness checks and implementation staging even in manually configured projects without generated ignore rules.
+- Admit goal implementation and routing calls through the shared worker pool, disable unmanaged native delegation, inherit runner defaults, and report measured token overruns even when acceptance passes.
+- Account for all model requests in a native turn using durable cumulative usage baselines; react to valid streamed usage with budget cancellation without double-counting progress frames.
+- Persist safe run identity, execution mode, selection and consumed iteration budget; dashboard resume selects that run rather than an unrelated unfinished goal.
+- Preserve absolute exploration deadlines on dashboard resume and retain exclusive supervisor ownership between batches and during idle waits.
+
+### Migration and validation limits
+- Existing unbound goals now stop before execution. Review the acceptance contract, then run `yoke goal bind . --criteria=<ids>`. Binding retains previous attempts and does not refresh protected infrastructure.
+- Goal `--minutes` remains cumulative admitted provider time; `--wall-minutes` also includes admission and verification. Providers with end-of-call telemetry can exceed token ceilings within a call; Yoke records the overrun and blocks further budgeted work. Unknown interrupted usage remains conservative.
+- Native goals remain disabled by default and depend on installed Codex app-server capabilities. Unsupported goal methods fall back to ordinary Codex; other protocol/authentication failures remain visible. Native goal accounting and Yoke token totals can use different units.
+- Native Codex app-server lacks exec's bare startup control. Native plus bare stops before dispatch; use `--no-native-goal` to keep bare execution or explicitly disable bare when opting into native goals.
+- The new check pool covers asynchronous goal checks. Synchronous `yoke check` and story gates keep their existing execution contracts. Concurrency permits do not enforce CPU/RAM quotas or demonstrate general savings over direct Codex.
+- Resume through the dashboard retains the original exploration deadline. An explicit fresh CLI invocation can establish a new duration. Parallel recovery requires a validated unchanged contract; stale candidates need reconciliation. Serial `--resume-worktree` does not adopt parallel candidates.
+- Local Windows validation on Node.js 24.13.0 passed: lint, build, Canon validation, README metadata, package dry-run, dependency audit (0 vulnerabilities), and 1,418 tests across 155 files (2 skipped). Authenticated parallel validation accepted 3/3 stories with 15/15 immutable tests; a native goal completed and resumed with cumulative usage accounting. These small fixtures do not establish general efficiency superiority; live small-budget native cancellation and the cross-platform CI matrix remain unverified. See [release preparation](docs/RELEASE-VALIDATION-1.20.0.md). No publication is implied by this entry.
+
 ## 1.19.0 — 2026-09-28
 
 ### Added

package/README.md

@@ -11,7 +11,7 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 ![Node.js 20+](https://img.shields.io/badge/node-%E2%89%A520-339933?logo=node.js&logoColor=white)
 
-<!-- yoke:version:start -->1.19.0<!-- yoke:version:end --> · <!-- yoke:tests:start -->1339<!-- yoke:tests:end --> test cases · <!-- yoke:skills:start -->34<!-- yoke:skills:end --> skills
+<!-- yoke:version:start -->1.20.0<!-- yoke:version:end --> · <!-- yoke:tests:start -->1420<!-- yoke:tests:end --> test cases · <!-- yoke:skills:start -->34<!-- yoke:skills:end --> skills
 
 <!-- yoke:agents:start -->Claude | Codex | Gemini | Qwen | OpenCode | Kilo | Pi | Hermes<!-- yoke:agents:end -->
 
@@ -40,6 +40,7 @@ Each story carries observable acceptance criteria and targeted test commands. Pa
 | --- | --- |
 | **Verified completion** | Checks acceptance criteria, the project verify command, and any configured completion, review, quality, or browser gates before accepting work. |
 | **Parallel execution** | Schedules independent stories in isolated worktrees, respects dependencies and write scopes, and coordinates a shared worker limit across projects. |
+| **Durable goals** | Binds objectives to executable acceptance, shares worker capacity, records budgets, and optionally resumes native Codex goal threads. |
 | **Long-running autonomy** | Recovers from provider failures and blocked work. Optional exploration discovers new, repository-evidenced tasks after the planned backlog drains. |
 | **A choice of agents** | Uses the native CLI for Claude, Codex, Gemini, Qwen, OpenCode, Kilo, Pi, or Hermes. Install and authenticate the CLI you choose; Yoke does not bundle model runtimes or credentials. |
 | **Project visibility** | A local dashboard shows project status, **Workspace analytics**, **History**, and controls such as **Queue a change**, safe-boundary pause/resume, and operator notes. It runs with the local Yoke process. Dark and light themes are available. |
@@ -117,8 +118,10 @@ The dashboard is a local control room. It does not discover every process or run
 | [Parallel execution](docs/parallel-execution.md) | Worker scheduling, shared capacity, integration, and recovery |
 | [Continuous exploration](docs/CONTINUOUS-EXPLORATION.md) | Autonomous discovery, runtime limits, pause/resume, and stop detection |
 | [Project workflows](docs/VERIFIED-PROJECTS.md) | Setup, verification, goals, and execution defaults |
+| [Verified goals](docs/GOALS.md) | Acceptance binding, native Codex goals, budgets, and resource admission |
 | [Code Intelligence](docs/CODE-INTELLIGENCE.md) | Optional Graphify, Serena, and Graft evidence providers |
 | [Dashboard](docs/DASHBOARD-EVOLUTION.md) | Project views, history, controls, and reporting boundaries |
+| [Benchmarks](bench/RESULTS.md) | Direct Codex comparison, routing studies, sample limits, and integration findings |
 | [Changelog](CHANGELOG.md) | Release features, behavior changes, and migration notes |
 
 ## Safety and limits

package/bench/RESULTS.md

@@ -1,11 +1,41 @@
 # Benchmark results
 
+The [1.20.0 parallel acceptance smoke](results/parallel-validation-2026-09-30.json)
+accepted all three independent stories and passed all 15 immutable replay tests after
+the runtime claim exclusion fix. Its single corrected run took 112,949 ms. This is
+validation of the corrected fixture, not a new A/B efficiency comparison; the dated
+1.19.0 comparisons below remain historical. See the
+[release validation report](../docs/RELEASE-VALIDATION-1.20.0.md) for limits.
+
 Result schema v1 records fixture version, sample label, permission profile, telemetry/model
 availability, verdict/blocker, conflicts, wall time, iterations, and final fixture-test status.
 
 Fixture `string-kit` (3 stories, 16 pre-written assertions). Methodology and caveats:
 [README.md](README.md). One row per run — raw JSON in [`results/`](results/).
 
+## Direct Codex comparison and integration audit (2026-09-29)
+
+Authenticated comparison of Yoke 1.19.0 against direct Codex, requesting the same
+`gpt-6.1-sol / low` model and effort with routing and native delegation disabled.
+Two alternating queue pairs passed the same ten original tests: median elapsed time
+was **118.3 seconds for direct Codex** and **274.9 seconds for Yoke serial**.
+Yoke used **91.9% more fresh input tokens** in this small sample.
+
+One corrected independent-task run per arm passed all fifteen original tests for
+direct Codex (71.3 seconds) and Yoke serial (442.2 seconds). Yoke parallel used three
+workers but accepted **0/3 stories**: integration gates lost the worker's
+`YOKE_STORY` context. Its 117.1-second failure is **not** a speedup.
+The deterministic control probe reproduced this integration defect separately
+from provider calls. Initial fixture setup/path failures are retained as diagnostics.
+
+These measurements do not establish general superiority, USD cost, CPU/RAM savings,
+or routing benefits. Host skills/plugins were not fully audited and background load
+was uncontrolled. See [the complete comparison](../docs/CODEX-COMPARISON-2026-09-29.md),
+[Goals/resource findings](../docs/GOALS-RESOURCE-AUDIT-2026-09-29.md), and the separately
+formatted [comparison summary](results/codex-comparison-2026-09-29.json) and
+[integration diagnostics](results/goal-integration-probes-2026-09-29.json).
+These two aggregate audit artifacts are not individual result-schema-v1 run records.
+
 ## Synthetic dispatcher matrix (2026-09-27)
 
 One local run of `node bench/run-parallel-matrix.mjs` after the shared integration pipeline was

package/bench/analyze-codex-comparison.mjs

@@ -0,0 +1,22 @@
+// node bench/analyze-codex-comparison.mjs <results.json> ... > summary.json
+import { readFileSync } from 'node:fs'
+const sources = process.argv.slice(2).map(path => JSON.parse(readFileSync(path, 'utf8')))
+if (!sources.length) throw new Error('Supply comparison results.json files')
+const rows = sources.flatMap(s => s.results).map(({ dir, ...row }) => ({
+  ...row,
+  freshInputTokens: Number.isFinite(row.usage?.inputTokens) && Number.isFinite(row.usage?.cachedInputTokens)
+    ? row.usage.inputTokens - row.usage.cachedInputTokens : null,
+}))
+if (!rows.length) throw new Error('No completed runs')
+for (const row of rows) if (!Number.isFinite(row.wallMs) || row.wallMs <= 0 || (row.freshInputTokens !== null && row.freshInputTokens < 0)) throw new Error('Invalid measurement')
+const median = values => { const sorted = [...values].sort((a,b) => a-b); const n = sorted.length; return n ? (sorted[Math.floor((n-1)/2)] + sorted[Math.floor(n/2)]) / 2 : null }
+const groups = [...new Set(rows.map(r => `${r.fixture}:${r.arm}`))].map(key => {
+  const runs = rows.filter(r => `${r.fixture}:${r.arm}` === key)
+  if (new Set(runs.map(r => `${r.model}:${r.effort}:${r.routing}`)).size !== 1) throw new Error('Incompatible execution policies in one comparison group')
+  return { fixture: runs[0].fixture, arm: runs[0].arm, runs: runs.length, accepted: runs.filter(r => r.accepted).length,
+    medianWallMs: median(runs.map(r => r.wallMs)),
+    medianFreshInputTokens: runs.every(r => r.freshInputTokens !== null) ? median(runs.map(r => r.freshInputTokens)) : null,
+    medianOutputTokens: runs.every(r => Number.isFinite(r.usage?.outputTokens)) ? median(runs.map(r => r.usage.outputTokens)) : null,
+    medianAllInputTokens: runs.every(r => Number.isFinite(r.usage?.inputTokens)) ? median(runs.map(r => r.usage.inputTokens)) : null }
+})
+console.log(JSON.stringify({ auditedVersion: '1.19.0', auditedCommit: '05fac3db1a51412563005e07f80e6e5a9aab8e06', models: [...new Set(rows.map(r => r.model))], effort: 'low', groups, runs: rows, limitations: [...new Set(sources.flatMap(s => s.limits))], pricesMeasured: false, cpuMeasured: false, memoryMeasured: false }, null, 2))

package/bench/compare-codex.mjs

@@ -0,0 +1,71 @@
+// Controlled live comparison. Run after npm run build.
+// node bench/compare-codex.mjs --repeats=2 --fixture=routing-queue
+import { cpSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { spawn, spawnSync } from 'node:child_process'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { parse, stringify } from 'yaml'
+import { buildProviderInvocation, startProviderProcess } from '../dist/agents/providers.js'
+const repo = dirname(dirname(fileURLToPath(import.meta.url)))
+const version = JSON.parse(readFileSync(join(repo, 'package.json'), 'utf8')).version
+const opts = Object.fromEntries(process.argv.slice(2).map(x => x.replace(/^--/, '').split('=')))
+const fixture = opts.fixture ?? 'routing-queue'
+if (!['routing-queue', 'string-kit', 'independent-utils'].includes(fixture)) throw new Error('Unsupported fixture')
+const repeats = Number(opts.repeats ?? 2)
+if (!Number.isInteger(repeats) || repeats < 1 || repeats > 10) throw new Error('repeats must be 1..10')
+const model = opts.model ?? 'gpt-6.1-sol'
+const root = resolve(opts.root ?? `G:/NN-Developed/Yoke-Testground/b${Date.now().toString(36)}`)
+mkdirSync(root, { recursive: true })
+const seed = join(repo, 'bench', 'fixtures', fixture)
+const stories = parse(readFileSync(join(seed, '.yoke/prd.yaml'), 'utf8'))
+const originalTests = readdirSync(join(seed, 'tests')).filter(f => f.endsWith('.test.mjs')).sort()
+const protectedFiles = new Map(['bench-verify.mjs', ...originalTests.map(f => join('tests', f))].map(file => [file, readFileSync(join(seed, file))]))
+const acceptanceDigest = createHash('sha256').update(Buffer.concat([...protectedFiles].flatMap(([file, bytes]) => [Buffer.from(file + '\0'), bytes]))).digest('hex')
+const prompt = 'Implement all requirements below. Run node bench-verify.mjs. Preserve tests and the verification script. Do not commit.\n' + stories.map(s => `${s.id}: ${s.title}\n${s.acceptance.join('\n')}`).join('\n\n')
+const results = []
+const requestedArms = opts.arms?.split(',')
+if (requestedArms && (!requestedArms.length || requestedArms.some(arm => !['codex', 'yoke-serial', 'yoke-parallel'].includes(arm)))) throw new Error('arms must name codex,yoke-serial,yoke-parallel')
+for (let repeat = 0; repeat < repeats; repeat++) {
+  const baseArms = fixture === 'independent-utils' ? ['codex', 'yoke-serial', 'yoke-parallel'] : ['codex', 'yoke-serial']
+  const selectedArms = requestedArms ? baseArms.filter(arm => requestedArms.includes(arm)) : baseArms
+  if (!selectedArms.length) throw new Error('No requested arms apply to this fixture')
+  const arms = repeat % 2 ? [...selectedArms].reverse() : selectedArms
+  for (const arm of arms) {
+    const dir = join(root, `${repeat + 1}-${arm}`)
+    mkdirSync(dir); cpSync(seed, dir, { recursive: true })
+    const parallel = arm === 'yoke-parallel' ? 3 : 1
+    writeFileSync(join(dir, '.yoke/config.yaml'), stringify({ canonVersion: '1.2.0', agents: ['codex'], loop: { enabled: true, parallel, isolate: true }, runner: { agent: 'codex', model, reasoningEffort: 'low', bare: true }, routing: { enabled: false }, verify: { command: 'node bench-verify.mjs' } }))
+    for (const args of [['init', '-q'], ['add', '-A'], ['-c', 'user.name=benchmark', '-c', 'user.email=benchmark@yoke.local', 'commit', '-qm', 'Immutable fixture seed']]) {
+      const r = spawnSync('git', args, { cwd: dir, encoding: 'utf8' }); if (r.status !== 0) throw new Error(r.stderr)
+    }
+    console.log(JSON.stringify({ type: 'start', fixture, repeat: repeat + 1, arm, model, dir }))
+    const start = Date.now(); let outcome; let events = []; let usage
+    if (arm === 'codex') {
+      const inv = buildProviderInvocation('codex', prompt, dir, 'unsafe', { model, reasoningEffort: 'low', bare: true, nativeMultiAgent: false })
+      inv.args.push('--ignore-rules')
+      const controller = new AbortController(); const timer = setTimeout(() => controller.abort(), 600_000)
+      try {
+        const r = await startProviderProcess('codex', inv, { signal: controller.signal, idleTimeoutMs: 180_000 }).completion
+        outcome = r.kind; usage = r.telemetry.tokens
+        writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.log`), JSON.stringify(r, null, 2))
+      } finally { clearTimeout(timer) }
+    } else {
+      const child = spawn(process.execPath, [join(repo, 'dist/cli.js'), 'loop', 'run', dir, '--json', '--runner=codex', '--no-routing', `--parallel=${parallel}`, '--max=3', '--timeout=10', '--unsafe'], { cwd: dir, env: { ...process.env, LOCALAPPDATA: join(root, 'state') }, stdio: ['ignore', 'pipe', 'pipe'] })
+      let output = '', errors = ''; child.stdout.on('data', d => { output += d }); child.stderr.on('data', d => { errors += d })
+      outcome = await new Promise((res, rej) => { child.on('error', rej); child.on('close', res) })
+      events = output.split('\n').flatMap(line => { try { return [JSON.parse(line)] } catch { return [] } })
+      writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.log`), output + '\nSTDERR\n' + errors)
+      usage = events.filter(e => e.type === 'status' && e.tokens).at(-1)?.tokens
+    }
+    const wallMs = Date.now() - start
+    // Replay immutable originals after the agent exits. Agent-written tests never determine quality.
+    mkdirSync(join(dir, 'tests'), { recursive: true })
+    for (const [file, bytes] of protectedFiles) writeFileSync(join(dir, file), bytes)
+    const testFiles = originalTests.map(f => join('tests', f))
+    const checkStart = Date.now(); const check = spawnSync(process.execPath, ['--test', ...testFiles], { cwd: dir, encoding: 'utf8', timeout: 60_000 })
+    writeFileSync(join(root, `${fixture}-${repeat + 1}-${arm}.acceptance.log`), check.stdout + check.stderr)
+    const result = { fixture, repeat: repeat + 1, arm, model, effort: 'low', routing: false, nativeMultiAgent: false, parallel, acceptanceDigest, wallMs, acceptanceMs: Date.now() - checkStart, accepted: check.status === 0, outcome, usage: usage ?? null, events: events.length, dir }
+    results.push(result); writeFileSync(join(root, 'results.json'), JSON.stringify({ version, root, results, limits: ['Small fixture sample; not representative of production projects', 'CPU and RAM not measured', 'Routing disabled; fixed model and effort', 'Immutable tests replayed after execution; not hidden from agents', 'User config disabled; not an audit of every installed plugin'] }, null, 2)); console.log(JSON.stringify({ type: 'result', ...result }))
+  }
+}

package/bench/fixtures/independent-utils/.yoke/prd.yaml

@@ -0,0 +1,30 @@
+- id: STORY-1
+  title: Stable unique values
+  priority: 1
+  writes: [src/unique.mjs]
+  needs: []
+  acceptance:
+    - Export unique(values) from src/unique.mjs, returning first occurrences in input order using SameValueZero equality.
+    - Never mutate the input. Non-array input throws TypeError. Preserve object identity.
+    - node bench-verify.mjs exits 0
+  passes: false
+- id: STORY-2
+  title: Array chunking
+  priority: 2
+  writes: [src/chunk.mjs]
+  needs: []
+  acceptance:
+    - Export chunk(values,size) from src/chunk.mjs. Split arrays into consecutive new arrays of at most size elements.
+    - An empty input returns an empty array. Never mutate the input. Non-array input throws TypeError; size must be a positive integer or throw RangeError.
+    - node bench-verify.mjs exits 0
+  passes: false
+- id: STORY-3
+  title: Numeric range
+  priority: 3
+  writes: [src/range.mjs]
+  needs: []
+  acceptance:
+    - Export range(start,end,step=1) from src/range.mjs. Generate start-inclusive, end-exclusive numbers with a positive or negative step.
+    - A step pointing away from end returns an empty array. Zero step or any non-finite argument throws RangeError. Equal endpoints return an empty array.
+    - node bench-verify.mjs exits 0
+  passes: false

package/bench/fixtures/independent-utils/bench-verify.mjs

@@ -0,0 +1,4 @@
+import { spawnSync } from 'node:child_process'
+const ids = process.env.YOKE_STORY ? [process.env.YOKE_STORY] : ['STORY-1', 'STORY-2', 'STORY-3']
+const r = spawnSync(process.execPath, ['--test', ...ids.map(id => `tests/${id}.test.mjs`)], { stdio: 'inherit' })
+process.exit(r.status ?? 1)

package/bench/fixtures/independent-utils/package.json

@@ -0,0 +1 @@
+{"name":"yoke-independent-utils-benchmark","private":true,"type":"module","scripts":{"test":"node bench-verify.mjs"}}

package/bench/fixtures/independent-utils/src/chunk.mjs

@@ -0,0 +1 @@
+export function chunk() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/src/range.mjs

@@ -0,0 +1 @@
+export function range() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/src/unique.mjs

@@ -0,0 +1 @@
+export function unique() { throw new Error('Not implemented') }

package/bench/fixtures/independent-utils/tests/STORY-1.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { unique } from '../src/unique.mjs'
+test('deduplicates in order', () => assert.deepEqual(unique([2,1,2,3,1]), [2,1,3]))
+test('empty', () => assert.deepEqual(unique([]), []))
+test('SameValueZero', () => assert.deepEqual(unique([NaN,NaN,0,-0]), [NaN,0]))
+test('identity and immutable input', () => { const a = {}; const b = {}; const input = Object.freeze([a,b,a]); assert.deepEqual(unique(input), [a,b]) })
+test('invalid input', () => assert.throws(() => unique('abc'), TypeError))

package/bench/fixtures/independent-utils/tests/STORY-2.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { chunk } from '../src/chunk.mjs'
+test('consecutive chunks', () => assert.deepEqual(chunk([1,2,3,4,5],2), [[1,2],[3,4],[5]]))
+test('empty', () => assert.deepEqual(chunk([],2), []))
+test('large size', () => assert.deepEqual(chunk([1,2],9), [[1,2]]))
+test('immutable input and new arrays', () => { const input = Object.freeze([1,2]); assert.notEqual(chunk(input,2)[0], input) })
+test('invalid input and size', () => { assert.throws(() => chunk('abc',2), TypeError); for (const size of [0,-1,1.5,NaN,Infinity]) assert.throws(() => chunk([],size), RangeError) })

package/bench/fixtures/independent-utils/tests/STORY-3.test.mjs

@@ -0,0 +1,8 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { range } from '../src/range.mjs'
+test('ascending', () => assert.deepEqual(range(1,5), [1,2,3,4]))
+test('descending', () => assert.deepEqual(range(5,0,-2), [5,3,1]))
+test('fractional', () => assert.deepEqual(range(0,1,0.25), [0,0.25,0.5,0.75]))
+test('empty', () => { assert.deepEqual(range(1,1), []); assert.deepEqual(range(1,5,-1), []); assert.deepEqual(range(5,1,1), []) })
+test('invalid numbers', () => { for (const args of [[0,1,0],[NaN,1],[0,Infinity],[0,1,Infinity]]) assert.throws(() => range(...args), RangeError) })

package/bench/probe-goal-integration.mjs

@@ -0,0 +1,93 @@
+// Read-only protocol capability probe plus disposable local goal resource test.
+import { spawn } from 'node:child_process'
+import { join, resolve } from 'node:path'
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { createProjectGoal, runProjectGoal } from '../dist/goals/command.js'
+import { acquireSharedWorker, sharedPoolStatus } from '../dist/loop/resource-pool.js'
+const root = resolve(process.argv[2] ?? `G:/NN-Developed/Yoke-Testground/goal-probe-${Date.now()}`)
+mkdirSync(join(root, '.yoke'), { recursive: true })
+process.env.LOCALAPPDATA = join(root, 'isolated-state')
+process.env.YOKE_MAX_PARALLEL_WORKERS = '1'
+process.env.YOKE_STATE_DIR = join(root, 'yoke-state')
+writeFileSync(join(root, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: outcome\n  text: Expected outcome\n  commands: [node test.mjs]\n')
+writeFileSync(join(root, 'test.mjs'), 'import {existsSync} from "node:fs"; process.exit(existsSync("implemented.txt") ? 0 : 1)')
+createProjectGoal(root, 'Disposable test goal', { acceptanceIds: ['outcome'] })
+const lease = await acquireSharedWorker({ targetDir: root, storyId: 'occupied', provider: 'codex', role: 'implementation' })
+let executedWhilePoolFull = false, occupiedPermitHeld = true
+let goal, queuedWhilePoolFull = false
+try {
+  const running = runProjectGoal(root, { execute: async () => {
+    const pool = sharedPoolStatus(); executedWhilePoolFull = occupiedPermitHeld && pool.activeUnits === pool.limit
+    writeFileSync(join(root, 'implemented.txt'), 'done')
+    return { success: true, summary: 'Fake executor for mechanical pool test', inputTokens: 1, outputTokens: 1 }
+  } })
+  // Admission is asynchronous. Release the occupied provider permit only after
+  // the goal has completed its independent check and queued for implementation.
+  const deadline = Date.now() + 15_000
+  while (Date.now() < deadline) {
+    if (sharedPoolStatus().waitingWorkers > 0) { queuedWhilePoolFull = true; break }
+    await new Promise(resolve => setTimeout(resolve, 100))
+  }
+  occupiedPermitHeld = false
+  await lease.release()
+  goal = await running
+} finally { await lease.release() }
+const findings = { poolProbe: { fakeExecutor: true, limit: 1, queuedWhilePoolFull, executedWhilePoolFull, goalStatus: goal.status }, protocol: [] }
+// A successful implementation that overshoots budget must remain blocked.
+const budgetRoot = join(root, 'budget-probe'); mkdirSync(join(budgetRoot, '.yoke'), { recursive: true })
+writeFileSync(join(budgetRoot, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: outcome\n  text: Expected outcome\n  commands: [node test.mjs]\n')
+writeFileSync(join(budgetRoot, 'test.mjs'), 'import {existsSync} from "node:fs"; await new Promise(r=>setTimeout(r,120)); process.exit(existsSync("implemented.txt") ? 0 : 1)')
+createProjectGoal(budgetRoot, 'Disposable budget test', { acceptanceIds: ['outcome'], tokenBudget: 1, maxMinutes: 0.001 })
+const budgetStart = Date.now()
+const budgetGoal = await runProjectGoal(budgetRoot, { execute: async () => {
+  writeFileSync(join(budgetRoot, 'implemented.txt'), 'done')
+  return { success: true, summary: 'Fake executor reporting 100 tokens', inputTokens: 90, outputTokens: 10 }
+} })
+findings.budgetProbe = { fakeExecutor: true, tokenBudget: 1, measuredTokens: 100, timeBudgetMs: 60, totalWallMs: Date.now() - budgetStart, recordedAgentMs: budgetGoal.attempts[0]?.durationMs, status: budgetGoal.status }
+const objectiveRoot = join(root, 'objective-probe'); mkdirSync(join(objectiveRoot, '.yoke'), { recursive: true })
+writeFileSync(join(objectiveRoot, '.yoke/acceptance.yaml'), 'version: 1\nprotected: [test.mjs]\ncriteria:\n- id: old-feature\n  text: Existing feature still works\n  commands: [node test.mjs]\n')
+writeFileSync(join(objectiveRoot, 'test.mjs'), 'import {existsSync} from "node:fs"; process.exit(existsSync("old-feature.txt") ? 0 : 1)')
+writeFileSync(join(objectiveRoot, 'old-feature.txt'), 'already implemented')
+createProjectGoal(objectiveRoot, 'Implement the new feature by creating new-feature.txt')
+let objectiveExecutorCalled = false
+const objectiveGoal = await runProjectGoal(objectiveRoot, { execute: async () => { objectiveExecutorCalled = true; return { success: false, summary: 'Should need implementation' } } })
+findings.objectiveProbe = { requestedArtifact: 'new-feature.txt', requestedArtifactExists: existsSync(join(objectiveRoot, 'new-feature.txt')), acceptance: 'only checks old-feature.txt; intentionally unbound objective', executorCalled: objectiveExecutorCalled, attempts: objectiveGoal.attempts.length, status: objectiveGoal.status }
+const cli = join(process.env.APPDATA, 'npm/node_modules/@openai/codex/bin/codex.js')
+const child = spawn(process.execPath, [cli, 'app-server', '--stdio', '--enable', 'goals'], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] })
+let next = 1, buffer = '', errorText = ''; const pending = new Map()
+child.stderr.on('data', d => { errorText += d })
+child.stdout.on('data', data => {
+  buffer += data
+  while (buffer.includes('\n')) {
+    const i = buffer.indexOf('\n'), line = buffer.slice(0, i); buffer = buffer.slice(i + 1)
+    try { const message = JSON.parse(line); if (pending.has(message.id)) { const p = pending.get(message.id); pending.delete(message.id); message.error ? p.reject(new Error(JSON.stringify(message.error))) : p.resolve(message.result) } } catch {}
+  }
+})
+function rpc(method, params) {
+  return new Promise((resolve, reject) => {
+    const id = next++; const timer = setTimeout(() => { pending.delete(id); reject(new Error(`Timeout: ${method}`)) }, 30_000)
+    pending.set(id, { resolve: result => { clearTimeout(timer); resolve(result) }, reject: error => { clearTimeout(timer); reject(error) } })
+    child.stdin.write(JSON.stringify({ id, method, params }) + '\n')
+  })
+}
+try {
+  await rpc('initialize', { clientInfo: { name: 'yoke-goals-probe', version: '1.0.0' }, capabilities: { experimentalApi: true } })
+  child.stdin.write(JSON.stringify({ method: 'initialized' }) + '\n')
+  const start = await rpc('thread/start', { cwd: root, model: 'gpt-6.1-sol', approvalPolicy: 'never', sandbox: 'read-only' })
+  const threadId = start.thread.id
+  for (const [method, params] of [
+    ['thread/goal/set', { threadId, objective: 'Protocol-only goal: no development turn requested', tokenBudget: 1000 }],
+    ['thread/goal/get', { threadId }],
+    ['thread/goal/set', { threadId, status: 'paused' }],
+    ['thread/goal/get', { threadId }],
+    ['thread/goal/clear', { threadId }],
+    ['thread/goal/get', { threadId }],
+  ]) {
+    const result = await rpc(method, params); findings.protocol.push({ method, requestedStatus: params.status ?? null, result })
+  }
+  await rpc('thread/archive', { threadId })
+} catch (error) { findings.protocolError = error.message; findings.stderrTail = errorText.slice(-2000) }
+finally { child.stdin.end(); child.kill() }
+writeFileSync(join(root, 'findings.json'), JSON.stringify(findings, null, 2))
+console.log(JSON.stringify(findings, null, 2))
+if (findings.protocolError) process.exitCode = 1

package/bench/probe-parallel-gate-context.mjs

@@ -0,0 +1,29 @@
+// Diagnostic using fake agents/Git adapters, exercising the real loop and dispatcher.
+import { cpSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { runLoopCommand } from '../dist/loop/run-command.js'
+import { saveConfig } from '../dist/retrofit/config.js'
+import { loadPrd, savePrd } from '../dist/loop/prd.js'
+const base = resolve(process.argv[2] ?? `G:/NN-Developed/Yoke-Testground/p${Date.now().toString(36)}`)
+process.env.LOCALAPPDATA = join(base, 'state')
+const findings = []
+for (const requiresStoryContext of [false, true]) {
+  const root = join(base, requiresStoryContext ? 'scoped' : 'control'); mkdirSync(join(root, '.yoke'), { recursive: true })
+  saveConfig(root, { canonVersion: 'test', agents: ['codex'], loop: { enabled: true }, verify: { command: 'node test.mjs' } })
+  savePrd(join(root, '.yoke/prd.yaml'), ['A','B','C'].map((id, index) => ({ id, title: id, priority: index + 1, acceptance: ['Expected result'], writes: [`src/${id}`], passes: false })))
+  const observedContexts = []
+  const code = await runLoopCommand(root, { parallel: 3, maxIterations: 3, quiet: true,
+    runner: () => ({ success: true, summary: 'Fake agent completed' }), isAvailable: () => true,
+    verify: () => { const context = process.env.YOKE_STORY ?? null; observedContexts.push(context); return { passed: !requiresStoryContext || ['A','B','C'].includes(context), summary: context ? 'Story-scoped verification passed' : 'Missing YOKE_STORY context' } },
+    git: { isClean: () => true, commitAll: () => undefined,
+      addWorktree: (_target, worktree) => { mkdirSync(join(worktree, '.yoke'), { recursive: true }); cpSync(join(root, '.yoke/prd.yaml'), join(worktree, '.yoke/prd.yaml')) },
+      // Retain disposable directories for inspection; no recursive deletion.
+      removeWorktree: () => undefined,
+      integrate: (_target, worktree) => savePrd(join(root, '.yoke/prd.yaml'), loadPrd(join(worktree, '.yoke/prd.yaml'))),
+    },
+  })
+  findings.push({ fakeAgentsAndGit: true, requiresStoryContext, exitCode: code, observedContexts, acceptedStories: loadPrd(join(root, '.yoke/prd.yaml')).filter(s => s.passes).length })
+}
+writeFileSync(join(base, 'findings.json'), JSON.stringify(findings, null, 2))
+console.log(JSON.stringify(findings, null, 2))
+if (findings.some(row => row.exitCode !== 0 || row.acceptedStories !== 3 || row.observedContexts.includes(null))) process.exitCode = 1