claude-dev-env 2.4.0 → 2.5.0

package/skills/plan-to-pr/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: plan-to-pr
+description: >-
+  Coordinates source-grounded implementation through a validated plan packet,
+  planned task tickets, fixed model routing, verified commits, independent Luna
+  review, and publication gates. Triggers: "Plan-to-PR", "plan to PR",
+  "implement this with one task per commit", "run the Plan-to-PR workflow",
+  "validate Plan-to-PR", "publish the PR".
+---
+
+# Plan-to-PR
+
+## Purpose and boundary
+
+Use this skill for source-grounded implementation with one deliverable, one
+allowed file set, one acceptance check, and one commit per task. The planning
+phase creates and validates a tool-neutral `docs/plans/<slug>/` packet
+before any `TaskCreate` or `TodoWrite` seeding.
+
+The skill coordinates planning, task records, model routing, commit order,
+review, verification, and publication. It does not replace the orchestrator or
+advisor capabilities used by later phases.
+
+## Native planning phase
+
+Run this phase before task seeding and before implementation:
+
+1. The Luna max planner reads the request, repository guidance, relevant
+   source, tests, and documentation, then selects a unique lowercase slug.
+2. The planner consults a Sol xhigh advisor heavily at scope, dependency,
+   task-boundary, acceptance, and risk decisions. The advisor supports planning
+   decisions and packet review.
+3. The planner writes the packet files and validates them against
+   [`reference/packet-contract.md`](reference/packet-contract.md) and
+   [`reference/packet-schema.json`](reference/packet-schema.json).
+4. The planner repairs packet findings and repeats deterministic validation
+   until the packet passes. A failed validation blocks task seeding.
+5. Only a passing packet with `status: approved` may seed host tasks. Record the
+   packet path and validation result in the task ledger.
+
+The packet is the sole planning handoff. It contains its own scope, evidence,
+task boundaries, acceptance checks, risks, and implementation order. Do not
+seed tasks from conversational notes or an incomplete packet.
+
+## Capability boundary
+
+This skill owns the native planning packet, task records, routing, review,
+verification, and publication decisions. Later execution uses the companion
+orchestrator and advisor capabilities.
+
+## Refusal cases
+
+Refuse the first matching case and stop:
+
+- The request has no source-grounded plan packet.
+- The packet is missing, invalid, outside `docs/plans/<slug>/`, or not approved.
+- A requested change spans files outside the packet's allowed file set.
+- A task contains more than one deliverable, acceptance check, or commit.
+- A required task tool, verifier, model tier, advisor, review path, or gate is unavailable.
+- The user asks to bypass verification, `verified_commit_gate`, independent
+  review, final validation, or a publication gate.
+
+Return exactly: `Plan-to-PR blocked: <missing input or capability>.`
+
+## Runtime and task seeding
+
+The packet and task-run validators use Python 3 standard library only. From this
+skill directory, create a packet skeleton with:
+
+`python scripts/create_packet.py --repo-root <repository> --slug <slug> --base-ref <base-ref>`
+
+After the planner fills the packet, validate it with:
+
+`python scripts/validate_packet.py <repository>/docs/plans/<slug>`
+
+Run `python scripts/validate_protocol.py <record.json>` for each task record;
+exit `0` means valid and exit `2` means invalid.
+
+After packet approval, seed one host task for every packet task with
+`TaskCreate`, `TodoWrite`, or its equivalent. Each task records exactly one
+deliverable, one allowed file set, one acceptance check, and one commit. Mark a
+task complete only with verifier output and its commit identity. Use the fixed
+contracts in `reference/task-ticket.md`, `reference/model-routing.md`,
+`reference/task-seeds.md`, `reference/final-validation-tasks.md`, and
+`reference/self-audit-tasks.md`. The fixed fields live in those references.
+
+## Model contract
+
+The planner and final validator use Luna max with Sol xhigh advisory heavily
+at decisive points. The orchestrator uses the max route and delegates every work
+task. Every implementation,
+review, and repair worker uses fast, low-effort Luna. Unavailable models or routing tools
+fail closed; never promote workers,
+demote planners or validators, or substitute a role route.
+
+The planner owns the approved packet. The orchestrator owns task assignment,
+ledger state, and result reconciliation. Workers change only their ticket's
+files and run its acceptance check. The final validator checks the complete
+history and publication gates.
+
+## One-task and one-commit protocol
+
+For each seeded task:
+
+1. The orchestrator issues the standalone task ticket.
+2. One worker implements one deliverable within the ticket's allowed files.
+3. The worker runs the one acceptance check and reports exact output and blockers.
+4. A fresh verifier checks the task diff, baseline, named gates, and ticket-to-diff
+   scope. It must pass `verified_commit_gate` for the exact surface.
+5. The orchestrator creates exactly one commit and records its hash.
+
+No task borrows files, acceptance checks, or commit history from another task.
+Unrelated changes remain untouched and uncommitted.
+
+## Review and repair
+
+Before every commit, require fresh verification and `verified_commit_gate`.
+After the commit, a separate fast low-effort Luna review worker runs native
+findings-only correctness review at `/e-code-review low`. The review returns
+findings only and has no repair flag.
+
+A separate fast low-effort Luna repair worker applies only confirmed findings.
+Record resolved model, effort, command, findings, repair status, and surface
+hash. Rerun the task acceptance check and fresh exact-surface verification, amend the task commit,
+and repeat native review until clean. The max review is the correctness
+gate after cleanup.
+
+## Final validation and publication
+
+The Luna max final validator maps every commit to one packet task and checks
+cumulative behavior, the allowed-file ledger, acceptance checks, verifier
+output, `verified_commit_gate` evidence, and post-commit review records. Any
+unmapped commit, missing record, failed gate, or unresolved finding blocks
+publication.
+
+Run the workflow self-audit and retain its evidence. Publish only when final validation
+and self-audit pass. After the branch is finalized and pushed, run Luna max `/e-simplify`
+for cleanup-only fixes, then Luna low `/e-code-review max loop` with a separate
+Luna low repair worker. commit, and push every validated repair;
+finish only when the max review is clean.
+
+## Companion references
+
+- [`reference/packet-contract.md`](reference/packet-contract.md) — native planning packet contract.
+- [`reference/packet-schema.json`](reference/packet-schema.json) — machine-readable packet schema.
+- [`scripts/create_packet.py`](scripts/create_packet.py) — deterministic packet skeleton creator.
+- [`scripts/validate_packet.py`](scripts/validate_packet.py) — deterministic packet validator.
+- [`reference/model-routing.md`](reference/model-routing.md) — fixed model and gate matrix.
+- [`reference/task-ticket.md`](reference/task-ticket.md) — task, commit, and review record contract.
+- [`reference/review-loop.md`](reference/review-loop.md) — review and repair loop.
+- [`reference/process-inventory.md`](reference/process-inventory.md) — evidence homes.
+- [`reference/run-record.schema.json`](reference/run-record.schema.json) — machine-checkable task-run record.
+
+Run `scripts/validate_run.py` with the task records and commit set during final
+validation. Add `--worktree PATH` when the commit set belongs to another tree.

package/skills/plan-to-pr/reference/final-validation-tasks.md

@@ -0,0 +1,15 @@
+# Final Validation Task Seeds
+
+Register each item as a host task before final validation. Complete each with
+PASS, FAIL plus file and line evidence, or N/A plus a reason.
+
+1. Map every task commit to exactly one approved task identity.
+2. Confirm every task record has required identity, files, acceptance, and commit fields.
+3. Confirm every committed task has native findings-only review and separate repair records.
+4. Confirm every repair has acceptance output, fresh exact-surface verification, and an amended commit before the next review.
+5. Confirm all review records are clean and all verifier records pass.
+6. Confirm the complete allowed-file ledger contains no extra changed files.
+7. Confirm final validation and workflow self-audit evidence are present before release.
+8. Confirm the finalized PR branch receives Luna max `/e-simplify` cleanup with
+   fixes, then Luna low `/e-code-review max loop` with separate repairs, required
+   checks, commits, pushes, and a clean final max review.

package/skills/plan-to-pr/reference/model-routing.md

@@ -0,0 +1,36 @@
+# Model Routing Contract
+
+This reference fixes the model role for native packet planning, task execution,
+review, repair, validation, and post-PR cleanup.
+Unavailable models or unavailable model-selection tools fail closed.
+
+## Role matrix
+
+| Role | Required route | Required behavior |
+|---|---|---|
+| Planner | Luna max with Sol xhigh advisor | Creates and validates the native packet before task seeding; consults the warm advisor heavily at decisive planning points |
+| Orchestrator | Max route | Assigns tickets, owns the ledger, delegates every work task, and reconciles results |
+| Implementation worker | Fast, low-effort Luna | Changes only the ticket's allowed files and runs its acceptance check |
+| Review worker | Fast, low-effort Luna | Invokes the native `/e-code-review low` correctness review against the committed diff and returns findings only |
+| Repair worker | Fast, low-effort Luna | Applies only confirmed findings from the native correctness review |
+| Final validator | Luna max with Sol xhigh advisor | Maps commits to tasks and validates the cumulative release surface; consults the warm advisor heavily at decisive validation points |
+
+## Routing gates
+
+1. Bind the planner and final validator to Luna max.
+2. Bind the planner and final validator to a Sol xhigh advisor and consult it before routing decisions, task approval, repair plans, commit authorization, and final validation decisions.
+3. Bind the orchestrator to the max route and require it to delegate work tasks.
+4. Bind every implementation, review, and repair worker to fast, low-effort Luna.
+5. Stop when a required tier, model, advisor, or routing tool is unavailable.
+6. Do not promote workers, demote planners or validators, or substitute a role's route.
+
+The orchestrator records the selected route and the final validator checks it
+against this matrix. The native review is findings-only and has no repair flag.
+The review record captures resolved model, effort, command, findings, repair status,
+and surface hash. Missing native review or verifier capability fails closed.
+
+After the PR is finalized and pushed, run `/e-simplify` with Luna max for
+cleanup-only fixes. Then run `/e-code-review max loop` with Luna low. A separate
+Luna low repair worker applies confirmed findings, runs required checks, commits,
+and pushes before the next loop. A clean max review is required; nits are fixed
+and pushed before the next max review, while any non-nit finding blocks readiness.

package/skills/plan-to-pr/reference/packet-contract.md

@@ -0,0 +1,43 @@
+# Native Plan-to-PR packet contract
+
+The planning phase produces one self-contained packet at
+`docs/plans/<slug>/`. The slug contains lowercase letters, numbers, and single
+hyphens, starts and ends with a letter or number, and is unique among active
+plans. The packet is complete before `TaskCreate` or `TodoWrite` runs.
+
+## Required files
+
+| File | Required content |
+|---|---|
+| `packet.json` | Validates against `reference/packet-schema.json`; includes every required field. |
+| `context.md` | Request, repository facts, constraints, source references, and open questions. |
+| `plan.md` | Ordered implementation approach, decisions, dependencies, and risks. |
+| `tasks.md` | Ordered task list with one deliverable, file set, acceptance command, and commit per task. |
+| `handoff.md` | Exact task-seeding input and the approval state. |
+
+## Deterministic boundaries
+
+- `packet.json` is the machine-readable authority. Markdown restates the same
+  scope, tasks, files, commands, and acceptance criteria.
+- `status` is `draft` while writing and `approved` only after all checks pass.
+- `allowed_files` contains repository-relative file paths only. Every task file
+  belongs to that set, so task edits stay within the packet scope.
+- `tasks` is ordered, non-empty, and each task has exactly one deliverable,
+  one non-empty `allowed_files` list, one acceptance command, one test command,
+  one verification command, and one commit.
+- Every source reference identifies a repository-relative path and a line or
+  section locator. Unknown facts are recorded in `open_questions`.
+- Acceptance commands are executable, deterministic checks against real behavior.
+  Each task carries an executable command rather than a prose-only statement.
+- `handoff.md` names the packet path, validation result, task order, and exact
+  host-task fields. It lists exactly the tasks declared in `packet.json`.
+
+## Validation sequence
+
+1. Parse `packet.json` as JSON and validate it against the schema.
+2. Validate the slug, required files, path boundaries, task uniqueness, and
+   task-to-file containment.
+3. Confirm every source reference, command, and acceptance check is concrete.
+4. Compare Markdown task and handoff content with `packet.json`.
+5. Set `status` to `approved` after every check passes. Keep `draft` packets in
+   planning and validation until that approval state is reached.

package/skills/plan-to-pr/reference/packet-schema.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Native Plan-to-PR packet",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "slug", "status", "request", "allowed_files", "sources", "decisions", "open_questions", "tasks", "validation"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "slug": {"type": "string", "pattern": "^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$"},
+    "status": {"enum": ["draft", "approved"]},
+    "request": {"type": "string", "minLength": 1},
+    "allowed_files": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1, "pattern": "^(?!/)(?!.*\\\\)(?!.*\\.\\.).+$"}},
+    "sources": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/source"}},
+    "decisions": {"type": "array", "minItems": 1, "items": {"type": "string", "minLength": 1}},
+    "open_questions": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "tasks": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/task"}},
+    "validation": {"$ref": "#/$defs/validation"}
+  },
+  "$defs": {
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["path", "locator", "fact"],
+      "properties": {
+        "path": {"type": "string", "minLength": 1, "pattern": "^(?!/)(?!.*\\\\)(?!.*\\.\\.).+$"},
+        "locator": {"type": "string", "minLength": 1, "pattern": "^(?:[lL][iI][nN][eE][sS]?|[sS][eE][cC][tT][iI][oO][nN])\\s+\\S(?:.*\\S)?$"},
+        "fact": {"type": "string", "minLength": 1}
+      }
+    },
+    "task": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "deliverable", "allowed_files", "acceptance_command", "test_command", "verification_command", "commit"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^task-[0-9]+$"},
+        "deliverable": {"type": "string", "minLength": 1},
+        "allowed_files": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+        "dependencies": {"type": "array", "uniqueItems": true, "items": {"type": "string", "pattern": "^task-[0-9]+$"}},
+        "acceptance_command": {"type": "string", "minLength": 1},
+        "test_command": {"type": "string", "minLength": 1},
+        "verification_command": {"type": "string", "minLength": 1},
+        "commit": {"const": 1}
+      }
+    },
+    "validation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["schema_valid", "boundary_valid", "markdown_matches", "validated_by"],
+      "properties": {
+        "schema_valid": {"type": "boolean"},
+        "boundary_valid": {"type": "boolean"},
+        "markdown_matches": {"type": "boolean"},
+        "validated_by": {"const": "native-plan-to-pr"}
+      }
+    }
+  }
+}

package/skills/plan-to-pr/reference/process-inventory.md

@@ -0,0 +1,22 @@
+# Process Inventory
+
+This inventory classifies every required workflow step and names its evidence
+home. Deterministic work is represented by a fixed reference or task seed;
+judgment remains in the hub or companion reference.
+
+| Step | Class | Home | Evidence | Paired test |
+|---|---|---|---|---|
+| Create and validate native plan packet | deterministic | `reference/packet-contract.md` and `reference/packet-schema.json` | Approved packet, validation result, and packet path | `test_skill_contract.py` and `test_task_ticket_contract.py` |
+| Approve scope and acceptance | judgment | `SKILL.md` | Approved plan and acceptance contract | N/A: human decision |
+| Seed implementation work after packet approval | deterministic | `task-seed:reference/task-seeds.md` | Host task IDs, packet path, and evidence | task-tool |
+| Record task fields | deterministic | `reference/run-record.schema.json` and `scripts/validate_protocol.py` | Validator output and exit code | `scripts/test_validate_protocol.py` |
+| Implement one deliverable | judgment | `SKILL.md` | Worker report and diff | N/A: implementation choice |
+| Verify exact surface | deterministic | `task-seed:reference/task-seeds.md` | Verifier output and `verified_commit_gate` | task-tool |
+| Review committed task | deterministic | `reference/review-loop.md` | Findings-only native review record | `test_task_ticket_contract.py` |
+| Repair confirmed findings | deterministic | `reference/review-loop.md` | Separate repair record and confirmed findings | `test_task_ticket_contract.py` |
+| Decide whether a finding is confirmed | judgment | `reference/review-loop.md` | Repair record names the confirmed finding | N/A: review judgment |
+| Repeat until clean | borderline | `reference/review-loop.md` | Amended commit and clean review record | `test_task_ticket_contract.py` |
+| Validate cumulative release | deterministic | `task-seed:reference/final-validation-tasks.md` | Final validator task evidence | task-tool |
+| Self-audit the workflow | deterministic | `task-seed:reference/self-audit-tasks.md` | Self-audit task evidence | task-tool |
+| Run post-PR cleanup | deterministic | `SKILL.md` and `reference/model-routing.md` | Luna max `/e-simplify` result and pushed cleanup commit | task-tool |
+| Run post-PR max review | deterministic | `reference/review-loop.md` | Luna low max-loop findings, repairs, pushes, and clean result | task-tool |

package/skills/plan-to-pr/reference/review-loop.md

@@ -0,0 +1,33 @@
+# Review Loop
+
+Run this loop for every committed task. Store each pass in the task record.
+
+1. A separate fast low-effort Luna review worker reads the committed task diff.
+2. It invokes the native findings-only `/e-code-review low` correctness
+   capability; the review has no repair flag.
+3. Record resolved model, effort, command, findings, repair status, and surface
+   hash. Missing native review or verifier capability fails closed.
+4. A separate fast low-effort Luna repair worker applies only confirmed findings.
+5. Rerun the task acceptance check and fresh exact-surface verification.
+6. Amend the task commit and repeat the native review until clean.
+
+## Accepted records
+
+Clean means the native review reports no findings for the exact committed
+surface. A repaired pass is not accepted until acceptance and fresh verifier
+output are recorded against the amended commit.
+
+## Example
+
+`review: findings=["missing field"]` → `repair: confirmed=["missing field"]` →
+`acceptance: PASS` → `verification: PASS` → `amend` → `review: clean`.
+
+## Post-PR max loop
+
+After the PR branch is finalized and pushed, Luna max runs `/e-simplify` and
+applies only cleanup fixes. Commit and push those fixes before correctness review.
+
+Then Luna low invokes `/e-code-review max loop`. It returns findings only. A
+separate Luna low repair worker applies confirmed bugs or nits, runs required
+checks, commits, and pushes. Repeat the max loop until it is clean. Fix and push
+all nits before the next loop; any non-nit finding blocks readiness until repaired.

package/skills/plan-to-pr/reference/run-record.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Plan-to-PR task run record",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["task_identity", "deliverable", "allowed_files", "acceptance_check", "baseline", "worker_route", "commit", "review_record", "repair_record", "reverification_record", "verification_record"],
+  "properties": {
+    "task_identity": {"type": "string", "minLength": 1},
+    "deliverable": {"type": "string", "minLength": 1},
+    "allowed_files": {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1},
+    "acceptance_check": {"type": "string", "minLength": 1},
+    "baseline": {"type": "string", "minLength": 1},
+    "worker_route": {"type": "string", "minLength": 1},
+    "commit": {"type": "string", "pattern": "^[0-9a-f]{7,40}$"},
+    "worktree": {"type": "string", "minLength": 1},
+    "review_record": {"$ref": "#/$defs/review_record"},
+    "repair_record": {"$ref": "#/$defs/repair_record"},
+    "reverification_record": {"$ref": "#/$defs/verification_record"},
+    "verification_record": {"$ref": "#/$defs/verification_record"}
+  },
+  "$defs": {
+    "finding": {"type": "object", "additionalProperties": false, "required": ["finding", "disposition"], "properties": {"finding": {"type": "string", "minLength": 1}, "disposition": {"enum": ["confirmed", "dismissed"]}}},
+    "review_record": {"type": "object", "additionalProperties": false, "required": ["resolved_model", "effort", "command", "findings", "repair_status", "surface_hash", "findings_only", "has_repair_flag"], "properties": {"resolved_model": {"type": "string", "minLength": 1}, "effort": {"type": "string", "minLength": 1}, "command": {"type": "string", "minLength": 1}, "findings": {"type": "array", "items": {"$ref": "#/$defs/finding"}}, "repair_status": {"type": "string", "minLength": 1}, "surface_hash": {"type": "string", "minLength": 1}, "findings_only": {"const": true}, "has_repair_flag": {"const": false}}},
+    "repair_record": {"type": "object", "additionalProperties": false, "required": ["resolved_model", "effort", "confirmed_findings", "repair_status", "surface_hash"], "properties": {"resolved_model": {"type": "string", "minLength": 1}, "effort": {"type": "string", "minLength": 1}, "confirmed_findings": {"type": "array", "items": {"type": "string", "minLength": 1}}, "repair_status": {"type": "string", "minLength": 1}, "surface_hash": {"type": "string", "minLength": 1}}},
+    "verification_record": {"type": "object", "additionalProperties": false, "required": ["acceptance_output", "verifier_output", "verified_commit_gate", "surface_hash"], "properties": {"acceptance_output": {"type": "string", "minLength": 1}, "verifier_output": {"type": "string", "minLength": 1}, "verified_commit_gate": {"type": "string", "minLength": 1}, "surface_hash": {"type": "string", "minLength": 1}}}
+  }
+}

package/skills/plan-to-pr/reference/self-audit-tasks.md

@@ -0,0 +1,15 @@
+# Self-Audit Task Seeds
+
+Register each item as a host task before delivery. Complete each with PASS,
+FAIL plus file and line evidence, or N/A plus a reason.
+
+1. Confirm the hub names native packet planning before task seeding.
+2. Confirm every packet, task, review, validation, and audit reference is linked directly from the hub.
+3. Confirm packet markdown and schema paths exist with the validation scripts.
+4. Confirm the ordered task-seed catalog and task-tool seeding instruction are present after packet approval.
+5. Confirm every process step is classified with a home and evidence path.
+6. Confirm final-validation and self-audit seed lists are present.
+7. Confirm concrete review-loop examples show findings, repair, reverify, amend, and clean review.
+8. Confirm the schema requires task identity, commit, review, repair, reverification, and verification records.
+9. Confirm planning uses the native packet contract and no absolute machine paths appear.
+10. Confirm the focused contract tests pass and the owned-file diff is complete.

package/skills/plan-to-pr/reference/task-seeds.md

@@ -0,0 +1,14 @@
+# Task Seeds
+
+Register each item as one host task with `TaskCreate`, `TodoWrite`, or the host
+equivalent before implementation. Mark it complete only with evidence.
+
+1. Approve the plan, task scope, acceptance check, and allowed files.
+2. Capture the baseline and create one task record from the run-record schema.
+3. Implement the single deliverable within the allowed file set.
+4. Run the acceptance check and record its exact output.
+5. Run fresh exact-surface verification and `verified_commit_gate`.
+6. Create exactly one task commit and record its identity.
+7. Run the separate native review and record findings-only output.
+8. Run separate Luna repair only for confirmed findings; rerun acceptance and
+   exact-surface verification before amending and reviewing again.

package/skills/plan-to-pr/reference/task-ticket.md

@@ -0,0 +1,38 @@
+# Task Ticket Contract
+
+Each ticket is created from an approved native plan packet after packet validation
+passes. It describes one independently verifiable deliverable. The orchestrator
+must reject a ticket that combines deliverables, file sets, acceptance checks, or
+commits.
+
+## Required ticket fields
+
+| Field | Contract |
+|---|---|
+| Task identity | One stable task name and one planned task mapping |
+| Deliverable | Exactly one concrete output |
+| Allowed files | The complete file set the worker may change |
+| Acceptance check | Exactly one command or deterministic check |
+| Baseline | Fresh output captured before implementation |
+| Worker route | The model role and selected route from `reference/model-routing.md`; planner and final-validator records include Luna max plus Sol xhigh advisor evidence, and orchestrator records the max route |
+| Commit record | Exactly one commit hash for this ticket |
+| Review record | Separate fast low-effort Luna review output that invokes native `/e-code-review low` and returns findings only, followed by separate fast low-effort Luna repair output, including resolved model, effort, command, findings, repair status, and surface hash |
+| Verification record | Fresh verifier output and `verified_commit_gate` result for the exact surface |
+
+## Execution contract
+
+The worker changes only the allowed files, runs the acceptance check, and reports
+the exact output. A fresh verifier checks the ticket against the diff before one
+commit is created. The commit hash is recorded before the separate review pass.
+
+## Review and completion contract
+
+A separate fast low-effort Luna review worker invokes native `/e-code-review low`
+after the commit. It reads the committed diff, returns findings only, and has no
+repair flag. A separate fast low-effort Luna repair worker applies only confirmed findings. The record names
+the resolved model, effort, command, findings, repair status, and surface hash.
+Confirmed repairs require the acceptance check and fresh exact-surface verification
+again; amend the task commit and repeat the native review until clean. Missing
+native review or required verifier capability fails closed. The
+final validator maps the commit to this ticket and rejects missing or extra
+records.

package/skills/plan-to-pr/scripts/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration values for the skill protocol validator."""