@arbiterforge/ca-pi 0.14.10 → 0.14.16

package/plugins/ca-pi/hooks/releasehash.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 # codeArbiter — executable release-command confirmation (A-2.10).
 #
-# A row's `pre-tag` commands and optional `release-build` are operator-authored
-# shell that `/ca:release` EXECUTES before composing a tag.
+# A row's `pre-tag`, `release-build`, `rebuild`, and `generate` commands are
+# operator-authored shell that `/ca:release` may execute before publication.
 # `.codearbiter/release-targets.md` is
 # marker-gated under H-22, so changing those commands already costs a fresh
 # authoring marker — but that gate is about WRITING the file. Nothing made the
@@ -31,11 +31,13 @@
 # file.
 #
 # Public API:
-#   pre_tag_digest(commands, release_build=None) -> str
+#   pre_tag_digest(commands, release_build=None, rebuild=None, generate=None)
+#       -> str
 #   confirmation_path(root, target) -> str
 #   read_confirmation(root, target) -> str | None
 #   record_confirmation(root, target, digest) -> str
-#   confirmation_state(root, target, commands, release_build=None) -> str
+#   confirmation_state(root, target, commands, release_build=None,
+#                      rebuild=None, generate=None) -> str
 #   main(argv) -> int
 #
 # CLI:
@@ -78,7 +80,7 @@ NEVER = "never-confirmed"
 NO_COMMANDS = "no-commands"
 
 
-def pre_tag_digest(commands, release_build=None):
+def pre_tag_digest(commands, release_build=None, rebuild=None, generate=None):
     """A stable digest of a row's executable release command inputs.
 
     ORDER-SENSITIVE on purpose. The commands run in declared order and a
@@ -91,10 +93,10 @@ def pre_tag_digest(commands, release_build=None):
     change to this construction cannot be mistaken for a content change
     by an old recorded value.
 
-    Rows without `release-build` deliberately retain the exact v1 digest and
-    marker identity, so existing confirmations do not churn. A present build
-    command is appended with a typed, length-prefixed record, so changing only
-    that command invalidates the same per-target confirmation marker.
+    Rows without any newly bound scalar command deliberately retain the exact
+    v1 digest and marker identity, so existing confirmations do not churn.
+    Each present scalar command is appended with a typed, length-prefixed
+    record, so changing only one invalidates the same per-target marker.
 
     Pure and non-raising: malformed values degrade conservatively to their
     absent forms rather than raising inside a release lane.
@@ -108,6 +110,10 @@ def pre_tag_digest(commands, release_build=None):
         parts.append(f"{len(command)}:{command}")
     if isinstance(release_build, str) and release_build:
         parts.append(f"release-build:{len(release_build)}:{release_build}")
+    if isinstance(rebuild, str) and rebuild:
+        parts.append(f"rebuild:{len(rebuild)}:{rebuild}")
+    if isinstance(generate, str) and generate:
+        parts.append(f"generate:{len(generate)}:{generate}")
     joined = "\n".join(parts)
     return hashlib.sha256(joined.encode("utf-8")).hexdigest()
 
@@ -162,22 +168,24 @@ def record_confirmation(root, target, digest):
     return path
 
 
-def confirmation_state(root, target, commands, release_build=None):
+def confirmation_state(root, target, commands, release_build=None,
+                       rebuild=None, generate=None):
     """One of `confirmed` / `changed` / `never-confirmed` / `no-commands`.
 
     `no-commands` is deliberately distinct from `confirmed`: a row that
-    declares neither pre-tag commands nor release-build has nothing to
-    confirm, and reporting it as confirmed would claim an operator approved
-    something that does not exist. A release-build-only row still requires
-    confirmation. The lane treats `no-commands` and `confirmed` as
+    declares none of pre-tag, release-build, rebuild, or generate has nothing
+    to confirm, and reporting it as confirmed would claim an operator approved
+    something that does not exist. A row with any one scalar command still
+    requires confirmation. The lane treats `no-commands` and `confirmed` as
     "proceed", but only one of them is a statement about human review.
     """
-    if not commands and not release_build:
+    if not commands and not release_build and not rebuild and not generate:
         return NO_COMMANDS
     recorded = read_confirmation(root, target)
     if recorded is None:
         return NEVER
-    return (CONFIRMED if recorded == pre_tag_digest(commands, release_build)
+    return (CONFIRMED if recorded == pre_tag_digest(
+        commands, release_build, rebuild, generate)
             else CHANGED)
 
 
@@ -187,7 +195,8 @@ def _row_executable_inputs(target, targets_path=None):
     row = next((r for r in rows if r["target"] == target), None)
     if row is None:
         return None
-    return row.get("pre_tag") or [], row.get("release_build")
+    return (row.get("pre_tag") or [], row.get("release_build"),
+            row.get("rebuild"), row.get("generate"))
 
 
 def main(argv=None):
@@ -207,26 +216,29 @@ def main(argv=None):
     if executable_inputs is None:
         sys.stderr.write(f"unknown release target: {target}\n")
         return 65
-    commands, release_build = executable_inputs
+    commands, release_build, rebuild, generate = executable_inputs
 
     if command == "digest":
-        print(pre_tag_digest(commands, release_build))
+        print(pre_tag_digest(commands, release_build, rebuild, generate))
         return 0
 
     if command == "record":
         path = record_confirmation(
-            root, target, pre_tag_digest(commands, release_build))
+            root, target, pre_tag_digest(
+                commands, release_build, rebuild, generate))
         print(f"recorded executable-command confirmation for {target}: {path}")
         return 0
 
-    state = confirmation_state(root, target, commands, release_build)
+    state = confirmation_state(
+        root, target, commands, release_build, rebuild, generate)
     print(state)
     if state in (CONFIRMED, NO_COMMANDS):
         return 0
     if state == CHANGED:
         sys.stderr.write(
             f"releasehash: {target}'s executable release commands have CHANGED "
-            "since they were last confirmed. Read every pre-tag and release-build "
+            "since they were last confirmed. Read every pre-tag, release-build, "
+            "rebuild, and generate "
             "command, and re-confirm with "
             f"`releasehash.py record {target}` before releasing. These commands "
             "are executed by the release lane, so a change nobody has read is "
@@ -234,7 +246,8 @@ def main(argv=None):
         return 1
     sys.stderr.write(
         f"releasehash: {target}'s executable release commands have never been "
-        f"confirmed. Read every pre-tag and release-build command, then run "
+        f"confirmed. Read every pre-tag, release-build, rebuild, and generate "
+        f"command, then run "
         f"`releasehash.py record {target}`.\n")
     return 2
 

package/plugins/ca-pi/includes/artifacts.md

@@ -10,11 +10,30 @@ default to canonical `.html`. Check the installed capability before writing; a
 missing, invalid, mismatched or unqualified capability is a STOP and
 the workflow must not fall back to Markdown or create any fallback artifact.
 Report `CAPABILITY_MISSING` and direct the user to repair or reinstall the pinned
-artifact payload before retrying. An existing `.md` exact pair remains Markdown
+artifact payload before retrying. The payload ships only through the release
+channels: Claude Code `/plugin marketplace update codearbiter` then
+`/plugin update ca@codearbiter`; Codex the `ca-codex-marketplace` ref; Pi
+`pi install npm:@arbiterforge/ca-pi`. A main-branch checkout never carries it. An existing `.md` exact pair remains Markdown
 and continues on the legacy path without automatic conversion. The feature
 small lane remains an inline mini-spec and creates no artifact. HTML `--farm`
 dispatch remains disabled and outside this rollout.
 
+## Installed host admission
+
+Before new full-lane or plan authoring, the bridge checks the exact installed
+host's required producers, helpers, reviewer charter where applicable, and
+platform-specific hook registrations. `_select_authoring_route` and
+`_preflight_plan_authoring` require this read-only preflight in addition to the
+native engine capability. `HOST_WORKFLOW_UNAVAILABLE` stops before authoring;
+repair the installed package or use a supported host. Never create a fallback
+artifact, substitute another package, or mint an authority event to proceed.
+
+`ArtifactClient.workflow_preflight()` reports only installed resources. It does
+not prove host trust, enabled hooks, supported host-version behavior, reviewer
+independence, or a completed live workflow. Actual authority producers and their
+existing validation remain required. Pi currently fails this admission check;
+existing Markdown pairs and the inline small feature lane are unchanged.
+
 ## Internal execution contract
 
 The normal qualified package's installation-owned `release.json` pins the native
@@ -79,10 +98,11 @@ python "<plugin-root>/hooks/_approvallib.py" cancel --root "<project-root>" --ar
 ```
 
 Cancellation records no authority. Other workflow authorities must use their
-corresponding host-owned adapters; never call `capture` with request-authored
-`authority_kind`, verdict, actor, or source-text labels, and never create an
-authority source merely to satisfy an artifact transition.
-`capture` does not change approval state. `approve` checks the resulting receipt
+corresponding host-owned adapters. Legacy `capture` events remain readable for
+inventory but are inspection-only: the engine refuses to wrap them in a current
+receipt. Current authority requires `capture-observation` over a closed producer
+profile and engine-issued evidence context; never create an authority source
+merely to satisfy an artifact transition. `approve` checks the resulting receipt
 against current ready content. A missing or changed receipt, captured event, or
 still-present policy source returns `AUTHORITY_UNVERIFIED`. Receipt format 0.1.0
 remains readable for inspection after upgrade but is not authority-bearing; the
@@ -91,11 +111,20 @@ approval, dispatch, acceptance, commit proof, or finalization. This is the
 repository's cooperative same-user attestation model, not cryptographic identity
 proof or protection from an unrestricted same-user filesystem writer.
 
-Create a plan as `draft_preview`, consume existing criterion IDs, then `plan-bind`
-to the approved spec. Approve the plan through the applicable existing workflow.
+For ordinary sequential planning, create a plan as `draft_preview`, consume existing criterion IDs,
+then `plan-bind` to the approved spec and approve the plan through its existing workflow. Initial
+combined HTML sprint review uses the explicit paired path below instead of separate approvals.
 A normative change invalidates its approval. Rebinding is explicit and preserves
 history; it does not waive coverage or permit silent reinterpretation.
 
+## Initial sprint pair and delegated methods
+
+Only when preparing initial combined approval, replaying an observed reply, or revising a task's
+method under its existing grant, load `<plugin-root>/includes/sprint-authority.md`. That private
+card owns the `arm-sprint` / `resume-sprint` / `smarts` bridge and the native pair/method operations.
+Do not bulk-load it for ordinary task reads. Scoring is not consent; the initial observed user reply,
+protected scope, real producer, current evidence and existing security/permission gates remain required.
+
 ## Reading and dispatch
 
 Use `index`, then `outline`, then symbol-scoped `read`. Exact reads are explicitly
@@ -147,8 +176,8 @@ python "<plugin-root>/hooks/_prerequisitelib.py" supersede --root "<project-root
 ```
 
 The adapter fixes `authority_kind: user_workflow` and `verdict: satisfied`;
-there is no caller-selected authority or bulk-satisfaction path. SMARTS remains
-unsupported until a real policy-owned SMARTS decision producer exists. Pi has no
+there is no caller-selected authority or bulk-satisfaction path. SMARTS prerequisite satisfaction remains unsupported; the plan-method producer below does not
+grant prerequisite, security, backend or publication authority. Pi has no
 qualified pre-model prompt seam and must remain blocked. Do not infer eligibility from one satisfied prerequisite:
 rerun `eligible`, and resolve each remaining record independently against the
 new current plan identity.
@@ -161,10 +190,88 @@ verification and spec review. Across checkpoints, dependencies require accepted
 scope evidence. Provisional progress never counts as completion.
 
 The orchestrator executes the declared verification through its existing governed
-execution tool, captures actual named-test outcomes and output hashes, and obtains
-a separate spec review. `task-review` records those receipts. After every task in
-the scope reaches `REVIEW`, reverify against one current source snapshot, review
-the combined scope, and use `accept-scope` once. Do not accept tasks individually.
+execution tool through the installed production authority adapter; it never
+constructs a successful workflow event itself. Arm an exact task request first.
+Verification and review authority below is supported on Codex and Claude Code.
+On Pi, stop at this boundary rather than treating model-authored results as
+authority; its installed prompt approval seam does not imply verification or
+review support.
+Every distinct `cwd` label in the engine context must be mapped once to an exact
+linked Git worktree root. Mapped worktrees must share the artifact repository's
+Git common directory, and the adapter freezes their filesystem identity, HEAD,
+status digest, effective argv, and executable bytes:
+
+```sh
+python "<plugin-root>/hooks/artifact-authority.py" arm --root "<project-root>" --artifact-id <plan-id> --record-id <task-id> --activity verification --workspace "candidate worktree=<absolute-worktree>" --workspace "baseline-evidence worktree=<absolute-worktree>"
+```
+
+Use only the mappings actually named by that task; missing or extra labels fail
+closed. Run the returned request through one plain governed exec invocation (no
+compound shell expression), then publish only after the host's matching
+`PostToolUse` has corroborated the wrapper's completed request-bound result:
+
+```sh
+python "<plugin-root>/hooks/artifact-authority.py" verify --root "<project-root>" --request-id <request-id>
+python "<plugin-root>/hooks/artifact-authority.py" publish --root "<project-root>" --request-id <request-id>
+```
+
+The verifier launches exact engine-declared argv without a shell, supervises the
+whole process tree, bounds output, requires exact named outcomes, and rejects
+workspace or executable drift. If an attempt is interrupted, use the adapter's
+`recover` operation to retain it as failed or abandoned; never rerun an uncertain
+attempt under the same request.
+
+For `spec_review` or `quality_review`, arm the corresponding activity without
+workspace mappings and dispatch the returned `launch_envelope` unchanged to one
+fresh host subagent. The host hooks bind the exact launch call, child start and
+the child's first stop; a pasted or coordinator-authored decision is not review
+authority.
+Publish the completed request through the same `publish` command. `task-review`
+records the separate verification and spec-review receipts. After every task in
+the scope reaches `REVIEW`, reverify against one current source snapshot, run the
+combined quality review, and use `accept-scope` once. Do not accept tasks
+individually.
+
+An interrupted or `BLOCKED` HTML task never resumes by editing its status. Arm
+the installed reconciliation adapter for the exact task or scope, present its
+returned reply verbatim, and let `UserPromptSubmit` capture and apply the observed
+user decision across repositories:
+
+```sh
+python "<plugin-root>/hooks/artifact-reconcile.py" --root "<project-root>" --artifact-id <plan-id> --target-id <task-id> --operation task-reconcile --target-state PENDING --reason "<reviewed reason>" --assessment "<reviewed assessment>"
+python "<plugin-root>/hooks/artifact-reconcile.py" --root "<project-root>" --artifact-id <plan-id> --target-id <checkpoint-id> --operation scope-reconcile --assessment "<reviewed assessment>"
+```
+
+Ambiguous armed requests, changed identities, stale inputs, wrong replies, or a
+foreign Git repository all fail closed. Re-run `eligible` after reconciliation;
+the prompt reply itself is not proof that the lifecycle mutation committed.
+If a mutation response is lost, submit the same exact reply again: the adapter
+replays its durable operation ID and receipt without recapturing authority. A
+request that has not reached mutation can be cancelled with:
+
+```sh
+python "<plugin-root>/hooks/artifact-reconcile.py" --root "<project-root>" --artifact-id <plan-id> --cancel --prompt "<exact returned reply>"
+```
+
+If a crash left a complete pending request before its prompt route was
+registered, use this command instead. It refuses an active route or any
+in-flight mutation:
+
+```sh
+python "<plugin-root>/hooks/artifact-reconcile.py" --root "<project-root>" --artifact-id <plan-id> --cancel-orphan
+```
+
+If a durable mutation attempt exists, neither cancellation path can clear it.
+Replay the exact stored operation and receipt under the reconciliation lock:
+
+```sh
+python "<plugin-root>/hooks/artifact-reconcile.py" --root "<project-root>" --artifact-id <plan-id> --recover
+```
+
+Recovery clears the request only on a committed replay or a closed-set engine
+result proving no commit (`REVISION_CONFLICT` or `OPERATION_ROLLED_BACK`). Other
+errors retain it for investigation. Re-arm only after cancellation or recovery
+succeeds; a committed recovery is not permission to repeat the mutation.
 
 `IN_PROGRESS` after interruption requires reconciliation, not automatic completion.
 `REVIEW` requires fresh evidence. Source changes stale proof; state/branding updates

package/plugins/ca-pi/includes/sprint-authority.md

@@ -0,0 +1,69 @@
+# Sprint approval and delegated method authority
+
+This private extension adds no registered command, skill or agent. Check that the verified installed
+native capability lists `sprint-approval-context`, `sprint-approve` and `smarts-apply`; a schema name
+or model-written event is not an implementation. Qualified exact-prompt host observation remains
+Claude Code or Codex only. Pi must not arm it without a real pre-model prompt seam. Other existing
+host-specific verification/review restrictions are unchanged.
+
+Prepare the complete ready same-slug spec and plan as unapproved drafts. The private planner
+preflight accepts `draft_for_pair: true` only for a full-lane initial sprint, never `/feature`, an
+existing approved pair, or an execution shortcut. Keep its `draft_preview` binding until the paired
+transaction. Run scope/criterion coverage, recorded-intent and adversarial review on both drafts.
+Present the optional plan-method delegation in the review packet before arming:
+
+```sh
+python "<plugin-root>/hooks/_approvallib.py" arm-sprint --root "<project-root>" --spec-id <spec-id> --plan-id <plan-id> --delegate-methods
+```
+
+Omit `--delegate-methods` for approval without delegated plan-method changes. Show the returned
+`reply` verbatim. It explicitly names both IDs, `delegate-methods` or `approve-only`, and the nonce.
+An ordinary yes, wrong nonce/mode or changed member does not approve either. `sprint-approve`
+recomputes both model/revision identities and the projected binding, verifies both observations
+from the same actual reply, and commits the two approvals through the existing native journal.
+It produces separate bound receipts and an optional `grant_receipt`. No partial approval is visible
+while recovery is required. Generic `capture-observation` and single-artifact `approve` cannot reuse
+these pair events to approve one half. Confirm both current `approved` gates before dispatch.
+
+An interrupted observed submission retains its exact source events, operation ID and both CAS
+identities. Resume it without asking the user to repeat the same decision:
+
+```sh
+python "<plugin-root>/hooks/_approvallib.py" resume-sprint --root "<project-root>" --plan-id <plan-id>
+```
+
+Arming without an observed reply cannot be resumed as authority. Recovery completes only this
+exact observed transaction, not an unrelated pending operation. A committed replay is success;
+a closed-set `REVISION_CONFLICT` or `OPERATION_ROLLED_BACK` proves this mutation did not commit and
+retires only its stale pending request while preserving source history. Changed content needs a
+new genuine approval, not an invented receipt. Other failures retain the request for diagnosis.
+Before observation, the existing `cancel --artifact-id <plan-id>` clears an unapproved arm. After
+submission, resume/recover first; cancellation cannot erase an uncertain transaction.
+
+With an explicit paired user grant, evaluate an existing task-method choice using SMARTS Step 0,
+all six lens verdicts and the actual supporting reasons. Query only the `smarts-apply` request schema.
+Provide the exact current plan `artifact_id`, `expected` revision/model hash, unique `operation_id`,
+original `grant_receipt`, and `decision` with task ID, options, selected index, strength and rationale.
+Each option contains label, steps and the six qualitative verdict/reason cells. There is no new
+numeric threshold, mandatory invented alternative or tie-triggered user interview. Persist the
+bounded JSON request as inert input and invoke the installation-owned bridge:
+
+```sh
+python "<plugin-root>/hooks/_approvallib.py" smarts --root "<project-root>" --request-file <decision-request.json>
+```
+
+The native producer validates the original user grant and current bound spec/plan. Only the selected
+existing task's method `steps` may change. Every path, criterion, test/verification definition,
+prerequisite, dependency, checkpoint, rollback and input policy stays protected. Changes that widen
+this scope or need a different authority use their real owner. The producer does not turn step text
+into shell permission and never grants commit, network/provider, spending, disclosure, publication,
+prerequisite or security authority. Normal execution gates still apply to the chosen method.
+
+An affected `IN_PROGRESS` writer must quiesce before mutation. A successful method change emits an
+actual `smarts_workflow` event/receipt and current plan approval together, invalidates affected
+checkpoint/dependency proof to `PENDING` while preserving `BLOCKED` members and their reasons,
+retains evidence refs as history and requires fresh context,
+verification and reviews. It never accepts work. An identical method needs no new approval; retain
+current evidence rather than manufacturing another attempt. Log material reasoning and record
+citations in the existing sprint audit. Recorded judgments remain model judgments: integrity and
+scope checks do not independently prove their truth or create a malicious-same-user sandbox.

package/plugins/ca-pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arbiterforge/ca-pi",
-  "version": "0.14.10",
+  "version": "0.14.16",
   "private": true,
   "license": "AGPL-3.0-only",
   "type": "module",

package/plugins/ca-pi/routines/INDEX.md

@@ -2,7 +2,10 @@
 
 Skill bodies load on routing only. This index is the surface scan; never bulk-read
 `skills/*/SKILL.md`. Each skill is an orchestrator routine with gated phases, routed to, never
-"triggered." This index lists what each skill OWNS; to decide WHERE a trigger routes, load
+"triggered." Command-backed owners `commit-gate` and `skill-author` supply their
+complete public entries at build time. Claude keeps the owner discoverable and the
+command explicit-only; Codex/Pi expose the entry and keep the routine private. Read a needed owner directly or use the complete public body,
+not both merely to repeat the same procedure. This index lists what each skill OWNS; to decide WHERE a trigger routes, load
 `<plugin-root>/includes/routing-table.md` (the authoritative trigger→route surface).
 
 | Skill | Routed to by | Owns |
@@ -14,9 +17,9 @@ Skill bodies load on routing only. This index is the surface scan; never bulk-re
 | [refactor](refactor/SKILL.md) | `/refactor` | Behavior-preserving change behind a parity-coverage proof gate; routes to `tdd` Phase 1 only when new test seams are needed. |
 | [context-creation](context-creation/SKILL.md) | `/create-context` (brownfield) | Back-fills `.codearbiter/` from existing source via parallel scouts; writes `CONTEXT.md` (`arbiter: enabled` + `stage:`) and locks it `<!--INITIALIZED-->`. |
 | [decompose](decompose/SKILL.md) | greenfield startup, `/decompose` | Six-layer senior-architect interview, compaction-resilient via per-layer disk drafts + DRAFT ADRs; populates `.codearbiter/` and locks it initialized. |
-| [brainstorming](brainstorming/SKILL.md) | `/feature` (front), `/sprint` planning | Socratic idea→spec: split bundles, shape the approach, then decide parameters / ask forks in full; adversarial self-review before approval; writes new full-lane `specs/<slug>.html` through the installed engine while preserving existing Markdown authority. Its acceptance criteria become `tdd` obligations. Hard-gate: no code until the spec is approved. |
-| [writing-plans](writing-plans/SKILL.md) | `/feature`, `/sprint` (after the spec) | Decomposes an approved spec into small tasks, each with a path + a verification that maps to a `tdd` obligation; writes a same-format plan with bijective criterion↔task coverage (`.html` by default, `.md` for an existing Markdown spec). |
-| [executing-plans](executing-plans/SKILL.md) | `/feature` | Checkpoint coordinator — groups tasks into batches, delegates each to `subagent-driven-development` (fresh author agent per task, full review chain), stops for user acknowledgement between batches. |
+| [brainstorming](brainstorming/SKILL.md) | `/feature` (front), `/sprint` planning | Caller-scoped feature or coherent sprint specification. Initial approval is user-owned; delegated choices require existing authority. Uses the selected artifact format, preserves recorded intent, and returns or forwards to the caller's required planning step before execution. |
+| [writing-plans](writing-plans/SKILL.md) | `/feature`, `/sprint` (after the spec) | Decomposes the exact approved spec, or a ready draft through the initial sprint-only pair preflight. Retains same-format criterion/task coverage, paths and verification; combined drafts return for one real spec-and-plan reply before execution. Ordinary sequential binding remains unchanged. |
+| [executing-plans](executing-plans/SKILL.md) | `/feature` | Attended coordinator: uses authored HTML checkpoint membership or bounded legacy batches, delegates to `subagent-driven-development`, and retains the user checkpoint. A display batch never changes an HTML acceptance scope; sprint does not inherit these pauses. |
 | [subagent-driven-development](subagent-driven-development/SKILL.md) | `/sprint` (engine), `executing-plans` (batch scope) | Fresh subagent per task → spec-compliance then quality review → fresh-run verification; accepts only on proof. A quality failure blocks acceptance; approved sprint recovery owns correction. Security CRITICAL and unresolved `[CONFIRM-NN]` remain stops. |
 | [dispatching-parallel-agents](dispatching-parallel-agents/SKILL.md) | `subagent-driven-development`, `/sprint`, parallel `/review` | Reusable fan-out primitive: bound concurrency, collect, dedupe, funnel through `finding-triage`→`verdict-aggregator`. Results unused until the read-only funnel runs. |
 | [finishing-a-development-branch](finishing-a-development-branch/SKILL.md) | `/feature`, `/sprint` (terminal) | The terminal step after `commit-gate`: open-PR / merge-via-PR / discard. No direct-to-main, no force-push; `/sprint` auto-selects open-PR and never merges. |