@hecer/yoke 1.4.0 → 1.5.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.4.0",
+  "version": "1.5.0",
   "description": "Cross-agent coding harness: one curated skill canon (TDD, brainstorming, plans, reviews, shipping, design verification) 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.4.0",
+  "version": "1.5.0",
   "description": "Cross-agent coding discipline, mechanical gates, and release workflows",
   "skills": "./canon/skills/",
   "hooks": "./hooks/hooks.json"

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 
-## 1.4.0 — 2026-08-15
+## 1.5.0 — 2026-08-16
+
+### Added
+- Failed verify, executable-criterion, performance, configured custom-audit, and completion gates now produce deterministic byte-bounded previews and preserve large complete stdout/stderr in content-addressed `.yoke/artifacts/` files with SHA-256 references.
+- Projects can tune `output.previewBytes` and `output.artifactThresholdBytes`; existing projects use backward-compatible 2 KiB/8 KiB defaults.
+- A deterministic local benchmark verifies signal retention, preview bounds, compression measurement, and artifact digest round-trips without making provider-token claims.
+
+### Security
+- Output artifact paths sanitize story identifiers, stay below a project-local root, use user-only file modes where supported, and are excluded from Yoke's clean-tree and story-commit operations even in upgraded projects. Raw artifacts are never injected automatically and documentation warns that project commands may emit secrets or personal data.
+- Gate command capture is capped at 16 MiB per stdout/stderr stream. Quota overflow fails closed and labels retained evidence as truncated instead of risking unbounded memory or claiming partial output is complete.
+
+## 1.4.0 — 2026-08-15
 
 ### Added
 - `yoke loop run --parallel=N` now executes dependency-ready, non-colliding stories through real provider subprocess workers, isolated worktrees, leased claims, and a FIFO integration queue with fresh integrated-system gates.

package/README.md

@@ -2,8 +2,8 @@
 
 # 🐂 Yoke
 
-<!-- yoke:version:start -->1.4.0<!-- yoke:version:end -->
-<!-- yoke:tests:start -->928<!-- yoke:tests:end -->
+<!-- yoke:version:start -->1.5.0<!-- yoke:version:end -->
+<!-- yoke:tests:start -->971<!-- yoke:tests:end -->
 <!-- yoke:skills:start -->29<!-- yoke:skills:end -->
 <!-- yoke:agents:start -->Claude | Codex | Gemini<!-- yoke:agents:end -->
 
@@ -17,7 +17,7 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](#-license)
 ![Node](https://img.shields.io/badge/node-%E2%89%A520-339933?logo=node.js&logoColor=white)
 ![TypeScript](https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white)
-![Tests](https://img.shields.io/badge/tests-928%20passing-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-971%20passing-brightgreen.svg)
 ![Agents](https://img.shields.io/badge/agents-Claude%20%7C%20Codex%20%7C%20Gemini-8A2BE2)
 ![Built with TDD](https://img.shields.io/badge/built%20with-TDD%20%2B%20review-ff69b4.svg)
 
@@ -25,9 +25,14 @@
 
 </div>
 
-> **TL;DR** — `yoke setup .` asks six questions and installs the native harness for your agent. `yoke new my-app --idea="..."` bootstraps a project and drafts its story backlog. `yoke loop run my-app --isolate --review` then implements it behind hard gates: **clean tree → acceptance criteria → your real tests green → an independent model approves → commit**. Add `--parallel=N` for dependency-aware workers, or declare a reference and add `--quality` for a bounded critic/repair gauntlet. If any blocking gate is red, nothing is committed. Proof lives in `.yoke/proof/<story>/`.
-
-Yoke 1.4 adds opt-in parallel workers and a bounded, reference-driven quality gauntlet without
+> **TL;DR** — `yoke setup .` asks six questions and installs the native harness for your agent. `yoke new my-app --idea="..."` bootstraps a project and drafts its story backlog. `yoke loop run my-app --isolate --review` then implements it behind hard gates: **clean tree → acceptance criteria → your real tests green → an independent model approves → commit**. Add `--parallel=N` for dependency-aware workers, or declare a reference and add `--quality` for a bounded critic/repair gauntlet. If any blocking gate is red, nothing is committed. Proof lives in `.yoke/proof/<story>/`.
+
+Yoke 1.5 keeps failed gate output compact without throwing evidence away: deterministic previews
+retain actionable failures and final summaries, while large complete stdout/stderr remains available
+in private, content-addressed local artifacts. Existing projects keep their serial behavior and use
+safe 2 KiB preview / 8 KiB artifact defaults unless configured otherwise.
+
+Yoke 1.4 adds opt-in parallel workers and a bounded, reference-driven quality gauntlet without
 changing existing serial loop defaults. See [the 1.4 migration guide](docs/MIGRATING-TO-1.4.md)
 for the new flags, configuration, cleanup behavior, and review-verdict contract.
 
@@ -76,7 +81,7 @@ $ ls reading-app/.yoke/proof/STORY-2/
 home.png  list.png                            # photographic evidence, labelled per story
 ```
 
-Every claim in that transcript is enforced by code paths with tests behind them — 928 of them, and this repo was built by its own loop and gates ([how it was built](#-why--how-it-was-built)).
+Every claim in that transcript is enforced by code paths with tests behind them — 971 of them, and this repo was built by its own loop and gates ([how it was built](#-why--how-it-was-built)).
 
 ## 🚀 Quickstart
 
@@ -592,6 +597,41 @@ be fast" is a vibe the loop cannot enforce. Yoke makes it mechanical, at two lev
   method: profile first, optimize leaves not boundaries, commit benchmarks as tests, version
   the *why* of every optimization in `context/DECISIONS.md`.
 
+### Artifact-backed gate output: compact context, complete local evidence
+
+Failed verify, executable-criterion, performance, configured custom-audit, and completion commands can emit thousands of
+low-signal lines. Yoke keeps the model-visible failure summary deterministic and bounded while
+preserving large raw stdout/stderr below `.yoke/artifacts/`:
+
+```yaml
+output:
+  previewBytes: 2048             # default: maximum compact preview bytes
+  artifactThresholdBytes: 8192   # default: persist raw output only above this size
+```
+
+The preview prioritizes errors, warnings, adjacent context, and final test summaries. Above the
+artifact threshold it also includes a project-relative path, byte count, and full SHA-256 digest,
+for example:
+
+```text
+[full output: .yoke/artifacts/STORY-4/verify-0123abcd4567.log | 42810 bytes | sha256:0123...]
+```
+
+An agent can read that ordinary file when the preview is insufficient; nothing is injected into
+later stories automatically. Repeated identical failures reuse the same content-addressed path.
+Successful gate output is discarded as before. This affects only commands executed by Yoke's own
+gates. It does **not** intercept tool output generated internally by Claude Code, Codex, or Gemini,
+so benchmark ratios for this feature are not provider-token or billing claims.
+
+Command capture is capped at 16 MiB per stdout/stderr stream. Exceeding that quota fails the gate
+closed and stores the captured prefix with a `[truncated output: ...]` marker; Yoke never labels
+partial evidence as full output.
+
+Yoke treats `.yoke/artifacts/` as local, non-committable runtime state and excludes it from its
+clean-tree and story-commit operations; `yoke retrofit` also adds it to `.gitignore`. Raw command output is intentionally stored
+without redaction so it remains valid evidence and may therefore contain credentials, personal
+data, or other sensitive text emitted by project commands. Inspect artifacts before sharing them.
+
 The loop trusts **verify**, not the agent's exit code: a story whose tests are green is
 committed even if the agent process exited non-zero (a common Windows `.cmd`-wrapper ghost).
 A failing verify is retried up to `verify.retries` times (default 1) so a transient flake
@@ -599,7 +639,7 @@ self-heals while a real failure still blocks. Structured acceptance criteria are
 individually; an unrelated green suite cannot satisfy a criterion without its proof command.
 
 `.yoke/loop-status.json`, `.yoke/loop.log`, `.yoke/loop.lock`, its takeover/recovery leases, lock/decision temp files, `.yoke/story-durations.json`,
-`.yoke/ambiguity.md`, and the critical-decision request/answering files are runtime artifacts;
+`.yoke/ambiguity.md`, `.yoke/artifacts/`, and the critical-decision request/answering files are runtime artifacts;
 `yoke retrofit` gitignores them (along with
 `.yoke/worktrees/`, `.yoke/backup/`, `.yoke/proof/`, and `.yoke/changes/`) so they never trip the clean-tree gate.
 
@@ -795,7 +835,7 @@ release provenance.
 ## 🧪 Development
 
 ```bash
-npm test          # vitest (928 tests)
+npm test          # vitest (971 tests)
 npm run build     # tsc, no emit errors
 npm run yoke -- validate canon
 ```

package/bench/README.md

@@ -1,74 +1,83 @@
 # Yoke benchmark — tokens · speed · quality
 
-Reproducible cross-runner and routing A/B benchmarks for the Yoke loop. Fixed fixture projects,
-the same PRD within each comparison, and three measured dimensions:
-
-Adaptive routing is implemented for Claude Code, Codex CLI, and Gemini CLI. The checked-in
-multi-run performance study currently measures Codex only; provider support tests are not treated
-as performance evidence for Claude or Gemini.
+Reproducible cross-runner and routing A/B benchmarks for the Yoke loop. Fixed fixture projects,
+the same PRD within each comparison, and three measured dimensions:
+
+Adaptive routing is implemented for Claude Code, Codex CLI, and Gemini CLI. The checked-in
+multi-run performance study currently measures Codex only; provider support tests are not treated
+as performance evidence for Claude or Gemini.
 
 | Dimension | How it is measured |
 |---|---|
-| **Tokens** | The loop's own provider telemetry in `.yoke/loop-status.json`, split into total input, cached input, fresh input (`input − cached`), output, and reasoning tokens when the provider reports them. Adaptive runs preserve one entry per orchestrator/worker call. Missing telemetry is `null`, never estimated. |
+| **Tokens** | The loop's own provider telemetry in `.yoke/loop-status.json`, split into total input, cached input, fresh input (`input − cached`), output, and reasoning tokens when the provider reports them. Adaptive runs preserve one entry per orchestrator/worker call. Missing telemetry is `null`, never estimated. |
 | **Speed** | Wall-clock, measured by the harness from outside: total run + per-story (from `--json` NDJSON event timestamps). The loop itself stores no durations. |
 | **Quality** | Objective, not judged by any model: the fixture ships **pre-written tests** the agent never has to write (only satisfy). After the run, each story's test file is executed against the final tree. `srcLoc` (non-empty lines in `src/`) is a code-economy proxy. |
 
-## The fixture (`fixtures/string-kit`)
+## The fixture (`fixtures/string-kit`)
 
 A dependency-free ESM library with 3 stories (`slugify`, `truncate`, `titleCase`) and 16
 `node:test` assertions total. `bench-verify.mjs` is cumulative: story N runs the tests of
 stories 1…N (the loop exports `YOKE_STORY`), so later stories cannot break earlier work; the
 final quality check runs everything. No npm installs, so results measure the agent — not the
-network.
-
-## The routing fixture (`fixtures/routing-queue`)
-
-A dependency-free in-memory priority queue with two cumulative stories and 10 pre-written
-`node:test` cases covering idempotency, priority/FIFO ordering, leases, retry/backoff, dead
-letters, expired lease recovery, filters, and state statistics. It is intentionally substantial
-enough that a lower-cost worker can potentially repay one routing-controller call per story.
+network.
+
+## The routing fixture (`fixtures/routing-queue`)
+
+A dependency-free in-memory priority queue with two cumulative stories and 10 pre-written
+`node:test` cases covering idempotency, priority/FIFO ordering, leases, retry/backoff, dead
+letters, expired lease recovery, filters, and state statistics. It is intentionally substantial
+enough that a lower-cost worker can potentially repay one routing-controller call per story.
 
 ## Running it
 
 ```bash
 npm run build
-node bench/run.mjs --runner=claude   # or gemini / codex
-node bench/run.mjs --runner=codex --fixture=routing-queue --routing=off --unsafe --run-root=G:\NN-Developed\Yoke-Testground
-node bench/run.mjs --runner=codex --fixture=routing-queue --routing=on  --unsafe --run-root=G:\NN-Developed\Yoke-Testground
-node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-large-seed-2026-08-02 --routing=off --run-root=G:\NN-Developed\Yoke-Testground
-node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-large-seed-2026-08-02 --routing=on  --run-root=G:\NN-Developed\Yoke-Testground
-node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-codex-study-seed-2026-08-02 --routing=on  --label=codex-only-pair1-on  --run-root=G:\NN-Developed\Yoke-Testground
-node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-codex-study-seed-2026-08-02 --routing=off --label=codex-only-pair1-off --run-root=G:\NN-Developed\Yoke-Testground
-node bench/analyze-routing-study.mjs
-node bench/run-matrix.mjs --label=release-1.0
+node bench/run.mjs --runner=claude   # or gemini / codex
+node bench/run.mjs --runner=codex --fixture=routing-queue --routing=off --unsafe --run-root=G:\NN-Developed\Yoke-Testground
+node bench/run.mjs --runner=codex --fixture=routing-queue --routing=on  --unsafe --run-root=G:\NN-Developed\Yoke-Testground
+node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-large-seed-2026-08-02 --routing=off --run-root=G:\NN-Developed\Yoke-Testground
+node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-large-seed-2026-08-02 --routing=on  --run-root=G:\NN-Developed\Yoke-Testground
+node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-codex-study-seed-2026-08-02 --routing=on  --label=codex-only-pair1-on  --run-root=G:\NN-Developed\Yoke-Testground
+node bench/run-large.mjs --seed=G:\NN-Developed\Yoke-Testground\yoke-codex-study-seed-2026-08-02 --routing=off --label=codex-only-pair1-off --run-root=G:\NN-Developed\Yoke-Testground
+node bench/analyze-routing-study.mjs
+node bench/run-matrix.mjs --label=release-1.0
+node bench/output-compaction.mjs  # deterministic local gate-output benchmark; no provider call
 ```
 
-Each run copies the fixture to `bench/.runs/<fixture>-<runner>-<routing>-<stamp>` (or the
-explicit `--run-root`), git-inits it,
-drives `yoke loop run --json --max=6 --timeout=10`, and writes a result JSON to
+Each run copies the fixture to `bench/.runs/<fixture>-<runner>-<routing>-<stamp>` (or the
+explicit `--run-root`), git-inits it,
+drives `yoke loop run --json --max=6 --timeout=10`, and writes a result JSON to
 `bench/results/`. Runs are billed against your own accounts for the agent CLIs involved.
 The matrix is sequential to avoid cross-provider load distortion. Missing CLIs and authentication
-failures are stored as honest `unavailable`/`auth-failed` rows and never presented as quality measurements.
-
-`run-large.mjs` accepts an external full-repository seed, starts each arm with a separate empty
-routing registry, junctions this checkout's dependencies, and replays the seed's original
-acceptance tests under fresh filenames after the agent run. This prevents an agent editing a
-visible test from turning into false benchmark evidence. A seed can provide `bench-acceptance.json`
-to declare its fixture identity and hidden-test files. `analyze-routing-study.mjs` validates and
-aggregates the checked-in three-pair Codex-only study.
+failures are stored as honest `unavailable`/`auth-failed` rows and never presented as quality measurements.
+
+### Gate-output compaction benchmark
+
+`output-compaction.mjs` exercises only Yoke's deterministic failure-preview and artifact path.
+It emits a fixed noisy gate failure, verifies that the early compiler error and final test summary
+remain visible, and checks the stored SHA-256 digest. Its byte/token approximation is not a provider
+bill and says nothing about tool output generated inside Claude Code, Codex, or Gemini. It makes no
+comparison to Aphrodite's corpus or published ratios.
+
+`run-large.mjs` accepts an external full-repository seed, starts each arm with a separate empty
+routing registry, junctions this checkout's dependencies, and replays the seed's original
+acceptance tests under fresh filenames after the agent run. This prevents an agent editing a
+visible test from turning into false benchmark evidence. A seed can provide `bench-acceptance.json`
+to declare its fixture identity and hidden-test files. `analyze-routing-study.mjs` validates and
+aggregates the checked-in three-pair Codex-only study.
 
 ## Caveats (read before quoting numbers)
 
-- Agent runs are stochastic. Older rows are N=1; the 2026-08-02 Codex-only study uses three
-  alternating-order pairs per arm. Re-run before setting broad policy defaults.
-- Compare routing on/off only when fixture, parent model/effort, permissions, native-subagent
-  policy, and host load are controlled. The checked-in routing fixture uses `runner.bare: true`
-  to exclude personal MCP/plugin startup from both sides.
-- Model identity matters more than CLI identity: `tokens.model` records what actually served
-  the run. Different default models per CLI make "claude vs gemini" really "model X vs model Y".
-- Codex input telemetry includes cache reads. Compare both total input and fresh input; do not
-  treat cached input as equivalent to newly processed input. Dollar cost is reported only when
-  the provider emits it—Yoke does not guess prices from a model name.
+- Agent runs are stochastic. Older rows are N=1; the 2026-08-02 Codex-only study uses three
+  alternating-order pairs per arm. Re-run before setting broad policy defaults.
+- Compare routing on/off only when fixture, parent model/effort, permissions, native-subagent
+  policy, and host load are controlled. The checked-in routing fixture uses `runner.bare: true`
+  to exclude personal MCP/plugin startup from both sides.
+- Model identity matters more than CLI identity: `tokens.model` records what actually served
+  the run. Different default models per CLI make "claude vs gemini" really "model X vs model Y".
+- Codex input telemetry includes cache reads. Compare both total input and fresh input; do not
+  treat cached input as equivalent to newly processed input. Dollar cost is reported only when
+  the provider emits it—Yoke does not guess prices from a model name.
 - The fixture is deliberately small (a loop-overhead + basic-competence probe, minutes not
   hours). It does not measure large-context refactoring, UI work, or long-horizon planning.
 - Cumulative verify means a story's duration includes fixing any regressions it caused.

package/bench/output-compaction.mjs

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto'
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+async function runtimeModules() {
+  const builtCompact = new URL('../dist/output/compact.js', import.meta.url)
+  const builtArtifact = new URL('../dist/output/artifact.js', import.meta.url)
+  const useBuild = existsSync(fileURLToPath(builtCompact)) && existsSync(fileURLToPath(builtArtifact))
+  return Promise.all([
+    import(useBuild ? builtCompact.href : new URL('../src/output/compact.ts', import.meta.url).href),
+    import(useBuild ? builtArtifact.href : new URL('../src/output/artifact.ts', import.meta.url).href),
+  ])
+}
+
+function fixture() {
+  return [
+    '=== stdout ===',
+    'compiling application',
+    'src/core.ts:17: error TS2304: Cannot find name ImportantWidget',
+    'the failing call is part of the checkout flow',
+    ...Array.from({ length: 600 }, (_, index) => `progress shard=${index % 12} status=unchanged cache=hit`),
+    '=== stderr ===',
+    'Tests: 1 failed, 249 passed, 250 total',
+  ].join('\n')
+}
+
+export async function runOutputCompactionBenchmark() {
+  const [{ compactCommandOutput }, { writeOutputArtifact }] = await runtimeModules()
+  const raw = fixture()
+  const previewBudgetBytes = 512
+  const compacted = compactCommandOutput(raw, { previewBytes: previewBudgetBytes })
+  const dir = mkdtempSync(join(tmpdir(), 'yoke-output-bench-'))
+  try {
+    const artifact = writeOutputArtifact(dir, raw, { phase: 'verify', storyId: 'BENCH' })
+    const stored = readFileSync(join(dir, ...artifact.relativePath.split('/')))
+    const storedDigest = createHash('sha256').update(stored).digest('hex')
+    const previewBytes = Buffer.byteLength(compacted.preview)
+    const referencedBytes = previewBytes + Buffer.byteLength(artifact.marker)
+    return {
+      fixture: 'gate-output-v1',
+      rawBytes: Buffer.byteLength(raw),
+      rawApproxTokens: Math.ceil(Buffer.byteLength(raw) / 4),
+      previewBudgetBytes,
+      previewBytes,
+      previewApproxTokens: Math.ceil(previewBytes / 4),
+      referencedBytes,
+      compressionRatio: Number((Buffer.byteLength(raw) / referencedBytes).toFixed(2)),
+      earlyErrorRetained: compacted.preview.includes('error TS2304'),
+      finalSummaryRetained: compacted.preview.includes('Tests: 1 failed, 249 passed'),
+      digestRoundTrip: storedDigest === artifact.sha256,
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const result = await runOutputCompactionBenchmark()
+  console.log(JSON.stringify(result, null, 2))
+  if (!result.earlyErrorRetained || !result.finalSummaryRetained || !result.digestRoundTrip || result.previewBytes > result.previewBudgetBytes) {
+    process.exitCode = 1
+  }
+}

package/canon/manifest.yaml

@@ -1,5 +1,5 @@
 name: yoke-canon
-version: 1.4.0
+version: 1.5.0
 agents: [claude, codex, gemini]
 skills:
   - { id: tdd, path: skills/tdd, kind: methodology }

package/dist/audit/command.js

@@ -22,12 +22,20 @@ export function runAudit(targetDir, opts = {}) {
         }
         findings.push(...scanSensitiveChanges(changed));
         if (opts.command) {
-            try {
-                execSync(opts.command, { cwd: targetDir, stdio: 'pipe' });
-            }
-            catch {
-                findings.push({ ruleId: 'audit.custom-command', severity: 'high', message: `Audit command failed: ${opts.command}`, file: '.yoke/config.yaml' });
+            let commandResult;
+            if (opts.commandRunner)
+                commandResult = opts.commandRunner(opts.command, targetDir);
+            else {
+                try {
+                    execSync(opts.command, { cwd: targetDir, stdio: 'pipe' });
+                    commandResult = { passed: true, summary: `audit passed: ${opts.command}` };
+                }
+                catch {
+                    commandResult = { passed: false, summary: `Audit command failed: ${opts.command}` };
+                }
             }
+            if (!commandResult.passed)
+                findings.push({ ruleId: 'audit.custom-command', severity: 'high', message: commandResult.summary, file: '.yoke/config.yaml' });
         }
         else {
             const dependency = opts.dependency ?? ((repoFiles) => {

package/dist/loop/git.js

@@ -1,14 +1,16 @@
 import { execFileSync } from 'node:child_process';
 import { sanitizeCommitMessage } from './identity.js';
+const OUTPUT_ARTIFACT_EXCLUDE = ':(exclude).yoke/artifacts/**';
 export const realGitOps = {
     isClean(dir) {
-        const out = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString();
+        const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all', '--', '.', OUTPUT_ARTIFACT_EXCLUDE], { cwd: dir }).toString();
         return out.trim() === '';
     },
     commitAll(dir, message, identity) {
-        execFileSync('git', ['add', '-A'], { cwd: dir, stdio: 'pipe' });
-        const status = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString().trim();
-        if (status === '') {
+        execFileSync('git', ['reset', '--quiet', '--', '.yoke/artifacts'], { cwd: dir, stdio: 'pipe' });
+        execFileSync('git', ['add', '-A', '--', '.', OUTPUT_ARTIFACT_EXCLUDE], { cwd: dir, stdio: 'pipe' });
+        const staged = execFileSync('git', ['diff', '--cached', '--name-only'], { cwd: dir }).toString().trim();
+        if (staged === '') {
             throw new Error('nothing to commit after agent run');
         }
         const identityArgs = identity

package/dist/loop/run-command.js

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { loadConfig, saveConfig, defaultConfig, resolveVerifyCommand } from '../retrofit/config.js';
+import { loadConfig, saveConfig, defaultConfig, resolveOutputPolicy, resolveVerifyCommand } from '../retrofit/config.js';
 import { loadPrd, progress } from './prd.js';
 import { runLoop } from './loop.js';
 import { commitPaths, realGitOps } from './git.js';
@@ -144,6 +144,7 @@ export function runLoopCommand(targetDir, opts) {
             return 2;
         }
     }
+    const outputPolicy = resolveOutputPolicy(config);
     let verify = opts.verify;
     if (!verify) {
         const command = resolveVerifyCommand(targetDir, config);
@@ -151,16 +152,16 @@ export function runLoopCommand(targetDir, opts) {
             console.error('No verify command configured. Set verify.command in .yoke/config.yaml (e.g. "npm test") so the loop can confirm tests pass before marking work done.');
             return 2;
         }
-        verify = retryingVerifier(commandVerifier(command), config.verify?.retries ?? 1);
+        verify = retryingVerifier(commandVerifier(command, { phase: 'verify', policy: outputPolicy }), config.verify?.retries ?? 1);
     }
     // Optional performance budget gate: same contract as verify (exit 0 = within
     // budget), same flake tolerance (benchmarks are noisy).
     let perf = opts.perf;
     if (!perf && config.perf?.command) {
-        perf = retryingVerifier(commandVerifier(config.perf.command), config.perf.retries ?? 1);
+        perf = retryingVerifier(commandVerifier(config.perf.command, { phase: 'perf', policy: outputPolicy }), config.perf.retries ?? 1);
     }
     const completion = config.completion?.command
-        ? retryingVerifier(commandVerifier(config.completion.command), config.completion.retries ?? 1)
+        ? retryingVerifier(commandVerifier(config.completion.command, { phase: 'completion', policy: outputPolicy }), config.completion.retries ?? 1)
         : undefined;
     // Opt-in self-update, loop START only — this run keeps executing the version
     // it started with; a fetched upgrade applies from the next invocation.
@@ -181,8 +182,12 @@ export function runLoopCommand(targetDir, opts) {
     let audit = opts.audit;
     if (!audit && config.audit?.enabled) {
         audit = (dir) => {
-            const result = runAudit(dir, { command: config.audit?.command, suppressions: config.audit?.suppressions });
-            return { passed: result.code === 0, summary: result.error ?? (result.findings.map(f => `${f.ruleId} ${f.file}${f.line ? `:${f.line}` : ''}`).join(', ') || 'audit passed') };
+            const result = runAudit(dir, {
+                command: config.audit?.command,
+                suppressions: config.audit?.suppressions,
+                commandRunner: (command, commandDir) => commandVerifier(command, { phase: 'audit', policy: outputPolicy })(commandDir),
+            });
+            return { passed: result.code === 0, summary: result.error ?? (result.findings.map(f => `${f.ruleId} ${f.file}${f.line ? `:${f.line}` : ''}: ${f.message}`).join('\n') || 'audit passed') };
         };
     }
     if (commitIdentity) {
@@ -413,7 +418,7 @@ export function runLoopCommand(targetDir, opts) {
             git: opts.git,
             identity: commitIdentity,
             verify,
-            verifyCriterion: (dir, _story, criterion) => commandsVerifier(criterion.verify)(dir),
+            verifyCriterion: (dir, _story, criterion) => commandsVerifier(criterion.verify, { phase: 'criterion', policy: outputPolicy })(dir),
             requireCriterionEvidence: config.verify?.requireCriteria ?? false,
             perf,
             audit,
@@ -433,7 +438,7 @@ export function runLoopCommand(targetDir, opts) {
             git,
             commitIdentity,
             verify,
-            verifyCriterion: (dir, _story, criterion) => commandsVerifier(criterion.verify)(dir),
+            verifyCriterion: (dir, _story, criterion) => commandsVerifier(criterion.verify, { phase: 'criterion', policy: outputPolicy })(dir),
             requireCriterionEvidence: config.verify?.requireCriteria ?? false,
             completion,
             intake,

package/dist/loop/verify.js

@@ -1,26 +1,80 @@
 import { execSync } from 'node:child_process';
-// Runs a shell command in the target dir; passed = exit 0. execSync goes through the
-// shell, so `npm test` resolves npm.cmd on Windows. Output is captured (not streamed).
-export function commandVerifier(command) {
+import { compactCommandOutput } from '../output/compact.js';
+import { writeOutputArtifact } from '../output/artifact.js';
+import { DEFAULT_OUTPUT_POLICY } from '../output/types.js';
+function outputText(value) {
+    if (Buffer.isBuffer(value))
+        return value.toString('utf8');
+    return typeof value === 'string' ? value : '';
+}
+function labelledOutput(stdout, stderr) {
+    const sections = [];
+    if (stdout)
+        sections.push(`=== stdout ===\n${stdout}`);
+    if (stderr)
+        sections.push(`=== stderr ===\n${stderr}`);
+    return sections.join(stdout.endsWith('\n') ? '' : '\n');
+}
+function errorMessage(error) {
+    return (error instanceof Error ? error.message : String(error))
+        .replace(/[\u0000-\u001F\u007F]/gu, ' ')
+        .slice(0, 240);
+}
+const COMMAND_CAPTURE_BYTES = 16 * 1024 * 1024;
+// Runs a shell command in the target dir; passed = exit 0. The explicit capture quota
+// avoids Node's 1 MiB default without allowing noisy commands to consume unbounded memory.
+export function commandVerifier(command, options = {}) {
     return (targetDir) => {
+        const phase = options.phase ?? 'verify';
         try {
-            execSync(command, { cwd: targetDir, stdio: 'pipe', timeout: 600_000 });
-            return { passed: true, summary: `verify passed: ${command}` };
+            execSync(command, {
+                cwd: targetDir,
+                stdio: 'pipe',
+                timeout: options.timeoutMs ?? 600_000,
+                maxBuffer: COMMAND_CAPTURE_BYTES,
+            });
+            return { passed: true, summary: `${phase} passed: ${command}` };
         }
         catch (e) {
             const err = e;
-            const out = (err.stderr?.toString('utf8') ?? '') || (err.stdout?.toString('utf8') ?? '');
-            const tail = out.trim().split('\n').slice(-5).join('\n');
-            const suffix = err.signal === 'SIGTERM' ? ' (timed out)' : (tail ? `\n${tail}` : '');
-            return { passed: false, summary: `verify failed: ${command}${suffix}` };
+            const captureExceeded = err.code === 'ENOBUFS';
+            const captured = labelledOutput(outputText(err.stdout), outputText(err.stderr));
+            const captureNotice = `[output truncated: exceeded ${COMMAND_CAPTURE_BYTES}-byte per-stream capture limit]`;
+            const raw = captureExceeded
+                ? `${captured}${captured ? '\n' : ''}=== capture ===\n${captureNotice}`
+                : captured;
+            const policy = options.policy ?? DEFAULT_OUTPUT_POLICY;
+            const compacted = compactCommandOutput(raw, { previewBytes: policy.previewBytes });
+            const timedOut = !captureExceeded && (err.signal === 'SIGTERM' || err.code === 'ETIMEDOUT');
+            const qualifier = captureExceeded
+                ? ' (capture limit exceeded)'
+                : timedOut ? ' (timed out)' : '';
+            const parts = [`${phase} failed: ${command}${qualifier}`];
+            if (compacted.preview)
+                parts.push(compacted.preview);
+            if (compacted.originalBytes > policy.artifactThresholdBytes) {
+                try {
+                    const artifact = (options.artifactWriter ?? writeOutputArtifact)(targetDir, raw, {
+                        phase,
+                        storyId: process.env.YOKE_STORY,
+                    });
+                    parts.push(captureExceeded
+                        ? artifact.marker.replace('[full output:', '[truncated output:')
+                        : artifact.marker);
+                }
+                catch (error) {
+                    parts.push(`[artifact unavailable: ${errorMessage(error)}]`);
+                }
+            }
+            return { passed: false, summary: parts.join('\n') };
         }
     };
 }
 /** Execute the proof commands attached to one acceptance criterion. */
-export function commandsVerifier(commands) {
+export function commandsVerifier(commands, options = {}) {
     return (targetDir) => {
         for (const command of commands) {
-            const result = commandVerifier(command)(targetDir);
+            const result = commandVerifier(command, options)(targetDir);
             if (!result.passed)
                 return result;
         }

package/dist/output/artifact.js

@@ -0,0 +1,63 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+function safeLabel(value) {
+    const cleaned = (value ?? '')
+        .replace(/[^A-Za-z0-9._-]+/gu, '-')
+        .replace(/^[.-]+|[.-]+$/gu, '')
+        .slice(0, 80);
+    return cleaned || 'session';
+}
+function assertContained(root, candidate) {
+    const fromRoot = relative(resolve(root), resolve(candidate));
+    if (fromRoot.startsWith('..') || isAbsolute(fromRoot))
+        throw new Error('artifact path escaped the project artifact root');
+}
+export function writeOutputArtifact(targetDir, raw, options) {
+    const sha256 = createHash('sha256').update(raw).digest('hex');
+    const label = safeLabel(options.storyId);
+    const relativeDir = join('.yoke', 'artifacts', label);
+    const projectRoot = realpathSync(targetDir);
+    const yokeRoot = join(targetDir, '.yoke');
+    if (existsSync(yokeRoot)) {
+        if (lstatSync(yokeRoot).isSymbolicLink())
+            throw new Error('artifact root parent must not be a symlink');
+        assertContained(projectRoot, realpathSync(yokeRoot));
+    }
+    else {
+        mkdirSync(yokeRoot, { mode: 0o700 });
+    }
+    const artifactRoot = join(targetDir, '.yoke', 'artifacts');
+    mkdirSync(artifactRoot, { recursive: true, mode: 0o700 });
+    if (lstatSync(artifactRoot).isSymbolicLink())
+        throw new Error('artifact root must not be a symlink');
+    const resolvedArtifactRoot = realpathSync(artifactRoot);
+    assertContained(projectRoot, resolvedArtifactRoot);
+    const artifactDir = join(artifactRoot, label);
+    mkdirSync(artifactDir, { recursive: true, mode: 0o700 });
+    assertContained(resolvedArtifactRoot, realpathSync(artifactDir));
+    let digestLength = 12;
+    let filename = `${options.phase}-${sha256.slice(0, digestLength)}.log`;
+    let file = join(artifactDir, filename);
+    while (existsSync(file) && !lstatSync(file).isSymbolicLink() && createHash('sha256').update(readFileSync(file)).digest('hex') !== sha256) {
+        if (digestLength === sha256.length)
+            throw new Error('artifact digest path contains mismatched content');
+        digestLength = Math.min(sha256.length, digestLength + 8);
+        filename = `${options.phase}-${sha256.slice(0, digestLength)}.log`;
+        file = join(artifactDir, filename);
+    }
+    if (existsSync(file) && lstatSync(file).isSymbolicLink())
+        throw new Error('artifact file must not be a symlink');
+    if (!existsSync(file))
+        writeFileSync(file, raw, { encoding: 'utf8', mode: 0o600 });
+    else
+        chmodSync(file, 0o600);
+    const relativePath = `${relativeDir.replace(/\\/gu, '/')}/${filename}`;
+    const bytes = Buffer.byteLength(raw);
+    return {
+        relativePath,
+        bytes,
+        sha256,
+        marker: `[full output: ${relativePath} | ${bytes} bytes | sha256:${sha256}]`,
+    };
+}