{"id":50062530,"url":"https://github.com/agent-pattern-labs/iso","last_synced_at":"2026-05-21T20:01:51.849Z","repository":{"id":352235173,"uuid":"1214388218","full_name":"Agent-Pattern-Labs/iso","owner":"Agent-Pattern-Labs","description":"Isomorphic agent tooling: author once, run anywhere. Build, lint, route, fan out, eval, trace, guard, contract, and ledger AI-agent workflows across Cursor, Claude Code, Codex, and OpenCode.","archived":false,"fork":false,"pushed_at":"2026-05-15T00:14:36.000Z","size":1010,"stargazers_count":5,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-05-16T10:49:38.243Z","etag":null,"topics":["agent-evals","agent-harness","agent-orchestration","agents","ai-agents","claude-code","codex","cursor","evals","iso-contract","iso-guard","iso-ledger","llm","monorepo","observability","opencode","prompt-engineering","runtime-control","typescript","workflow-automation"],"latest_commit_sha":null,"homepage":null,"language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Agent-Pattern-Labs.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-04-18T14:05:07.000Z","updated_at":"2026-05-16T01:52:40.000Z","dependencies_parsed_at":null,"dependency_job_id":"536ab08f-530d-4495-876c-b945db31a965","html_url":"https://github.com/Agent-Pattern-Labs/iso","commit_stats":null,"previous_names":["razroo/iso","agent-pattern-labs/iso"],"tags_count":61,"template":false,"template_full_name":null,"purl":"pkg:github/Agent-Pattern-Labs/iso","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Agent-Pattern-Labs%2Fiso","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Agent-Pattern-Labs%2Fiso/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Agent-Pattern-Labs%2Fiso/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Agent-Pattern-Labs%2Fiso/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Agent-Pattern-Labs","download_url":"https://codeload.github.com/Agent-Pattern-Labs/iso/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Agent-Pattern-Labs%2Fiso/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33313325,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-21T12:23:38.849Z","status":"ssl_error","status_checked_at":"2026-05-21T12:22:11.673Z","response_time":62,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agent-evals","agent-harness","agent-orchestration","agents","ai-agents","claude-code","codex","cursor","evals","iso-contract","iso-guard","iso-ledger","llm","monorepo","observability","opencode","prompt-engineering","runtime-control","typescript","workflow-automation"],"created_at":"2026-05-21T20:01:15.986Z","updated_at":"2026-05-21T20:01:51.835Z","avatar_url":"https://github.com/Agent-Pattern-Labs.png","language":"TypeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\"\u003e\n  \u003cimg src=\"./assets/logo.svg\" alt=\"iso\" width=\"320\"\u003e\n\u003c/p\u003e\n\n# iso\n\n**Write your AI agent instructions once. Run them anywhere, on any model.**\n\n`iso` is Razroo's toolchain for making agent harnesses *isomorphic* — one\nauthored source fans out to every coding harness (Cursor, Claude Code,\nCodex, OpenCode, Pi) and stays legible across model tiers (frontier models down\nto 7B local models). The repo now covers the full loop: build portable\nharness files, route models, replay evals, parse production traces, scope\nrole capabilities, select deterministic context bundles, audit runtime policy,\ncache reusable artifacts, canonicalize identity keys, score deterministic\nrubrics, rank work queues, track artifact lineage, plan dispatches, settle dispatch results, redact sensitive output,\nmaterialize source-backed facts, migrate consumer projects, validate artifact contracts, and persist local\nworkflow truth. The only narrower surface is `iso-trace model-score`, which still\ndepends on transcripts exposing stable model metadata.\n\nToday, agent workflow reliability is fragmented on three axes:\n\n1. **Harness fragmentation.** Each coding agent reads a different file\n   layout — `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/*.mdc`,\n   `.opencode/agents/*.md`, `.pi/prompts/*.md`, `.mcp.json` vs\n   `opencode.json` vs `.codex/config.toml` vs `.pi/settings.json`.\n   Keeping them in sync is copy-paste drift.\n2. **Model fragmentation.** A prompt written with a frontier model in mind\n   quietly breaks on smaller models: soft imperatives (`should`,\n   `when relevant`), taste words, ambiguous cross-references, and\n   unstructured rationale all drop silently at 7B. You don't find out\n   until the agent misbehaves in production.\n3. **Runtime fragmentation.** Workflows rely on fragile prompt prose for\n  fan-out limits, context loading, artifact reuse, fact extraction, identity keys, rubric scoring, time-based next actions, priority queues, artifact staleness, project upgrades, role permissions, output shape, duplicate checks, post-dispatch settlement, redaction, and\n  \"what already happened.\" Those invariants belong in deterministic local packages,\n  not in repeatedly re-tokenized instructions.\n\nTwenty-five packages solve that in one pipeline with runtime control and a\nfeedback loop:\n\n- **Four build-time tools** turn your authored source into every harness's file layout:\n  [`@agent-pattern-labs/agentmd`](./packages/agentmd) validates *structure*,\n  [`@agent-pattern-labs/isolint`](./packages/isolint) rewrites *prose* for small-model safety,\n  [`@agent-pattern-labs/iso-harness`](./packages/iso-harness) *fans out* to every harness, and\n  [`@agent-pattern-labs/iso-route`](./packages/iso-route) compiles *one model policy* into each harness's config.\n- **One wrapper** runs the whole build chain:\n  [`@agent-pattern-labs/iso`](./packages/iso) chains the above into a single `iso build`.\n- **Seventeen runtime-control libraries** handle durable execution, context selection, artifact caching, artifact lookup, fact materialization, identity canonicalization, deterministic scoring, time-based next-action planning, priority queue selection, artifact lineage, preflight dispatch planning, postflight settlement, redaction, project migration, role capabilities, artifact shape, and operational truth:\n  [`@agent-pattern-labs/iso-orchestrator`](./packages/iso-orchestrator) provides resumable\n  steps, keyed mutexes, and bounded fan-out for side-effectful agent workflows,\n  [`@agent-pattern-labs/iso-context`](./packages/iso-context) resolves context bundles,\n  estimates tokens, checks budgets, and renders deterministic context packs,\n  [`@agent-pattern-labs/iso-cache`](./packages/iso-cache) stores and verifies\n  content-addressed local artifacts with TTL-aware reads and pruning,\n  [`@agent-pattern-labs/iso-index`](./packages/iso-index) builds and queries compact\n  local indexes that point to authoritative facts across artifacts,\n  [`@agent-pattern-labs/iso-facts`](./packages/iso-facts) extracts, queries, verifies,\n  and checks provenance-rich local facts,\n  [`@agent-pattern-labs/iso-canon`](./packages/iso-canon) produces stable URL,\n  company, role, and company-role keys for duplicate checks,\n  [`@agent-pattern-labs/iso-score`](./packages/iso-score) computes weighted rubric\n  scores, bands, comparisons, and gate decisions from structured evidence,\n  [`@agent-pattern-labs/iso-timeline`](./packages/iso-timeline) computes due,\n  overdue, suppressed, and blocked next actions from dated events and\n  cadence policy,\n  [`@agent-pattern-labs/iso-prioritize`](./packages/iso-prioritize) ranks, gates,\n  quotas, and selects local queue items with deterministic policy,\n  [`@agent-pattern-labs/iso-lineage`](./packages/iso-lineage) records artifact\n  dependencies and detects stale derived outputs,\n  [`@agent-pattern-labs/iso-preflight`](./packages/iso-preflight) validates\n  source-backed candidate facts, applies gates, and produces bounded\n  dispatch rounds before tool-heavy work starts,\n  [`@agent-pattern-labs/iso-postflight`](./packages/iso-postflight) reconciles\n  dispatch plans with observed outcomes, required artifacts, and post-run\n  steps before the workflow advances or closes,\n  [`@agent-pattern-labs/iso-redact`](./packages/iso-redact) scans, applies, verifies,\n  and explains local sensitive-data redaction policies,\n  [`@agent-pattern-labs/iso-migrate`](./packages/iso-migrate) plans and applies\n  idempotent consumer-project file migrations,\n  [`@agent-pattern-labs/iso-capabilities`](./packages/iso-capabilities) resolves,\n  checks, and renders role-level tool/MCP/command/filesystem/network policy,\n  [`@agent-pattern-labs/iso-contract`](./packages/iso-contract) validates, parses, and\n  renders structured workflow artifacts, and [`@agent-pattern-labs/iso-ledger`](./packages/iso-ledger)\n  records append-only domain events with idempotency keys, queries,\n  verification, and materialized views.\n- **Three feedback tools** close the loop after deploy:\n  [`@agent-pattern-labs/iso-eval`](./packages/iso-eval) scores *did the agent complete the task?* and\n  [`@agent-pattern-labs/iso-trace`](./packages/iso-trace) parses production transcripts to show *what the agent actually did*,\n  while [`@agent-pattern-labs/iso-guard`](./packages/iso-guard) enforces operational policies against those event streams.\n\n```\n                authoring                          build                               output                        feedback\n  ┌────────────────────┐  agentmd  ┌───────────────────┐  isolint  ┌─────────────────┐  iso-harness  ┌───────────────────────┐    iso-eval  ──▶  per-task pass / fail\n  │ agent.md           │ ────────▶ │ validated rules,  │ ────────▶ │ small-model-    │ ────────────▶ │ CLAUDE.md             │                    (behavioral scoring)\n  │ + fixtures         │   lint    │ scope labels,     │ lint/fix  │ safe prose      │    build      │ AGENTS.md             │\n  │                    │   render  │ load-bearing why  │           │                 │               │ .cursor/rules/*       │    iso-trace ──▶  production events,\n  └────────────────────┘           └───────────────────┘           └─────────────────┘               │ .opencode/agents/*    │                    which rules ever fired,\n                                                                                                     │ settings.json         │                    regression-fixture mining\n                                                                                                     │ .pi/skills/*          │\n                                                                                                     │ .pi/prompts/*         │\n                                                                                                     │                      │    iso-guard ─▶  policy pass / fail\n                                                                                                     │                      │    iso-context ─▶ context bundle plan\n                                                                                                     │                      │    iso-cache ─▶ artifact reuse\n                                                                                                     │                      │    iso-index ─▶ artifact lookup\n                                                                                                     │                      │    iso-facts ─▶ fact materialization\n                                                                                                     │                      │    iso-canon ─▶ identity keys\n                                                                                                     │                      │    iso-score ─▶ rubric gates\n                                                                                                     │                      │    iso-timeline ─▶ due next actions\n                                                                                                     │                      │    iso-prioritize ─▶ priority queue\n                                                                                                     │                      │    iso-lineage ─▶ artifact freshness\n                                                                                                     │                      │    iso-preflight ─▶ dispatch plan\n                                                                                                     │                      │    iso-postflight ─▶ settlement gate\n                                                                                                     │                      │    iso-redact ─▶ safe exports\n                                                                                                     │                      │    iso-migrate ─▶ project upgrades\n                                                                                                     │                      │    iso-capabilities ─▶ role permission policy\n  ┌────────────────────┐                                                                             │ .codex/config.toml    │\n  │ models.yaml        │ ───────────────────── iso-route build ─────────────────────────────────────▶│ opencode.json         │\n  │ (roles + fallback) │                                                                             │ .pi/settings.json     │\n  │                    │                                                                             │ .mcp.json             │\n  └────────────────────┘                                                                             └───────────────────────┘\n\n                    @agent-pattern-labs/iso chains agentmd → isolint → iso-route (when models.yaml exists) → iso-harness in one command.\n```\n\n## Quickstart\n\nMost users want `@agent-pattern-labs/iso` — one install, one command, every harness:\n\n```bash\nnpm install -D @agent-pattern-labs/iso\nnpx iso build .\n```\n\nGiven an `agent.md` (or an existing `iso/instructions.md`) and an `iso/`\nsource directory, this lints the authored source, rewrites it for\nsmall-model safety, and fans it out into `CLAUDE.md`, `AGENTS.md`,\n`.cursor/rules/*`, `.opencode/*`, `.pi/*`, and the matching MCP config files.\n\nSee [`packages/iso`](./packages/iso) for the full CLI reference and\nlibrary API, or [`examples/dogfood/`](./examples/dogfood) for a runnable\nproject that exercises the wrapper end-to-end.\n\n## Shipped Support Matrix\n\nPrompt/config build and model routing now include Pi. Replay and transcript\nparsing currently ship across Claude Code, Codex, OpenCode, and Cursor. The\nremaining narrower surface is `iso-trace model-score`, which is only available\nwhere the source transcript exposes stable model metadata.\n\n| Harness       | Prompt/config build | Model binding      | `iso-eval` runner | `iso-trace` parser | `model-score` |\n| ------------- | ------------------- | ------------------ | ----------------- | ------------------ | ------------- |\n| Claude Code   | yes                 | yes                | yes               | yes                | yes           |\n| Codex         | yes                 | yes                | yes               | yes                | yes           |\n| OpenCode      | yes                 | yes                | yes               | yes                | yes           |\n| Cursor        | yes                 | advisory note only | yes               | yes                | not yet       |\n| Pi            | yes                 | default + notes    | not yet           | not yet            | not yet       |\n\n## Tiny-Model Loop\n\nIf the real target is \"the same workflow still works on smaller models,\"\nthe repo now supports a tighter loop:\n\n- `isolint` rewrites authored prose into smaller-model-safe instructions.\n- `iso-route` lets you pin cheaper or local roles without forking prompts.\n- `iso-context plan/check/render` keeps mode/reference file selection local\n  instead of repeating context-loading matrices in prompts.\n- `iso-cache put/get/verify` keeps reusable artifacts local instead of\n  refetching or rederiving safe inputs on every run.\n- `iso-index build/query/has` keeps artifact lookup local instead of\n  grepping and loading growing state/report trees into prompts.\n- `iso-facts build/query/has/verify` keeps source-backed fact extraction\n  local instead of asking a model to reread broad artifact trees.\n- `iso-canon normalize/key/compare` keeps duplicate/entity keys local\n  instead of repeatedly restating URL, company, and role matching rules.\n- `iso-score compute/check/gate` keeps weighted rubric scoring local\n  instead of asking a model to redo arithmetic, bands, and threshold checks.\n- `iso-timeline plan/due/check` keeps follow-up, stale-item, retry, and\n  other dated next-action policy local instead of asking a model to reason\n  over dates from growing tracker files.\n- `iso-prioritize rank/select/check` keeps queue ordering, quota, and\n  tie-break policy local instead of asking a model to re-sort growing worklists.\n- `iso-lineage record/check/stale` keeps artifact freshness local instead of\n  asking a model whether generated outputs still match their source inputs.\n- `iso-preflight plan/check` keeps dispatch eligibility and batching local\n  instead of relying on prompt prose for source-backed facts and fan-out rules.\n- `iso-postflight status/check` keeps dispatch settlement local instead of\n  asking an agent to infer whether outcomes, artifacts, and post-steps are done.\n- `iso-redact scan/apply/verify` keeps secret and PII scrubbing local\n  instead of trusting every agent summary, trace export, or fixture writer\n  to remember sensitive-data handling rules.\n- `iso-migrate plan/apply/check` keeps consumer project upgrades local\n  instead of hand-editing package scripts, dependency ranges, and ignores.\n- `iso-capabilities check/render` keeps role permission matrices local\n  instead of repeating tool/MCP/filesystem boundaries in prompts.\n- `iso-trace model-score` catches tool-schema failures that weaker routes\n  tend to surface first on Claude Code, Codex, and OpenCode.\n- `iso-trace export-fixture --runner \u003cname\u003e` turns a real failure into an\n  `iso-eval` suite you can replay across shipped runners.\n- `iso-contract validate/render` makes artifact formats deterministic\n  instead of repeatedly restating TSV/JSON/markdown layouts in prompts.\n- `iso-ledger append/query/has` gives workflows a deterministic source of\n  operational truth instead of repeated markdown/TSV scraping.\n- `iso-guard audit` checks whether a real run obeyed operational policy\n  without turning those rules into more prompt tokens.\n\n## Runtime Control\n\nThe runtime layer is intentionally MCP-free and model-free. Domain packages\ncan use it from ordinary Node scripts to keep expensive or fragile facts out\nof the prompt:\n\n- `iso-orchestrator` persists resumable `step()` results, mutexes work by\n  entity key, and bounds fan-out for side-effectful workflows.\n- `iso-context` makes context selection executable: resolve inherited\n  file bundles, estimate local token cost, enforce budgets, and render\n  deterministic context packs without asking a model which files to load.\n- `iso-cache` makes artifact reuse executable: stable keys,\n  content-addressed blobs, TTL-aware reads, integrity verification, and\n  pruning without asking a model to refetch safe inputs.\n- `iso-index` makes artifact lookup executable: text/TSV/markdown-table/JSONL\n  sources compile into a compact queryable index, so agents can ask where a\n  fact lives without repeatedly grepping or loading growing files.\n- `iso-facts` makes fact materialization executable: local artifacts compile\n  into provenance-rich fact records that can be queried, verified, and checked\n  before downstream contracts or dispatch gates run.\n- `iso-canon` makes identity canonicalization executable: URLs, companies,\n  roles, and company-role pairs compile to stable keys with explainable\n  `same` / `possible` / `different` comparisons.\n- `iso-score` makes rubric scoring executable: structured dimension scores\n  compile into weighted totals, bands, comparisons, and gate decisions with\n  deterministic ids and local verification.\n- `iso-timeline` makes time-based next-action policy executable: dated\n  events compile into upcoming, due, overdue, suppressed, and blocked\n  actions with deterministic ids and local verification.\n- `iso-prioritize` makes queue prioritization executable: structured work\n  items compile into ranked, gated, quota-aware selections with deterministic\n  ids and local verification.\n- `iso-lineage` makes artifact freshness executable: source inputs and derived\n  outputs compile into a hash-verified graph that identifies stale downstream\n  artifacts without rereading broad project trees.\n- `iso-preflight` makes dispatch planning executable: validate required\n  file-backed facts, apply skip/block gates, avoid same-key overlap inside\n  rounds, and emit pre/post steps before tool-heavy work starts.\n- `iso-postflight` makes dispatch settlement executable: reconcile planned\n  rounds with observed outcomes, required artifacts, and post-run steps before\n  continuing, replacing candidates, waiting, collecting output, or closing.\n- `iso-redact` makes sensitive-data handling executable: scan, apply,\n  verify, and explain local redaction policies for trace exports, logs,\n  telemetry, eval fixtures, and domain artifacts without a model call.\n- `iso-migrate` makes project upgrades executable: JSON pointer edits, line\n  insertion, exact replacement, and guarded file writes run as idempotent\n  migrations instead of one-off shell patches.\n- `iso-capabilities` makes role boundaries executable: resolve inherited\n  tool/MCP/command/filesystem/network policy, check proposed actions, and\n  render compact harness guidance without asking a model to remember a\n  permission matrix.\n- `iso-contract` makes artifact shape executable: validate records, parse\n  existing TSV/markdown/JSON, and render canonical output without asking a\n  model to remember delimiters.\n- `iso-ledger` records append-only local events with idempotency keys, then\n  answers cheap `has/query/materialize` questions without loading growing\n  tracker files into context.\n- `iso-guard` audits the normalized event streams from real runs so runtime\n  policy stays verifiable after deploy.\n\n## Packages (25 Total)\n\n1. **[`packages/iso`](./packages/iso)** — [`@agent-pattern-labs/iso`](https://www.npmjs.com/package/@agent-pattern-labs/iso) · *recommended entry point*\n   The wrapper CLI for the whole flow. If `agent.md` is your authored\n   source, `iso build` runs `agentmd lint`, `agentmd render`, `isolint\n   lint`, then `iso-harness build` in one command. Use this unless you\n   have a reason to reach for a sub-package directly.\n\n2. **[`packages/agentmd`](./packages/agentmd)** — [`@agent-pattern-labs/agentmd`](https://www.npmjs.com/package/@agent-pattern-labs/agentmd)\n   A structured-markdown dialect for agent prompts. Rules are scoped\n   (`[H1]` hard limit, `[D1]` default) with load-bearing `why:` rationale.\n   Ships a linter for structure (missing rationale, dangling refs, no\n   fallback row) and a fixture-driven harness that measures per-rule\n   adherence against the target model.\n\n3. **[`packages/isolint`](./packages/isolint)** — [`@agent-pattern-labs/isolint`](https://www.npmjs.com/package/@agent-pattern-labs/isolint)\n   Lints the compiled prose for phrases weak small models can't parse —\n   `should`, `when relevant`, `one of the usual categories`, taste words,\n   long sentences, unclosed `etc.` lists. `--fix --llm` rewrites offenders\n   and re-lints the rewrite before accepting. Also ships an Isomorphic\n   Plan engine for fully-deterministic large-model-plans → small-model-run\n   pipelines.\n\n4. **[`packages/iso-harness`](./packages/iso-harness)** — [`@agent-pattern-labs/iso-harness`](https://www.npmjs.com/package/@agent-pattern-labs/iso-harness)\n   One `iso/` source directory → the file layout each coding agent\n   actually reads. Transpiles instructions, subagents, slash commands, and\n   MCP servers into `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/*.mdc`,\n   `.opencode/agents/*.md`, `.pi/skills/*/SKILL.md`,\n   `.pi/prompts/*.md`, etc., so supported harnesses stay in lockstep.\n\n5. **[`packages/iso-route`](./packages/iso-route)** — [`@agent-pattern-labs/iso-route`](https://www.npmjs.com/package/@agent-pattern-labs/iso-route)\n   One model policy, every harness. Declare a default model plus named\n   roles (`planner`, `fast-edit`, `reviewer`, …) in a single\n   `models.yaml`; iso-route compiles that into `.claude/settings.json`,\n   `.codex/config.toml`, `opencode.json`, `.pi/settings.json`, and\n   resolved notes/maps that `iso-harness` can consume when stamping\n   per-subagent frontmatter. Honest about ceilings — warns loudly where a\n   harness (e.g. Cursor or Pi roles) can't bind models programmatically.\n\n6. **[`packages/iso-eval`](./packages/iso-eval)** — [`@agent-pattern-labs/iso-eval`](https://www.npmjs.com/package/@agent-pattern-labs/iso-eval)\n   Behavioral eval runner for the produced harness. Snapshots a workspace\n   per task, hands it to a runner with the task prompt, then scores the\n   resulting filesystem / command state — answering \"did the agent\n   actually do it?\" that structural and prose lints can't. Ships a\n   deterministic `fake` runner for CI smoke plus packaged real runners for\n   Cursor, Codex, Claude Code, and OpenCode. The library still accepts\n   custom `RunnerFn`s for teams that need a different invocation surface.\n\n7. **[`packages/iso-trace`](./packages/iso-trace)** — [`@agent-pattern-labs/iso-trace`](https://www.npmjs.com/package/@agent-pattern-labs/iso-trace)\n   Local observability for real agent transcripts. Parses Claude Code,\n   Cursor, Codex, and OpenCode sessions into a harness-agnostic event model so\n   you can ask \"which rules ever actually fired?\", \"which\n   tools does my agent reach for most?\", and \"which captured sessions\n   would make good regression fixtures?\" Ships redacted export / fixture\n   helpers so that feedback loop is easier to reuse safely. `model-score`\n   currently stays on Claude Code, Codex, and OpenCode because Cursor\n   transcripts do not yet expose stable model metadata. Zero upload —\n   everything is local reads and user-controlled output.\n\n8. **[`packages/iso-guard`](./packages/iso-guard)** — [`@agent-pattern-labs/iso-guard`](https://www.npmjs.com/package/@agent-pattern-labs/iso-guard)\n   Deterministic runtime policy checks for agent workflows. Reads normalized\n   event streams or `iso-trace export` JSON/JSONL and verifies invariants\n   such as bounded fan-out, cleanup-before-dispatch, required follow-up\n   commands, no overlapping same-key work, and prompt secret redaction.\n   No model calls, no MCP server, and no injected prompt overhead.\n\n9. **[`packages/iso-ledger`](./packages/iso-ledger)** — [`@agent-pattern-labs/iso-ledger`](https://www.npmjs.com/package/@agent-pattern-labs/iso-ledger)\n   Append-only operational state for agent workflows. Stores local JSONL\n   events with deterministic ids and idempotency keys, supports\n   `append/query/has/verify/materialize`, and gives domain packages a\n   canonical state source without loading tracker files into the prompt.\n\n10. **[`packages/iso-context`](./packages/iso-context)** — [`@agent-pattern-labs/iso-context`](https://www.npmjs.com/package/@agent-pattern-labs/iso-context)\n   Deterministic context bundles for agent workflows. Loads JSON bundle\n   policies, resolves inheritance, estimates file tokens, checks file and\n   bundle budgets, and renders markdown/json context packs so domain\n   packages can keep context-loading rules out of prompt prose.\n\n11. **[`packages/iso-cache`](./packages/iso-cache)** — [`@agent-pattern-labs/iso-cache`](https://www.npmjs.com/package/@agent-pattern-labs/iso-cache)\n   Deterministic content-addressed artifact cache for agent workflows.\n   Generates stable keys, stores UTF-8 blobs with metadata and optional\n   TTLs, retrieves/list entries, verifies object hashes, and prunes\n   expired/orphaned artifacts so domain packages can reuse safe inputs\n   without model calls or MCP overhead.\n\n12. **[`packages/iso-index`](./packages/iso-index)** — [`@agent-pattern-labs/iso-index`](https://www.npmjs.com/package/@agent-pattern-labs/iso-index)\n   Deterministic local artifact index for agent workflows. Builds compact\n   lookup indexes from configured text, TSV, markdown-table, and JSONL\n   sources, then supports `query/has/verify` so domain packages can find\n   authoritative facts without loading whole artifact trees into prompt\n   context.\n\n13. **[`packages/iso-facts`](./packages/iso-facts)** — [`@agent-pattern-labs/iso-facts`](https://www.npmjs.com/package/@agent-pattern-labs/iso-facts)\n   Deterministic fact materialization for agent workflows. Extracts\n   provenance-rich facts from configured text, TSV, markdown-table, JSONL,\n   and JSON sources, then supports `query/has/verify/check` so domain\n   packages can feed source-backed facts into contracts and dispatch gates\n   without model calls.\n\n14. **[`packages/iso-canon`](./packages/iso-canon)** — [`@agent-pattern-labs/iso-canon`](https://www.npmjs.com/package/@agent-pattern-labs/iso-canon)\n   Deterministic canonicalization and entity matching for agent workflows.\n   Normalizes URLs, companies, roles, and company-role pairs into stable\n   keys, then compares them with an explainable score so domain packages\n   can keep duplicate checks out of prompt prose.\n\n15. **[`packages/iso-score`](./packages/iso-score)** — [`@agent-pattern-labs/iso-score`](https://www.npmjs.com/package/@agent-pattern-labs/iso-score)\n   Deterministic weighted rubric scoring for agent workflows. Computes\n   profile-specific scores, bands, gate decisions, comparisons, and\n   content-derived result ids from structured dimension inputs so domain\n   packages can keep arithmetic and threshold checks out of prompt prose.\n\n16. **[`packages/iso-timeline`](./packages/iso-timeline)** — [`@agent-pattern-labs/iso-timeline`](https://www.npmjs.com/package/@agent-pattern-labs/iso-timeline)\n   Deterministic time-based next-action planning for agent workflows.\n   Computes upcoming, due, overdue, suppressed, and blocked actions from\n   dated events plus local cadence policy so domain packages can keep\n   follow-up, retry, and stale-item date math out of prompt prose.\n\n17. **[`packages/iso-prioritize`](./packages/iso-prioritize)** — [`@agent-pattern-labs/iso-prioritize`](https://www.npmjs.com/package/@agent-pattern-labs/iso-prioritize)\n   Deterministic priority queue selection for agent workflows. Scores\n   structured work items against weighted criteria, applies skip/block gates,\n   enforces quotas, and emits ranked selections so domain packages can keep\n   queue ordering out of prompt prose.\n\n18. **[`packages/iso-lineage`](./packages/iso-lineage)** — [`@agent-pattern-labs/iso-lineage`](https://www.npmjs.com/package/@agent-pattern-labs/iso-lineage)\n   Deterministic artifact lineage for agent workflows. Records source input\n   hashes for generated artifacts, verifies graph integrity, and detects stale\n   downstream outputs so domain packages can avoid trusting old reports, PDFs,\n   plans, or derived indexes after inputs change.\n\n19. **[`packages/iso-preflight`](./packages/iso-preflight)** — [`@agent-pattern-labs/iso-preflight`](https://www.npmjs.com/package/@agent-pattern-labs/iso-preflight)\n   Deterministic preflight planning for agent workflows. Validates\n   source-backed candidate facts, applies precomputed skip/block gates,\n   avoids same-key overlap inside bounded rounds, and emits pre/post steps\n   so domain packages can fail closed before browser or MCP work starts.\n\n20. **[`packages/iso-postflight`](./packages/iso-postflight)** — [`@agent-pattern-labs/iso-postflight`](https://www.npmjs.com/package/@agent-pattern-labs/iso-postflight)\n   Deterministic postflight settlement for agent workflows. Reconciles\n   bounded dispatch plans with observed outcomes, required artifacts, and\n   post-run steps, then emits the next safe action: dispatch the next round,\n   wait, collect missing output, replace failed candidates, run post-steps,\n   stop, or close.\n\n21. **[`packages/iso-redact`](./packages/iso-redact)** — [`@agent-pattern-labs/iso-redact`](https://www.npmjs.com/package/@agent-pattern-labs/iso-redact)\n   Deterministic sensitive-data redaction for agent workflows. Loads local\n   redaction policies, scans text for builtin/pattern/field matches, applies\n   replacements without leaking matched values in findings, and verifies\n   exported traces, fixtures, telemetry, logs, or domain artifacts before\n   they are shared.\n\n22. **[`packages/iso-migrate`](./packages/iso-migrate)** — [`@agent-pattern-labs/iso-migrate`](https://www.npmjs.com/package/@agent-pattern-labs/iso-migrate)\n   Deterministic project migrations for agent workflow packages. Plans,\n   applies, checks, and explains idempotent JSON/text file upgrades so\n   domain packages can update consumer-owned files without prompt prose,\n   ad hoc shell scripts, or mandatory migration history state.\n\n23. **[`packages/iso-contract`](./packages/iso-contract)** — [`@agent-pattern-labs/iso-contract`](https://www.npmjs.com/package/@agent-pattern-labs/iso-contract)\n   Deterministic artifact contracts for agent workflows. Loads JSON\n   contract catalogs, validates records, and parses/renders JSON, TSV,\n   and markdown table rows so domain packages can keep artifact formats\n   out of prompt prose.\n\n24. **[`packages/iso-capabilities`](./packages/iso-capabilities)** — [`@agent-pattern-labs/iso-capabilities`](https://www.npmjs.com/package/@agent-pattern-labs/iso-capabilities)\n   Deterministic role capability policies for agent workflows. Loads JSON\n   role catalogs, resolves inheritance, checks proposed tool/MCP/command/\n   filesystem/network access, and renders compact target guidance so\n   domain packages can keep permission matrices out of prompt prose.\n\n25. **[`packages/iso-orchestrator`](./packages/iso-orchestrator)** — [`@agent-pattern-labs/iso-orchestrator`](https://www.npmjs.com/package/@agent-pattern-labs/iso-orchestrator)\n   Durable orchestration primitives for the runtime layer above a single\n   agent session. Persists workflow state to local disk, memoizes\n   load-bearing `step()` results, provides keyed mutexes for \"same\n   entity\" exclusion, and offers bounded `forEach()` fan-out so domain\n   packages can move invariants out of prompt prose and shell scripts.\n   Library-first today: no CLI, no harness-specific task-dispatch adapter.\n\nEach package is independently published on npm and works on its own.\nThey're in one repo because they're designed to compose.\n\n**Working on integrations across packages?** Read\n[`INTEGRATIONS.md`](./INTEGRATIONS.md). It now serves as the shipped\ncomposition ledger plus the list of deliberate non-integrations, so an\nAI agent (or human) pointed at this repo can tell what is already wired\nup vs. what is intentionally kept decoupled.\n\n## Commands cheat sheet\n\nInstall any one package globally or per-project; every CLI below is the\nbin exposed by that package.\n\n### `@agent-pattern-labs/iso` — wrapper (recommended)\n\n```bash\niso build                         # run agentmd → isolint → iso-harness on ./\niso build path/to/project         # target another project\niso build . --out dist            # write generated harness files under ./dist\niso build . --target claude,cursor\niso build . --skip-isolint        # skip the portable-prose pass\niso build . --dry-run             # dry-run iso-route + iso-harness writes\niso plan  .                       # print planned steps without executing\n```\n\n### `@agent-pattern-labs/agentmd` — author structure\n\n```bash\nagentmd lint   \u003cfile\u003e                                     # structural lint (rule IDs, refs, why:)\nagentmd render \u003cfile\u003e [--out compiled.md]                 # render compiled prompt with scope labels\nagentmd test   \u003cfile\u003e --fixtures \u003cpath\u003e [--via api|claude-code] [--model \u003cid\u003e]\n```\n\n### `@agent-pattern-labs/isolint` — portable prose\n\n```bash\nisolint lint .                                            # default preset\nisolint lint . --preset recommended,performance\nisolint lint . --since origin/main --fail-on warn         # gate PRs\nisolint lint . --format sarif \u003e lint.sarif                # for GitHub code scanning\nisolint lint . --fix --llm --large anthropic/claude-3.5-sonnet\nisolint plan  \u003cspec\u003e                                      # generate portable instructions from a plan\n```\n\n### `@agent-pattern-labs/iso-harness` — fan out to every harness\n\n```bash\niso-harness build                                         # reads ./iso, writes to ./\niso-harness build --target claude,cursor                  # subset of targets\niso-harness build --source path/to/iso --out path/to/project\niso-harness build --dry-run                               # print planned writes\niso-harness build --watch                                 # rebuild on every source change\n```\n\n### `@agent-pattern-labs/iso-route` — one model policy, every harness\n\n```bash\niso-route build models.yaml --out .                       # emit .claude/settings.json, config.toml, etc.\niso-route build models.yaml --targets claude,codex        # subset of harnesses\niso-route build models.yaml --dry-run                     # preview without touching disk\niso-route build models.yaml --verify-models               # opt-in early model verification\niso-route plan  models.yaml                               # print resolved role table\niso-route verify models.yaml                              # verify model IDs without emitting files\n```\n\n### `@agent-pattern-labs/iso-eval` — did the agent actually do the task?\n\n```bash\niso-eval run  eval.yml                                    # run the suite\niso-eval run  eval.yml --filter write-greeting --concurrency 2 --json\niso-eval run  eval.yml --runner claude-code --harness-source dist\niso-eval run  eval.yml --runner cursor --harness-source dist\niso-eval run  eval.yml --runner opencode --harness-source dist\niso-eval run  eval.yml --keep-workspaces                  # keep tmpdirs for debugging\niso-eval plan eval.yml                                    # list tasks + checks, no execution\n```\n\n### `@agent-pattern-labs/iso-trace` — what the agent *actually* did (production)\n\n```bash\niso-trace sources                                         # detected transcript roots + parser status\niso-trace list                                            # recent sessions across every root\niso-trace list --since 7d --cwd .\niso-trace show \u003cid-or-prefix\u003e [--events tool_call,file_op]\niso-trace show \u003cid\u003e --grep \"H3\"                           # regex across messages + tool input\niso-trace stats [ids…] [--since 7d] [--cwd .]             # aggregate tool/rule stats\niso-trace stats --source path/to/sample.jsonl             # one file, no discovery\niso-trace model-score --cwd . --harness opencode --tool read\niso-trace model-score --cwd . --harness opencode --tool read --since-hours 24 --fail-on-schema\niso-trace model-score --cwd . --harness opencode --tool read --since-hours 24 --fail-on-model openrouter/z-ai/glm-4.5-air:free\niso-trace export \u003cid\u003e --format jsonl --redact \u003e session.jsonl\niso-trace export-fixture \u003cid\u003e --out fixtures/my-task --runner codex --edit-checks exists-only --run\n```\n\n### `@agent-pattern-labs/iso-guard` — did the run obey policy?\n\n```bash\niso-guard audit guard.yaml --events session.json\niso-guard audit guard.yaml --events session.jsonl --json\niso-guard verify guard.yaml --events session.json --fail-on warn\niso-guard explain guard.yaml\n```\n\n### `@agent-pattern-labs/iso-ledger` — what is canonically true?\n\n```bash\niso-ledger init\niso-ledger append application.submitted --key \"url:https://example.test/jobs/123\" --idempotency-key \"apply:https://example.test/jobs/123\" --data '{\"status\":\"applied\"}'\niso-ledger has --key \"url:https://example.test/jobs/123\"\niso-ledger query --type application.submitted --where status=applied\niso-ledger verify\niso-ledger materialize --out state.json\n```\n\n### `@agent-pattern-labs/iso-context` — what context should this task load?\n\n```bash\niso-context list --policy context.json\niso-context explain apply --policy context.json\niso-context plan apply --policy context.json --root .\niso-context check apply --policy context.json --root . --budget 12000\niso-context render apply --policy context.json --root . --target markdown\n```\n\n### `@agent-pattern-labs/iso-cache` — which reusable artifact already exists?\n\n```bash\niso-cache key --namespace jobforge.jd --part https://example.test/jobs/123 --part geometra-text-v1\niso-cache put \"jd:example:123\" --kind jd --ttl 7d --meta '{\"url\":\"https://example.test/jobs/123\"}' --input @job-description.md\niso-cache has \"jd:example:123\"\niso-cache get \"jd:example:123\" --output cached-job-description.md\niso-cache verify\niso-cache prune --expired\n```\n\n### `@agent-pattern-labs/iso-index` — where is the authoritative fact?\n\n```bash\niso-index build --config index.json --root . --out .iso-index.json\niso-index query \"example labs\" --index .iso-index.json\niso-index has --index .iso-index.json --key \"company-role:example-labs:staff-agent-engineer\"\niso-index verify --index .iso-index.json\niso-index explain --config index.json\n```\n\n### `@agent-pattern-labs/iso-facts` — what facts can this workflow trust?\n\n```bash\niso-facts build --config facts.json --root . --out .iso-facts.json\niso-facts query --facts .iso-facts.json --fact job.url\niso-facts has --facts .iso-facts.json --fact job.score\niso-facts verify --facts .iso-facts.json\niso-facts check --facts .iso-facts.json --config facts.json\niso-facts explain --config facts.json\n```\n\n### `@agent-pattern-labs/iso-canon` — what stable key names this entity?\n\n```bash\niso-canon normalize url \"https://www.example.com/jobs/123?utm_source=x\"\niso-canon key company-role --company \"Anthropic, PBC\" --role \"Senior SWE - Remote US\"\niso-canon compare company \"OpenAI, Inc.\" \"Open AI\" --config canon.json --profile jobforge\niso-canon explain --config canon.json --profile jobforge\n```\n\n### `@agent-pattern-labs/iso-score` — what does this rubric deterministically decide?\n\n```bash\niso-score compute --config score.json --input evaluation.json --out score-result.json\niso-score verify --score score-result.json\niso-score check --config score.json --input evaluation.json\niso-score gate --config score.json --input evaluation.json --gate apply\niso-score compare --config score.json --left evaluation.json --right evaluation-alt.json\niso-score explain --config score.json\n```\n\n### `@agent-pattern-labs/iso-timeline` — what is due now?\n\n```bash\niso-timeline plan --config timeline.json --events events.jsonl --now 2026-04-27T00:00:00Z\niso-timeline due --config timeline.json --events events.jsonl --now 2026-04-27T00:00:00Z\niso-timeline check --config timeline.json --events events.jsonl --fail-on overdue\niso-timeline verify --timeline timeline-result.json\niso-timeline explain --config timeline.json\n```\n\n### `@agent-pattern-labs/iso-prioritize` — what should run first?\n\n```bash\niso-prioritize rank --config prioritize.json --items items.json --out priority-result.json\niso-prioritize select --config prioritize.json --items items.json --limit 3\niso-prioritize check --config prioritize.json --items items.json --min-selected 3\niso-prioritize verify --result priority-result.json\niso-prioritize explain --config prioritize.json\n```\n\n### `@agent-pattern-labs/iso-lineage` — is this artifact still fresh?\n\n```bash\niso-lineage record --artifact reports/812.md --input cv.md --input profile.yml\niso-lineage check --artifact reports/812.md\niso-lineage stale\niso-lineage verify --graph .iso-lineage.json\niso-lineage explain --artifact reports/812.md\n```\n\n### `@agent-pattern-labs/iso-preflight` — is this workflow safe to dispatch?\n\n```bash\niso-preflight plan --config preflight.json --candidates candidates.json\niso-preflight check --config preflight.json --candidates candidates.json\niso-preflight explain --config preflight.json\n```\n\n### `@agent-pattern-labs/iso-postflight` — is this dispatched workflow settled?\n\n```bash\niso-postflight status --config postflight.json --plan plan.json --outcomes outcomes.json\niso-postflight check --config postflight.json --plan plan.json --outcomes outcomes.json\niso-postflight explain --config postflight.json\n```\n\n### `@agent-pattern-labs/iso-redact` — is this output safe to export?\n\n```bash\niso-redact scan --config redact.json --input session.jsonl\niso-redact verify --config redact.json --input fixture/task.md\niso-redact apply --config redact.json --input raw.txt --output safe.txt\niso-redact explain --config redact.json\n```\n\n### `@agent-pattern-labs/iso-migrate` — what project-owned files need upgrading?\n\n```bash\niso-migrate plan --config migrations.json --root .\niso-migrate apply --config migrations.json --root .\niso-migrate check --config migrations.json --root .\niso-migrate explain --config migrations.json\n```\n\n### `@agent-pattern-labs/iso-contract` — what shape must this artifact have?\n\n```bash\niso-contract list --contracts contracts.json\niso-contract explain jobforge.tracker-row --contracts contracts.json\niso-contract validate jobforge.tracker-row --contracts contracts.json --input @row.json\niso-contract render jobforge.tracker-row --contracts contracts.json --input @row.json --format tsv\niso-contract parse jobforge.tracker-row --contracts contracts.json --format tsv --input \"812\t2026-04-26\tExample Labs\tStaff Agent Engineer\tApplied\t4.2/5\tyes\t[812](reports/812-example-labs-2026-04-26.md)\tSubmitted\"\n```\n\n### `@agent-pattern-labs/iso-capabilities` — what may this role do?\n\n```bash\niso-capabilities list --policy capabilities.json\niso-capabilities explain applicant --policy capabilities.json\niso-capabilities check applicant --policy capabilities.json --tool browser --mcp geometra --command \"npx job-forge merge\" --filesystem write --network restricted\niso-capabilities render applicant --policy capabilities.json --target opencode\n```\n\n## Layout\n\n```\niso/\n├── package.json          # workspaces root\n├── tsconfig.base.json    # shared compiler options\n└── packages/\n    ├── agentmd/          # structure + adherence\n    ├── isolint/          # portable prose\n    ├── iso-harness/      # one source, every harness\n    ├── iso/              # one command for the whole pipeline\n    ├── iso-route/        # one model policy → per-harness config\n    ├── iso-orchestrator/ # durable runtime control above one agent session\n    ├── iso-eval/         # behavioral eval on the produced harness\n    ├── iso-trace/        # parse + query real agent transcripts (observability)\n    ├── iso-guard/        # deterministic runtime policy checks over events\n    ├── iso-ledger/       # append-only operational event/state ledger\n    ├── iso-context/      # deterministic context bundle policy\n    ├── iso-cache/        # deterministic content-addressed artifact cache\n    ├── iso-index/        # deterministic local artifact lookup index\n    ├── iso-facts/        # deterministic source-backed fact materialization\n    ├── iso-canon/        # deterministic identity canonicalization\n    ├── iso-score/        # deterministic weighted rubric scoring\n    ├── iso-timeline/     # deterministic time-based next-action planning\n    ├── iso-prioritize/   # deterministic priority queue selection\n    ├── iso-lineage/      # deterministic artifact lineage freshness\n    ├── iso-preflight/    # deterministic preflight dispatch planning\n    ├── iso-postflight/   # deterministic postflight settlement\n    ├── iso-redact/       # deterministic sensitive-data redaction\n    ├── iso-migrate/      # deterministic consumer project migrations\n    ├── iso-contract/     # deterministic artifact contracts\n    └── iso-capabilities/ # deterministic role capability policy\n```\n\n## Build \u0026 test\n\n```bash\nnpm install                 # install all workspace deps\nnpm run build               # build every package\nnpm run test                # run every package's tests\nnpm run typecheck           # typecheck every package\nnpm run test:dogfood        # wrapper-level local dogfood project\nnpm run test:pack           # pack local tarballs and smoke installed CLIs\nnpm run test:pipeline       # end-to-end demo (agentmd → isolint → iso-harness)\nnpm --workspace @agent-pattern-labs/iso-eval  run example   # iso-eval against the bundled example suite\nnpm --workspace @agent-pattern-labs/iso-trace run example   # iso-trace stats on the bundled sample transcript\nnpm --workspace @agent-pattern-labs/iso-guard run test      # iso-guard policy engine tests\nnpm --workspace @agent-pattern-labs/iso-ledger run test     # iso-ledger event/state tests\nnpm --workspace @agent-pattern-labs/iso-context run test    # iso-context bundle/budget tests\nnpm --workspace @agent-pattern-labs/iso-cache run test      # iso-cache artifact cache tests\nnpm --workspace @agent-pattern-labs/iso-index run test      # iso-index artifact lookup tests\nnpm --workspace @agent-pattern-labs/iso-facts run test      # iso-facts materialization tests\nnpm --workspace @agent-pattern-labs/iso-canon run test      # iso-canon identity key tests\nnpm --workspace @agent-pattern-labs/iso-score run test      # iso-score rubric scoring tests\nnpm --workspace @agent-pattern-labs/iso-timeline run test   # iso-timeline next-action tests\nnpm --workspace @agent-pattern-labs/iso-prioritize run test # iso-prioritize queue selection tests\nnpm --workspace @agent-pattern-labs/iso-lineage run test    # iso-lineage artifact freshness tests\nnpm --workspace @agent-pattern-labs/iso-preflight run test  # iso-preflight dispatch planning tests\nnpm --workspace @agent-pattern-labs/iso-postflight run test # iso-postflight settlement tests\nnpm --workspace @agent-pattern-labs/iso-redact run test     # iso-redact policy/redaction tests\nnpm --workspace @agent-pattern-labs/iso-migrate run test    # iso-migrate project migration tests\nnpm --workspace @agent-pattern-labs/iso-contract run test   # iso-contract artifact contract tests\nnpm --workspace @agent-pattern-labs/iso-capabilities run test # iso-capabilities policy tests\n\n# Target a single package\nnpm run build --workspace @agent-pattern-labs/isolint\nnpm run test  --workspace @agent-pattern-labs/agentmd\nnpm run test  --workspace @agent-pattern-labs/iso\n```\n\n## Releasing\n\nVersion bumps are driven by [Changesets](https://github.com/changesets/changesets).\nEvery PR that changes a package should include a changeset describing the\nuser-visible impact:\n\n```bash\nnpm run changeset          # interactive — pick packages + bump level + summary\nnpm run changeset:status   # preview what the next `version` would do\n```\n\nWhen you're ready to cut a release:\n\n```bash\nnpm run version            # bumps package versions + writes CHANGELOG.md\ngit commit -am \"Version packages\"\ngit tag \u003cpkg\u003e-v\u003cversion\u003e   # e.g. agentmd-v0.3.0\ngit push \u0026\u0026 git push --tags\ngh release create \u003cpkg\u003e-v\u003cversion\u003e --generate-notes\n```\n\nThe tag-triggered release workflows in `.github/workflows/*-release.yml`\ntake over from there — verify the tag matches `package.json`, run tests,\nbuild, and `npm publish --provenance`.\n\n## End-to-end example\n\n[`examples/pipeline/`](./examples/pipeline) is an executable demonstration\nthat exercises **seven of the twenty-five packages end-to-end** in one `npm run\ntest:pipeline` invocation: `agentmd lint` + `render` → `isolint lint` →\n`iso-route build` (from a bundled `models.yaml` that extends the\n`standard` preset) → `iso-harness build` (which consumes iso-route's\nresolved map and stamps `model:` onto the Claude subagent) →\n`iso-eval run` against a tiny fake-runner suite → `iso-trace stats`\nagainst a bundled sample session. The assertion set includes a\ncross-package check that the `researcher` subagent's emitted\nfrontmatter contains `model: claude-opus-4-7`, driven from the\n`models.yaml` policy.\n\n[`examples/dogfood/`](./examples/dogfood) is a local dogfood project for the\nwrapper CLI itself. It starts from `agent.md` + `iso/` source and runs the\nrepo's local `packages/iso/bin/iso.mjs` entrypoint to produce the full harness\nfan-out. Run `npm run test:dogfood` to exercise the same wrapper path a\ndownstream repo would use.\n\n`npm run test:pack` goes one level further: it packs the local workspaces into\ntarballs, installs them into fresh temp projects, and smoke-tests the packaged\n`iso-harness`, `iso`, `iso-eval`, `iso-trace`, `iso-route`, `iso-guard`, `iso-ledger`, `iso-context`, `iso-cache`, `iso-index`, `iso-facts`, `iso-canon`, `iso-score`, `iso-timeline`, `iso-prioritize`, `iso-lineage`, `iso-preflight`, `iso-postflight`, `iso-redact`, `iso-migrate`, `iso-contract`, and `iso-capabilities`\nCLIs. This guards against packaging regressions that workspace-only tests can\nmiss.\n\n[`packages/iso-eval/examples/suites/echo-basic/`](./packages/iso-eval/examples/suites/echo-basic)\nis a runnable eval suite for the downstream side: a baseline workspace, a\ntask prompt, and a set of file/command checks. Run `npm --workspace\n@agent-pattern-labs/iso-eval run example` to see the full pass-report against the\nbundled `fake` runner.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fagent-pattern-labs%2Fiso","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fagent-pattern-labs%2Fiso","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fagent-pattern-labs%2Fiso/lists"}