@arbiterforge/ca-pi 0.10.12 → 0.14.6

package/plugins/ca-pi/routines/subagent-driven-development/SKILL.md

@@ -6,6 +6,19 @@ disable-model-invocation: true
 
 # subagent-driven-development
 
+## Structured-artifact format boundary
+
+New full-lane workflows default to HTML through the installed engine. Existing
+HTML pairs use the same path. Load
+`<plugin-root>/includes/artifacts.md` before HTML artifact I/O;
+its typed identity, binding, receipt, contextual-read, and scope-state rules
+replace rendered-document parsing and direct status-cell edits. Existing
+authoritative Markdown pairs stay on their exact legacy path without conversion.
+A missing, invalid, or unqualified HTML capability must fail closed rather than
+fall back to new Markdown authority. HTML `--farm` dispatch remains disabled.
+Keep every other workflow gate, including human checkpoints, unchanged.
+
+
 One task, one fresh subagent, two reviews, proof on a fresh run. Routed to by `/sprint` (full plan,
 autonomous) and by `executing-plans` (one batch at a time, with human checkpoints between batches).
 The loop processes tasks in dependency order and never trusts a self-report.
@@ -15,8 +28,15 @@ The loop processes tasks in dependency order and never trusts a self-report.
 Read these, or STOP and surface the gap — never guess scope, command, or obligation:
 
 - `<project-root>/.codearbiter/CONTEXT.md` — the `stage:` frontmatter (the maturity value) and project context.
-- `<project-root>/.codearbiter/plans/<slug>.md` — the approved plan. Each task carries an exact path set and a verification command. This is the task source.
-- `<project-root>/.codearbiter/specs/<slug>.md` — the approved spec. Each task's obligation traces to it. The spec-compliance review measures against it.
+- The discovered authoritative spec/plan pair. Existing Markdown pairs retain
+  their current ledger. For HTML, load `<plugin-root>/includes/artifacts.md`,
+  retain the exact artifact identities and engine-written receipts, and read
+  the approved spec binding, obligations, paths, verification definitions,
+  dependencies, and state only through `identity`, `index`, `outline`,
+  symbol-scoped `read`, and `eligible`. The engine `eligible` response is authoritative;
+  the workflow must not infer authority from rendered text, checkboxes, status
+  words, digests, or caller-supplied labels, and must not read or write a shadow
+  Markdown ledger.
 - `<project-root>/.codearbiter/tech-stack.md` — build, test, and verification invocations; file layout; the scope-to-author mapping.
 - `<project-root>/.codearbiter/security-controls.md` — only when a task touches a security boundary (auth, crypto, secrets, a trust boundary).
 
@@ -30,6 +50,18 @@ Pull the next unblocked task from the plan in dependency order. When a `scope` w
 selection to tasks in that list. A task is one verifiable unit of work with a path set, a spec
 obligation, and a verification command.
 
+For HTML, select only a task returned as eligible for the exact selected plan
+identity. Follow contextual `read` pages to completion, retain their context
+ticket, and use `task-start` before author dispatch. Do not translate a displayed
+status or a copied task label into a transition.
+
+After process recreation, rediscover the same authoritative pair and query
+`identity` and `eligible` again. Reconcile an interrupted `IN_PROGRESS` task only
+through an authority-backed `task-reconcile`, then redispatch with `task-start`
+and a fresh complete context ticket. A task in `REVIEW` is not accepted on
+resume; obtain fresh evidence when required and finish the current combined
+scope review before `accept-scope`.
+
 - Confirm every dependency task is `ACCEPTED` before selecting.
 - Confirm no unresolved `[CONFIRM-NN]` blocks the task. One that does halts the loop — see Hard rules.
 
@@ -74,6 +106,11 @@ traces to — not against whether tests merely pass.
 - Out-of-scope work the subagent noticed is recorded with an inline `[NEEDS-TRIAGE]` marker — never
   acted on inside this task.
 
+For HTML, capture the actual spec-review event against the exact task and
+artifact identities. After the governed verification runner has produced its
+separate receipt, use `task-review` with those two engine-written receipts. A
+digest or the reviewer/subagent's label is not evidence by itself.
+
 Gate: the obligation is fully satisfied and scope is clean. A shortfall returns the task to Phase 2
 with a corrective brief.
 
@@ -116,13 +153,13 @@ Gate: the verification command exits clean and its output demonstrates the oblig
 
 ## Phase 6 — Accept and advance · gate: BLOCK
 
-Mark the task `ACCEPTED` only when its spec-compliance review and fresh verification passed AND the
-scope's Phase 4 quality review passed.
-Record acceptance **in the plan file itself** — set the task's `status` cell in
-`.codearbiter/plans/<slug>.md` to `ACCEPTED` the moment it is accepted, plus any `[NEEDS-TRIAGE]`
-markers and the `.codearbiter/` audit trail. The plan's status column is the pipeline's resume
-ledger: an interrupted run is re-entered at the first non-`ACCEPTED` task, and an acceptance that
-lives only in conversation context is lost to the interruption.
+Mark a task accepted only when its spec-compliance review and fresh verification
+passed AND the scope's Phase 4 quality review passed. For Markdown, record the
+existing status-cell transition in the plan. For HTML, capture the actual
+combined quality-review event and call `accept-scope` once for the whole scope;
+the resulting engine state and acceptance receipts are the resume ledger. Never
+edit an HTML status cell or create a Markdown counterpart. In either format, an
+acceptance that lives only in conversation context is lost to interruption.
 
 - Tasks remain in the current scope → return to Phase 1.
 - **Scoped invocation** (`scope` was passed by `executing-plans`): all scoped tasks `ACCEPTED` → signal
@@ -130,6 +167,13 @@ lives only in conversation context is lost to the interruption.
 - **Full-plan invocation** (no `scope`, i.e. `/sprint`): plan complete → hand the branch to
   `commit-gate`, then to the caller's finishing step. The loop does not commit on its own authority.
 
+When either path claims the entire HTML plan is currently accepted, invoke the
+installed bridge's `_preflight_current_acceptance` with the exact
+`_resolve_workflow_pair` result, repository-bound client, and engine-returned
+spec/plan IDs. Do not pass or derive authority from a caller label, digest,
+status, or receipt. A refusal means the plan is not complete; return to the
+appropriate execution/reconciliation phase instead of handing off.
+
 Gate: every task in the current scope `ACCEPTED`, the suite green, ready for the caller's next step.
 
 ## Hard rules

package/plugins/ca-pi/routines/subagent-driven-development/references/farm-dispatch.md

@@ -9,6 +9,11 @@ designed for — roadmap, not built). It does **not** replace review: every task
 still routed through Phases 3, 4, and 5 before acceptance. Swapping the worker only changes who *writes*
 the code, never whether it is *reviewed*. See `<plugin-root>/includes/farm.md` for setup.
 
+**Current rollout gate:** HTML-backed farm use is disabled. Do not launch it in ordinary feature or
+sprint work until the fresh frontier/low-tier qualification matrix, native payload packaging and real
+authority integration are complete. The checks below define the real qualification boundary; the June
+2026 run has zero promotion credit. Legacy farm plans with no sibling HTML retain their existing path.
+
 ## Step 1 — Model selection
 
 If `FARM_MODEL` env var is set, use it directly and skip selection. Otherwise, prefer a **measured**
@@ -24,7 +29,9 @@ choice over web hearsay:
    and call `codearbiter_farm_preview` with the project-relative plan plus
    `canary: true`. It runs the plan's
    smallest task against each candidate and writes `.farm/canary-report.json` ranked by measured
-   pass-rate / attempts / latency. Pick the top passing model.
+   pass-rate / attempts / latency. For an HTML projection, the shared backend first invokes the pinned
+   artifact engine's `farm-verify` canary phase. A missing/stale source binding blocks before worktree,
+   report or network activity. Pick the top passing model.
 4. Surface the choice with its measured basis: "Selected `<model-id>` — canary passed in `<n>` attempts,
    `<ms>`ms (vs. `<alternatives>`). Proceed, or set `FARM_MODEL` to override." For any opaque codename,
    add one line of websearched identity context (e.g. "community reports GLM4-based") for the audit log.
@@ -32,8 +39,12 @@ choice over web hearsay:
    websearch-selected model with a clear warning that the choice is unmeasured; (c) only if all fail,
    BLOCK and ask the user to set `FARM_MODEL`. Halting the whole feature on a noisy websearch is wrong —
    exhaust the ladder first.
-6. Write the chosen `meta.model` + `meta.apiBaseUrl` into `plan.json`, and update `.farm/model-cache.json`
-   (model + timestamp + canary pass-rate) before dispatching.
+6. Write only the chosen `meta.model` + `meta.apiBaseUrl` into `plan.json`. For an HTML projection,
+   immediately call the artifact protocol's `farm-seal` operation with the exact effective model,
+   API base URL, bounded selection source and caller-stated origin. These are auditable assertions,
+   not independently authenticated provenance. It rejects any other base-projection
+   change and seals the exact full execution bytes plus provider identity. Then update
+   `.farm/model-cache.json` (model + timestamp + canary pass-rate) before dispatching.
 
 ## Step 2 — Farm dispatch
 
@@ -58,6 +69,12 @@ enforces gates and a zero-token anti-gaming guard, and writes to `<project-root>
   each task settles (drives completion-order consumption — see Step 2.6)
 - `diffs/<task-id>.patch` — the actual change per task, for audit
 
+The built shared dispatcher resolves `ca-artifact` only from its manifest-verified sibling payload.
+It never consults PATH or repository configuration. Immediately before ordinary HTML dispatch it
+invokes `farm-verify` with the effective model and API base URL; missing or mismatched full-byte seals
+fail before creating `.farm/`, worktrees, branches, or network requests. Pi preview uses this same built
+backend and therefore the same guard. Do not bypass it with a source-tree or host-local dispatcher.
+
 Each of those is published twice: once under the run's own artifact directory
 `<project-root>/.farm/runs/<run-id>/` (the durable, attributable receipt — concurrent runs never
 overwrite each other's artifacts) and once at the top-level `.farm/` path above as a **latest**

package/plugins/ca-pi/routines/tdd/SKILL.md

@@ -6,6 +6,18 @@ disable-model-invocation: true
 
 # tdd
 
+## Authoritative format boundary
+
+For an HTML spec/plan pair, load `<plugin-root>/includes/artifacts.md` and use
+the installed structured-artifact engine for artifact I/O. Verify the plan's
+binding to the approved spec, use typed `index`, `outline`, and symbol-scoped `read`,
+and follow contextual pages for the selected task. The workflow must not parse rendered HTML
+for criteria, status, evidence, or authority. Missing or
+invalid HTML capability is a STOP, not a fallback to Markdown. Existing
+authoritative Markdown pairs continue through the legacy path. HTML `--farm`
+dispatch remains blocked.
+
+
 Test-first, or it does not ship. Routed to by `/feature` (after spec approval), `/fix`, and `/refactor`.
 
 ## Pre-flight
@@ -14,8 +26,13 @@ Read these, or STOP and surface the gap — never guess a command or a threshold
 
 - `<project-root>/.codearbiter/CONTEXT.md` — the `stage:` frontmatter (the maturity value) and project context.
 - `<project-root>/.codearbiter/tech-stack.md` — test, coverage, and lint invocations; file layout; mock patterns.
+- `<plugin-root>/includes/verification-boundary.md` — the required split between focused local proof and exhaustive exact-head hosted CI.
 - `<project-root>/.codearbiter/coding-standards.md` — style, structure, naming. Required for Phase 3.
-- `<project-root>/.codearbiter/specs/<slug>.md` — the approved spec, when `/feature` produced one. It is the primary obligation source.
+- The authoritative approved spec selected by `/feature`. For HTML, read its
+  typed criterion records through the installed engine and confirm the paired
+  plan's exact binding; for legacy Markdown, read
+  `<project-root>/.codearbiter/specs/<slug>.md`. It is the primary obligation
+  source.
 - `<project-root>/.codearbiter/security-controls.md` — only when the change touches a security boundary (auth, crypto, secrets, a trust boundary). Optional; absent on most changes.
 - `<project-root>/.codearbiter/code-map.md` — if present, a coarse concern→path→role map to orient before writing tests and code. Absent is fine — it is read-on-demand, populated by context-creation or commit-gate heal.
 
@@ -27,7 +44,10 @@ test is `MISSING`. "We should test X" is not an obligation.
 
 Derive every obligation before any code is written, and record each as `ID · source · OPEN`:
 
-- **Spec** — one obligation per acceptance criterion in the approved spec.
+- **Spec** — one obligation per acceptance criterion in the approved spec. For
+  HTML, cite the exact artifact ID and criterion ID returned by the engine;
+  caller-supplied labels cannot manufacture obligations or widen the approved
+  criterion set.
 - **Contract** — API and input-validation invariants, error responses, boundary conditions.
 - **Security** — only when `security-controls.md` applies: the assertion that the security-relevant boundary holds.
 
@@ -66,10 +86,12 @@ obligation `MAPPED` to a failing test. No implementation code is written until t
 ## Phase 3 — Green · gate: BLOCK
 
 Write the **minimum** implementation that satisfies the Phase 2 tests — no speculative logic, no
-gold-plating — to the conventions in `coding-standards.md`. Run the full suite. A broken pre-existing
-test is a regression: fix it.
+gold-plating — to the conventions in `coding-standards.md`. Run the impact-bounded local tests from
+`verification-boundary.md`: the new regression plus affected pre-existing contracts. A broken
+pre-existing test is a regression: fix it. Exhaustive and cross-platform suites run on exact-head
+hosted CI before merge.
 
-Gate: full suite green, reached by satisfying the Phase 2 tests — not by weakening them. A test's
+Gate: the applicable local suite is green, reached by satisfying the Phase 2 tests — not by weakening them. A test's
 assertions MUST be unchanged between red and green; only fixtures and setup may move. A relaxed
 assertion is a gate violation.
 

package/plugins/ca-pi/routines/using-git-worktrees/SKILL.md

@@ -21,8 +21,17 @@ that terminal step into one PR per unit.
 Read these, or STOP and surface the gap — never guess:
 
 - `<project-root>/.codearbiter/CONTEXT.md` — confirm the repo is a git repo and the base/working branch.
-
-Confirm the caller passed an explicit isolation opt-in AND the parallel unit list (from `plans/<slug>.md`). Absent either, do not stand up worktrees.
+- The discovered authoritative spec/plan pair for the caller's pipeline. Use its
+  exact selected plan for the parallel unit list. Re-run the private bridge resolver
+  `_resolve_workflow_pair` with the trusted project root and pipeline slug rather
+  than reconstructing either path. For an HTML pair, load
+  `<plugin-root>/includes/artifacts.md` and obtain
+  HTML task and path records only through the installed engine `identity`, `index`, and symbol-scoped `read`
+  operations. For a Markdown pair, use its existing Markdown task table. Worktree
+  planning must not create, convert, or consult a counterpart.
+
+Confirm the caller passed an explicit isolation opt-in AND the parallel unit list
+from the exact selected plan. Absent either, do not stand up worktrees.
 
 ## Phase 1 — Provision · gate: BLOCK
 

package/plugins/ca-pi/routines/writing-plans/SKILL.md

@@ -1,18 +1,32 @@
 ---
 name: writing-plans
-description: The spec-to-plan bridge. Routed to by /feature once the brainstormed spec is approved, and by /sprint before execution. Decomposes the spec into 2–5 minute tasks, each carrying its exact file path(s) and a concrete verification step that maps to a tdd obligation. Writes the plan to .codearbiter/plans/<slug>.md, ordered with dependencies flagged and an MVP slice identifiable. Nothing executes until every task has a path and a verification and the task set covers every acceptance criterion.
+description: The spec-to-plan bridge. Routed to by /feature once the brainstormed spec is approved, and by /sprint before execution. Decomposes the spec into 2–5 minute tasks, each carrying its exact file path(s) and a concrete verification step that maps to a tdd obligation. Writes the plan in the approved spec's authoritative format, ordered with dependencies flagged and an MVP slice identifiable. Nothing executes until every task has a path and a verification and the task set covers every acceptance criterion.
 disable-model-invocation: true
 ---
 
 # writing-plans
 
+## Authoritative format boundary
+
+For a new full-lane HTML spec, load `<plugin-root>/includes/artifacts.md` and
+use the installed structured-artifact engine for every spec and plan read or
+write. The resulting pair is `.codearbiter/specs/<slug>.html` and
+`.codearbiter/plans/<slug>.html`. Missing or invalid HTML capability is a STOP
+before writing and must not fall back to Markdown. An existing authoritative
+Markdown spec continues through the legacy Markdown path without conversion.
+HTML `--farm` dispatch remains blocked.
+
+
 Turn an approved spec into an executable plan. Routed to by `/feature` (after spec approval) and `/sprint`.
 
 ## Pre-flight
 
 Read these, or STOP and surface the gap — never plan against an unapproved or missing spec:
 
-- `<project-root>/.codearbiter/specs/<slug>.md` — the approved brainstorming spec. The single source of acceptance criteria. Absent or unapproved → STOP and route back to `/feature`.
+- The authoritative approved spec selected by `/feature`: for HTML, resolve it
+  through the installed engine and verify its ready approval and exact identity;
+  for legacy Markdown, read `<project-root>/.codearbiter/specs/<slug>.md`.
+  Absent or unapproved → STOP and route back to `/feature`.
 - `<project-root>/.codearbiter/CONTEXT.md` — the `stage:` frontmatter (the maturity value) and project context.
 - `<project-root>/.codearbiter/tech-stack.md` — file layout, build/test/lint invocations. A verification step cites a real command from here, never a guess.
 - `<project-root>/.codearbiter/coding-standards.md` — structure and naming, so a task names the right path.
@@ -21,8 +35,10 @@ Read these, or STOP and surface the gap — never plan against an unapproved or
 
 ## Phase 1 — Criterion extraction · gate: BLOCK
 
-Lift every acceptance criterion from the spec verbatim and assign each a stable ID (`AC-01`,
-`AC-02`, …). This list is the coverage ledger for the whole plan — Phase 4 checks the task set
+Lift every acceptance criterion from the spec and retain its stable ID (`AC-01`,
+`AC-02`, …). For HTML, obtain criterion records through typed engine reads and
+retain their typed IDs; rendered document text is not an authority source. This
+list is the coverage ledger for the whole plan — Phase 4 checks the task set
 against it.
 
 A criterion the spec leaves ambiguous is a `[CONFIRM-NN]` against
@@ -31,7 +47,8 @@ A criterion the spec leaves ambiguous is a `[CONFIRM-NN]` against
 **Backstop the ledger against the spec's own stated intent, mechanically, before trusting it — this
 runs even when `brainstorming` already ran the same check, because a hole that survived Phase 3
 survives Phase 4's bijection too, silently** (#566): run `"$PY" "<plugin-root>/hooks/_intentlib.py"
-uncovered-intent <project-root>/.codearbiter/specs/<slug>.md [--issue-body <scratch-file>]` —
+uncovered-intent <spec-path> [--issue-body <scratch-file>]`, where `<spec-path>`
+is the authoritative `.html` or legacy `.md` spec selected above —
 `<scratch-file>` holds the linked issue's body when one exists (`gh issue view <N> --json body -q
 .body > <scratch-file>`, written outside the working tree), omitted when none does. A non-empty
 result names an in-scope bullet or an acceptance checkbox the criteria never cited — BLOCK and route
@@ -89,10 +106,20 @@ that completeness gap is caught earlier, by Phase 1's `uncovered_intent` backsto
 - Every `AC-NN` is covered by at least one task's `covers`. An uncovered criterion blocks — author the missing task.
 - Every task advances at least one `AC-NN`. A task that covers nothing is scope creep — cut it or surface it.
 
-Then write the plan to `<project-root>/.codearbiter/plans/<slug>.md` — `<slug>` matching the
-spec — with the `AC-NN` ledger, the ordered task table (id · path(s) · verification · maps-to ·
-covers · depends-on · **status**, initialized `PENDING`), the marked MVP slice, and any out-of-scope
-item tagged inline `[NEEDS-TRIAGE]`.
+For an HTML source, pass the selected route, installed client, and the spec
+identity just read from the engine through `_preflight_plan_authoring`. Only its
+returned same-slug `.codearbiter/plans/<slug>.html` target may be created. Create
+that plan through the installed structured-artifact engine as `draft_preview`,
+using the approved spec's exact artifact ID and normative digest. Populate it only with typed operations,
+validate it at the ready gate, then use `plan-bind` to bind it to that approved
+spec before plan approval. This path must not create `.codearbiter/plans/<slug>.md`;
+that would be a shadow authority.
+
+For an existing authoritative Markdown source, write
+`<project-root>/.codearbiter/plans/<slug>.md` — `<slug>` matching the spec —
+with the `AC-NN` ledger, the ordered task table (id · path(s) · verification ·
+maps-to · covers · depends-on · **status**, initialized `PENDING`), the marked
+MVP slice, and any out-of-scope item tagged inline `[NEEDS-TRIAGE]`.
 
 The status column is the pipeline's resume ledger: `subagent-driven-development` flips a task to
 `ACCEPTED` the moment it accepts it, so an interrupted run (crash, compaction, closed session) is
@@ -106,7 +133,7 @@ completeness of the ledger itself was Phase 1's gate, not this one. This clears
 
 ### Phase 4-farm extension (only when `--farm` was requested)
 
-When `--farm` was requested, after the bijective coverage gate passes and the `.md` plan is written,
+When `--farm` was requested for a legacy Markdown workflow, after the bijective coverage gate passes and the `.md` plan is written,
 produce the farm artifact (`plan.json`) — **one MVP slice at a time** — per
 `<plugin-root>/routines/writing-plans/references/farm-plan.md`. Load that leaf and follow it;
 it owns the per-task failing-test + schema-valid `plan.json` procedure.
@@ -117,6 +144,8 @@ artifacts exist before handing off to `subagent-driven-development` (`<plugin-ro
 ## Hard rules
 
 - MUST NOT plan against an absent or unapproved spec — STOP and route back to `/feature`.
+- MUST NOT write or parse rendered HTML directly, create a Markdown shadow for
+  an HTML spec, or bind a plan from a caller-supplied identity.
 - MUST NOT emit a task without an exact path AND a concrete verification step.
 - MUST NOT let a task's verification stand in for a `tdd` gate — it maps to a tdd obligation, it does not replace one.
 - MUST NOT write the plan while any acceptance criterion is uncovered or any task covers nothing.

package/plugins/ca-pi/routines/writing-plans/references/farm-plan.md

@@ -3,7 +3,16 @@
 Loaded by `writing-plans` Phase 4 only when `--farm` was requested. The base plan (Phases 1–4) is
 unchanged; this leaf adds the machine artifact the farm dispatcher needs.
 
-After the bijective coverage gate passes and the `.md` plan is written, produce the farm artifact —
+Apply the shared `<plugin-root>/includes/verification-boundary.md`: the slice's narrow RED test and
+affected contracts run locally, while exhaustive repository/cross-platform proof remains an
+exact-head hosted-CI requirement.
+
+**Rollout gate:** HTML-backed farm use remains disabled until the repository's fresh model-era
+qualification matrix, native payload packaging, and real authority adapters are complete. The
+projection contract below is implemented so qualification can exercise the real boundary; it is not
+permission to use HTML farm dispatch in ordinary work.
+
+After the bijective coverage gate passes and the canonical plan is written, produce the farm artifact —
 **one MVP slice at a time, not the whole plan up front.** Front-loading every failing test for the
 entire plan would be the waterfall this skill otherwise rejects (Phase 3), and it maximizes the cost
 of a mid-flight spec change. So the farm artifact is scoped to the **current slice** (the MVP slice on
@@ -16,26 +25,32 @@ dependency order:
    non-zero). A test that passes before implementation means the obligation is wrong — STOP and revisit
    Phase 2.
 
-Then write `<project-root>/.codearbiter/plans/<slug>.plan.json` (the current slice's tasks only)
-conforming to `<plugin-root>/tools/plan.schema.json`:
+For a legacy Markdown plan, retain the existing schema-driven path below unchanged. For an HTML plan,
+do **not** hand-write the projection. Construct the minimal candidate in memory and submit it through
+the on-demand artifact protocol's `farm-project` operation. That operation atomically writes
+`<project-root>/.codearbiter/plans/<slug>.plan.json` and an immutable content-addressed base binding
+only after the approved source pair, current input snapshot, selected scope/slice, deterministic ID
+mapping, projection bytes, and fresh RED result for every task all agree.
+
+The HTML projection is the current slice's tasks only and is a strict subset of the unchanged farm
+runtime schema:
 
 - `meta.name` ← slug
-- `meta.repo` ← project name from CONTEXT.md
 - `meta.model` and `meta.apiBaseUrl` — **leave unset**. These are written by
   `subagent-driven-development`'s model research step at dispatch time. Writing them here would bake in
   a potentially stale selection.
 - Per task: `id` ← T-NN (normalized to kebab-case), `description` ← task description,
   `filesInScope` ← path(s) from the task table, `test.path` ← the failing test written above,
-  `gate.commands` ← verification command from task table plus full-suite and lint/typecheck from
-  `tech-stack.md`, `deps` ← dependency ids (empty array if none), `context` ← a minimal slice of
-  relevant types/interfaces (omit if the test file plus task description is self-contained),
-  `maxRetries` ← omit to use the farm default.
+  `gate.commands` ← the canonical task verification argv joined without shell reinterpretation;
+  `deps` ← dependency ids inside the selected slice (empty array if none). Do not add `repo`,
+  `context`, setup, retry, or task-model fields to an HTML projection. A canonical argv token that
+  cannot be represented without shell quoting makes the slice unsupported and BLOCKS projection.
 - **`gate.commands[0]` MUST be the task's narrow behavioral test** (the command that runs just
-  `test.path`), with the full suite and lint/typecheck following. The farm's mutation guard re-runs
-  `gate.commands[0]` per mutant; if the first command were the full suite, mutation testing would be
+  `test.path`), with affected contract tests and lint/typecheck following. The farm's mutation guard re-runs
+  `gate.commands[0]` per mutant; if the first command were an exhaustive suite, mutation testing would be
   prohibitively slow.
 
-Validate the JSON against the schema before writing (load the schema from
+For the legacy path, validate the JSON against the schema before writing (load the schema from
 `<plugin-root>/tools/plan.schema.json` and check). A schema-invalid plan BLOCKS.
 
 `plan.schema.json` is the **authoring** contract. The dispatcher enforces its own **runtime** contract
@@ -46,5 +61,11 @@ satisfies the schema is accepted at runtime — with one deliberate exception, t
 pattern, which is stricter here than the runtime path-safety rule. Both objects are closed: an
 undeclared property is an error, not an ignored extra.
 
-Gate: all failing tests written and confirmed failing; `plan.json` written and schema-valid. Both
-artifacts exist before handing off to `subagent-driven-development`.
+For the HTML path, the existing user/SMARTS workflow must capture a `farm_authorization` receipt whose
+payload binds the current spec/plan/input hashes, scope, base projection hash, and each task's source
+ID, farm ID, test path, verification-definition hash, command, failing exit, stdout hash and stderr
+hash. A digest is correspondence, not approval authentication. Call `farm-project` with that receipt;
+do not create a binding file directly.
+
+Gate: all failing tests written and freshly observed failing; the legacy JSON is schema-valid or the
+HTML projection and immutable binding were committed together. Both artifacts exist before handoff.

package/plugins/ca-pi/skills/ca-chore/SKILL.md

@@ -26,12 +26,15 @@ the gates that fit it — and nothing it doesn't need. Everything still exits th
 **deps** — bump an existing dependency's version (manifest + lockfile together, never one without
 the other).
 - Gates: dispatch `dependency-reviewer` (same vetting as `/ca-add-dep` — license, provenance,
-  supply chain, changelog of the bump); full test suite green after the bump; `commit-gate`.
+  supply chain, changelog of the bump); affected local tests green under
+  `<plugin-root>/includes/verification-boundary.md`; exhaustive exact-head hosted CI before merge;
+  `commit-gate`.
 - A bump that requires code changes to adopt is not a chore — route the code change through
   `/ca-feature` or `/ca-fix`.
 
 **revert** — back out a named commit.
-- Gates: `git revert <SHA>` (never hand-edited backout); full suite green after the revert; the
+- Gates: `git revert <SHA>` (never hand-edited backout); affected local tests green under the shared
+  `verification-boundary`, exhaustive exact-head hosted CI before merge; the
   commit message references the reverted SHA and the reason; `commit-gate`.
 - No new regression test demanded — the revert restores already-tested behavior. If the revert is
   fixing a defect the suite missed, open `/ca-fix` afterward to pin it.
@@ -48,7 +51,8 @@ the other).
 
 MUST reject a change containing behavioral code (beyond the revert itself) — that is `/ca-feature`
 or `/ca-fix` territory. MUST keep manifest and lockfile changes in the same commit for `deps`.
-MUST run the full suite for `deps` and `revert`. MUST run the anti-slop copy pass on any user-facing
+MUST run impact-bounded local verification for `deps` and `revert` and require exhaustive exact-head
+hosted CI before merge. MUST run the anti-slop copy pass on any user-facing
 doc a `docs` change authors or edits. Never skips `commit-gate`.
 
 ## When NOT to use

package/plugins/ca-pi/skills/ca-commit/SKILL.md

@@ -23,5 +23,6 @@ is canonical for its phases, gates, and output format.
 
 ## Hard gate
 
-MUST NOT commit without `commit-gate` clearing. MUST NOT commit if the project test suite is not
-green.
+MUST NOT commit without `commit-gate` clearing. The applicable impact-bounded local tests from
+`<plugin-root>/includes/verification-boundary.md` must be green; exhaustive repository and
+cross-platform suites are exact-head hosted-CI merge gates, not local commit prerequisites.

package/plugins/ca-pi/skills/ca-doctor/SKILL.md

@@ -12,6 +12,17 @@ remediation.
 
 ## Flow
 
+
+The mechanical report also invokes the installation-pinned artifact client's `capabilities`
+operation. When the repository contains an HTML authority, it performs a bounded catalog read to
+surface invalid or ambiguous artifacts. It MUST NOT load the artifact schema, search `PATH`, use a
+repository binary, mutate an artifact, or silently fall back to Markdown.
+
+- `CAPABILITY_MISSING` or another installation identity failure is unhealthy: report “repair or
+  reinstall the pinned artifact payload; HTML work is blocked.” Unrelated legacy Markdown remains
+  usable.
+- An invalid HTML artifact is unhealthy: preserve the bounded engine code and direct the user to
+  inspect `repair-preview` before any explicit reviewed repair.
 1. The `/ca-doctor` alias has already run the extension's structured Pi doctor report before sending
    this generated skill. Present the `<codearbiter-doctor-report>` block below verbatim.
 2. The report inspects, without granting trust: active Git package origin/version, exact Pi CLI and
@@ -24,6 +35,9 @@ remediation.
 4. Its `active-dispatch` row remains degraded because supported Pi 0.84.1 public extension
    APIs cannot submit that deterministic call through the active dispatcher. PI-AC-28 remains blocked
    until supported-version real-host promotion/CI evidence closes the gap.
+5. Resolve Python once, run `<plugin-root>/hooks/doctor.py`, and present its mechanical report
+   verbatim. This is the on-demand artifact-capability and repository-artifact check; it is separate
+   from the wrapper self-test and must not be respelled into an active-dispatch claim.
 
 ## Remediation ladder
 

package/plugins/ca-pi/skills/ca-feature/SKILL.md

@@ -8,14 +8,45 @@ argument-hint: "<what you want to build>"
 
 The single permitted entry to implementation work. No feature code is written before a spec is approved and `tdd` Phase 1 clears. A one-line idea is not a spec — `brainstorming` makes it one.
 
+## Structured-artifact boundary
+
+For new full-lane work or an existing `.html` spec/plan match, load
+`<plugin-root>/includes/artifacts.md` before resume classification or artifact
+I/O. After lane classification, call
+`_select_authoring_route` with the trusted project root, slug, `workflow: feature`,
+and the selected lane. Use only its returned mode, format, and paths. For a
+selected HTML route it
+checks the installed capability before writing; a missing or invalid helper is
+a STOP and the workflow must not fall back to Markdown.
+Its validated identity, authority, binding and task-state operations replace this
+command's `.md`, approval-label and status-cell assumptions for that pipeline.
+New full-lane specs use the installed structured-artifact engine and default to
+canonical `.html`. An existing `.md` pair remains on the legacy path. Discovery requires a
+complete same-extension spec/plan pair: select that exact pair as authoritative. A
+mixed-extension or duplicate match is a STOP. A lone spec resumes in its exact format,
+and the next plan must use the same extension. The workflow must not create, rename, or convert its counterpart to repair ambiguity. HTML `--farm` dispatch stays
+blocked. Small-lane behavior is unchanged: its confirmed mini-spec remains inline
+and does not create a spec artifact.
+
 **Orientation:** if `.codearbiter/code-map.md` is present, read it first — a coarse concern→path→role map that orients task authoring. Absent is fine; it is read-on-demand, populated by context-creation or commit-gate heal.
 
 ## Resume — an interrupted pipeline is re-entered, never restarted
 
-Before triage, scan `<project-root>/.codearbiter/specs/` and `plans/` for an existing slug
-matching `$ARGUMENTS` (invoked bare, list every resumable pipeline and ask which). A crash,
-compaction, or closed session mid-pipeline loses nothing — the spec, the plan, and each task's
-`status` cell are on disk. On a match, confirm the resume with the user in one line
+Before triage, scan `<project-root>/.codearbiter/specs/` and `plans/` for artifacts
+whose slug matches `$ARGUMENTS` (invoked bare, list every resumable pipeline and
+ask which). Call the private bridge resolver `_resolve_workflow_pair` with the
+trusted project root and selected slug; its returned paths and format own this
+resume. Select a complete same-extension pair as authoritative. A lone spec
+resumes in its exact format, and the next plan must use the same extension. A
+mixed-extension or duplicate match is a STOP. A crash, compaction,
+or closed session mid-pipeline loses nothing — the spec, the plan, and each task's
+state are on disk. For an HTML pair, obtain state only through the installed
+engine `identity`, `index`, and symbol-scoped `read` operations; do not scrape
+rendered labels or embedded JSON. For a Markdown pair, use the
+existing Markdown status ledger. Resume either exact format
+without creating or consulting a shadow artifact; the workflow must not create,
+rename, or convert its counterpart. On a match,
+confirm the resume with the user in one line
 ("resume `<slug>` at <point>?") and re-enter at the furthest checkpoint reached:
 
 1. **Plan exists with non-`ACCEPTED` tasks** → `executing-plans` (its Phase 1 batches only the
@@ -62,12 +93,14 @@ Route through the pipeline in order; each step gates the next:
 
 1. **`brainstorming`** (`<plugin-root>/routines/brainstorming/SKILL.md`) — refine `$ARGUMENTS` into a concrete spec by Socratic questioning: challenge
    vague language, surface hidden complexity, force trade-offs. Writes the spec to
-   `<project-root>/.codearbiter/specs/<slug>.md`. **Hard gate: no plan and no code until the
+   route-selected spec path. New full-lane work writes
+   `<project-root>/.codearbiter/specs/<slug>.html` through the installed engine.
+   **Hard gate: no plan and no code until the
    user approves the spec.** Genuinely-unresolved unknowns become `[CONFIRM-NN]` in
    `open-questions.md`, never guesses.
 2. **`writing-plans`** (`<plugin-root>/routines/writing-plans/SKILL.md`) — decompose the approved spec into small tasks, each with an exact path and a
    verification that maps to a `tdd` obligation (it does not replace one). Writes
-   `<project-root>/.codearbiter/plans/<slug>.md` with bijective criterion↔task coverage.
+   matching route-selected plan path with bijective criterion↔task coverage.
 3. **`executing-plans`** (`<plugin-root>/routines/executing-plans/SKILL.md`) — coordinates the plan in small batches with human checkpoints. Each batch is
    delegated to `subagent-driven-development` (`<plugin-root>/routines/subagent-driven-development/SKILL.md` — fresh author agent per task, spec-compliance review,
    quality review, fresh verification). The user acknowledges between batches; nothing advances until
@@ -84,8 +117,9 @@ not `/feature`.
 
 Scope determines which author agent `subagent-driven-development` dispatches per task:
 `backend-author`, `frontend-author`, or `infra-author` — per the mapping in `tech-stack.md`. A
-multi-area feature runs the appropriate agent per task; the full suite must be green before
-transitioning between scope areas.
+multi-area feature runs the appropriate agent per task. Each transition requires the affected local
+tests from `<plugin-root>/includes/verification-boundary.md` to be green; exhaustive cross-area and
+cross-platform proof runs in exact-head hosted CI before merge.
 
 ## When NOT to use
 

package/plugins/ca-pi/skills/ca-refactor/SKILL.md

@@ -19,8 +19,10 @@ Routes to the `refactor` skill — six phases:
    Phase 1 to write failing tests pinning the seam's contract first.
 4. **Implementation** — apply the restructure mechanically within the surface table; no new behavior,
    branches, error paths, or side effects.
-5. **Parity verification** — the full pre-existing suite passes with zero edits to any pre-existing
-   test file.
+5. **Parity verification** — every impact-bounded local parity test identified for the surface passes
+   with zero edits to any pre-existing test file; the shared
+   `<plugin-root>/includes/verification-boundary.md` reserves the exhaustive suite for exact-head
+   hosted CI before merge.
 6. **Lint / coverage gate** — lint, type-check, and coverage clear; surface coverage MUST NOT regress.
 
 ## Routes to