@hecer/yoke 0.9.0 → 1.0.0

package/docs/superpowers/plans/2026-07-27-yoke-1.0-release.md

@@ -0,0 +1,205 @@
+# Yoke 1.0 Release Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Ship Yoke 1.0 with native Codex parity, safe and observable runners, mechanical reviews, human-owned commits, a security gate, dependency-aware parallel execution, and reproducible release claims.
+
+**Architecture:** Keep the existing canon → retrofit → loop layers, but split provider-specific execution from loop policy. Add small schema-validated modules for review verdicts, commit identity, audits, PRD dependencies, and parallel scheduling; the CLI composes them without duplicating policy.
+
+**Tech Stack:** TypeScript ESM, Node.js 20+, Zod, YAML, Vitest, Git worktrees, npm packaging, provider CLIs.
+
+---
+
+### Task 1: Release truth and dependency baseline
+
+**Files:**
+- Modify: `package.json`
+- Modify: `package-lock.json`
+- Modify: `canon/manifest.yaml`
+- Create: `scripts/release-metadata.mjs`
+- Create: `tests/release/metadata.test.ts`
+- Modify: `.github/workflows/ci.yml`
+
+- [ ] **Step 1: Write a failing metadata test** proving the script reads package version, manifest skill/agent counts, and a Vitest summary string and produces stable README replacements.
+- [ ] **Step 2: Run `npm test -- tests/release/metadata.test.ts`** and confirm failure because `scripts/release-metadata.mjs` does not exist.
+- [ ] **Step 3: Implement exported `collectMetadata(root, testSummary)` and `updateReadme(readme, metadata)` functions** plus `--check` and `--write` CLI modes. The updater owns markers for version, test count, skill count, and agents.
+- [ ] **Step 4: Upgrade Vitest to the newest compatible stable release, regenerate the lockfile, and set package/canon/plugin/extension versions to `1.0.0`.**
+- [ ] **Step 5: Add `lint`, `docs:check`, `docs:update`, `audit:ci`, and `package:check` scripts and exercise them in CI on Windows and Linux.**
+- [ ] **Step 6: Run the focused test, `npm audit`, `npm run build`, and `npm test`; commit as `chore(release): establish 1.0 release truth`.**
+
+### Task 2: Native Codex skills, hooks, agents, and plugin
+
+**Files:**
+- Modify: `src/retrofit/planners/codex.ts`
+- Modify: `src/retrofit/merge-json.ts`
+- Modify: `canon/AGENTS.md`
+- Create: `codex-plugin/plugin.json`
+- Create: `codex-plugin/hooks/hooks.json`
+- Create: `codex-plugin/agents/implementer.toml`
+- Create: `codex-plugin/agents/reviewer.toml`
+- Create: `codex-plugin/agents/security.toml`
+- Create: `codex-plugin/agents/docs.toml`
+- Modify: `tests/retrofit/planners-codex.test.ts`
+- Modify: `tests/retrofit/retrofit.integration.test.ts`
+
+- [ ] **Step 1: Extend the Codex planner tests** to require every manifest skill under `.agents/skills`, a merged `.codex/config.toml`, `.codex/hooks.json`, four `.codex/agents/*.toml` files, `RTK.md`, and `@RTK.md` in generated `AGENTS.md`.
+- [ ] **Step 2: Run `npm test -- tests/retrofit/planners-codex.test.ts tests/retrofit/retrofit.integration.test.ts`** and confirm missing-artifact failures.
+- [ ] **Step 3: Implement skill copying and generated Codex artifacts.** Config uses project-local `[mcp_servers.*]`; the hook uses `PreToolUse` with command `rtk hook codex`; each agent file defines `name`, `description`, `sandbox_mode`, and narrow `developer_instructions`.
+- [ ] **Step 4: Add the distributable Codex plugin manifest** referencing `../canon/skills`, bundled hooks, MCP configuration, and agents without duplicating skill bodies.
+- [ ] **Step 5: Re-run focused tests and canon validation; commit as `feat(codex): add native skills hooks agents and plugin`.**
+
+### Task 3: Provider adapters and permission profiles
+
+**Files:**
+- Create: `src/agents/types.ts`
+- Create: `src/agents/providers.ts`
+- Create: `src/agents/telemetry.ts`
+- Modify: `src/loop/runner.ts`
+- Modify: `src/retrofit/config.ts`
+- Modify: `src/cli.ts`
+- Create: `tests/agents/providers.test.ts`
+- Create: `tests/agents/telemetry.test.ts`
+- Modify: `tests/loop/runner.test.ts`
+
+- [ ] **Step 1: Write failing tests** for `safe`, `unsafe`, and `read-only` invocations for Claude, Codex, and Gemini, plus structured usage/model parsing with an explicit unavailable state.
+- [ ] **Step 2: Run the three focused test files** and confirm the provider module is missing.
+- [ ] **Step 3: Implement `AgentProvider` and `PermissionProfile`** with provider-owned invocation and telemetry parsing. `unsafe` contains the previous bypass flags; safe/read-only never contain them.
+- [ ] **Step 4: Add optional `runner.permissions` and CLI `--unsafe`; default to `safe`.** Reject unsupported provider/profile pairs with exit code 2 and print the effective profile at startup.
+- [ ] **Step 5: Refactor runner construction through the provider registry while preserving watchdog and Claude usage behavior.**
+- [ ] **Step 6: Run focused and full tests; commit as `feat(runner): add safe provider profiles and telemetry`.**
+
+### Task 4: Schema-validated independent review
+
+**Files:**
+- Create: `src/review/verdict.ts`
+- Modify: `src/review/command.ts`
+- Modify: `src/loop/runner.ts`
+- Modify: `src/loop/run-command.ts`
+- Modify: `src/cli.ts`
+- Create: `tests/review/verdict.test.ts`
+- Modify: `tests/review/command.test.ts`
+- Modify: `tests/loop/standalone-review.test.ts`
+- Modify: `tests/loop/loop-cli.integration.test.ts`
+
+- [ ] **Step 1: Write failing verdict tests** for approve, reject, malformed JSON, missing file, findings, and cleanup.
+- [ ] **Step 2: Write failing resolution tests** proving reviewer differs from implementer and self-review requires `--allow-self-review`.
+- [ ] **Step 3: Run focused tests** and confirm failures against the exit-code implementation.
+- [ ] **Step 4: Implement `ReviewVerdictSchema`, `readReviewVerdict`, and `reviewVerdictPath`.** Prompts receive the absolute path and exact JSON contract; process failure and verdict are reported separately.
+- [ ] **Step 5: Make standalone and loop reviews parse the verdict, reject missing/malformed output, and expose `--json` plus `--allow-self-review`.**
+- [ ] **Step 6: Run focused and full tests; commit as `feat(review): enforce independent structured verdicts`.**
+
+### Task 5: Explicit commit identity
+
+**Files:**
+- Create: `src/loop/identity.ts`
+- Modify: `src/loop/git.ts`
+- Modify: `src/loop/gates.ts`
+- Modify: `src/loop/run-command.ts`
+- Modify: `src/retrofit/config.ts`
+- Modify: `canon/skills/ship/SKILL.md`
+- Modify: `tests/loop/git.test.ts`
+- Create: `tests/loop/identity.test.ts`
+
+- [ ] **Step 1: Write failing tests** for config precedence, Git fallback, missing identity, exact commit author/committer, and absence of AI trailers.
+- [ ] **Step 2: Run focused tests** and confirm the current ambient-only behavior fails.
+- [ ] **Step 3: Add optional `commit.authorName`, `commit.authorEmail`, and `commit.allowCoAuthors` defaulting false.** Implement `resolveCommitIdentity` and pass identity via `git -c user.name=... -c user.email=... commit`.
+- [ ] **Step 4: Resolve identity before acquiring the loop lock and print it once; fail before implementation when incomplete.** Remove the Claude co-author recipe from `ship` and state that project commit policy wins.
+- [ ] **Step 5: Run focused/full tests; commit as `feat(git): enforce human-owned commit identity`.**
+
+### Task 6: First-class security audit gate
+
+**Files:**
+- Create: `src/audit/types.ts`
+- Create: `src/audit/dependencies.ts`
+- Create: `src/audit/secrets.ts`
+- Create: `src/audit/changes.ts`
+- Create: `src/audit/command.ts`
+- Modify: `src/retrofit/config.ts`
+- Modify: `src/loop/loop.ts`
+- Modify: `src/loop/reporter.ts`
+- Modify: `src/cli.ts`
+- Create: `tests/audit/command.test.ts`
+- Create: `tests/audit/secrets.test.ts`
+- Modify: `tests/loop/loop.test.ts`
+
+- [ ] **Step 1: Write failing tests** for stable finding schema, high-confidence secret patterns, dependency command resolution, sensitive changed paths, suppression reasons, human/JSON output, and loop blocking.
+- [ ] **Step 2: Run audit tests** and confirm module-not-found failures.
+- [ ] **Step 3: Implement `runAudit` with deterministic injected command/Git seams.** Findings contain `ruleId`, `severity`, `message`, `file`, and optional `line`; exit 0 means no unsuppressed blocking findings, 1 means findings, 2 means not runnable.
+- [ ] **Step 4: Add `yoke audit`, `--json`, `audit.enabled`, `audit.command`, and versioned suppressions.** Run it after verify/perf and before review.
+- [ ] **Step 5: Run focused/full tests and `npm audit`; commit as `feat(audit): add dependency secret and diff security gate`.**
+
+### Task 7: PRD dependency graph and scheduler
+
+**Files:**
+- Modify: `src/loop/prd.ts`
+- Modify: `src/prd/command.ts`
+- Modify: `canon/loop/prd.schema.md`
+- Modify: `canon/skills/authoring-prd/SKILL.md`
+- Modify: `tests/loop/prd.test.ts`
+- Modify: `tests/prd/command.test.ts`
+- Create: `tests/loop/scheduler.test.ts`
+- Create: `src/loop/scheduler.ts`
+
+- [ ] **Step 1: Write failing schema tests** for optional `needs`, `area`, and `agent`, plus unknown dependency, self-dependency, duplicate ID, and cycle diagnostics.
+- [ ] **Step 2: Write failing scheduler tests** for ready-set priority, dependency blocking, area exclusion, and affinity.
+- [ ] **Step 3: Run focused tests** and confirm new fields/validation are absent.
+- [ ] **Step 4: Extend `StorySchema`, implement `validateDependencies` and `readyStories`, and update PRD drafting guidance.** Missing optional fields normalize to dependency-free serial behavior.
+- [ ] **Step 5: Run focused/full tests; commit as `feat(prd): add dependency graph and ready scheduler`.**
+
+### Task 8: Claims, merge queue, and bounded parallel execution
+
+**Files:**
+- Create: `src/loop/claims.ts`
+- Create: `src/loop/merge-queue.ts`
+- Create: `src/loop/parallel.ts`
+- Modify: `src/loop/git.ts`
+- Modify: `src/loop/gates.ts`
+- Modify: `src/loop/run-command.ts`
+- Modify: `src/loop/cleanup.ts`
+- Modify: `src/loop/reporter.ts`
+- Modify: `src/cli.ts`
+- Create: `tests/loop/claims.test.ts`
+- Create: `tests/loop/merge-queue.test.ts`
+- Create: `tests/loop/parallel.test.ts`
+- Modify: `tests/loop/git.test.ts`
+- Modify: `tests/loop/cleanup.test.ts`
+
+- [ ] **Step 1: Write failing claim tests** for atomic acquisition, stale takeover, dispatcher ownership, and scoped cleanup.
+- [ ] **Step 2: Write failing merge-queue tests** for FIFO order, rebase, integrated-tree re-verification, conflict retry, identity-preserving commit, and never persisting `passes: true` on failure.
+- [ ] **Step 3: Write failing dispatcher tests** for max concurrency, dependencies, areas, affinity, pause, iteration cap, and `--parallel=1` equivalence.
+- [ ] **Step 4: Implement claim and merge-queue modules with injectable clocks, workers, Git, and gates.** Add Git rebase/base SHA operations without weakening existing fast-forward integrity.
+- [ ] **Step 5: Implement `runParallelLoop` and CLI `--parallel=N`; force worktree isolation for `N > 1`.** Emit worker/queue NDJSON events and retain the dispatcher lock.
+- [ ] **Step 6: Extend cleanup with explicit provider-worktree reporting/removal flag.** Default cleanup remains project-scoped and non-destructive.
+- [ ] **Step 7: Run focused/full tests; commit as `feat(loop): add dependency-aware parallel merge queue`.**
+
+### Task 9: Cross-runner benchmark evidence
+
+**Files:**
+- Modify: `bench/run.mjs`
+- Create: `bench/run-matrix.mjs`
+- Modify: `bench/README.md`
+- Modify: `bench/RESULTS.md`
+- Create: `tests/bench/result-schema.test.ts`
+
+- [ ] **Step 1: Write a failing schema test** requiring fixture version, permission profile, model/usage availability, verdict, conflicts, wall time, iterations, final tests, and sample label.
+- [ ] **Step 2: Run the focused test** and confirm existing result objects are incomplete.
+- [ ] **Step 3: Extend the harness and add a sequential matrix launcher** that records unavailable/auth failures as honest result rows without treating them as quality measurements.
+- [ ] **Step 4: Build Yoke and run available authenticated provider benchmarks.** Never invent Codex/Gemini results; record the exact blocker where credentials or CLI support are absent.
+- [ ] **Step 5: Run benchmark schema/full tests; commit as `bench: add cross-runner telemetry matrix`.**
+
+### Task 10: Documentation, migration, package, and publication
+
+**Files:**
+- Modify: `README.md`
+- Modify: `CHANGELOG.md`
+- Create: `docs/MIGRATING-TO-1.0.md`
+- Create: `TODOS.md`
+- Modify: `CONTRIBUTING.md`
+- Modify: `.github/workflows/ci.yml`
+
+- [ ] **Step 1: Update README commands, architecture, agent artifact table, safety model, review contract, parallel loop, audit gate, benchmark caveats, and generated metadata markers.** Remove completed roadmap items and link remaining work to `TODOS.md`.
+- [ ] **Step 2: Add migration and changelog entries** covering safe permissions, independent verdicts, commit identity, PRD fields, and new CLI flags.
+- [ ] **Step 3: Run `npm run docs:update` followed by `npm run docs:check`; commit as `docs: prepare Yoke 1.0 release`.**
+- [ ] **Step 4: Run fresh full verification:** `npm ci`, `npm run lint`, `npm run build`, `npm test`, `npm run yoke -- validate canon`, `npm audit`, `npm run package:check`, `npm pack`, and tarball install smoke test.
+- [ ] **Step 5: Inspect `git diff`, `git log`, package contents, version, and author/committer identity; ensure the tree is clean and every commit is authored by `HECer <hec_er@web.de>`.**
+- [ ] **Step 6: Push `main` to `origin`, publish `@hecer/yoke@1.0.0`, verify the registry version, and push the `v1.0.0` tag.** If npm requires interactive 2FA, report the exact OTP command boundary without changing package state further.

package/docs/superpowers/specs/2026-07-27-yoke-1.0-hardening-and-codex-parity-design.md

@@ -0,0 +1,164 @@
+# Yoke 1.0 — hardening, Codex parity, and parallel delivery
+
+**Status:** Approved design, ready for implementation planning  
+**Release target:** `@hecer/yoke@1.0.0`
+
+## Goal
+
+Make Yoke's cross-agent promise true at the integration, execution, and evidence layers:
+Codex receives the same reusable methodology as Claude; reviews produce a mechanical verdict;
+autonomous execution is safe by default; commits have an explicit human identity; parallel work
+lands through a verified merge queue; and published claims are generated from reproducible data.
+
+## Compatibility contract
+
+- Existing `.yoke/config.yaml` files remain valid. New fields are optional and receive safe defaults.
+- The CLI keeps all existing commands and exit codes. New commands and flags are additive.
+- `--unsafe` is an explicit per-run escalation. Existing configurations do not silently gain broader permissions.
+- Existing PRDs without `needs`, `area`, or `agent` behave as serial, dependency-free backlogs.
+- Serial execution remains the default. Parallel execution requires `--parallel=N`, where `N > 1`.
+- A 1.0 migration note documents every behavior whose default becomes safer.
+
+## Native Codex integration
+
+The Codex retrofit planner copies every canon skill to `.agents/skills/<id>/SKILL.md`, the native
+repository skill location. It generates a directly usable, trusted-project `.codex/config.toml`
+instead of describing it as a global snippet. Codex receives an RTK `PreToolUse` hook through
+`.codex/hooks.json`; `RTK.md` remains as readable fallback guidance and `AGENTS.md` imports it.
+
+Yoke also ships a Codex-compatible plugin bundle containing the canon skills, hook definition, and
+MCP declarations. Repository-local custom agents provide narrow implementer, reviewer, security,
+and documentation roles. These are conveniences over the same canon, not a second source of truth.
+
+Generated artifacts remain non-destructive: Yoke backs up overwritten files, merges supported
+configuration, and preserves project-owned instruction blocks.
+
+## Mechanical review verdicts
+
+`--review` resolves the first available agent that differs from the implementer. If no independent
+agent is available, the command fails before implementation unless the caller explicitly requests
+`--allow-self-review`.
+
+Reviewers write a versioned JSON verdict to a Yoke-owned temporary path:
+
+```json
+{
+  "schemaVersion": 1,
+  "verdict": "approve",
+  "summary": "All acceptance criteria are covered.",
+  "findings": []
+}
+```
+
+Yoke validates the file, rejects missing or malformed verdicts, and blocks on any `reject` verdict.
+The process exit code remains execution telemetry only. Standalone `yoke review` uses the same
+protocol and prints findings in human or JSON form.
+
+## Safe runner profiles
+
+- `safe` is the default and uses each CLI's non-interactive workspace-write mode without granting
+  arbitrary host access where the provider supports it.
+- `unsafe` uses full-bypass flags and requires `--unsafe` or `runner.permissions: unsafe`.
+- `read-only` is available for reviewer and audit roles.
+
+The effective runner, model when reported, permission profile, working directory, and network mode
+are emitted at run start. Yoke refuses incompatible combinations instead of silently escalating.
+Worktree isolation is automatic for parallel runs and recommended for serial unsafe runs.
+
+## Human-owned commits
+
+Configuration accepts:
+
+```yaml
+commit:
+  authorName: HECer
+  authorEmail: hec_er@web.de
+  allowCoAuthors: false
+```
+
+When absent, Yoke resolves the repository's Git identity and fails clearly if no name or email is
+available. Each commit passes the identity directly to Git. Yoke never adds AI co-author trailers;
+canon skills respect `allowCoAuthors: false`, which is the default.
+
+## Dependency-aware parallel loop
+
+PRD stories gain optional `needs: string[]`, `area: string`, and
+`agent: claude | codex | gemini`. `yoke prd check` rejects missing dependencies,
+self-dependencies, and cycles. The scheduler runs only ready stories and never runs two stories
+from the same area concurrently.
+
+Workers claim stories through project-scoped claim files containing dispatcher ID, PID, base commit,
+and timestamp. Each worker runs implement, verify, performance, and independent review gates in its
+own worktree. Successful workers enter a FIFO merge queue. The integrator rebases onto current HEAD,
+re-runs verification when HEAD moved, fast-forward integrates, updates context and PRD state, and
+commits with the configured human identity. Conflicts or post-rebase failures return the story to the
+open set; they never mark it passed.
+
+The dispatcher owns the existing loop lock. Cleanup removes only project-owned claims and processes.
+`--parallel=1` is behaviorally equivalent to the serial isolated loop.
+
+## Security gate
+
+`yoke audit [dir]` provides exit-code and JSON contracts for dependency auditing, conservative
+tracked-secret detection, sensitive changed-file checks, and an optional project security command.
+Findings have stable rule IDs and severities. Suppressions require a versioned reason and exact rule
+ID. The loop can run audit after verify and before review.
+
+## Cross-runner telemetry and benchmarks
+
+Provider adapters own invocation, structured event parsing, usage/model extraction, permissions, and
+review transport. Claude keeps stream-json; Codex and Gemini use supported JSON modes where available
+and explicitly report unavailable usage otherwise.
+
+Benchmarks record fixture version, runner/model, permission profile, outcome, wall time, token usage,
+iterations, review verdict, conflicts, and final tests. Authenticated live runs stay opt-in and public
+CI uses deterministic fake CLIs. Committed results state sample size and missing credentials honestly.
+
+## CI, dependencies, and release truth
+
+Vitest and its Vite/PostCSS chain are upgraded until development and production audits are clean. CI
+adds deterministic source checks, build/tests, canon validation, audit policy, documentation drift
+checks, `npm pack --dry-run`, and a tarball install smoke test.
+
+A metadata script derives package version, skill count, test count, and supported agents for README
+badges and prose. The canon version follows the package version and the `0.0.0` fallback is removed.
+CHANGELOG and migration documentation explain 1.0 behavior.
+
+## Repository hygiene
+
+Cleanup detects stale Yoke and provider worktrees but does not remove provider-owned worktrees without
+an explicit flag. Open roadmap work is mirrored into a versioned backlog or GitHub issues so it is
+executable rather than living only in README prose.
+
+## Error handling and observability
+
+All machine interfaces are schema-versioned. Missing or malformed verdicts, unavailable CLIs,
+unsupported safe modes, stale claims, conflicts, and audit findings preserve evidence and produce
+distinct reasons. NDJSON includes worker, queue, review, security, cost, and commit-identity events.
+No failure path marks a story passed before integrated-tree gates and the commit succeed.
+
+## Testing strategy
+
+Implementation follows red-green-refactor. Tests cover schema compatibility, generated artifacts,
+review parsing and selection, safe invocations, Git identity, DAG validation, scheduling, claims,
+merge retries, audit rules, telemetry, metadata generation, and CLI exit codes. Temporary Git repos
+exercise commits, worktrees, conflicts, and authorship. Optional authenticated smoke scripts cover
+real CLIs without blocking public CI.
+
+Final verification runs the complete test matrix, build, canon validation, audit, documentation check,
+package dry-run, and fresh install smoke test from the generated tarball.
+
+## Delivery sequence
+
+1. Release truth and dependency baseline.
+2. Codex native artifacts and plugin.
+3. Provider adapters, safe permissions, and telemetry.
+4. Mechanical review verdict and independent reviewer resolution.
+5. Commit identity enforcement.
+6. Security gate.
+7. PRD dependency schema and scheduler.
+8. Claims, workers, and merge queue.
+9. Cross-runner benchmarks and authenticated smoke scripts.
+10. README, migration guide, changelog, version 1.0.0, verification, Git push, npm publish.
+
+Each item lands as a focused commit authored only by `HECer <hec_er@web.de>`.

package/hooks/hooks.json

@@ -0,0 +1,19 @@
+{
+  "description": "Yoke command compression for Codex",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "^Bash$",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$PLUGIN_ROOT/canon/tools/codex-rtk-hook.mjs\"",
+            "commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -Command \"node (Join-Path $env:PLUGIN_ROOT 'canon/tools/codex-rtk-hook.mjs')\"",
+            "timeout": 5,
+            "statusMessage": "Compressing command output with RTK"
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -1,67 +1,82 @@
-{
-  "name": "@hecer/yoke",
-  "version": "0.9.0",
-  "description": "One harness, three agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, and Gemini CLI: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
-  "type": "module",
-  "bin": {
-    "yoke": "./dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "canon",
-    "bench",
-    "docs",
-    "CHANGELOG.md",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/HECer/yoke.git"
-  },
-  "homepage": "https://github.com/HECer/yoke#readme",
-  "bugs": {
-    "url": "https://github.com/HECer/yoke/issues"
-  },
-  "keywords": [
-    "claude-code",
-    "codex",
-    "gemini-cli",
-    "agents",
-    "agentic-coding",
-    "harness",
-    "autonomous",
-    "ralph-loop",
-    "code-review",
-    "skills",
-    "agents-md",
-    "tdd",
-    "claude-plugin",
-    "claude-code-plugin",
-    "gemini-cli-extension"
-  ],
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "yoke": "tsx src/cli.ts",
-    "prepublishOnly": "npm run build && vitest run"
-  },
-  "dependencies": {
-    "yaml": "^2.5.0",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/node": "^22.7.0",
-    "smol-toml": "^1.7.0",
-    "tsx": "^4.19.1",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.1"
-  }
-}
+{
+  "name": "@hecer/yoke",
+  "version": "1.0.0",
+  "description": "One harness, three agents, zero trust in \"done\" — cross-agent coding harness for Claude Code, Codex CLI, and Gemini CLI: one skill canon, mechanical safety gates, an autonomous loop with screenshot/video proofs.",
+  "type": "module",
+  "bin": {
+    "yoke": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "canon",
+    ".codex-plugin",
+    "agents",
+    "hooks",
+    "bench/README.md",
+    "bench/RESULTS.md",
+    "bench/result-schema.mjs",
+    "bench/run.mjs",
+    "bench/run-matrix.mjs",
+    "bench/fixtures",
+    "bench/results",
+    "docs",
+    "CHANGELOG.md",
+    "TODOS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HECer/yoke.git"
+  },
+  "homepage": "https://github.com/HECer/yoke#readme",
+  "bugs": {
+    "url": "https://github.com/HECer/yoke/issues"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "agents",
+    "agentic-coding",
+    "harness",
+    "autonomous",
+    "ralph-loop",
+    "code-review",
+    "skills",
+    "agents-md",
+    "tdd",
+    "claude-plugin",
+    "claude-code-plugin",
+    "gemini-cli-extension"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "docs:check": "node scripts/release-metadata.mjs --check",
+    "docs:update": "node scripts/release-metadata.mjs --write",
+    "audit:ci": "npm audit --audit-level=high",
+    "package:check": "npm pack --dry-run",
+    "yoke": "tsx src/cli.ts",
+    "prepublishOnly": "npm run lint && npm run build && vitest run && npm run docs:check && npm run package:check"
+  },
+  "dependencies": {
+    "yaml": "^2.5.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "smol-toml": "^1.7.0",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2",
+    "vitest": "^4.1.10"
+  }
+}

package/bench/.runs/claude-2026-07-09T22-34-01/.yoke/config.yaml

@@ -1,6 +0,0 @@
-canonVersion: 0.1.0
-agents: []
-loop:
-  enabled: true
-verify:
-  command: node bench-verify.mjs

package/bench/.runs/claude-2026-07-09T22-34-01/.yoke/context/DECISIONS.md

@@ -1,9 +0,0 @@
-
-## 2026-07-09 — STORY-1: slugify(text): URL-safe slugs
-claude implemented STORY-1
-
-## 2026-07-09 — STORY-2: truncate(text, max): word-boundary truncation with ellipsis
-claude implemented STORY-2
-
-## 2026-07-09 — STORY-3: titleCase(text): English title casing
-claude implemented STORY-3

package/bench/.runs/claude-2026-07-09T22-34-01/.yoke/prd.yaml

@@ -1,38 +0,0 @@
-- id: STORY-1
-  title: "slugify(text): URL-safe slugs"
-  priority: 1
-  acceptance:
-    - Export `slugify(text)` from src/index.mjs
-    - Lowercases input and joins words with single dashes
-    - "Strips characters that are not alphanumeric, dash, or space (apostrophes
-      vanish: \"What's Up, Doc?\" -> \"whats-up-doc\")"
-    - Collapses runs of spaces/dashes into one dash; trims leading/trailing
-      dashes
-    - Input with no usable characters returns the empty string
-    - node bench-verify.mjs exits 0
-  passes: true
-- id: STORY-2
-  title: "truncate(text, max): word-boundary truncation with ellipsis"
-  priority: 2
-  acceptance:
-    - Export `truncate(text, max)` from src/index.mjs
-    - Strings with length <= max are returned unchanged
-    - Longer strings are cut at a word boundary and end with the single
-      character … (U+2026); result length never exceeds max
-    - If even the first word does not fit, hard-cut mid-word so the result
-      (incl. …) has exactly max characters
-    - max < 1 throws RangeError
-    - node bench-verify.mjs exits 0
-  passes: true
-- id: STORY-3
-  title: "titleCase(text): English title casing"
-  priority: 3
-  acceptance:
-    - Export `titleCase(text)` from src/index.mjs
-    - Capitalizes the first letter of each significant word; rest of each word
-      lowercased (handles ALL-CAPS input)
-    - Small words (a, an, the, and, but, or, for, nor, of, on, in, to, at, by,
-      up) stay lowercase mid-title
-    - The first and the last word are always capitalized, even if small
-    - node bench-verify.mjs exits 0
-  passes: true

package/bench/.runs/claude-2026-07-09T22-34-01/bench-verify.mjs

@@ -1,15 +0,0 @@
-// Cumulative verify: the loop sets YOKE_STORY (e.g. STORY-2); we run the test
-// files for that story AND all earlier ones, so later stories can't break
-// earlier work. Without YOKE_STORY (final quality check), all tests run.
-import { spawnSync } from 'node:child_process'
-
-const TOTAL = 3
-const story = process.env.YOKE_STORY
-const n = story ? Number(story.split('-')[1]) : TOTAL
-const upTo = Number.isFinite(n) && n >= 1 && n <= TOTAL ? n : TOTAL
-
-const files = []
-for (let i = 1; i <= upTo; i++) files.push(`tests/STORY-${i}.test.mjs`)
-
-const r = spawnSync(process.execPath, ['--test', ...files], { stdio: 'inherit' })
-process.exit(r.status ?? 1)

package/bench/.runs/claude-2026-07-09T22-34-01/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "bench-string-kit",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "test": "node bench-verify.mjs"
-  }
-}