code-foundry 1.12.0 → 1.14.0

package/.github/CONTRIBUTING.md

@@ -41,13 +41,14 @@ This repository uses the `direct` workflow. Topic pull requests target `main`.
 - Open every ordinary pull request as a draft. Use `gh pr create --draft` or
   set `draft: true` in the GitHub API; never create a ready ordinary pull
   request as a shortcut.
-- Keep ordinary pull requests in draft while making commits. The generated
-  Draft Guard resets a ready ordinary pull request to draft on creation,
-  reopening, or a new commit, and runner-heavy validation starts only after an
+- Keep ordinary pull requests in draft while preparing them. The generated
+  Draft Guard converts ready ordinary pull requests to draft when they are
+  opened or reopened, and runner-heavy validation starts only after an
   explicit `ready_for_review` transition.
 - Run local validation and finish review preparation before marking an ordinary
-  pull request ready. After any later commit, mark it ready again only after
-  the current head is ready for review.
+  pull request ready. Ready pull requests stay ready when new commits arrive,
+  and validation reruns for the current head; draft updates allocate no
+  validation runner until the pull request is ready.
 - Release Please version pull requests are managed by the Code Foundry release
   workflow; do not manually change their draft state unless the workflow asks.
 
@@ -183,7 +184,7 @@ Keep pull requests focused and reviewable. Include screenshots or recordings for
 | Push to a working branch                           | Draft PR workflow                                                                     |
 | Push to `main`                                     | Release workflow plus default-branch CodeQL scan; validation ran on the merged PR     |
 
-Draft pull requests do not start validation. The lightweight Draft Guard also converts ordinary pull requests opened, reopened, or updated while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier. Convert it back to draft after an update, then mark it ready again after every update so the required checks attach to the current head. Converting it to draft runs only the lightweight cancellation control.
+Draft pull requests do not start validation. The lightweight Draft Guard converts ordinary pull requests opened or reopened while ready back to draft; it never checks out pull-request code and it excludes Release Please version heads, whose release workflow owns their state. Marking a pull request ready for review starts the applicable validation tier, and each new commit on a ready pull request reruns that tier for the current head. Draft updates allocate no validation runner. Converting a pull request to draft runs only the lightweight cancellation control.
 
 Pull-request validation keys concurrency by event and pull-request head, so a newer update cancels its superseded run. Scheduled and manual audits use a separate caller pinned to the protected default branch; this prevents caller-selected runtime code from executing with default-branch cache access. Pull-request and scheduled/manual callers use the mode-aware orchestrator, which fans out only the required jobs and concludes with the stable aggregate gate. Main pushes run the default-branch CodeQL lane separately.
 

package/.github/workflows/draft-enforcement_self-ci.yml

@@ -8,7 +8,6 @@ on:
     types:
       - opened
       - reopened
-      - synchronize
 
 permissions:
   pull-requests: write
@@ -55,8 +54,8 @@ jobs:
               ;;
           esac
 
-          # A newer state transition or commit superseded this event. Do not
-          # undo a user's later explicit readiness decision with a stale event.
+          # A newer state transition superseded this event. Do not undo a
+          # user's later explicit readiness decision with a stale event.
           if [ "$head_sha" != "$EVENT_HEAD_SHA" ] || [ "$updated_at" != "$EVENT_UPDATED_AT" ]; then
             echo 'A newer pull-request state or head commit superseded this draft-guard event; leaving the current state unchanged.'
             exit 0
@@ -76,4 +75,4 @@ jobs:
             "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER" \
             -F draft=true \
             --silent >/dev/null
-          echo "Converted ordinary pull request #$PR_NUMBER to draft; runner-heavy validation waits for ready_for_review."
+          echo "Converted ordinary pull request #$PR_NUMBER to draft; validation waits for ready_for_review."

package/.github/workflows/opencode-security_self-ci.yml

@@ -5,6 +5,7 @@ on:
     branches: [main, staging]
     types:
       - ready_for_review
+      - synchronize
   workflow_dispatch:
 
 permissions:
@@ -13,7 +14,7 @@ permissions:
 jobs:
   detect:
     name: OpenCode Security / Detect
-    if: vars.CI_BILLING_PAUSED != 'true'
+    if: vars.CI_BILLING_PAUSED != 'true' && (github.event_name == 'workflow_dispatch' || github.event.pull_request.draft == false)
     runs-on: ubuntu-slim
     outputs:
       enabled: ${{ steps.detect.outputs.enabled }}

package/.github/workflows/validation_self-ci.yml

@@ -7,6 +7,7 @@ on:
     branches: [main, staging]
     types:
       - ready_for_review
+      - synchronize
 
 # Default every caller job to no repository permissions. Individual jobs grant
 # only the scopes their own validation path consumes.
@@ -20,9 +21,10 @@ concurrency:
 jobs:
   mode:
     name: Mode
-    # The mode classifier is only needed for pull requests. Main pushes use
-    # the dedicated default-branch CodeQL lane below.
-    if: vars.CI_BILLING_PAUSED != 'true' && github.event_name == 'pull_request'
+    # The mode classifier is only needed for ready pull requests. Main pushes
+    # use the dedicated default-branch CodeQL lane below; draft updates do not
+    # allocate a validation runner.
+    if: vars.CI_BILLING_PAUSED != 'true' && github.event_name == 'pull_request' && github.event.pull_request.draft == false
     runs-on: ubuntu-slim
     timeout-minutes: 10
     permissions:
@@ -62,7 +64,7 @@ jobs:
   validation:
     name: Validation
     needs: mode
-    if: vars.CI_BILLING_PAUSED != 'true' && github.event_name == 'pull_request'
+    if: vars.CI_BILLING_PAUSED != 'true' && github.event_name == 'pull_request' && github.event.pull_request.draft == false
     # Reusable workflows can only maintain or reduce the caller job's scopes.
     # The audit tier needs security-events: write for CodeQL uploads.
     permissions:

package/AGENTS.md

@@ -103,13 +103,14 @@ This repository uses the `direct` workflow. Topic pull requests target `main`.
 - Open every ordinary pull request as a draft. Use `gh pr create --draft` or
   set `draft: true` in the GitHub API; never create a ready ordinary pull
   request as a shortcut.
-- Keep ordinary pull requests in draft while making commits. The generated
-  Draft Guard resets a ready ordinary pull request to draft on creation,
-  reopening, or a new commit, and runner-heavy validation starts only after an
+- Keep ordinary pull requests in draft while preparing them. The generated
+  Draft Guard converts ready ordinary pull requests to draft when they are
+  opened or reopened, and runner-heavy validation starts only after an
   explicit `ready_for_review` transition.
 - Run local validation and finish review preparation before marking an ordinary
-  pull request ready. After any later commit, mark it ready again only after
-  the current head is ready for review.
+  pull request ready. Ready pull requests stay ready when new commits arrive,
+  and validation reruns for the current head; draft updates allocate no
+  validation runner until the pull request is ready.
 - This contract is mandatory for every agent scope. Nested `AGENTS.md` files
   may add stricter rules but must not weaken or replace it.
 - Release Please version pull requests are managed by the Code Foundry release

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.14.0](https://github.com/0xPlayerOne/code-foundry/compare/v1.13.0...v1.14.0) (2026-09-09)
+
+
+### Features
+
+* **cli:** add shared validation plans and agent check evidence ([#538](https://github.com/0xPlayerOne/code-foundry/issues/538)) ([95af9ed](https://github.com/0xPlayerOne/code-foundry/commit/95af9ed42682ff3ed1dc74609ea4628d0c95a799))
+
+## [1.13.0](https://github.com/0xPlayerOne/code-foundry/compare/v1.12.0...v1.13.0) (2026-09-09)
+
+
+### Features
+
+* **fleet:** add declared inventory and resumable canary rollouts ([#536](https://github.com/0xPlayerOne/code-foundry/issues/536)) ([6aa86d4](https://github.com/0xPlayerOne/code-foundry/commit/6aa86d4cd85cdbd4041c70d8c01d8e351e21fc0b))
+
 ## [1.12.0](https://github.com/0xPlayerOne/code-foundry/compare/v1.11.0...v1.12.0) (2026-09-09)
 
 

package/README.md

@@ -76,12 +76,13 @@ The standard workflow triggers are:
 
 Automated feature/fix and staging-promotion pull requests open as drafts.
 The trusted Draft Guard is a fallback for manually created or reopened ready
-PRs and for new commits to ordinary ready PRs: it converts them to drafts
-without checking out PR code. It verifies the event head and update timestamp
-before changing state, and excludes Release Please version PRs whose release
-workflow owns readiness. Pull-request validation runs only on the
-ready-for-review transition. Converting a PR to draft runs only the lightweight
-cancellation control. Scheduled and manually dispatched audits are unaffected.
+PRs: it converts them to drafts without checking out PR code. It verifies the
+event head and update timestamp before changing state, and excludes Release
+Please version PRs whose release workflow owns readiness. Pull-request
+validation runs on the ready-for-review transition and on new commits while a
+PR remains ready; draft updates allocate no validation runner. Converting a PR
+to draft runs only the lightweight cancellation control. Scheduled and manually
+dispatched audits are unaffected.
 
 Jobs are language-aware and skip irrelevant setup inside the applicable
 aggregate checks. TypeScript uses Oxlint, Oxfmt, and Bun's native

package/docs/PERFORMANCE.md

@@ -15,9 +15,9 @@ belong to the run that produced them, not the source tree.
 | Format, lint, type-check, and build |   15 s | Bound the local CI feedback loop                     |
 | Runtime dependencies                |      0 | Keep the installed CLI dependency-free               |
 | Development dependencies            |      4 | Prevent unreviewed toolchain growth                  |
-| Packed artifact                     | 200 kB | Bound registry transfer and install cost             |
-| Unpacked artifact                   | 750 kB | Bound installed footprint                            |
-| Packed files                        |     80 | Detect accidental release contents                   |
+| Packed artifact                     | 210 kB | Bound registry transfer and install cost             |
+| Unpacked artifact                   | 820 kB | Bound installed footprint                            |
+| Packed files                        |     92 | Detect accidental release contents                   |
 
 The performance workflow disables build-cache reads and writes for this task.
 That makes timing comparisons independent of a warm protected-branch cache and

package/docs/README.md

@@ -14,6 +14,8 @@ its own names, environments, and deployment details.
 - [Caching and remote caching](CACHING.md)
 - [Performance budgets and baselines](PERFORMANCE.md)
 - [Required capabilities and task evidence](required-capabilities.md)
+- [Agent-facing validation commands](agent-validation.md)
+- [Declarative fleet inventory and staged rollouts](fleet-rollouts.md)
 
 ## Repository-specific documentation
 

package/docs/WORKFLOWS.md

@@ -15,19 +15,19 @@ pull_request:
   # direct topology: branches: [main]
 ```
 
-The generated validation caller listens for `ready_for_review` and `push` to
-`main`. Draft pull requests register no validation checks and allocate no
-validation runner; main pushes run only the default-branch CodeQL lane, while
-full validation remains pull-request-only.
-A separate lightweight Draft Guard runs from the trusted base branch on
-`opened`, `reopened`, and `synchronize`; it converts ordinary ready pull
-requests back to draft without checking out pull-request code. It rechecks the
-current head and update timestamp before mutating state, so a stale event
-cannot undo a later draft or ready transition. Release Please version heads are
-excluded because the release workflow owns their state. A separate draft-control
-caller listens for `converted_to_draft` and cancels queued or running
-pull-request workflows without creating skipped validation jobs. Marking a pull
-request ready again starts validation for the current head.
+The generated validation caller listens for `ready_for_review` and
+`synchronize`. Its jobs require the pull request to remain ready, so draft
+updates allocate no validation runner; main pushes run only the default-branch
+CodeQL lane, while full validation remains pull-request-only. A separate
+lightweight Draft Guard runs from the trusted base branch on `opened` and
+`reopened`; it converts ordinary ready pull requests back to draft without
+checking out pull-request code. It rechecks the current head and update
+timestamp before mutating state, so a stale event cannot undo a later draft or
+ready transition. Release Please version heads are excluded because the
+release workflow owns their state. A separate draft-control caller listens for
+`converted_to_draft` and cancels queued or running pull-request workflows.
+Marking a pull request ready starts validation, and each new commit on a ready
+pull request starts it again for the current head.
 
 The separate `validation-audit.yml` caller is pinned to the configured released
 runtime and handles scheduled and manual audits:
@@ -108,7 +108,7 @@ opt in or out without a code change.
 | Security    | Profile, audits, and public-only Dependency Review                |
 | CodeQL      | GitHub-native code scanning, kept separate from CI                |
 | Draft PR    | Create/update development pull requests                           |
-| Draft Guard | Keep ordinary PRs draft until `ready_for_review`                  |
+| Draft Guard | Keep opened/reopened ordinary PRs draft until `ready_for_review`  |
 | Release PR  | Promote `staging` into `main` (staging-release topology only)     |
 | Release     | Release Please, GitHub release, and optional npm publication      |
 

package/docs/agent-validation.md

@@ -0,0 +1,94 @@
+# Agent-facing validation commands
+
+The public CLI now exposes a stable plan/check interface using the same discovery,
+required-capability policy, ecosystem executor, and task receipts as reusable CI.
+
+```sh
+code-foundry plan --changed --base origin/main --json
+code-foundry check --tier fast --json
+code-foundry check --tier audit --json
+```
+
+Both commands accept `--target PATH`. Use the Code Foundry version pinned by the
+repository, not an unreviewed floating installation. `plan` executes discovery
+only: it does not install dependencies, run project checks, modify source files,
+or emit skip-receipt files. Required entrypoints are validated across the complete
+task set, including tasks deferred from the selected local tier.
+
+## Tiers and change awareness
+
+`fast` selects formatting, linting, type checking, build, unit tests, and performance.
+`audit` adds integration, E2E, and smoke tests. Ecosystem commands and applicability
+come from the shared runtime; the CLI does not invent alternate test commands.
+Repository-owned scripts remain authoritative. Missing required tasks fail
+planning instead of returning a misleading successful subset.
+
+`--changed` includes paths changed from the selected base, staged changes,
+unstaged changes, and untracked files. Committed paths use the merge-base with
+that ref, so an independently advanced base branch does not make base-only
+changes look like head changes. `--base` defaults to HEAD and requires `--changed`.
+Invalid or unavailable base revisions fail rather than being treated as no changes.
+Paths use Git's NUL-separated format, preserving whitespace and unusual filenames.
+Generated `.code-foundry/` evidence is excluded from change annotations. Change awareness is **annotation-only**: without a verified dependency
+graph it does not skip required tasks or assume a documentation change cannot
+affect a custom command.
+
+Local tiers are not a replacement for the complete GitHub Validation / Gate.
+Security scans, CodeQL, release-diff policy where applicable, protected-environment
+checks, and required reviews remain separate. Every plan/result explicitly marks
+remote validation as required. A fast result also names deferred local tasks.
+A local audit result is not permission to mark a PR ready or merge it.
+
+## Execution and evidence
+
+Install the repository's locked dependencies through its normal setup process
+before running checks. This CLI does not add an implicit install step or grant
+credentials. It runs trusted repository scripts in the existing environment;
+those scripts are not sandboxed and retain their normal tool/network behavior.
+The formatter/runtime's existing semantics are unchanged: a configured command
+that rewrites files still rewrites files. Prefer check-only scripts in CI.
+
+Task stdout/stderr goes to stderr, keeping `--json` stdout parseable. Each selected
+applicable task runs through the public runtime. A zero exit without a fresh,
+matching, successful task receipt fails. A failed task blocks remaining applicable
+tasks; optional inapplicable tasks are reported as skipped. An entirely skipped
+check is labeled `skipped`, never `passed`.
+
+A run stores `.code-foundry/agent-results/check-*/summary.json` and snapshots of
+its task receipts. The result includes the source commit, dirty-tree indication,
+selected/deferred tasks, reasons, exit codes, signals, receipt paths, and repository
+artifact paths such as coverage or browser evidence. HEAD identifies the base
+commit; a dirty working tree is not a cryptographically identified immutable
+source snapshot. Reports are local evidence, not signed provenance.
+
+The aggregate and task receipts are retained per run so later checks do not
+overwrite the earlier JSON evidence. Artifact paths inside receipts point to
+repository-owned files and may be overwritten by subsequent test runs; copy them
+into a CI artifact for long-term retention. Do not upload the whole hidden
+repository tree or secrets. The CLI neither captures environment variables into
+reports nor grants publish/merge/deploy access.
+
+An exclusive local `agent-results/active.lock` prevents overlapping agent checks
+from confusing receipts. After a killed process, inspect the checkout and confirm
+there is no active check before manually removing a stale lock. Normal completion
+and failures clean the lock. This is a local CLI lock, not a distributed lock
+against every other tool writing into the repository.
+
+`--timeout SECONDS` bounds each check subprocess (default 600, range 1–3600).
+A timeout or missing receipt fails. Project scripts remain responsible for
+cleaning up their own servers and subprocesses. Plans do not accept an execution
+timeout. Unknown, duplicate, or ignored arguments fail rather than silently alter
+validation behavior.
+
+## Integration and tests
+
+This change depends on the required-capabilities/task-evidence runtime change.
+It deliberately imports shared policy instead of maintaining a competing copy.
+Merge that prerequisite before this CLI change and retain `runtime-core.mjs` when
+vendoring the runtime.
+
+Run `node --test test/agent-check.test.mjs`. Tests exercise real Git change
+inspection and the actual policy/evidence wrapper with a deterministic ecosystem
+executor, including read-only planning, required deferred tasks, failed commands,
+stale evidence, receipt snapshots, locking, and separation of JSON from task logs.
+Full ecosystem dependencies and GitHub-side checks still need their own CI run.

package/docs/fleet-rollouts.md

@@ -0,0 +1,139 @@
+# Declarative fleet inventory and staged rollouts
+
+Place `code-foundry-fleet.json` in the directory passed to `--root`. Its presence
+opts that fleet into inventory-based discovery and controlled upgrades, without
+changing legacy directory discovery for existing users.
+
+```json
+{
+  "schemaVersion": 1,
+  "cohorts": ["canary", "applications"],
+  "repositories": [
+    {
+      "repository": "owner/package-canary",
+      "path": "packages/package-canary",
+      "cohort": "canary",
+      "profile": "published-package",
+      "expected": { "git_workflow": "direct" },
+      "requiredCapabilities": ["unit", "performance"],
+      "validation": [
+        ["bun", "install", "--frozen-lockfile"],
+        ["bun", "run", "test:unit"],
+        ["bun", "run", "test:consumer"],
+        ["bun", "run", "performance:check"]
+      ],
+      "requiredChecks": ["Validation / Gate"]
+    },
+    {
+      "repository": "owner/application",
+      "path": "applications/application",
+      "cohort": "applications",
+      "validation": [
+        ["bun", "install", "--frozen-lockfile"],
+        ["bun", "run", "type-check"],
+        ["bun", "run", "test:unit"]
+      ],
+      "requiredChecks": ["Validation / Gate"]
+    }
+  ]
+}
+```
+
+Repository names in the example are placeholders. Populate the actual fleet
+before use. Paths are relative to the manifest, may be arbitrarily nested, and
+must not escape through `..`, absolute paths, or symlinks. Missing checkouts and
+origin mismatches remain visible as blocked inventory entries rather than silently
+disappearing. There is no automatic clone or repository-settings mutation.
+
+`profile` is a descriptive inventory annotation; it does not install tools or
+activate a quality profile. `expected` maps scalar `.github/code-foundry.yml` keys
+to desired values; `requiredCapabilities` audits declarations in that same file.
+The runtime-upgrade operation does not silently author missing capability policy.
+Adopt those requirements in consumer repositories before requiring them here.
+
+## Commands
+
+```sh
+code-foundry fleet status --root /path/to/fleet
+code-foundry fleet upgrade --root /path/to/fleet --dry-run
+code-foundry fleet upgrade --root /path/to/fleet --create-pr
+```
+
+Run from the intended released Code Foundry installation/checkout. The existing
+source-version guard still rejects mismatched `--version` requests. Manifest mode
+requires `--create-pr` or `--dry-run` and never syncs original checkouts in place.
+`--force` does not bypass dirty-tree safety in manifest mode. Dry-run reports
+inventory, target version, and configuration drift without network calls, running
+consumer commands, or modifying files. Status likewise audits local facts; it does
+not pretend to verify remote branch protection or environment settings.
+
+The first incomplete cohort is the only cohort allowed to create PRs. All
+non-excepted members of each earlier cohort must have a matching managed upgrade
+PR that is merged, successful explicitly named required checks on its head SHA,
+no still-pending/failed checks, and the target runtime/configuration still present
+on its current base branch. Neutral/skipped required checks do not qualify.
+Unknown, inaccessible, closed-without-merge, stale, or failed evidence does not
+unlock subsequent cohorts. One local validation failure stops remaining work.
+
+Each repository must supply explicit validation argv arrays. Include locked
+installation, application checks, and genuine consumer compatibility tests where
+relevant. No shell splitting is used. Commands run in an isolated detached
+worktree, have bounded execution time, and must not rewrite the candidate source.
+Validation is not a security sandbox: commands run as the invoking user with its
+inherited environment and network access. Treat the manifest and every validation
+command as trusted code; do not use this feature with unreviewed manifests or
+credentials that the checks should not access.
+Only files changed by Code Foundry sync are staged; generated test evidence and
+other untracked files are not swept into the commit. A commit-hook change to the
+validated Git tree is rejected before publishing.
+
+This implementation does not create an automatic scheduler, mark PRs ready,
+merge PRs, lower checks, or bypass review. After reviewing and validating canaries,
+merge their PRs normally and run the fleet command again to advance the cohort.
+A repository already at the target version with no managed PR does not establish
+canary evidence; choose a real upgrade canary rather than treating an empty diff
+as successful rollout validation.
+
+## Resuming and intentional exceptions
+
+The target version and complete repository policy produce a deterministic branch
+and PR marker. Repeated runs return an existing matching open PR instead of
+creating duplicates. If push succeeded but PR creation failed, the next run
+recognizes the managed commit and recorded tree identity, reruns consumer
+validation, and creates the missing **draft** PR without force-pushing. Unknown
+branches or commits with mismatched tree markers are preserved and blocked for
+manual review. Local managed refs preserve committed work after a failed push.
+The marker is an ownership/recovery guard, not a cryptographic signature.
+
+PR creation is draft-first in both manifest and legacy discovery modes. A PR that
+a human has already made ready is not silently converted back or modified.
+
+An entry may include a reviewed time-limited exception:
+
+```json
+{ "exception": { "reason": "Pending consumer compatibility work", "expires": "2026-10-01" } }
+```
+
+Exceptions appear explicitly in inventory/rollout output. Expired/invalid dates
+fail parsing. The command's existing `--exclude` flag is also honored. Excluding
+all canaries never satisfies a canary gate or unlocks later cohorts. Update the
+manifest deliberately when cohort membership or compatibility policy changes.
+
+## Evidence and tests
+
+Upgrade output is schema-versioned JSON with target version, aggregate status,
+per-repository cohort/status, PR link, and local validation command exit statuses.
+Failed command output is not copied into reports, avoiding accidental credentials
+in logs; reproduce the declared command locally for full debugging output. A
+failed rollout returns a nonzero exit status. Pending PRs are not failures and do
+not grant permission to advance a cohort. Worktree cleanup failures preserve the
+isolated path and report it rather than deleting unknown paths.
+
+`node --test test/fleet-manifest.test.mjs` includes actual local Git repositories,
+bare remotes, isolated worktrees, validation failure, orphan-branch recovery,
+clean-original preservation, and canary advancement. Only GitHub responses are
+fixture-backed; no real fleet repositories or remote PRs are modified by tests.
+
+GitHub CLI contracts:
+https://cli.github.com/manual/gh_pr_list
+https://cli.github.com/manual/gh_pr_create

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-foundry",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "description": "A fast, language-aware repository factory for agent-ready workflows, testing, security, and release automation.",
   "homepage": "https://github.com/0xPlayerOne/code-foundry#readme",
   "bugs": {

package/src/cli.mjs

@@ -16,6 +16,8 @@ Usage:
   npx code-foundry init [--target PATH]
   npx code-foundry sync [--target PATH]
   npx code-foundry doctor [--target PATH]
+  npx code-foundry plan [--target PATH] [--tier fast|audit] [--changed] [--base REF] [--json]
+  npx code-foundry check [--target PATH] [--tier fast|audit] [--changed] [--base REF] [--timeout SECONDS] [--json]
   npx code-foundry ci pause|resume|status [--target PATH]
   npx code-foundry release reconcile [--github] [--base BRANCH] [--head BRANCH]
   npx code-foundry release hook --tag TAG --workflow WORKFLOW
@@ -124,6 +126,11 @@ function parseArgs(argv) {
 }
 
 async function main() {
+  if (['plan', 'check'].includes(process.argv[2])) {
+    const { agentCommand } = await import('./commands/agent-check.mjs')
+    process.exitCode = agentCommand(process.argv.slice(2))
+    return
+  }
   const { command, options } = parseArgs(process.argv.slice(2))
   const target = resolve(options.target)