@hecer/yoke 0.8.0 → 1.0.0

package/canon/skills/authoring-prd/SKILL.md

@@ -21,6 +21,17 @@ good stories (small, testable, ordered) let it run overnight.
 5. **Greenfield: STORY-1 scaffolds.** Project skeleton + runnable test suite + a criterion
    that the verify command (`verify.command` in `.yoke/config.yaml`) exits 0. Every later
    story stands on a green pipeline.
+6. **Performance requirements are acceptance criteria — with numbers.** "Should be fast" is
+   a vibe the loop cannot gate; "imports 1M rows in < 2s (asserted by the bench test)" is a
+   criterion. If the whole project has a budget, wire `perf.command` in `.yoke/config.yaml`
+   (see the `performance` skill) instead of repeating it per story.
+7. **Ask everything now.** Clarifying questions belong in this planning round — a loop run
+   has nobody to ask. A criterion that still needs a decision ("TBD", "choose a provider")
+   is not loop-ready; resolve it here or the agent will either guess (default) or block
+   (`--on-ambiguity=abort`).
+8. **Model real dependencies.** Add `needs` only for hard prerequisites, `area` for files or
+   subsystems that must not be edited concurrently, and `agent` only as an affinity hint.
+   Dependency IDs must exist; self-dependencies and cycles are invalid.
 
 ## Format (`.yoke/prd.yaml`)
 
@@ -35,6 +46,9 @@ good stories (small, testable, ordered) let it run overnight.
 - id: STORY-2
   title: add the sum command
   priority: 2
+  needs: [STORY-1]
+  area: cli
+  agent: codex
   acceptance:
     - "cli sum 1 2 prints 3"
     - "non-numeric input exits 1 with an error message"

package/canon/skills/performance/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: performance
+description: Use when a task has efficiency requirements or touches a hot path — make performance a measured requirement (benchmarks as tests, budgets as gates), keep interfaces clean and optimizations local, and version the WHY so future agents don't "clean up" fast code back to slow.
+---
+
+# Performance (measured, not vibed)
+
+"Efficient" is a requirement, not a code style. Untested performance claims rot exactly like
+untested behavior claims. This skill makes efficiency mechanical — the same move Yoke makes
+for everything else.
+
+## The decision ladder
+
+1. **Default: clean + minimal.** For ~90% of code, the `minimal-code` rules ARE the
+   performance strategy — less code, fewer layers, no speculative abstraction. Do not
+   micro-optimize code that no measurement flagged (premature optimization).
+2. **Performance requirement? Make it an acceptance criterion.** A number, not an adjective:
+   - Good: "imports 1M rows in < 2s", "p95 request latency < 50ms in the bench test",
+     "no allocation inside the render loop (verified by the bench assertion)"
+   - Bad: "should be fast", "optimize the importer"
+3. **Whole-project budget? Use the perf gate.** Set `perf.command` in `.yoke/config.yaml`
+   (a benchmark script; exit 0 = within budget). The loop runs it after verify — a story
+   that breaks the budget is blocked, no matter how clean its diff is.
+
+## Writing efficient code that agents can maintain
+
+- **Clean at the boundaries, aggressive in the leaves.** Interfaces, data flow, and names
+  stay simple and obvious. Optimization lives inside a few clearly-bounded leaf functions
+  whose contracts are pinned by tests. An ugly-fast function is maintainable; an
+  ugly-fast architecture is not.
+- **Profile before optimizing.** Find the actual hot 5% (a profiler, a timing harness, the
+  bench script) — never optimize from intuition. Record the measurement in the PR/commit.
+- **Benchmarks are tests. Commit them.** An optimization without a committed benchmark is
+  one refactor away from silently disappearing. The bench script doubles as `perf.command`.
+- **Version the WHY.** Every non-obvious optimization gets a one-line comment
+  (`perf: avoids N+1 — see bench/import.mjs`) and, if it shaped a design, a line in
+  `context/DECISIONS.md`. The most common AI maintenance accident is a later agent
+  "simplifying" fast code back to slow because nothing said why it was shaped that way.
+- **Know the classics before reaching for cleverness:** right data structure (map vs list
+  scan), batching over per-item round trips (N+1), streaming over buffering, avoiding
+  repeated work in loops, caching only with a measured hit rate and an invalidation story.
+
+## Red flags
+
+- Optimizing without a measurement or a budget → stop, measure first.
+- A "refactor" or "cleanup" story touching code with `perf:` comments → re-run the bench
+  before AND after; keep the numbers in the story outcome.
+- Hand-rolled cleverness where the stdlib is already O(right) → `minimal-code` wins.

package/canon/skills/ship/SKILL.md

@@ -526,15 +526,10 @@ Analyze the diff and group changes into logical commits. Each commit should repr
 
 **Each commit must be independently valid** — no broken imports, no references to code that doesn't exist yet.
 
-The **final commit** (VERSION + CHANGELOG) gets the version tag and co-author trailer:
+The **final commit** contains VERSION + CHANGELOG. The project's commit identity and co-author policy always wins; never add an AI co-author trailer unless the project explicitly allows it.
 
 ```bash
-git commit -m "$(cat <<'EOF'
-chore: bump version and changelog (vX.Y.Z.W)
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
-EOF
-)"
+git commit -m "chore: bump version and changelog (vX.Y.Z.W)"
 ```
 
 ---

package/canon/tools/codex-rtk-hook.mjs

@@ -0,0 +1,36 @@
+import { spawnSync } from 'node:child_process'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+function rtkCheck(command) {
+  const result = spawnSync('rtk', ['hook', 'check', command], { encoding: 'utf8', timeout: 3000 })
+  return result.status === 0 ? result.stdout.trim() : ''
+}
+
+export function rewriteHookInput(input, check = rtkCheck) {
+  if (input?.tool_name !== 'Bash' && input?.toolName !== 'Bash') return null
+  const toolInput = input.tool_input ?? input.toolInput
+  const command = toolInput?.command
+  if (typeof command !== 'string' || command.trim() === '') return null
+  const rewritten = check(command)
+  if (!rewritten || rewritten === command) return null
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      updatedInput: { ...toolInput, command: rewritten },
+    },
+  }
+}
+
+async function main() {
+  let raw = ''
+  for await (const chunk of process.stdin) raw += chunk
+  try {
+    const output = rewriteHookInput(JSON.parse(raw))
+    if (output) process.stdout.write(JSON.stringify(output))
+  } catch {
+    // Compression is an optimization. Malformed input must never block Codex.
+  }
+}
+
+if (process.argv[1] && pathToFileURL(resolve(process.argv[1])).href === import.meta.url) await main()

package/dist/agents/providers.js

@@ -0,0 +1,23 @@
+const argsFor = (agent, permissions) => {
+    if (agent === 'claude') {
+        const mode = permissions === 'unsafe' ? 'bypassPermissions' : permissions === 'read-only' ? 'plan' : 'auto';
+        const args = ['-p', '--permission-mode', mode];
+        if (permissions === 'unsafe')
+            args.push('--dangerously-skip-permissions');
+        return [...args, '--output-format', 'stream-json', '--verbose'];
+    }
+    if (agent === 'codex') {
+        if (permissions === 'unsafe')
+            return ['exec', '--dangerously-bypass-approvals-and-sandbox', '--json'];
+        if (permissions === 'read-only')
+            return ['exec', '--sandbox', 'read-only', '--json'];
+        return ['exec', '--full-auto', '--json'];
+    }
+    if (permissions === 'unsafe')
+        return ['--yolo', '--output-format', 'stream-json'];
+    const approval = permissions === 'read-only' ? 'plan' : 'auto_edit';
+    return ['--approval-mode', approval, '--sandbox', '--output-format', 'stream-json'];
+};
+export function buildProviderInvocation(agent, prompt, cwd, permissions = 'safe') {
+    return { command: agent, args: argsFor(agent, permissions), input: prompt, cwd };
+}

package/dist/agents/telemetry.js

@@ -0,0 +1,30 @@
+const finite = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+export function parseProviderTelemetry(agent, lines) {
+    let inputTokens;
+    let outputTokens;
+    let model;
+    for (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const message = event.message && typeof event.message === 'object' ? event.message : undefined;
+        const usage = (event.usage && typeof event.usage === 'object' ? event.usage : message?.usage);
+        const inValue = finite(usage?.input_tokens ?? usage?.inputTokens ?? usage?.prompt_tokens);
+        const outValue = finite(usage?.output_tokens ?? usage?.outputTokens ?? usage?.completion_tokens);
+        if (inValue !== undefined)
+            inputTokens = inValue;
+        if (outValue !== undefined)
+            outputTokens = outValue;
+        const eventModel = event.model ?? message?.model;
+        if (typeof eventModel === 'string' && eventModel)
+            model = eventModel;
+    }
+    if (inputTokens === undefined && outputTokens === undefined)
+        return { usageAvailable: false };
+    const tokens = { inputTokens: inputTokens ?? 0, outputTokens: outputTokens ?? 0, ...(model ? { model } : {}) };
+    return { usageAvailable: true, tokens };
+}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/audit/changes.js

@@ -0,0 +1,6 @@
+const SENSITIVE = /(^|\/)(\.github\/workflows|auth|permissions?|secrets?|infra|terraform)(\/|\.|$)/i;
+export function scanSensitiveChanges(files) {
+    return [...new Set(files)].filter(file => SENSITIVE.test(file.replace(/\\/g, '/'))).sort().map(file => ({
+        ruleId: 'changes.sensitive-path', severity: 'medium', message: 'Security-sensitive path changed; review explicitly', file,
+    }));
+}

package/dist/audit/command.js

@@ -0,0 +1,64 @@
+import { execFileSync, execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { dependencyAuditCommand, parseDependencyAudit } from './dependencies.js';
+import { scanSensitiveChanges } from './changes.js';
+import { scanSecrets } from './secrets.js';
+const lines = (value) => value.split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+export function applySuppressions(findings, suppressions = [], now = new Date()) {
+    return findings.filter(finding => !suppressions.some(s => s.reason.trim() && s.ruleId === finding.ruleId && (!s.file || s.file === finding.file) && (!s.expires || Date.parse(s.expires) >= now.getTime())));
+}
+export function runAudit(targetDir, opts = {}) {
+    try {
+        const files = opts.files?.() ?? lines(execFileSync('git', ['ls-files'], { cwd: targetDir }).toString());
+        const changed = opts.changed?.() ?? lines(execFileSync('git', ['diff', '--name-only', 'HEAD'], { cwd: targetDir }).toString());
+        const read = opts.read ?? ((file) => readFileSync(join(targetDir, file), 'utf8'));
+        let findings = [];
+        for (const file of files) {
+            try {
+                findings.push(...scanSecrets(file, read(file)));
+            }
+            catch { /* binary/deleted file */ }
+        }
+        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' });
+            }
+        }
+        else {
+            const dependency = opts.dependency ?? ((repoFiles) => {
+                const command = dependencyAuditCommand(repoFiles);
+                if (!command)
+                    return [];
+                try {
+                    return parseDependencyAudit(execFileSync(command[0], command[1], { cwd: targetDir, stdio: ['ignore', 'pipe', 'pipe'] }).toString());
+                }
+                catch (error) {
+                    return parseDependencyAudit(String(error.stdout ?? '{}'));
+                }
+            });
+            findings.push(...dependency(files));
+        }
+        findings = applySuppressions(findings, opts.suppressions).sort((a, b) => a.file.localeCompare(b.file) || (a.line ?? 0) - (b.line ?? 0) || a.ruleId.localeCompare(b.ruleId));
+        return { code: findings.some(f => f.severity === 'high' || f.severity === 'critical') ? 1 : 0, findings };
+    }
+    catch (error) {
+        return { code: 2, findings: [], error: error.message };
+    }
+}
+export function printAudit(result, json = false) {
+    if (json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    for (const finding of result.findings)
+        console.log(`${finding.severity.toUpperCase()} ${finding.ruleId} ${finding.file}${finding.line ? `:${finding.line}` : ''} — ${finding.message}`);
+    if (result.error)
+        console.error(`Audit unavailable: ${result.error}`);
+    else
+        console.log(result.code === 0 ? '✓ audit passed' : `✗ audit found ${result.findings.length} issue(s)`);
+}

package/dist/audit/dependencies.js

@@ -0,0 +1,21 @@
+export function dependencyAuditCommand(files) {
+    if (files.includes('package-lock.json'))
+        return ['npm', ['audit', '--json']];
+    if (files.includes('pnpm-lock.yaml'))
+        return ['pnpm', ['audit', '--json']];
+    if (files.includes('yarn.lock'))
+        return ['yarn', ['npm', 'audit', '--json']];
+    return null;
+}
+export function parseDependencyAudit(output) {
+    let value;
+    try {
+        value = JSON.parse(output);
+    }
+    catch {
+        return [{ ruleId: 'dependencies.audit-error', severity: 'high', message: 'Dependency audit returned invalid JSON', file: 'package manifest' }];
+    }
+    const vulnerabilities = value?.metadata?.vulnerabilities;
+    const count = Number(vulnerabilities?.high ?? 0) + Number(vulnerabilities?.critical ?? 0);
+    return count > 0 ? [{ ruleId: 'dependencies.high', severity: 'high', message: `${count} high/critical dependency vulnerabilities`, file: 'package lock' }] : [];
+}

package/dist/audit/secrets.js

@@ -0,0 +1,16 @@
+const RULES = [
+    { ruleId: 'secret.github-token', severity: 'critical', pattern: /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g, message: 'GitHub token detected' },
+    { ruleId: 'secret.aws-access-key', severity: 'critical', pattern: /\bAKIA[0-9A-Z]{16}\b/g, message: 'AWS access key detected' },
+    { ruleId: 'secret.private-key', severity: 'critical', pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g, message: 'Private key material detected' },
+];
+export function scanSecrets(file, content) {
+    const findings = [];
+    for (const rule of RULES) {
+        rule.pattern.lastIndex = 0;
+        for (const match of content.matchAll(rule.pattern)) {
+            const line = content.slice(0, match.index).split(/\r?\n/).length;
+            findings.push({ ruleId: rule.ruleId, severity: rule.severity, message: rule.message, file, line });
+        }
+    }
+    return findings.sort((a, b) => (a.line ?? 0) - (b.line ?? 0) || a.ruleId.localeCompare(b.ruleId));
+}

package/dist/audit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -13,6 +13,7 @@ import { runLoopCleanup } from './loop/cleanup.js';
 import { runFlowSmoke } from './smoke/command.js';
 import { maybeNotifyUpdate, currentYokeVersion } from './update/check.js';
 import { runUpgrade } from './update/upgrade.js';
+import { printAudit, runAudit } from './audit/command.js';
 export { runRetrofit } from './retrofit/command.js';
 export function runValidate(canonDir) {
     const issues = validateCanon(canonDir);
@@ -90,7 +91,7 @@ function main(argv) {
                 return 0;
             }
             if (sub === 'cleanup')
-                return runLoopCleanup(targetDir);
+                return runLoopCleanup(targetDir, { removeWorktrees: rest.includes('--remove-worktrees') });
             if (sub === 'run') {
                 const maxArg = rest.find(a => a.startsWith('--max='));
                 const rawMax = maxArg ? Number(maxArg.slice('--max='.length)) : 25;
@@ -116,6 +117,14 @@ function main(argv) {
                     reviewer = reviewerArg;
                 }
                 const review = rest.includes('--review');
+                const allowSelfReview = rest.includes('--allow-self-review');
+                const permissions = rest.includes('--unsafe') ? 'unsafe' : undefined;
+                const parallelArg = rest.find(a => a.startsWith('--parallel='));
+                const parallel = parallelArg ? Number(parallelArg.slice('--parallel='.length)) : 1;
+                if (!Number.isInteger(parallel) || parallel < 1) {
+                    console.error(`Invalid --parallel value: ${parallelArg}`);
+                    return 1;
+                }
                 const json = rest.includes('--json');
                 const toArg = rest.find(a => a.startsWith('--timeout='));
                 let timeoutMinutes;
@@ -132,9 +141,9 @@ function main(argv) {
                     console.error(`Invalid --on-ambiguity value: ${oaArg} (expected resolve|abort)`);
                     return 1;
                 }
-                return runLoopCommand(targetDir, { maxIterations: rawMax, agent, isolate, reviewer, review, timeoutMinutes, json, onAmbiguity: oaArg });
+                return runLoopCommand(targetDir, { maxIterations: rawMax, agent, isolate, parallel, reviewer, review, allowSelfReview, timeoutMinutes, json, onAmbiguity: oaArg, permissions });
             }
-            console.log('usage: yoke loop <on|off|status|cleanup|run [--max=N] [--runner=<claude|codex|gemini>] [--reviewer=<claude|codex|gemini>] [--review] [--isolate] [--timeout=<minutes>] [--on-ambiguity=<resolve|abort>] [--json]> [targetDir]');
+            console.log('usage: yoke loop <on|off|status|cleanup [--remove-worktrees]|run [--max=N] [--parallel=N] [--runner=<claude|codex|gemini>] [--reviewer=<claude|codex|gemini>] [--review] [--allow-self-review] [--isolate] [--unsafe] [--timeout=<minutes>] [--on-ambiguity=<resolve|abort>] [--json]> [targetDir]');
             return 1;
         }
         case 'new': {
@@ -213,6 +222,8 @@ function main(argv) {
             }
             const base = rest.find(a => a.startsWith('--base='))?.slice('--base='.length);
             const focus = rest.find(a => a.startsWith('--focus='))?.slice('--focus='.length);
+            const allowSelfReview = rest.includes('--allow-self-review');
+            const json = rest.includes('--json');
             const toArg = rest.find(a => a.startsWith('--timeout='));
             let timeoutMinutes;
             if (toArg) {
@@ -223,7 +234,14 @@ function main(argv) {
                 }
                 timeoutMinutes = v;
             }
-            return runReview(targetDir, { reviewer: reviewerArg, base, focus, timeoutMinutes });
+            return runReview(targetDir, { reviewer: reviewerArg, base, focus, allowSelfReview, json, timeoutMinutes });
+        }
+        case 'audit': {
+            const targetDir = rest.find(a => !a.startsWith('-')) ?? '.';
+            const json = rest.includes('--json');
+            const result = runAudit(targetDir);
+            printAudit(result, json);
+            return result.code;
         }
         case 'flow-smoke': {
             const targetDir = rest.find(a => !a.startsWith('-')) ?? '.';

package/dist/loop/claims.js

@@ -0,0 +1,57 @@
+import { closeSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const pathFor = (dir, id) => join(dir, '.yoke', 'claims', `${id}.json`);
+export function acquireClaim(dir, storyId, owner, opts = {}) {
+    const path = pathFor(dir, storyId);
+    mkdirSync(join(dir, '.yoke', 'claims'), { recursive: true });
+    const now = opts.now ?? new Date();
+    try {
+        const old = JSON.parse(readFileSync(path, 'utf8'));
+        if (now.getTime() - Date.parse(old.claimedAt) <= (opts.staleMs ?? 30 * 60_000))
+            return null;
+        rmSync(path, { force: true });
+    }
+    catch { /* absent or malformed */ }
+    const claim = { storyId, owner, pid: opts.pid ?? process.pid, claimedAt: now.toISOString() };
+    try {
+        const fd = openSync(path, 'wx');
+        writeFileSync(fd, JSON.stringify(claim));
+        closeSync(fd);
+        return claim;
+    }
+    catch {
+        return null;
+    }
+}
+export function releaseClaim(dir, storyId, owner) {
+    const path = pathFor(dir, storyId);
+    try {
+        const claim = JSON.parse(readFileSync(path, 'utf8'));
+        if (claim.owner !== owner)
+            return false;
+        rmSync(path, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function cleanupClaims(dir, owner) {
+    const claimsDir = join(dir, '.yoke', 'claims');
+    let removed = 0;
+    try {
+        for (const file of readdirSync(claimsDir)) {
+            const path = join(claimsDir, file);
+            try {
+                const claim = JSON.parse(readFileSync(path, 'utf8'));
+                if (!owner || claim.owner === owner) {
+                    rmSync(path, { force: true });
+                    removed++;
+                }
+            }
+            catch { /* scoped cleanup never guesses ownership */ }
+        }
+    }
+    catch { /* no claims */ }
+    return removed;
+}

package/dist/loop/cleanup.js

@@ -53,6 +53,10 @@ export function runLoopCleanup(targetDir, opts = {}) {
     if (existsSync(wtDir)) {
         for (const name of readdirSync(wtDir)) {
             const path = join(wtDir, name);
+            if (!opts.removeWorktrees) {
+                console.log(`Yoke worktree retained: ${path} (pass --remove-worktrees to remove it)`);
+                continue;
+            }
             try {
                 git(['worktree', 'remove', '--force', path], targetDir);
                 removed++;
@@ -62,10 +66,12 @@ export function runLoopCleanup(targetDir, opts = {}) {
                 failed++;
             }
         }
-        try {
-            git(['worktree', 'prune'], targetDir);
+        if (opts.removeWorktrees) {
+            try {
+                git(['worktree', 'prune'], targetDir);
+            }
+            catch { /* best-effort */ }
         }
-        catch { /* best-effort */ }
     }
     const lockFile = lockPath(targetDir);
     if (existsSync(lockFile)) {
@@ -78,6 +84,6 @@ export function runLoopCleanup(targetDir, opts = {}) {
             console.log('Removed stale loop lock.');
         }
     }
-    console.log(removed === 0 && failed === 0 ? 'Nothing to clean.' : `Removed ${removed} worktree(s)${failed > 0 ? `, ${failed} failed` : ''}.`);
+    console.log(removed === 0 && failed === 0 ? 'No destructive cleanup performed.' : `Removed ${removed} worktree(s)${failed > 0 ? `, ${failed} failed` : ''}.`);
     return failed === 0 ? 0 : 1;
 }

package/dist/loop/git.js

@@ -1,16 +1,22 @@
 import { execFileSync } from 'node:child_process';
+import { sanitizeCommitMessage } from './identity.js';
 export const realGitOps = {
     isClean(dir) {
         const out = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString();
         return out.trim() === '';
     },
-    commitAll(dir, message) {
+    commitAll(dir, message, identity) {
         execFileSync('git', ['add', '-A'], { cwd: dir, stdio: 'pipe' });
         const status = execFileSync('git', ['status', '--porcelain'], { cwd: dir }).toString().trim();
         if (status === '') {
             throw new Error('nothing to commit after agent run');
         }
-        execFileSync('git', ['-c', 'commit.gpgsign=false', 'commit', '-m', message], { cwd: dir, stdio: 'pipe' });
+        const identityArgs = identity
+            ? ['-c', `user.name=${identity.authorName}`, '-c', `user.email=${identity.authorEmail}`]
+            : [];
+        const authorArgs = identity ? ['--author', `${identity.authorName} <${identity.authorEmail}>`] : [];
+        const cleanMessage = sanitizeCommitMessage(message, identity?.allowCoAuthors ?? false);
+        execFileSync('git', [...identityArgs, '-c', 'commit.gpgsign=false', 'commit', ...authorArgs, '-m', cleanMessage], { cwd: dir, stdio: 'pipe' });
     },
     addWorktree(repoDir, worktreePath) {
         execFileSync('git', ['worktree', 'add', '--detach', worktreePath, 'HEAD'], { cwd: repoDir, stdio: 'pipe' });

package/dist/loop/identity.js

@@ -0,0 +1,27 @@
+import { execFileSync } from 'node:child_process';
+const readGitConfig = (key, targetDir) => {
+    try {
+        return execFileSync('git', ['config', '--get', key], { cwd: targetDir, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    }
+    catch {
+        return '';
+    }
+};
+export function resolveCommitIdentity(targetDir, config, gitConfig = readGitConfig) {
+    const authorName = config?.authorName?.trim() || gitConfig('user.name', targetDir).trim();
+    const authorEmail = config?.authorEmail?.trim() || gitConfig('user.email', targetDir).trim();
+    if (!authorName)
+        throw new Error('Commit author name is missing. Set commit.authorName in .yoke/config.yaml or git config user.name.');
+    if (!authorEmail)
+        throw new Error('Commit author email is missing. Set commit.authorEmail in .yoke/config.yaml or git config user.email.');
+    return { authorName, authorEmail, allowCoAuthors: config?.allowCoAuthors ?? false };
+}
+export function sanitizeCommitMessage(message, allowCoAuthors) {
+    if (allowCoAuthors)
+        return message;
+    return message
+        .split(/\r?\n/)
+        .filter(line => !/^Co-Authored-By:/i.test(line.trim()))
+        .join('\n')
+        .trim();
+}

package/dist/loop/loop.js

@@ -26,6 +26,21 @@ export function pauseFilePath(targetDir) {
 export function ambiguityFilePath(dir) {
     return join(dir, '.yoke', 'ambiguity.md');
 }
+// Run a gate command with the story id exposed via YOKE_STORY (restored after),
+// so cumulative fixtures and story-aware benchmarks know which story is on trial.
+function runGate(gate, dir, storyId) {
+    const prev = process.env.YOKE_STORY;
+    process.env.YOKE_STORY = storyId;
+    try {
+        return gate(dir);
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.YOKE_STORY;
+        else
+            process.env.YOKE_STORY = prev;
+    }
+}
 function consumeAmbiguity(dir) {
     const file = ambiguityFilePath(dir);
     if (!existsSync(file))
@@ -106,18 +121,7 @@ export function runLoop(opts) {
                 // Verify is the source of truth — NOT the runner's exit code. A spurious non-zero
                 // exit (e.g. a Windows .cmd wrapper ghost) must not block a story whose tests are green.
                 reporter.phase('verifying');
-                const prevStory = process.env.YOKE_STORY;
-                process.env.YOKE_STORY = story.id;
-                let verdict;
-                try {
-                    verdict = opts.verify(wt);
-                }
-                finally {
-                    if (prevStory === undefined)
-                        delete process.env.YOKE_STORY;
-                    else
-                        process.env.YOKE_STORY = prevStory;
-                }
+                const verdict = runGate(opts.verify, wt, story.id);
                 if (!verdict.passed) {
                     const base = result.success
                         ? `story ${story.id} did not verify: ${verdict.summary}`
@@ -126,6 +130,24 @@ export function runLoop(opts) {
                     reporter.blocked(reason);
                     return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
                 }
+                if (opts.perf) {
+                    reporter.phase('perf');
+                    const perfVerdict = runGate(opts.perf, wt, story.id);
+                    if (!perfVerdict.passed) {
+                        const reason = blockReason(`story ${story.id} exceeded its performance budget: ${perfVerdict.summary}`, opts.targetDir, opts.git);
+                        reporter.blocked(reason);
+                        return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+                    }
+                }
+                if (opts.audit) {
+                    reporter.phase('audit');
+                    const auditVerdict = runGate(opts.audit, wt, story.id);
+                    if (!auditVerdict.passed) {
+                        const reason = blockReason(`story ${story.id} failed security audit: ${auditVerdict.summary}`, opts.targetDir, opts.git);
+                        reporter.blocked(reason);
+                        return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+                    }
+                }
                 const summary = result.success
                     ? result.summary
                     : `${result.summary} (runner exited non-zero but verify is green)`;
@@ -149,7 +171,7 @@ export function runLoop(opts) {
                 });
                 const updated = stories.map(s => (s.id === story.id ? { ...s, passes: true } : s));
                 savePrd(wtPrd, updated);
-                opts.git.commitAll(wt, `yoke: complete ${story.id} ${story.title}`);
+                opts.git.commitAll(wt, `yoke: complete ${story.id} ${story.title}`, opts.commitIdentity);
                 opts.git.integrate(opts.targetDir, wt);
                 landed = progress(updated);
             }
@@ -181,18 +203,7 @@ export function runLoop(opts) {
         // Verify is the source of truth — NOT the runner's exit code. A spurious non-zero
         // exit (e.g. a Windows .cmd wrapper ghost) must not block a story whose tests are green.
         reporter.phase('verifying');
-        const prevStory = process.env.YOKE_STORY;
-        process.env.YOKE_STORY = story.id;
-        let verdict;
-        try {
-            verdict = opts.verify(opts.targetDir);
-        }
-        finally {
-            if (prevStory === undefined)
-                delete process.env.YOKE_STORY;
-            else
-                process.env.YOKE_STORY = prevStory;
-        }
+        const verdict = runGate(opts.verify, opts.targetDir, story.id);
         if (!verdict.passed) {
             const base = result.success
                 ? `story ${story.id} did not verify: ${verdict.summary}`
@@ -206,6 +217,24 @@ export function runLoop(opts) {
                 finalProgress: progress(stories),
             };
         }
+        if (opts.perf) {
+            reporter.phase('perf');
+            const perfVerdict = runGate(opts.perf, opts.targetDir, story.id);
+            if (!perfVerdict.passed) {
+                const reason = blockReason(`story ${story.id} exceeded its performance budget: ${perfVerdict.summary}`, opts.targetDir, opts.git);
+                reporter.blocked(reason);
+                return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+            }
+        }
+        if (opts.audit) {
+            reporter.phase('audit');
+            const auditVerdict = runGate(opts.audit, opts.targetDir, story.id);
+            if (!auditVerdict.passed) {
+                const reason = blockReason(`story ${story.id} failed security audit: ${auditVerdict.summary}`, opts.targetDir, opts.git);
+                reporter.blocked(reason);
+                return { status: 'blocked', iterations, reason, finalProgress: progress(stories) };
+            }
+        }
         const summary = result.success
             ? result.summary
             : `${result.summary} (runner exited non-zero but verify is green)`;
@@ -236,7 +265,7 @@ export function runLoop(opts) {
         const updated = onDisk.map(s => (s.id === story.id ? { ...s, passes: true } : s));
         savePrd(opts.prdPath, updated);
         try {
-            opts.git.commitAll(opts.targetDir, `yoke: complete ${story.id} ${story.title}`);
+            opts.git.commitAll(opts.targetDir, `yoke: complete ${story.id} ${story.title}`, opts.commitIdentity);
         }
         catch (e) {
             savePrd(opts.prdPath, onDisk); // revert — never persist passes:true without a commit