@use-the-fork/spindle 0.1.0 → 0.2.0

package/build/Assets/Blueprints/Catalog.js

@@ -21,7 +21,12 @@ export const blueprintCatalog = {
             stacks: [],
             canReview: true,
         },
-        "sdd-task-reviewer": { path: "sdd-task-reviewer.agent.md", status: "active", stacks: [] },
+        "sdd-task-reviewer": {
+            path: "sdd-task-reviewer.agent.md",
+            status: "active",
+            stacks: [],
+            canReview: true,
+        },
         "shared-explore": { path: "shared-explore.agent.md", status: "active", stacks: [] },
         "shared-r": { path: "shared-r.agent.md", status: "active", stacks: [] },
         "shared-rw": { path: "shared-rw.agent.md", status: "active", stacks: [] },
@@ -60,7 +65,7 @@ export const blueprintCatalog = {
         },
     },
     skills: {
-        "asd-ste100": { path: "asd-ste100/", status: "active", stacks: [] },
+        "ref-asd-ste100": { path: "ref-asd-ste100/", status: "active", stacks: [] },
         "author-agent": { path: "author-agent/", status: "active", stacks: [] },
         "sdd-author-design": { path: "sdd-author-design/", status: "active", stacks: [] },
         "author-instruction": { path: "author-instruction/", status: "active", stacks: [] },

package/build/Assets/Blueprints/agents/sdd-implementer.agent.md

@@ -1,17 +1,17 @@
 ---
 name: sdd-implementer
-description: "Use when an orchestrator assigns one ticket or corrective round for subagent-driven development in an existing shared checkout."
+description: "Use when an orchestrator assigns one ticket or corrective round in its isolated worktree."
 tools: [read, search, edit, execute, read_skill, list_skills, skill]
 user-invocable: false
 agents: []
 metadata:
   spindle:
-    version: 1.4.1
+    version: 1.5.0
 ---
 
 # SDD implementer
 
-Implement one orchestrator-assigned ticket in an existing shared checkout. The orchestrator is the controller; it owns dispatch, execution states, acceptance, and the ticket-wide checks. Work sequentially with other editors and return evidence for the assigned ticket.
+Implement one orchestrator-assigned ticket in its isolated worktree. The orchestrator owns dispatch, execution states, acceptance, and the ticket-wide checks. Other tickets may run concurrently in their own worktrees.
 
 ## Required assignment gate
 
@@ -20,14 +20,14 @@ Before entering the flowchart, loading implementation skills, inspecting the che
 | Field                       | Required content                                                                                                                                      |
 | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `TICKET_ID`                 | The single assigned ticket identifier.                                                                                                                |
-| `CHECKOUT`                  | Absolute path to the existing shared checkout.                                                                                                        |
+| `CHECKOUT`                  | Absolute path to the assigned ticket worktree.                                                                                                        |
 | `ABSOLUTE_SOURCE_POINTERS`  | Absolute paths to the canonical ticket, comments, and spec/brief. Explicitly identify any source that does not apply.                                 |
 | `CRITERIA_AND_SEAMS`        | Acceptance criteria and confirmed test seams.                                                                                                         |
 | `DEPENDENCIES_AND_SNAPSHOT` | Completed dependencies and starting revision, including existing dirty/untracked changes. Explicitly state when there are no dependencies or changes. |
 | `FILE_SCOPE`                | Allowed code, test, and `.scratch` files.                                                                                                             |
 | `CHECKS_AND_DIRECTORY`      | Approved project checks and their test working directory; identify any checks explicitly scheduled for this worker.                                   |
 | `PERMISSIONS`               | Allowed actions, including explicit commit authorization or denial.                                                                                   |
-| `REPORT_PATH`               | Assigned `.scratch` report path within `FILE_SCOPE`, absolute or relative to `CHECKOUT`.                                                              |
+| `REPORT_PATH`               | Assigned absolute report path in the canonical feature workspace, within `FILE_SCOPE`.                                                               |
 | `MODE`                      | `INITIAL` or `CORRECTIVE`.                                                                                                                            |
 
 Accept populated template labels or equivalent structured fields, including grouped headings with labeled values beneath them. Legacy `For a fix: NONE` selects initial mode; populated fix context selects corrective mode. For `CORRECTIVE`, read `references/implementer-corrections.md` in the `int-subagent-driven-dev` skill before accepting the gate. Initial assignments need no corrective fields or resource.
@@ -74,4 +74,4 @@ Save the report at `REPORT_PATH` with:
 - For corrective mode, include the finding evidence required by `references/implementer-corrections.md` in the `int-subagent-driven-dev` skill.
 - A concise hand-back summary; include commit identifiers only when authorized.
 
-Update only assigned tracker files in `.scratch`, preserving history. Failed or unavailable required implementer checks block completion. Return the report path and concise summary, then stop. If the assignment gate is incomplete, return the context request instead of writing a report.
+Write only the assigned report in the canonical feature workspace; the controller owns tracker updates. Failed or unavailable required implementer checks block completion. Return the report path and concise summary, then stop. If the assignment gate is incomplete, return the context request instead of writing a report.

package/build/Assets/Blueprints/agents/sdd-orchestrator.agent.md

@@ -4,10 +4,10 @@ description: "Use when coordinating feature tickets, implementation, review, and
 argument-hint: The feature spec, tickets, constraints, and permissions.
 user-invocable: true
 tools: [vscode/askQuestions, execute, read, agent, edit, web, todo, read_skill, list_skills, skill]
-agents: [sdd-implementer, sdd-reviewer, sdd-code-reviewer, shared-explore]
+agents: [sdd-implementer, sdd-task-reviewer, sdd-reviewer, sdd-code-reviewer, shared-explore]
 metadata:
   spindle:
-    version: 1.2.1
+    version: 1.4.0
 ---
 
 You are the SDD orchestration agent for feature tickets and feature-level delivery. Follow the user's scope and permissions.
@@ -23,11 +23,8 @@ the current harness before dispatch. Catalog `canReview: true` establishes
 eligibility only; it does not establish harness access. Never create an
 automatic or default specialist batch.
 
-Close a ticket with `sdd ticket update --status closed` after its acceptance
-criteria are met. Do not require per-ticket accept or integration commands.
-Feature completion requires every ticket closed, current passing feature checks
-and reviews, and no unresolved delivery blockers. Use the normal Git workflow;
-never ask the CLI to stage, commit, stash, discard, push, or publish.
+Finish only after aggregate review, the final merge, and its declared checks.
+Preserve worktrees and records whenever validation or cleanup is blocked.
 
 <communication-style>
 - **ALWAYS** think and respond in the same spoken language the prompt was written in.

package/build/Assets/Blueprints/skills/author-agent/SKILL.md

@@ -15,13 +15,13 @@ Create or update a project agent in `.github/agents/<agent-name>.agent.md` based
 
 {{ computed.authoring_flowchart }}
 
-Before grilling, read and consider only the `int-writing-for-agents` and `asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
+Before grilling, read and consider only the `int-writing-for-agents` and `ref-asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
 
 After the user confirms shared understanding, load and follow:
 
 - **REQUIRED:** `int-writing-agents`
 - **REQUIRED:** `int-testing-agent-guidance`
 
-Apply the clarity rules from the `asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
+Apply the clarity rules from the `ref-asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
 
 Do not modify unrelated files. Report the skill changed and validation performed, including any blockers or unverified requirements.

package/build/Assets/Blueprints/skills/author-instruction/SKILL.md

@@ -15,14 +15,14 @@ Create or update a project instruction in `.github/instructions/**/*.instruction
 
 {{ computed.authoring_flowchart }}
 
-Before grilling, read and consider only the `int-writing-for-agents` and `asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
+Before grilling, read and consider only the `int-writing-for-agents` and `ref-asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
 
 After the user confirms shared understanding, load and follow:
 
 - **REQUIRED:** `int-writing-instruction`
 - **REQUIRED:** `int-testing-agent-guidance`
 
-Apply the clarity rules from the `asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
+Apply the clarity rules from the `ref-asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
 
 Verify any `applyTo` glob against concrete in-scope files and near misses; every intended file must match, and out-of-scope files must not.
 

package/build/Assets/Blueprints/skills/author-skill/SKILL.md

@@ -15,13 +15,13 @@ Create or update a project skill in `.github/skills/<skill-name>/SKILL.md` based
 
 {{ computed.authoring_flowchart }}
 
-Before grilling, read and consider only the `int-writing-for-agents` and `asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
+Before grilling, read and consider only the `int-writing-for-agents` and `ref-asd-ste100` skills. Do not follow their workflows or load skills they reference yet.
 
 After the user confirms shared understanding, load and follow:
 
 - **REQUIRED:** `int-writing-skills`
 - **REQUIRED:** `int-testing-agent-guidance`
 
-Apply the clarity rules from the `asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
+Apply the clarity rules from the `ref-asd-ste100` skill. Include a before/after table only when the user requests one. Run the core and expanded testing workflows in `int-testing-agent-guidance` for every authoring request.
 
 Do not modify unrelated files. Report the skill changed and validation performed, including any blockers or unverified requirements.

package/build/Assets/Blueprints/skills/int-subagent-driven-dev/SKILL.md

@@ -4,15 +4,13 @@ description: "This is an internal skill do not load it unless explicitly require
 user-invocable: false
 metadata:
   spindle:
-    version: 1.4.0
+    version: 1.6.0
 ---
 
 # Subagent-Driven Development
 
 The controller coordinates a feature's tickets, workers, checks, reviews, and completion. The feature workspace and `sdd.json` are the source of truth for structured ticket and delivery state; each ticket Markdown file holds its requirements, acceptance criteria, and discussion.
 
-Use the existing checkout and preserve user changes and report history. TDD is optional; write appropriate tests and record verification evidence. Load and follow `int-verification-before-completion` before claiming work is complete. Serialize implementation and fixes, and keep implementation edits frozen while a review batch is running.
-
 ## Workflow map
 
 Before acting on each chart node, announce `Step <node ID> - <node label>`, including initial entries, resumed steps, and loop re-entries. After each decision, state its result and selected branch before entering the target node.
@@ -20,7 +18,7 @@ Before acting on each chart node, announce `Step <node ID> - <node label>`, incl
 ```mermaid
 flowchart TD
     A[Restore feature state and readiness] --> B{Ready ticket available?}
-    B -- Yes --> C[Claim, implement, verify, submit, close ticket]
+    B -- Yes --> C[Implement, review, integrate, and validate tickets]
     C --> A
     B -- No --> D{All tickets closed?}
     D -- No --> E[Resolve prerequisites or record blocker]
@@ -41,11 +39,17 @@ flowchart TD
 
 ## Ticket workflow
 
-1. Read the feature spec, tickets, applicable instructions, glossary, and ADRs. Inspect `{{ computed.spindle_package_manager }} spindle sdd status --spec <path>` and `{{ computed.spindle_package_manager }} spindle sdd ready --spec <path>` to understand blockers, dependencies, and available work.
+1. Read the feature spec, tickets, applicable instructions, glossary, and ADRs. Inspect `{{ computed.spindle_package_manager }} spindle sdd status --spec <path>` and `{{ computed.spindle_package_manager }} spindle sdd ready --spec <path>` to understand blockers, dependencies, and available work. Inspect feature records for secrets and start the feature worktree with `{{ computed.spindle_package_manager }} spindle sdd start --spec <path> --workspace <external-directory> --confirm-records`. Handle unrelated changes before starting. Run subsequent controller commands in the feature worktree using its returned spec path.
 2. Create a ticket for independently actionable work with `{{ computed.spindle_package_manager }} spindle sdd ticket create`. Fill its `[REQUIREMENTS]` and `[ACCEPTANCE CRITERIA]` placeholders. Use `{{ computed.spindle_package_manager }} spindle sdd ticket update` for tracker status, explicit blockers, and dependencies; the supported lifecycle is `open`, `in-progress`, and `closed`. Readiness is derived from status, blockers, and dependencies rather than stored as a separate triage state.
-3. Claim a ready ticket with `{{ computed.spindle_package_manager }} spindle sdd claim`. Dispatch implementation with `{{ computed.spindle_package_manager }} spindle sdd implement`; pass the worker the exact assignment and report destination. Submit its report with `{{ computed.spindle_package_manager }} spindle sdd submit --role implementation`.
-4. Run relevant tests and checks and record their actual outcomes against the current snapshot. TDD is not required, but verification is.
-5. Address implementation and verification gaps, then close the ticket with `{{ computed.spindle_package_manager }} spindle sdd ticket update --status closed` once its acceptance criteria are met. Do not use per-ticket accept or integrate steps.
+3. Choose a safe concurrency limit. Use `{{ computed.spindle_package_manager }} spindle sdd implement --workspace <external-directory>` for each ready ticket and dispatch the returned assignment until capacity is full. As workers finish, dispatch other ready independent tickets without waiting for unrelated work. Inspect changed canonical records for secrets and pass `--confirm-records` before any automatic record commit. Each worker uses its own worktree. Give workers the canonical source and report paths; submit each implementation report with `{{ computed.spindle_package_manager }} spindle sdd submit --role implementation`.
+4. Have each implementer commit its changes. Record relevant checks and submit reviews against that exact ticket commit. Keep its worktree frozen during review; any changed commit requires fresh checks and review.
+5. Use `{{ computed.spindle_package_manager }} spindle sdd integrate` to merge reviewed work, inspecting changed canonical records and passing `--confirm-records` before any automatic record commit. Serialize merges and their post-merge checks. Declare the full non-empty check list with `checks require --scope post-merge`, run it in the feature worktree, and record results with `checks record --scope post-merge`. Passing checks close the ticket automatically and unblock eligible dependents.
+
+   If closure is blocked by a ticket blocker or unmet dependency, resolve it and repeat `checks require --scope post-merge` with the same complete list. Passing evidence is retained; rerun checks if their snapshot became stale.
+
+   If a post-merge check fails, keep other merges blocked. Fast-forward the clean ticket worktree to the recorded failed merge commit, then use `sdd correct --check-failure <command>` to dispatch a fix. Commit, check, and review the fix before merging it and rerunning the frozen post-merge check list.
+
+   If integration reports a conflict, rebase the ticket worktree onto the current feature branch, resolve and commit the conflict there, and use `sdd checks require --rebase-baseline` with an existing required command. Run fresh checks and obtain fresh review before retrying integration. Preserve all uncommitted changes and stop if recovery is unsafe.
 
 If work is interrupted, inspect `{{ computed.spindle_package_manager }} spindle sdd status` and use `{{ computed.spindle_package_manager }} spindle sdd resume` to restore the recorded assignment. Preserve existing reports, findings, and evidence. Do not invent missing results or reset progress.
 
@@ -55,7 +59,7 @@ After every ticket is closed, establish current feature-level checks and request
 
 Submit every assigned review report against its exact assignment. Register findings from their report and snapshot. A blocking finding can name `--related-ticket`; once the complete review batch is submitted, that ticket is reopened so work can resume. Resolve blocking findings through ticket work and repeat any invalidated checks and reviews.
 
-For detailed review, findings, correction, and finish steps, read [feature delivery](./references/full-spec.md). For feature-level corrective work, follow [corrective rounds](./references/corrective-rounds.md). Feature completion requires all tickets closed, current passing required checks and reviews, and no unresolved delivery blockers. Use the normal Git workflow; SDD does not stage, commit, or publish work and has no per-ticket integration command.
+For detailed review, findings, correction, final merge, checks, and cleanup, read [feature delivery](./references/full-spec.md). For feature-level corrective work, follow [corrective rounds](./references/corrective-rounds.md). Feature completion requires all tickets integrated, current passing required checks and reviews, no unresolved delivery blockers, and passing checks on the final merge. Do not modify the affected checkout concurrently with a Git transition. Never stash, discard, force-delete, push, or publish without authorization.
 
 ## Reports and verification
 

package/build/Assets/Blueprints/skills/int-subagent-driven-dev/assets/implementer-prompt.md

@@ -4,7 +4,7 @@
 ## Assignment
 
 Implement ticket: [TICKET_ID]
-Checkout: [CHECKOUT]
+Ticket worktree: [CHECKOUT]
 Mode: [INITIAL_OR_CORRECTIVE]
 
 ## Requirements and starting state
@@ -20,7 +20,7 @@ Completed dependencies and starting snapshot:
 
 ## Scope and permissions
 
-Allowed code, test, and `.scratch` files:
+Allowed code and test files in the ticket worktree, and the canonical report path:
 [FILE_SCOPE]
 
 Permissions, including commit authorization:

package/build/Assets/Blueprints/skills/int-subagent-driven-dev/references/example-workflow.md

@@ -9,17 +9,19 @@ status and dependencies.
 2. Record the dependency with
    `{{ computed.spindle_package_manager }} spindle sdd ticket update --ticket T-0002 --blocked-by T-0001`. Check `{{ computed.spindle_package_manager }} spindle sdd ready`:
    the prerequisite is ready and the dependent ticket is not.
-3. Claim and implement `T-0001`, submit its report, run and record relevant
-   checks, then close it with `{{ computed.spindle_package_manager }} spindle sdd ticket update --status closed`.
-4. `T-0002` becomes ready because its dependency is closed. Implement and
-   verify it in the same way, then close it.
+3. Start the feature worktree in the supplied external directory. Implement
+   `T-0001` in its ticket worktree, submit its report, review the committed
+   change, and merge it into the feature branch. Declare and record passing
+   post-merge checks before it closes.
+4. `T-0002` becomes ready once its dependency is integrated and validated.
+   Branch it from the updated feature branch and deliver it in the same way.
 5. Record current feature-level required checks and request the comprehensive
    review with `{{ computed.spindle_package_manager }} spindle sdd review --scope delivery`. Add only justified specialists.
 6. Submit every assigned report. Register findings from their report and
    snapshot. A blocking finding can reopen its related ticket; complete the
    correction, close the ticket again, and refresh stale checks and review.
-7. Finish when every ticket is closed, all required checks and reviews pass on
-   the current feature snapshot, and no delivery blockers remain.
-
-Use the normal Git workflow for code. There is no per-ticket accept or
-integration step; the SDD CLI does not stage or commit changes.
+7. Inspect canonical records and run `sdd finish --confirm-records` from the
+   feature worktree. In the original checkout, declare and run the complete
+   `checks require --scope final` list, record results against the returned
+   merge and snapshot, then run `sdd finish` again to clean up. The checked
+   merge and the later metadata-only commit are reported separately.

package/build/Assets/Blueprints/skills/int-subagent-driven-dev/references/full-spec.md

@@ -50,21 +50,41 @@ preserve existing assignments, attempts, evidence, and adjudication.
 
 ## Finish
 
-Use the normal Git workflow for code changes. SDD does not stage, commit,
-publish, or require a per-ticket integration confirmation. A changed code or
+Review each committed ticket before merging it into the feature worktree, then
+record post-merge checks before unblocking dependents. A changed code or
 requirements snapshot invalidates evidence that no longer covers it.
 
-Legacy feature workspaces without a recorded Git baseline stay blocked until
-the original comparison baseline is identified. Do not silently use the
-current `HEAD` after implementation; that could omit completed feature work
-from review.
-
-Finish with `{{ computed.spindle_package_manager }} spindle sdd finish --spec <spec> --author <author>`. Completion requires
-at least one ticket, every ticket closed, current passing required feature
-checks and reviews, and no unresolved delivery blockers. The retrospective
-policy is stored at feature creation: when required, attach a Markdown report
-with `--report`; otherwise it is optional. Any report must remain inside that
-feature's `reports/` directory.
+Do not silently substitute the current `HEAD` for the recorded Git baseline;
+that could omit completed feature work from review.
+
+Completion requires at least one ticket, every ticket integrated and validated,
+current passing required feature checks and reviews, and no unresolved delivery
+blockers. The retrospective policy is stored at feature creation: when required,
+attach a Markdown report with `--report`; otherwise it is optional. Any report
+must remain inside that feature's `reports/` directory.
+
+Inspect canonical records for sensitive content, then run
+`{{ computed.spindle_package_manager }} spindle sdd finish --spec <feature-spec> --author <controller> --confirm-records`
+from the feature worktree, adding `--report <absolute-report-path>` when needed.
+This merges into the recorded original branch and returns a pending final
+validation, merge SHA, snapshot, and original spec path; it does not yet complete
+the feature.
+
+In the original checkout, declare the entire non-empty final list with
+`{{ computed.spindle_package_manager }} spindle sdd checks require --spec <original-spec> --scope final --command <command> --author <controller>`,
+repeating `--command` for each check. Run each command there, then record each
+actual result with `{{ computed.spindle_package_manager }} spindle sdd checks record --spec <original-spec> --scope final --merge <merge-sha> --snapshot <snapshot> --command <command> --result <result> --author <controller>`.
+Failed or unavailable results require `--details` and block cleanup until the
+latest result for each command passes. The list is frozen once declared.
+
+Run `{{ computed.spindle_package_manager }} spindle sdd finish --spec <original-spec> --author <controller>`
+again to preflight and clean up the recorded worktrees and branches. The final
+merge is the checked commit; the subsequent ledger-only relocation commit is
+reported separately and is not itself checked. Preserve any dirty or unexpected
+work and follow the reported journal for recovery rather than forcing cleanup.
+Ignored files in worktrees slated for removal also block cleanup; do not discard
+them without authorization. After a crash, remove a reported finalization lock
+only after verifying its recorded owner has stopped.
 
 Use `{{ computed.spindle_package_manager }} spindle sdd status`, `{{ computed.spindle_package_manager }} spindle sdd next`, and
 `{{ computed.spindle_package_manager }} spindle sdd resume --scope delivery` to inspect blockers and

package/build/Assets/Blueprints/skills/int-subagent-driven-dev/references/review-inputs.md

@@ -6,18 +6,18 @@ Read when preparing or accepting a review assignment. The controller supplies th
 
 `REVIEW_INPUTS` names an absolute, read-required package/manifest path. Read it and its required sources before inspecting the checkout or reviewing. Equivalent structured inputs inline remain valid; preserve supplied values rather than inferring missing revisions from Git.
 
-| Input                  | Required meaning                                                                                                                                                                                                                          |
-| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Requirements           | Canonical ticket/spec/comments pointers, applicable instructions, criteria, and constraints. Identify inapplicable sources explicitly.                                                                                                    |
-| Workspace and snapshot | Absolute shared checkout; exact reviewed identity, comparison base and head revisions, and included dirty/untracked changes or `NONE`. SHAs are provenance metadata and may live in the package rather than repeated prompt fields.       |
-| Complete change        | Complete assigned diff with file inventory, stat, and enough context, or approved read-only retrieval using supplied revisions. Include dirty/untracked additions and binary changes, or identify unavailable material as a coverage gap. |
-| Verification           | Commands, results, test summary, exact snapshot covered, and unavailable required checks. Evidence pointers are valid; read them before judging coverage.                                                                                 |
+| Input                  | Required meaning                                                                                                                                                                                                                                               |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Requirements           | Canonical ticket/spec/comments pointers, applicable instructions, criteria, and constraints. Identify inapplicable sources explicitly.                                                                                                                         |
+| Workspace and snapshot | Absolute ticket or feature worktree, as appropriate; exact reviewed identity, comparison base and head revisions, and included dirty/untracked changes or `NONE`. SHAs are provenance metadata and may live in the package rather than repeated prompt fields. |
+| Complete change        | Complete assigned diff with file inventory, stat, and enough context, or approved read-only retrieval using supplied revisions. Include dirty/untracked additions and binary changes, or identify unavailable material as a coverage gap.                      |
+| Verification           | Commands, results, test summary, exact snapshot covered, and unavailable required checks. Evidence pointers are valid; read them before judging coverage.                                                                                                      |
 
 Keep every meaning authoritative in one place: reference canonical requirements, reports, and evidence rather than copying full logs or the entire ledger. A pointer must identify the required material, not merely say "see ledger". The role-specific assignment supplies phase, objective, history relevant to that role, and its distinct report destination.
 
 ## Snapshot ownership and completeness
 
-The controller owns construction, freezing, and freshness checks. Reuse existing durable complete diffs and evidence; no additional packaging command or hash scheme is required. The identity must distinguish uncommitted/untracked content, not just HEAD. Keep implementation frozen throughout the review batch, allowing assigned report writes without changing the reviewed code identity.
+The controller owns construction, freezing, and freshness checks. Reuse existing durable complete diffs and evidence; no additional packaging command or hash scheme is required. Ticket reviews must cover the exact committed ticket revision and its complete change against the assigned base. Keep that worktree clean and frozen throughout the review batch; reports are written to the canonical feature workspace.
 
 Corrections produce a new reviewed identity with fresh covering checks. Preserve the previous package and evidence as history rather than relabeling them as verification of changed code.
 

package/build/Assets/Blueprints/skills/{asd-ste100 → ref-asd-ste100}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: asd-ste100
+name: ref-asd-ste100
 description:  "Rewrites ambiguous English into ASD-STE100 style — one meaning per word, active voice, simple tense, short sentences. Use when agent output is hard to parse; triggers: simplify this, STE100 rewrite."
 user-invocable: false
 metadata:

package/build/Assets/Blueprints/skills/sdd-author-design/SKILL.md

@@ -16,9 +16,9 @@ Help the user clarify what they want before turning an idea into a design. A des
 
 Before drafting or editing, read:
 
-- **REQUIRED:** `asd-ste100`
+- **REQUIRED:** `ref-asd-ste100`
 
-Apply the clarity rules from the `asd-ste100` skill. Include a before/after table only when the user requests one.
+Apply the clarity rules from the `ref-asd-ste100` skill. Include a before/after table only when the user requests one.
 
 ## Process
 

package/build/Assets/Blueprints/skills/sdd-implement-spec/SKILL.md

@@ -4,13 +4,11 @@ description: "Implement the result of /sdd-to-spec and /sdd-to-tickets in code."
 disable-model-invocation: true
 metadata:
   spindle:
-    version: 1.0.0
+    version: 1.2.0
 ---
 
 # Implement a Spec
 
-Deliver the supplied spec and all associated tickets in the existing checkout. Require configured tracker guidance; if absent, request `/spindle-project-setup`.
-
 ## Required Skills
 
 Before acting, read and follow each required skill:
@@ -19,15 +17,15 @@ Before acting, read and follow each required skill:
 
 ## Steps
 
-1. **Bind the whole-spec assignment.** Locate the full spec, every ticket and its comments, and tracker guidance. Supply accessible context pointers rather than duplicating their contents. Record the existing checkout, starting revision, existing work and permissions.
+1. **Bind the whole-spec assignment.** Locate the full spec, every ticket and its comments, and tracker guidance. Supply accessible context pointers rather than duplicating their contents. Record the original branch, existing work, permissions, and the allowed feature worktree location; obtain an allowed location for each ticket at dispatch.
 
    **Complete when:** the complete graph and delivery inputs are available to one controller, or missing requirements are reported for triage.
 
-2. **Execute the complete graph.** Follow [int-subagent-driven-dev](../int-subagent-driven-dev/SKILL.md) once with the entire graph and explicit ownership of frontier selection, sequential ticket delivery, aggregate review, and retrospective. Do not call it as a separate standalone delivery for every ticket. Its dependency validation, shared-checkout workflow, resume handling, review budgets, and completion criteria are authoritative. Accepted work does not unblock dependents until integrated and verified in the existing checkout.
+2. **Execute the complete graph.** Follow the `int-subagent-driven-dev` skill once with the entire graph and explicit ownership of frontier selection, ticket delivery, aggregate review, and retrospective. Accepted work does not unblock dependents until integrated and verified in the feature worktree.
 
    If the tracker calls for a PR, or the user requests one, open an authorized draft during execution after the first authorized commit is available; retain it as draft while delivery is incomplete.
 
-   **Complete when:** its final report reconciles every ticket and requirement, one aggregate review, fresh verification and one retrospective for the spec, or explicitly identifies unfinished work and blockers.
+   **Complete when:** its final report reconciles every ticket and requirement, one aggregate review, fresh verification, and any retrospective required by policy or requested by the user, or explicitly identifies unfinished work and blockers.
 
 3. **Apply authorized publication transitions.** Mark an authorized draft ready only after the full delivery's review and checks pass. Apply closing references and ticket closure only with the user's authorization.
 

package/build/Assets/Templates/project/ticket-tracker.md

@@ -26,8 +26,16 @@ The command returns the new ticket ID and path. Complete its template, then set
 {{ computed.spindle_package_manager }} spindle sdd ready --spec <absolute-spec-path>
 ```
 
-Use `--clear-blocked-by` to remove dependencies. Use `ticket update --status` to change status. Ticket Markdown remains editable; attributed comments are appended under `## Comments`. Do not add an execution field to the ticket file: execution transitions are recorded in `sdd.json`.
+Use `--clear-blocked-by` to remove dependencies. Ticket Markdown remains editable; attributed comments are appended under `## Comments`. Do not add an execution field to the ticket file: execution transitions are recorded in `sdd.json`.
 
 ## Delivery
 
-Use `{{ computed.spindle_package_manager }} spindle sdd status` and `{{ computed.spindle_package_manager }} spindle sdd ready` to inspect work. Claim and dispatch ready tickets with `{{ computed.spindle_package_manager }} spindle sdd claim` and `{{ computed.spindle_package_manager }} spindle sdd implement`, submit the assigned report with `{{ computed.spindle_package_manager }} spindle sdd submit`, and close completed tickets with `{{ computed.spindle_package_manager }} spindle sdd ticket update --status closed`. Follow the `int-subagent-driven-dev` skill for review, correction, and feature completion.
+Use `{{ computed.spindle_package_manager }} spindle sdd status` and `{{ computed.spindle_package_manager }} spindle sdd ready` to inspect work. Follow the `int-subagent-driven-dev` skill for dispatch, review, correction, integration, and feature completion.
+
+Inspect feature records for sensitive content, then start a feature worktree in an existing external directory with `{{ computed.spindle_package_manager }} spindle sdd start --spec <absolute-spec-path> --workspace <absolute-directory> --confirm-records`. Use its returned spec path for subsequent commands.
+
+Dispatch each ready ticket to a separate worktree with `{{ computed.spindle_package_manager }} spindle sdd implement --spec <feature-spec-path> --ticket <id> --author <name> --workspace <absolute-directory>`. Inspect changed canonical records and pass `--confirm-records` before automatic record commits. Submit the implementation report and review the committed ticket before merging it with `{{ computed.spindle_package_manager }} spindle sdd integrate`.
+
+Declare the complete post-merge check list with `checks require --scope post-merge --ticket <id>`, run the checks, and record each result with `checks record --scope post-merge --ticket <id>`. Passing results close the ticket automatically unless a blocker or dependency prevents closure. Resolve it, then repeat `checks require` with the same complete list; rerun any stale checks. Failed checks block other merges until a reviewed correction passes. Resolve conflicts in the ticket worktree, adopt the rebased baseline with `checks require --rebase-baseline`, and obtain fresh checks and review.
+
+After aggregate checks and review pass, inspect records and run `{{ computed.spindle_package_manager }} spindle sdd finish --spec <feature-spec-path> --author <name> --confirm-records` from the feature worktree. Include `--report <absolute-report-path>` when a retrospective is required. In the original checkout, declare the complete list with `checks require --scope final`, run the checks, and record each result with `checks record --scope final --merge <merge-sha> --snapshot <snapshot>`. Repeat `finish` there to preflight and clean up. Final checks cover the merge; a separate ledger-only relocation commit follows. Preserve work and inspect the journal if recovery or cleanup is blocked.

package/build/SubagentDrivenDevelopment/Commands/ChecksRecordCommand.js

@@ -2,6 +2,7 @@ import { Command } from "../../Commands/Command.js";
 import { CommandOptions } from "../../Commands/CommandOptions.js";
 import { group } from "./groups.js";
 import { ChecksService } from "../Services/ChecksService.js";
+import { FeatureFinalizationService } from "../Services/FeatureFinalizationService.js";
 export class ChecksRecordCommand extends Command {
     static register(root, createApp) {
         group(root, "checks")
@@ -9,7 +10,8 @@ export class ChecksRecordCommand extends Command {
             .description("Record an externally executed check against a current snapshot.")
             .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
             .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
-            .option("--scope <scope>", "Workflow scope: delivery")
+            .option("--scope <scope>", "Workflow scope: delivery, post-merge or final")
+            .option("--merge <sha>", "Exact feature merge commit; required for scope final", CommandOptions.once("--merge"))
             .requiredOption("--snapshot <snapshot>", "CLI-returned content snapshot identity", CommandOptions.once("--snapshot"))
             .requiredOption("--command <command>", "Exact required command", CommandOptions.once("--command"))
             .requiredOption("--result <result>", "Check result: passed, failed, unavailable", CommandOptions.once("--result"))
@@ -18,11 +20,12 @@ export class ChecksRecordCommand extends Command {
             .requiredOption("--author <author>", "Acting controller", CommandOptions.once("--author"))
             .allowExcessArguments(false)
             .action(async (options) => {
-            if (options.scope !== undefined && options.scope !== "delivery") {
-                throw new Error("--scope must be 'delivery'.");
+            if (options.scope !== undefined &&
+                !["delivery", "post-merge", "final"].includes(options.scope)) {
+                throw new Error("--scope must be 'delivery', 'post-merge' or 'final'.");
             }
-            if (Boolean(options.ticket) === (options.scope === "delivery")) {
-                throw new Error("checks record needs exactly one of --ticket or --scope delivery.");
+            if ((options.scope === "delivery" || options.scope === "final") === Boolean(options.ticket)) {
+                throw new Error("checks record needs --ticket or --scope delivery/final; scope post-merge also needs --ticket.");
             }
             const command = await (await createApp()).make(ChecksRecordCommand);
             console.log(JSON.stringify(await command.run(options), null, 2));
@@ -30,6 +33,25 @@ export class ChecksRecordCommand extends Command {
     }
     async run(options) {
         this.assertApplicationBooted();
+        if (options.scope === "final") {
+            if (options.ticket || options.paths || !options.merge)
+                throw new Error("Final records require --merge and do not accept ticket/path coverage.");
+            const finalization = await this.app.make(FeatureFinalizationService);
+            const feature = finalization.recordedFeature(options.spec);
+            if (!feature)
+                throw new Error("Final records require a recorded feature merge.");
+            return finalization.record({
+                feature: feature.feature,
+                merge: options.merge,
+                snapshot: options.snapshot,
+                command: options.command,
+                result: options.result,
+                author: options.author,
+                ...(options.details ? { details: options.details } : {}),
+            });
+        }
+        if (options.merge)
+            throw new Error("--merge is only valid with --scope final.");
         return (await this.app.make(ChecksService)).checksRecord(options);
     }
 }

package/build/SubagentDrivenDevelopment/Commands/ChecksRequireCommand.js

@@ -2,6 +2,7 @@ import { Command } from "../../Commands/Command.js";
 import { CommandOptions } from "../../Commands/CommandOptions.js";
 import { group } from "./groups.js";
 import { ChecksService } from "../Services/ChecksService.js";
+import { FeatureFinalizationService } from "../Services/FeatureFinalizationService.js";
 export class ChecksRequireCommand extends Command {
     static register(root, createApp) {
         group(root, "checks")
@@ -9,25 +10,48 @@ export class ChecksRequireCommand extends Command {
             .description("Add or remove a required external check.")
             .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
             .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
-            .option("--scope <scope>", "Workflow scope: delivery")
-            .requiredOption("--command <command>", "Exact externally executed command", CommandOptions.once("--command"))
+            .option("--scope <scope>", "Workflow scope: delivery, post-merge or final")
+            .requiredOption("--command <command>", "Exact externally executed command; repeat for post-merge or final lists", (value, previous = []) => [...previous, value], [])
             .option("--remove", "Remove the requirement; requires --details rationale")
+            .option("--rebase-baseline", "Adopt current feature HEAD after manually rebasing the ticket worktree")
             .option("--details <details>", "Removal rationale")
             .requiredOption("--author <author>", "Acting controller", CommandOptions.once("--author"))
             .allowExcessArguments(false)
             .action(async (options) => {
-            if (options.scope !== undefined && options.scope !== "delivery") {
-                throw new Error("--scope must be 'delivery'.");
+            if (options.scope !== undefined &&
+                options.scope !== "delivery" &&
+                options.scope !== "post-merge" &&
+                options.scope !== "final") {
+                throw new Error("--scope must be 'delivery', 'post-merge' or 'final'.");
             }
-            if (Boolean(options.ticket) === (options.scope === "delivery")) {
-                throw new Error("checks require needs exactly one of --ticket or --scope delivery.");
+            if ((options.scope === "delivery" || options.scope === "final") === Boolean(options.ticket)) {
+                throw new Error("checks require needs --ticket or --scope delivery/final; scope post-merge also needs --ticket.");
             }
+            if (options.scope !== "post-merge" &&
+                options.scope !== "final" &&
+                options.command.length !== 1)
+                throw new Error("Exactly one --command is required outside scopes post-merge and final.");
             const command = await (await createApp()).make(ChecksRequireCommand);
-            console.log(JSON.stringify(await command.run(options), null, 2));
+            console.log(JSON.stringify(await command.run({
+                ...options,
+                command: options.scope === "post-merge" || options.scope === "final"
+                    ? options.command
+                    : options.command[0],
+            }), null, 2));
         });
     }
     async run(options) {
         this.assertApplicationBooted();
+        if (options.scope === "final") {
+            if (options.ticket || options.remove || options.details || options.rebaseBaseline) {
+                throw new Error("Final declarations do not accept ticket, removal, rebase or coverage options.");
+            }
+            return (await this.app.make(FeatureFinalizationService)).declare({
+                spec: options.spec,
+                command: Array.isArray(options.command) ? options.command : [options.command],
+                author: options.author,
+            });
+        }
         return (await this.app.make(ChecksService)).checksRequire(options);
     }
 }

package/build/SubagentDrivenDevelopment/Commands/CorrectCommand.js

@@ -15,7 +15,6 @@ export class CorrectCommand extends Command {
             .requiredOption("--details <details>", "Correction objective or adjudication rationale", CommandOptions.once("--details"))
             .option("--decision <decision>", "Continuation decision: continue or pause")
             .option("--assessment <assessment>", "Recorded progress assessment for the prior attempt")
-            .option("--assessment-result <result>", "Progress result: productive")
             .option("--reason <reason>", "Pause reason: no-progress, repeated-failure, recurring-blocker, requirements-disagreement, worker-blocked")
             .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
             .allowExcessArguments(false)

package/build/SubagentDrivenDevelopment/Commands/FinishCommand.js

@@ -6,10 +6,11 @@ export class FinishCommand extends Command {
     static register(root, createApp) {
         group(root)
             .command("finish")
-            .description("Complete feature delivery after all tickets are closed and required checks and reviews pass.")
+            .description("Merge approved feature delivery, then clean up only after exact final-merge checks pass.")
             .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
             .option("--report <path>", "Optional or policy-required Markdown report inside feature reports/", CommandOptions.once("--report"))
             .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .option("--confirm-records", "Confirm inspected canonical records may be committed")
             .allowExcessArguments(false)
             .action(async (options) => {
             const command = await (await createApp()).make(FinishCommand);

package/build/SubagentDrivenDevelopment/Commands/ImplementCommand.js

@@ -10,6 +10,8 @@ export class ImplementCommand extends Command {
             .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
             .requiredOption("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
             .requiredOption("--author <author>", "Controller author", CommandOptions.once("--author"))
+            .requiredOption("--workspace <directory>", "Existing absolute external directory for the ticket worktree", CommandOptions.once("--workspace"))
+            .option("--confirm-records", "Confirm that current canonical feature records were inspected before batching")
             .allowExcessArguments(false)
             .action(async (options) => {
             const command = await (await createApp()).make(ImplementCommand);