ultra-builder-pro-cli 0.25.1 → 0.26.1

package/skills/ultra-change/SKILL.md

@@ -1,54 +1,119 @@
 ---
 name: ultra-change
-description: Capture or revise one bounded feature, fix, redesign, or incident contract against a ready Ultra baseline. Use when post-baseline work needs accepted intent before research, planning, or implementation.
+description: Open one bounded unit of work by first reconciling what the specifications promise against what the code actually does, then writing the intent that closes the gap. Use when nothing is in flight and something new is being asked for — a feature, a fix, a redesign, or an incident response.
 ---
 
-# Capture accepted Change intent
-
-A Change is the durable unit connecting research, plan, implementation, verification,
-review, documentation, and delivery. Its draft stays editable until a semantic
-checkpoint accepts the downstream authority.
-
-## Inspect and align
-
-1. Call `ultra.context { stage: project, detail: full }`.
-2. Inspect or import the team checkpoint with `ultra.sync`. Stop only on a real
-   baseline, Change, task, ancestry, or active-session conflict.
-3. Reuse an existing matching Change. Do not duplicate authority.
-4. Convert the request into observable outcome, executable acceptance, non-goals,
-   public seams, recovery, verification, documentation impact, risk, and research
-   disposition.
-5. Recommend `quick`, `standard`, `major`, or `incident` from evidence, or record a
-   clearer bounded repository-specific kind when those profiles lose meaning. These
-   are model-owned labels, not SQLite enums. Ask only when
-   a choice changes accepted product intent, compatibility, security, material cost,
-   external effects, or recovery.
-
-Read `../ultra-think/references/interaction-boundary.md` before asking. MCP may report
-contradictory risk fields, but the model and owner choose the semantic correction.
-
-## Record the contract
-
-Use one `ultra.record` batch with `change_contract / open` or
-`change_contract / revise`, relevant `decision / accept`, and `artifact / bind` for
-an already-known typed delta. Every entry carries a stable idempotency key. Read the
-result through `ultra.context`.
-
-Keep every Change-owned semantic artifact below
-`.ultra/changes/active/<change-id>/`. Standard and major Changes require a typed delta
-before planning. A true no-semantic-change case records an explicit reason instead of
-manufacturing a mutation.
-
-Changing accepted intent creates a new accepted checkpoint revision and makes only
-genuinely dependent evidence stale. Readiness is derived, not a stored absorbing
-state. Semantic diagnostics remain advisory; structural, digest, path, or concurrency
-conflicts require repair and retry of the same draft.
-Use `change_contract / cancel` only when the owner intentionally abandons the Change.
-An archived or cancelled Change remains immutable history. When new evidence requires
-continued work, use `change_contract / supersede` to create one linked active successor;
-never patch SQLite, reopen the historical row, or duplicate the relationship manually.
-
-Publish the durable Change contract with `ultra.sync { action: publish }` when it is a
-useful team handoff. Recommend bounded `ultra-research` for a real evidence gap or
-`ultra-plan` when the contract is sufficiently evidenced. Do not invoke the next
-capability automatically.
+# Reconcile first, then write down what this Change commits to
+
+A Change is the durable unit connecting research, plan, implementation,
+verification, review and delivery. Reconciliation comes first because writing new
+intent on top of specifications that already disagree with the code buries the
+disagreement instead of resolving it.
+
+## Before you start
+
+1. Read `.ultra/tasks.json`, and the `context_file` of any task not yet finished.
+2. Read `CONTEXT.md` for vocabulary and `.ultra/decisions/` for entries in scope.
+3. Read `.ultra/north-star.md` — a Change that does not serve it is worth
+   questioning out loud before it is written down.
+4. Grep `.ultra/changes/archive/` for Changes that already touched this area. Read
+   `delivery.md` when present; otherwise read `archive-summary.md`, `verification.md` and
+   remaining owner-readable Markdown. A missing `delivery.md` does not mean no history;
+   a module that keeps reappearing is an architecture signal.
+
+## Whether this skill applies at all
+
+| Situation | Where it goes |
+|---|---|
+| No pending or in-progress task, and something new is asked for | Here |
+| A task is in progress and the specification turns out not to match reality | Not here — the dual-write path inside `ultra-dev` |
+| The change makes no sentence in the specifications false | Neither — just make the change |
+
+That third row is the checkable answer to "how small is too small to deserve a
+Change file": if nothing the specifications say becomes untrue, there is nothing
+to reconcile and nothing to record.
+
+## Definition of done
+
+- `.ultra/changes/active/<id>/intent.md` states the observable outcome, the
+  executable acceptance, the non-goals, and the public seams touched.
+- Each of the three reconciliation buckets is either empty or dispositioned, with
+  the owner's answer recorded for every bucket that was not empty.
+- The draft stays editable until then; the owner's acceptance is what turns it
+  into authority.
+
+## Reconcile against a bounded scope
+
+A whole-repository diff is unusable, so derive the scope with four steps anyone
+can rerun:
+
+1. Decide which specification sections this request touches.
+2. For each section, collect the past tasks whose `trace_to` points at it, and
+   from those the set of code files they changed.
+3. `git log -- .ultra/specs/<file>` gives the commit where that specification
+   last changed.
+4. `git diff <that commit>..HEAD -- <those code files>` is the reconciliation
+   scope.
+
+Sort what you find into three buckets, each with your recommended disposition:
+
+| Bucket | Meaning |
+|---|---|
+| Specification says it, code does not implement it | Promised and missing |
+| Code implements it, no specification says so | Built and unpromised |
+| Both speak and they conflict | Contradictory |
+
+Take the buckets to the owner — confirmed rather than assumed, because a
+disposition can quietly withdraw a commitment. Sort by risk first and match the
+asking to it: anything that touches a `HC-<n>` hard constraint or removes
+something already promised goes one at a time with your recommendation; the
+remaining low-risk rows go as a single list with a recommended disposition each,
+for one confirmation. Twenty separate questions about rows that change nothing
+spends the owner's attention where it was not needed, and trains them to approve
+without reading.
+
+## Write the intent
+
+Read `references/change-contract.md` and use its exact `intent.md` headings. The active
+Change directory contains only this accepted contract until planning or delivery adds
+its defined artifacts; do not invent a parallel semantic record.
+
+Follow `../ultra-grilling/SKILL.md` to settle the boundary — one question at a
+time, each with your recommendation. New domain terms go through
+`../ultra-domain-modeling/SKILL.md`.
+
+When the work is too large *and* the path itself is unclear, follow
+`../ultra-think/SKILL.md` for a decision ticket instead of forcing a task
+breakdown. What comes out is a question whose answer is a decision, not an
+implementation slice.
+
+When reconciliation proves the request is a directly executable one-slice correction,
+follow `../ultra-tdd/SKILL.md` at the confirmed public seam instead of manufacturing a
+task graph merely to satisfy ceremony.
+
+Output is `.ultra/changes/active/<id>/intent.md`, the specification patches
+reconciliation justified, possibly a `.ultra/decisions/<id>.md`, and any
+vocabulary update. Recommend `ultra-research` for a real evidence gap or
+`ultra-plan` once the contract is evidenced enough; do not invoke either.
+
+## Abandoning a Change
+
+A Change that turns out to be the wrong thing to build exits by
+`git mv .ultra/changes/active/<id> .ultra/changes/abandoned/<id>`, plus one line in
+its `intent.md` saying why. Completed tasks keep their evidence; the work is
+unlinked from the frontier, not deleted. This is the owner's call and a cheap one —
+a Change kept alive to avoid admitting it was wrong poisons every later
+reconciliation, which then measures the code against promises nobody intends to keep.
+
+## When the owner decides
+
+Every non-empty bucket, the Change boundary, abandonment, and anything
+reconciliation turns up that shrinks a prior commitment. A change that makes no
+specification sentence false needs no permission at all.
+
+## References
+
+- `../ultra-grilling/SKILL.md` — the loop for settling the boundary.
+- `references/change-contract.md` — exact `intent.md` structure and profile fields.
+- `../ultra-think/references/autonomy-boundary.md` — read before removing a promise.
+- `../ultra-tdd/SKILL.md` — read for an evidenced one-slice correction.

package/skills/ultra-change/references/change-contract.md

@@ -3,11 +3,56 @@
 Create one contract before planning. Keep every field specific enough to verify and
 stable enough to survive a fresh session.
 
-## Contract
+## Exact `intent.md` structure
+
+```markdown
+# Change <id>: <title>
+
+> **Status**: draft | accepted
+> **Profile**: quick | standard | major | incident
+
+## Outcome
+<one externally observable result>
+
+## Acceptance
+| ID | Criterion | Verification | Trace |
+|---|---|---|---|
+
+## Non-goals
+- <explicit boundary>
+
+## Public Seams
+- <entry point or output>
+
+## Reconciliation
+### Promised and Missing
+### Built and Unpromised
+### Contradictory
+
+## Planning Posture
+<EXPAND | SELECTIVE | HOLD | REDUCE, rationale, and owner confirmation>
+<!-- Scope for this Change only. Not the commitment classification: REDUCE here
+     means "plan less work now", while a REDUCTION in a Change Log means "a
+     promise the specification already made no longer holds". -->
+
+
+## Recovery
+<reversal or recovery path and its verification>
+
+## Unresolved Decisions
+- <stable id, summary, blocking state, owner>
+```
+
+Use `[NEEDS CLARIFICATION]` for missing semantic content. Do not silently omit a
+heading, and do not add another file that restates the same contract.
+
+## Contract fields
 
 - `outcome`: one externally observable result.
-- `acceptance`: stable ids with a criterion and exact verification for each accepted
-  behavior.
+- `acceptance`: stable ids, one criterion each, and a `Verification` that is an
+  **executable command** — something with an exit code, not a description of an
+  intention. `curl -sf localhost:3000/health` qualifies; "check that the endpoint
+  responds" does not.
 - `non_goals`: explicit boundaries that prevent accidental scope growth.
 - `public_seams`: entry points or outputs through which acceptance is observed.
 - `recovery`: a bounded reversal or recovery strategy and its verification.
@@ -16,6 +61,26 @@ stable enough to survive a fresh session.
 Resolve every blocking decision before planning. Keep non-blocking uncertainty visible
 in the task and verification contracts.
 
+## Why verification has to be executable
+
+A criterion whose verification cannot be run is not acceptance, it is a wish. Three
+consumers downstream depend on it being runnable:
+
+- task development can treat passing acceptance as an exit condition only when
+  something can actually decide "passing";
+- the review tests lens maps each acceptance claim to executable evidence, and can
+  only report an honest gap when there is something to map onto;
+- delivery cannot otherwise separate "shipped" from "believed shipped".
+
+Writing the command is also the cheapest way to find out that a criterion is vague.
+"The feature is wired up" resists a command until it becomes "this export has a
+non-test importer", which is a `grep`.
+
+Where a criterion is genuinely a judgement call — visual polish, wording, feel — it
+does not belong in Acceptance at all. Record it as a taste decision for the owner and
+keep Acceptance to what a machine can settle. Mixing the two is what makes an
+acceptance set undecidable.
+
 ## Profile
 
 - `quick`: one low-risk task, no material risk flags, and no research dependency.

package/skills/ultra-delegate/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: ultra-delegate
+description: Delegate one bounded workflow segment to another installed CLI in an isolated worktree and return only its stable result artifact. Use when the owner asks for another model or host to execute, review, verify, or continue a specific slice of current work.
+---
+
+# Run a bounded worker without giving it project authority
+
+Delegation is an execution mode, not another workflow stage. The primary host keeps
+semantic synthesis and remains the only writer of `.ultra/tasks.json`.
+
+## Before you start
+
+1. Read `.ultra/tasks.json`, the delegated task's `context_file` and `## Resume Note`.
+2. Read `CONTEXT.md`, relevant `.ultra/decisions/`, acceptance and current evidence.
+3. Define one bounded instruction, permission set, clean Git worktree and result.
+4. Read `references/delegation-contract.md` before writing either JSON artifact.
+
+## Definition of done
+
+- The worktree is a clean registered Git worktree; instruction, permission and worker
+  spec digests remain unchanged.
+- The worker terminates as `finished`, `blocked` or `failed` in a schema-valid
+  `result.json`; declared paths equal the actual Git diff and stay in writable roots.
+- No `writable_roots` entry is `.ultra/` or sits under it, and the actual diff touches
+  nothing there.
+- Timeout and cancellation reach a terminal failed result and release `run.lock`.
+- The primary host verifies the result against the delegated workflow's acceptance.
+
+## Prepare and run
+
+Write under `.ultra/.runtime/delegations/<id>/`:
+
+- `instruction.md`: bounded goal, sources, acceptance and forbidden effects;
+- `permission.json`: the exact file-local boundary in the contract reference;
+- `result.json`: launcher-published terminal artifact only.
+
+`writable_roots` is an array of existing worktree-relative directories. An empty array
+selects native read-only mode; one or more roots selects bounded write mode.
+**Neither `.ultra/` nor any path under it may appear in it.** The worktree carries a
+checkout of `.ultra` because Git tracks it, but the project's memory has exactly one
+writer. Two workers appending to `tasks.json`, `progress/` or `evidence/` in separate
+worktrees collide in the very files every later session reads to resume. Worker findings
+and state changes travel back in `result.json` and are applied by the primary host.
+`external_effects` must be empty in this portable launcher: commit, push, publish,
+deployment and other effects stay with the primary host. There is no `readable_roots`
+claim because the five host sandboxes do not share one mechanically enforceable read
+policy.
+
+Create `.ultra/.runtime/worktrees/<id>` as a real Git worktree and run:
+
+```text
+ubp delegate run --to <host> --instruction <file> --permission <file> --worktree <dir> --timeout <seconds>
+```
+
+The command returns a receipt. Immediately run `scripts/delegate_wait.py`; read no
+intermediate output. Use `ubp delegate status --delegation <dir>` for a read-only state
+and `ubp delegate cancel --delegation <dir>` to request termination. Never delete a lock
+to manufacture completion.
+
+The worker returns one schema-constrained JSON final response. The launcher extracts it
+from the host's native structured output, validates digests, process exit, exact schema,
+actual base-HEAD diff and writable roots, then atomically publishes `result.json`. The
+model never writes its own receipt. If owner input is needed, the worker terminates
+`blocked` with questions and evidence; start a new id and fresh packet after obtaining
+the answer.
+
+After `finished`, inspect the isolated diff, rerun acceptance checks, and integrate via
+the repository's normal Git workflow with ordinary authorization. Delegation never
+auto-merges or writes canonical task/evidence files.
+
+## Synthesize multiple results
+
+Three agreeing results are Consensus. Two of three are Majority and require examining
+the dissent. Three different results are No Consensus: narrow the question or add
+evidence. A failed external CLI does not block the underlying workflow; report the
+missing evidence rather than turning a vote or score into truth.
+
+## When the owner decides
+
+The owner authorizes delegation. External effects cannot be delegated by this launcher;
+the primary host obtains their separate authorization. The primary host owns result
+interpretation, risk acceptance, integration and task state.
+
+## References
+
+- `references/delegation-contract.md` — strict permission, receipt and result schemas.
+- `scripts/delegate_wait.py` — run immediately after the launch receipt.
+- `../ultra-think/SKILL.md` — read when No Consensus exposes a consequential decision.
+- `../ultra-think/references/autonomy-boundary.md` — read before granting write effects.

package/skills/ultra-delegate/references/delegation-contract.md

@@ -0,0 +1,59 @@
+# Delegation artifact contract
+
+## Permission
+
+```json
+{
+  "$schema": "ultra-delegation-permission-v1",
+  "writable_roots": ["src", "test"],
+  "external_effects": []
+}
+```
+
+Fields are exact. Roots are normalized worktree-relative directories that already
+exist. An empty array selects native read-only mode; `.` deliberately grants the whole
+isolated checkout except `.ultra/`. Absolute paths, symlink escapes, unknown fields,
+`readable_roots`, `.ultra` or any path beneath it, and non-empty external effects are
+rejected.
+
+`.ultra/` is never writable by a worker under any root, `.` included. The project's
+memory has exactly one writer — the primary host — because two worktrees appending to
+`tasks.json`, `progress/` or `evidence/` collide in precisely the files a later session
+reads to resume. Enforced twice: the launcher rejects a `.ultra` root before the
+delegation starts, and the worker fails an actual diff that touches it with
+`unauthorized_write`.
+
+## Model final response
+
+```json
+{
+  "$schema": "ultra-delegation-result-v1",
+  "status": "finished",
+  "summary": "Implemented the bounded slice.",
+  "changed_files": ["src/example.ts"],
+  "checks": [
+    {"command": "npm test -- example", "status": "passed", "output_ref": "stdout.log"}
+  ],
+  "evidence": ["src/example.ts"],
+  "questions": [],
+  "residual_risks": []
+}
+```
+
+Fields are exact. Status is `finished`, `blocked`, or `failed`; `blocked` requires a
+question. Check status is `passed`, `failed`, or `not_run`. Changed files are unique,
+normalized repository-relative paths and must exactly equal the launcher's Git diff.
+
+The launcher extracts this object from native structured output and adds
+`delegation_id`, `host`, instruction, permission, and output-schema digests,
+`read_only`, `base_head`, `final_head`, timestamps, `exit_code`, and signal. Launcher
+failures also add `failure_type`. A nonzero process cannot publish `finished`.
+
+## Recovery
+
+- `status` distinguishes running, cancelling, stalled, and terminal artifacts.
+- `cancel` writes `cancel.request`; the worker terminates its host process, publishes a
+  failed result with `failure_type: cancelled`, and removes `run.lock`.
+- `--timeout` does the same with `failure_type: timeout`.
+- A stopped worker with no result is recoverable through `cancel`, which finalizes the
+  stale run. Retry under a new delegation id and fresh digests.

package/skills/ultra-delegate/scripts/delegate_wait.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Wait for one delegated result to become non-empty and stable."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from pathlib import Path
+
+
+RESULT_SCHEMA = "ultra-delegation-result-v1"
+STATUSES = {"finished", "blocked", "failed"}
+CHECK_STATUSES = {"passed", "failed", "not_run"}
+
+
+def nonempty(value) -> bool:
+    return isinstance(value, str) and bool(value.strip())
+
+
+def validate_result(payload: dict) -> None:
+    if not isinstance(payload, dict):
+        raise ValueError("result must be a JSON object")
+    if payload.get("$schema") != RESULT_SCHEMA:
+        raise ValueError(f"result $schema must be {RESULT_SCHEMA}")
+    if payload.get("status") not in STATUSES:
+        raise ValueError("result status must be finished, blocked, or failed")
+    if not nonempty(payload.get("summary")):
+        raise ValueError("result summary must be non-empty")
+    for field in ("changed_files", "checks", "evidence", "questions", "residual_risks"):
+        if not isinstance(payload.get(field), list):
+            raise ValueError(f"result {field} must be an array")
+    for field in ("changed_files", "evidence", "questions", "residual_risks"):
+        if not all(nonempty(item) for item in payload[field]):
+            raise ValueError(f"result {field} must contain non-empty strings")
+    for check in payload["checks"]:
+        if not isinstance(check, dict) or not nonempty(check.get("command")):
+            raise ValueError("result checks require a command")
+        if check.get("status") not in CHECK_STATUSES:
+            raise ValueError("result check status is invalid")
+    if payload["status"] == "blocked" and not payload["questions"]:
+        raise ValueError("blocked result requires a question")
+    for field in ("delegation_id", "host", "base_head", "final_head", "started_at", "finished_at"):
+        if not nonempty(payload.get(field)):
+            raise ValueError(f"result {field} must be non-empty")
+    for field in ("instruction_digest", "permission_digest", "output_schema_digest"):
+        if not isinstance(payload.get(field), str) or not re.fullmatch(r"[0-9a-f]{64}", payload[field]):
+            raise ValueError(f"result {field} must be a SHA-256 digest")
+    if not isinstance(payload.get("read_only"), bool):
+        raise ValueError("result read_only must be a boolean")
+    if payload.get("exit_code") is not None and not isinstance(payload["exit_code"], int):
+        raise ValueError("result exit_code must be an integer or null")
+
+
+def wait_for_result(path: Path, interval: float, timeout: float) -> dict:
+    deadline = time.monotonic() + timeout
+    previous_size = -1
+    stable_reads = 0
+    while time.monotonic() < deadline:
+        size = path.stat().st_size if path.exists() else 0
+        if size > 0 and size == previous_size:
+            stable_reads += 1
+            if stable_reads >= 1:
+                payload = json.loads(path.read_text(encoding="utf-8"))
+                validate_result(payload)
+                return payload
+        else:
+            stable_reads = 0
+        previous_size = size
+        time.sleep(interval)
+    raise TimeoutError(f"result did not stabilize within {timeout:g}s: {path}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("result", type=Path)
+    parser.add_argument("--interval", type=float, default=1.0)
+    parser.add_argument("--timeout", type=float, default=1800.0)
+    args = parser.parse_args()
+    print(json.dumps(wait_for_result(args.result, args.interval, args.timeout)))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/ultra-deliver/SKILL.md

@@ -1,46 +1,102 @@
 ---
 name: ultra-deliver
-description: Reconcile and archive an explicitly accepted Ultra Change with recoverable local evidence. Use when the caller is ready to make a local delivery handoff with current managed evidence and an explicit rationale for any omitted capability.
+description: Reconcile one completed Change, run aggregate review and refactoring, refresh release documentation, and archive the local workflow record. Use when the task ledger is complete and the owner wants a delivery handoff or separately authorized release effects.
 ---
 
-# Converge and archive local authority
-
-Delivery closes local Ultra authority. It never grants commit, push, tag, registry
-publication, deployment, or another external effect.
-
-## Prepare the packet
-
-1. Call `ultra.context { stage: deliver, scope: { change_id }, detail: full }`.
-2. Import a newer team checkpoint with `ultra.sync`; stop on a real conflict.
-3. Inspect current task outcomes, tests, both review axes, accepted decisions, typed
-   delta, documentation reconciliation, and checkout evidence. Decide whether the
-   actual Change is sufficiently complete; explicitly record any omitted stage and its
-   evidence-based rationale instead of inventing a fixed recipe.
-4. Resolve every specification-learning candidate. Keep updates inside the Change
-   overlay until archive.
-5. Write and register documentation reconciliation and an
-   `ultra-delivery-report-v1` report. The report binds Change, baseline, HEAD,
-   worktree/context digests, local checks, rollback guidance, and timestamp; it contains
-   no release decision.
-
-Use one typed `ultra.record` batch for `artifact / bind`, any normalized
-`decision / accept`, and bounded `event / append` facts.
-
-## Archive once
-
-Call `ultra.archive` once with the Change id, stable idempotency key, archive summary,
-reconciliation fields, delivery evidence steps, explicit omissions, and report output.
-The model's report is the semantic handoff. MCP validates its current registered
-authority, paths, digests, reconciliation structure, and idempotency; applies the
-overlay and archive through the recoverable filesystem/DB transaction; rebinds
-registered artifacts into a self-contained archive; and publishes the updated team
-checkpoint. It does not require a hard-coded Plan/Dev/Test/Review/Deliver sequence.
-
-Semantic warnings remain in the archive history but do not reject an explicit local
-handoff. Corruption, unsafe paths, digest/CAS conflicts, permissions, or recovery
-failure remain fail-closed and route to `ultra-doctor`.
-
-Verify the archived packet, baseline, checkpoint, and rollback state. Handle any
-separately authorized Git or release effect only after local delivery and report it as
-external evidence, not Ultra delivery authority. Do not invoke another capability
-automatically.
+# Turn current evidence into a recoverable delivery handoff
+
+Delivery closes the local Change. Commit, push, tag, publication and deployment remain
+separate effects; local readiness grants none of them automatically.
+
+## Before you start
+
+1. Read `.ultra/tasks.json` and each completed task's `context_file`, Completion and
+   closing `## Resume Note`.
+2. Read `CONTEXT.md`, relevant `.ultra/decisions/`, active Change intent and evidence.
+3. Read `.ultra/test-report.json` and current `HEAD`. If `git_commit` differs from HEAD,
+   label the report stale and obtain current evidence before a release recommendation.
+
+## Definition of done
+
+- Actual outcome, specifications, docs, tests and aggregate review have been reconciled,
+  with every documentation file checked against the actual diff rather than from memory.
+- Every changed export has a non-test consumer or a recorded owner disposition.
+- Every omitted stage is explicitly recorded with its evidence-based rationale.
+- Build and release checks have exact commands and real results.
+- The Change is archived with `git mv`, and rollback remains a normal Git operation.
+
+## Review and refactor
+
+Follow `../ultra-review/SKILL.md` across the aggregate Change. This is where useful
+refactoring occurs: several completed slices now reveal real duplication, coupling and
+deep-module boundaries. Rerun every check affected by a refactor and refresh the report
+against the resulting HEAD.
+
+## Reconcile the handoff
+
+1. Compare accepted intent and task traces with delivered behavior.
+2. Apply justified specification corrections; route any REDUCTION to the owner.
+3. Reconcile every document against the actual diff, not only the ones you remember
+   touching. List the repository's documentation files, read the Change's full diff, and
+   repair each place a document now describes behavior that no longer exists. CHANGELOG
+   and README are the usual ones, but a stale example in a guide, a renamed flag in a
+   runbook and an obsolete field in an API note drift the same way and are found the
+   same way. Record bounded debt only in the active Change `delivery.md` under
+   `## Technical Debt`.
+4. Run the repository's build and packaging checks.
+5. Determine the version impact from the public contract and project convention.
+6. Follow `references/baseline-reconciliation.md` and write the one canonical active
+   Change `delivery.md` with exact checks, residual risks, omissions and rollback.
+
+Step 3 is the **exit** reconciliation and does not duplicate `ultra-change`'s entry
+reconciliation. Entry asks whether the specifications already disagreed with the code
+before this Change was written; exit asks which documents this Change just made wrong.
+One keeps the intent from inheriting drift, the other keeps the Change from leaving new
+drift behind.
+
+## The one delivery gate
+
+This gate applies only after the owner explicitly invokes `ultra-deliver`; it does not
+attach itself to ordinary repository packaging outside this workflow.
+
+Everything else in this workflow reports and hands over. This is the exception, and it
+is deliberately narrow:
+
+**Do not package while an export this Change added or changed has no non-test consumer
+and no recorded owner disposition.**
+
+| | |
+|---|---|
+| Invariant | Every changed export is either reachable from a non-test caller or explicitly declared internal |
+| Fact source | The Wiring Verification results in `.ultra/test-report.json`, bound to the current HEAD — the audit already found these; this is not a fresh opinion |
+| Blocked effect | Packaging and the release effects after it. Local commit and archival are untouched |
+| Repair | Wire the export to its caller, or record the owner's disposition in `delivery.md` naming it internal-only and why. Either one clears the gate |
+
+"Written but never connected" is the single defect that passes every other check: tests
+green, review clean, evidence complete, feature absent. An advisory here would be
+ignored exactly when it matters, because everything else already reads as done. The gate
+sits at the last step rather than at edit time on purpose — a gate early in the loop
+gets escaped by damaging the work.
+
+## Archive locally
+
+Move `.ultra/changes/active/<id>` to `.ultra/changes/archive/<id>` with `git mv` only
+after local reconciliation. Do not create a second standalone delivery report: archived
+`delivery.md`, test report, evidence and Git history are the handoff.
+
+For separately authorized effects, perform and verify each independently. Ask for
+authority at the point of effect: commit, then push, then tag, package publication and
+deployment as applicable. A failure in one does not imply permission to attempt another.
+
+## When the owner decides
+
+The owner accepts residual risk, reductions, the version, and every external effect.
+Without release authority, stop after the recoverable local archive and report it.
+
+## References
+
+- `../ultra-review/SKILL.md` — read before aggregate review and refactoring.
+- `../ultra-think/SKILL.md` — read when version or release posture is a consequential
+  trade-off rather than an established repository rule.
+- `../ultra-think/references/autonomy-boundary.md` — read before scope or evidence shrinks.
+- `references/baseline-reconciliation.md` — exact `delivery.md` reconciliation contract.