ultra-builder-pro-cli 0.26.1 → 0.26.2

package/docs/PHILOSOPHY.md

@@ -43,9 +43,11 @@ one or more.
 
 ### C1 — Goal-Always-Present
 
-The agent never stops seeing the north-star. Every hook trigger that costs context budget injects:
-the project one-liner plus the current task's acceptance criteria. The cost of repetition is
-always less than the cost of drift.
+The agent never stops seeing the current steering contract. Before Research accepts a
+baseline, the session Hook injects the raw Project Brief fallback. After Research, it
+injects the accepted North Star: Project Direction, any settled North Star Outcome, and
+Hard Constraints. Current task acceptance is appended in both cases. The cost of
+repetition is always less than the cost of drift.
 
 > **Test**: pick a random in-progress task, ask the agent "what's the acceptance criteria?" — if
 > it cannot answer in one sentence, this commandment is broken.
@@ -185,15 +187,15 @@ Skill instruction. Do not touch it casually.
 
 | Consumer | Reads | Source of truth | Failure mode if drifted |
 |---|---|---|---|
-| `session_context` | headings `## One-line`, `## Hard Constraints` | `.ultra-template/north-star.md` | SessionStart shows no goal; C1 dies |
-| `session_context` | active `in_progress` task → its context | `tasks.json[].context_file` | acceptance criteria never surfaced |
+| `session_context` | North Star headings `## Project Direction`, `## North Star Outcome`, `## Hard Constraints`; Project Brief `## One-line`, or legacy North Star `## One-line` | `.ultra-template/north-star.md`, `.ultra-template/project-brief.md`, and the Hook's legacy-read branch | SessionStart shows no accepted North Star or Project Brief fallback; C1 dies |
+| `session_context` | unique active `change_id` → one matching `in_progress` task, else first dependency-ready `pending` task → its context | active Change directory plus `tasks.json[].change_id`, dependencies, status, and `context_file` | abandoned or blocked acceptance is injected, or current acceptance never surfaces |
 | `mid_workflow_recall` | heading `## Acceptance Criteria` | `.ultra-template/contexts/TEMPLATE.md` | hook injects nothing; C1 dies silently |
 | `ultra-tdd` | path `references/templates/*` | `skills/ultra-tdd/references/templates/` | guidance points at a missing runnable alternative; C2 dies |
-| `post_edit_guard` | writes `.ultra/progress/<task-id>.json` | `tasks.json[].id`, created on demand | mechanical observations disappear; C4 weakens |
+| `post_edit_guard` | writes `.ultra/progress/<task-id>.json` for the active Change's current task | active Change directory plus `tasks.json[].change_id` and `id`, created on demand | historical work receives current observations; C4 weakens |
 | `ultra-dev` and `post_edit_guard` | 6 keys: `tests_written`, `tests_passed`, `persistence_real`, `feature_flags_audit`, `vertical_slice`, `spec_trace` | the six-dimension table in `skills/ultra-dev/SKILL.md` | sensor and workflow report different evidence |
 | planning and status | marker `[NEEDS CLARIFICATION]` | `.ultra-template/specs/*.md` | unresolved product truth is hidden |
 | `ultra-plan` / `ultra-dev` / hooks | `trace_to` form `.ultra/specs/file.md#anchor` | `tasks.json[].trace_to` + GFM heading slugify | traces appear resolved when their heading is absent |
-| `ultra-deliver` / `ultra-status` | field `git_commit` | `.ultra/test-report.json` | stale test results pass as current |
+| `ultra-deliver` / `ultra-status` | fields `change_id`, `task_ids`, `intent_digest`, `git_commit`, and `worktree.diff_digest` | `.ultra/test-report.json` plus `worktree_digest.cjs` | stale Change, intent, task set, or product results pass as current |
 | `compact_context` | `.ultra/.runtime/compact-snapshot.md` | derived from canonical files and Git | compact recovery loses acceleration, not authority |
 | every hook | existence of `.ultra/` | the project directory | Ultra taxes projects that never opted in (see `docs/PLUGIN-ISOLATION-CONTRACT.md`) |
 | `ultra-init` | the project data skeleton | `.ultra-template/` and the exact file list in its Skill | later Skills read missing authority paths; C1 dies |

package/docs/SKILL-AUTHORING.md

@@ -41,14 +41,15 @@ Every Skill has one outcome-led title and these semantic sections:
 ## References
 ```
 
-User workflows begin by reading `.ultra/tasks.json`, the unfinished task's
-`context_file` and Resume Note, `CONTEXT.md`, and relevant decisions. They name the
-files they write and read them back. Completion criteria must be observable without a
-semantic validator.
+User workflows first resolve at most one active `change_id`, then read only matching
+rows from `.ultra/tasks.json`, the frontier task's `context_file` and Resume Note,
+`CONTEXT.md`, and relevant decisions. Historical or abandoned rows never become current
+from status alone. They name the files they write and read them back. Completion
+criteria must be observable without a semantic validator.
 
 Use positive leading words consistently: tracer bullet, seam, deep module, red,
-frontier, and fog of war. Explain a branch by its checkable result, not the model's
-reason for choosing it.
+frontier, and research boundary. Explain a branch by its checkable result, not the
+model's reason for choosing it.
 
 ## Progressive disclosure
 
@@ -56,6 +57,9 @@ Keep resident `SKILL.md` short enough to load on every invocation. Move focused
 into `references/` and deterministic validation or waiting into `scripts/`.
 
 - Load one research step or review lens at a time.
+- Keep Research's semantic lenses and optional Wayfinding map inside
+  `ultra-research/references/`; they are stages of that public workflow, not reusable
+  model-invoked Skills.
 - Keep one canonical copy of grilling, TDD, review, domain language, and autonomy rules.
 - Cross-reference another model-invoked Skill by relative path.
 - Do not hide the primary workflow in a script.

package/docs/WORKFLOW-LIFECYCLE.md

@@ -6,9 +6,9 @@ criteria; repository files record facts; the host model chooses the route.
 ## Capability flow
 
 ```text
-ultra-init
-    ├─ unresolved external claims ─► ultra-research
-    └─ bounded requested outcome ──► ultra-change
+ultra-init ──raw Project Brief──► ultra-research ──accepted baseline──► ultra-change
+                                      ▲                                  │
+                                      └──── scoped consequential evidence gap ────┘
 
 ultra-change ─► ultra-plan ─► ultra-dev (per task) ─► ultra-test ─► ultra-deliver
                      ▲                 │                    │
@@ -19,51 +19,78 @@ ultra-delegate  orthogonal bounded execution on another CLI
 ```
 
 Arrows are recommendations, not automatic invocation. The owner explicitly selects
-each public workflow.
+each public workflow. Delivery archives one stable `change_id`; the next request opens
+a new active id while prior task rows remain in the append-only ledger.
 
 ## Common entry contract
 
 Every user-invoked Skill reads, in order:
 
-1. `.ultra/tasks.json`;
-2. the unfinished task's `context_file` and closing `## Resume Note`;
-3. `CONTEXT.md` and relevant `.ultra/decisions/`;
-4. the active Change, specifications, evidence, and Git state relevant to its scope.
+1. zero or one `.ultra/changes/active/<change_id>/intent.md`; more than one is a conflict;
+2. `.ultra/tasks.json`, selecting only tasks whose `change_id` matches that active id;
+3. the matching frontier task's `context_file` and closing `## Resume Note`;
+4. `.ultra/project-brief.md`, the accepted `.ultra/north-star.md`, `CONTEXT.md`, and
+   relevant `.ultra/decisions/`, where those artifacts already exist;
+5. the active Change, specifications, evidence, maintained documentation, and Git state
+   relevant to its scope.
 
 Missing files produce a precise recovery or initialization recommendation. They do not
 cause the Skill to invent a state transition.
 
 ## Initialization
 
-`ultra-init` distinguishes owner authorization from claims requiring evidence. It
-creates the file skeleton, preserves unknowns as `[NEEDS CLARIFICATION]`, initializes
-Git when absent, and records only repository-observable brownfield facts. It does not
-perform research or launch another workflow.
+Init writes the raw Project Brief and stable empty skeleton. `ultra-init` preserves the
+owner's one-line request, broad outline, explicit inputs, and open questions without
+turning them into validated product truth. It initializes Git when absent and may
+preserve repository-observable brownfield facts as Research inputs. It does not define
+success, establish the North Star, create `CONTEXT.md`, populate specifications, or
+launch another workflow.
 
 ## Research
 
-`ultra-research` maps unresolved claims to the smallest useful subset of seventeen
-focused references. Reports are written immediately. Three material checkpoints can
-change later scope; the owner resolves those checkpoints. The final distillate records
-Git blob hashes of the specifications it summarizes.
+Research turns the brief into an accepted North Star and evidence-backed baseline.
+`ultra-research` uses Wayfinding only when a multi-lens path is unclear, then maps the
+question to the smallest useful subset of seventeen focused references. The first six
+are semantic lenses with real dependencies: `00` precedes `01`; conditional `02` and
+`03` may fan out after the boundary is known; `04` consumes their relevant conclusions
+and is the first owner checkpoint; `05` extracts assumptions from `00` through `04`.
+Grilling controls how missing owner inputs are asked, Think tests one consequential
+decision, and Domain Modeling writes settled vocabulary; none owns the Research route.
+The final synthesis promotes accepted conclusions into the North Star, `CONTEXT.md`,
+three specifications, and a source-hash-bound distillate.
 
 ## Change reconciliation
 
-`ultra-change` first compares requested behavior with product truth and current code.
-It classifies changes by the resulting commitments:
+Change updates only the touched baseline rather than rebuilding it. `ultra-change`
+first compares requested behavior with accepted product truth and current code. It
+classifies changes by the resulting commitments:
 
 - expansion and correction may proceed inside accepted intent;
 - a reduction waits for explicit owner authority.
 
 The output is one active Change intent with observable outcome, acceptance, seams,
-non-goals, and trace anchors.
+non-goals, trace anchors, and an explicit Research Disposition. `none` cites sufficient
+existing evidence; `bounded` or `required` names the exact question, lenses, and exit
+evidence. Unsatisfied exit evidence routes to Research, then back through Change
+reconciliation before planning when the accepted contract needs an update.
+
+A micro edit that makes no specification sentence false stays outside the Ultra
+lifecycle and uses ordinary repository TDD/verification. Once an active Change exists,
+even a `quick` profile receives one minimal Plan task so evidence and delivery remain
+bound to its id. A separate request cannot open a second active Change: finish or
+deliver the current one, abandon it with owner authority, or explicitly reconcile the
+new request into the same stable id.
 
 ## Planning
 
-`ultra-plan` confirms the scope posture and public seams, then writes a task graph and
-one context file per task. Feature tasks are tracer bullets. A contract task precedes
-cross-process or cross-top-level-boundary implementations; integration checkpoints
-appear after several slices. Cycles and broken trace paths are repaired before handoff.
+`ultra-plan` confirms a material scope posture and records public seams, then appends a
+current-Change task graph and one context file per task without deleting historical
+rows. The model chooses ordinary technical seams; the owner is asked only when a seam
+changes a public contract, accepted risk, or another material trade-off. Every task
+stores the stable `change_id`; dependencies stay inside that Change and ids remain
+globally unique. Feature tasks are tracer bullets. A contract task precedes cross-process
+or cross-top-level-boundary implementations; integration checkpoints appear after
+several slices. Cycles and broken trace paths are repaired before handoff.
 
 ## Task development
 
@@ -78,15 +105,26 @@ duplication or coupling visible.
 
 ## Whole-system audit
 
-`ultra-test` runs once after the ledger is complete. It checks anti-patterns, coverage,
+`ultra-test` runs once after tasks for the active Change are complete. It checks anti-patterns, coverage,
 wiring, E2E behavior, performance, and security. It names the exact Git commit and
-never turns an orphan, failed command, stub, or omission into permission to alter scope.
+binds the report to `change_id`, exact current task ids, intent SHA-256, and the
+product-worktree digest. `passed: true` implies complete current tasks and no required
+area left `not_run`; task completion does not force a pass, and dispositioned gaps stay
+visible. It never turns an orphan,
+failed command, stub, or omission into permission to alter scope.
 
 ## Delivery
 
-`ultra-deliver` reconciles actual outcome, specifications, documentation, current test
-report, aggregate review, build, version impact, omissions, and rollback. It archives
-the Change with `git mv` after local reconciliation.
+`ultra-deliver` uses two observable passes. The first reconciles actual outcome,
+specifications, documentation, aggregate review, omissions, and rollback; if semantic
+or product files change, it stops and recommends a fresh Test. The second begins only
+when report Change/task/intent/HEAD/product identities match, applies the changed-export
+gate, runs build and non-publishing package inspection, records version impact, writes
+delivery metadata, and archives the same stable id with `git mv`. Delivery metadata and
+the directory move do not invalidate their own product snapshot. Producing a release
+package remains blocked while a changed export has neither a non-test consumer nor an
+owner disposition. That disposition is recorded against the finding in the current
+test report without changing the finding or `passed`, then carried into `delivery.md`.
 
 Commit, push, tag, publication, release, and deployment are independent external
 effects. Readiness grants none automatically.
@@ -95,27 +133,44 @@ effects. Readiness grants none automatically.
 
 `ultra-status` infers the smallest next route from observable files:
 
-- no healthy skeleton → init;
-- unresolved evidence-bearing claim → research;
+- no healthy skeleton or usable raw brief → init;
+- raw brief without an accepted baseline, or a consequential evidence gap → research;
 - requested outcome without active Change → change;
-- active Change without executable ledger → plan;
-- pending or in-progress task → dev;
-- completed ledger without current report → test;
-- current report and unarchived Change → deliver.
+- draft or blocking active intent → change;
+- unsatisfied Research Disposition → research;
+- active Change without matching executable tasks → plan;
+- matching pending or in-progress task → dev;
+- completed current-Change tasks without a matching fresh report → test;
+- false report → route by finding and owner disposition, not by the boolean alone;
+- fresh, dispositioned report and unarchived Change → deliver.
 
 It also checks installation provenance, stale reports, old in-progress work, and
 unresolved markers. It does not mutate artifacts.
 
+## Delegation
+
+`ultra-delegate` is orthogonal to the lifecycle and requires explicit owner authority.
+Its immutable instruction selects task execution/continuation, scoped Research evidence,
+or aggregate Change review/verification. Task execution reads one matching task context;
+the latter two may be read-only and do not require a task, so both pre-Plan evidence and
+post-task review remain reachable. Every scope still binds the one active `change_id`, a
+clean isolated worktree, strict permission/result schemas, and primary-host inspection.
+The worker cannot write canonical `.ultra` files or perform external effects.
+
 ## Artifact closure
 
 Every durable output has a later reader:
 
-- init's north star and specification skeletons are read by all later workflows;
-- research reports are traced into specifications, Change reconciliation, planning,
+- init's Project Brief is consumed by Research, Status, and the pre-baseline session
+  Hook fallback; its empty skeleton supplies stable paths rather than product claims;
+- Research's accepted North Star and domain/specification baseline are read by every
+  later workflow, while selected reports trace into Change reconciliation, planning,
   and delivery;
-- Change intent is consumed through planning, development, audit, review, status, and
-  delivery;
-- task ledger and contexts are the common resume input, while task evidence feeds
+- active Change intent and its touched specification deltas are consumed through
+  planning, development, audit, review, status, and delivery; an abandoned intent has
+  an exact `## Abandonment` closure consumed by future Change reconciliation and Status;
+- the append-only task ledger and contexts are the common resume input after filtering
+  by active `change_id`, while task evidence feeds
   review, whole-system audit, and delivery;
 - the current test report is consumed by status and delivery;
 - delivery moves with the Change into archive and remains historical evidence.
@@ -126,6 +181,11 @@ an unowned drift log, Change plan, technical-debt report, or second delivery sum
 
 ## Interruption and cross-host continuation
 
+There is one primary writer for canonical `.ultra` files. Review workers are read-only;
+delegated source edits use isolated worktrees and return results for explicit
+integration. Parallel canonical writes are unsupported because silently merging intent,
+task, evidence, or report authority would lose meaning.
+
 Before stopping, the active task context records current facts, exact verification,
 open questions, Completion, and a closing Resume Note. The next session or host repeats
 the common entry contract and compares the working tree with those claims.

package/hooks/README.md

@@ -5,8 +5,8 @@ directory and exits silently when the workflow is not active.
 
 | Hook | Lifecycle | Purpose |
 |---|---|---|
-| `session_context.py` | Session start | Inject the one-line north star and current acceptance criteria |
-| `mid_workflow_recall.py` | Before source reads or edits | Restate current acceptance only |
+| `session_context.py` | Session start | Inject the accepted North Star or Project Brief fallback, plus acceptance from the unique active Change's current task |
+| `mid_workflow_recall.py` | Before source reads or edits | Restate acceptance only for a task matching the unique active `change_id` |
 | `compact_context.py` | Before/after compaction | Save and restore a disposable snapshot derived from files and Git |
 | `post_edit_guard.py` | After edits | Record mechanical evidence observations without deciding completion |
 | `block_dangerous_commands.py` | Before shell execution | Advise on additive protected-branch publication; block history rewrites and a narrow destructive set until the exact command is owner-authorized |
@@ -14,6 +14,11 @@ directory and exits silently when the workflow is not active.
 `_common.py` is a shared library, not a lifecycle registration. Compact snapshots and
 progress observations live under ignored `.ultra/.runtime/` or `.ultra/progress/`; the
 canonical semantic facts remain the owner-readable files and Git.
+Legacy task rows with no `change_id` remain readable from an active-path `change_ref`
+during migration; a present canonical `change_id` always wins, and archived or
+abandoned paths are never revived as current work. Task
+selection prefers the single `in_progress` row, then the first `pending` row whose
+same-Change dependencies are complete; ambiguous concurrent work stays silent.
 
 Claude Code runs the hooks directly. Codex, Kimi Code, and Grok Build use the small
 wire adapters under `hooks/adapters/`. OpenCode calls the same scripts from its native

package/hooks/_common.py

@@ -47,12 +47,61 @@ def read_tasks(root: Path) -> list[dict[str, Any]]:
     return [item for item in tasks if isinstance(item, dict)] if isinstance(tasks, list) else []
 
 
+def active_change_id(root: Path) -> str | None:
+    active = root / ".ultra" / "changes" / "active"
+    try:
+        change_ids = sorted(
+            entry.name
+            for entry in active.iterdir()
+            if entry.is_dir() and (entry / "intent.md").is_file()
+        )
+    except OSError:
+        return None
+    if len(change_ids) != 1:
+        return None
+    change_id = change_ids[0]
+    return change_id if re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", change_id) else None
+
+
+def legacy_task_change_id(task: dict[str, Any]) -> str | None:
+    value = task.get("change_ref")
+    if not isinstance(value, str):
+        return None
+    match = re.fullmatch(
+        r"(?:\.ultra/)?changes/active/([A-Za-z0-9][A-Za-z0-9._-]*)/intent\.md",
+        value,
+    )
+    return match.group(1) if match else None
+
+
 def current_task(root: Path) -> dict[str, Any] | None:
-    tasks = read_tasks(root)
-    for status in ("in_progress", "pending"):
-        for task in tasks:
-            if task.get("status") == status:
-                return task
+    change_id = active_change_id(root)
+    if change_id is None:
+        return None
+    tasks = [
+        task for task in read_tasks(root)
+        if task.get("change_id") == change_id
+        or ("change_id" not in task and legacy_task_change_id(task) == change_id)
+    ]
+    in_progress = [task for task in tasks if task.get("status") == "in_progress"]
+    if len(in_progress) == 1:
+        return in_progress[0]
+    if len(in_progress) > 1:
+        return None
+    by_id = {task.get("id"): task for task in tasks if isinstance(task.get("id"), str)}
+    for task in tasks:
+        if task.get("status") != "pending":
+            continue
+        dependencies = task.get("dependencies", [])
+        if not isinstance(dependencies, list):
+            continue
+        if all(
+            isinstance(dependency, str)
+            and dependency in by_id
+            and by_id[dependency].get("status") == "completed"
+            for dependency in dependencies
+        ):
+            return task
     return None
 
 

package/hooks/session_context.py

@@ -1,22 +1,48 @@
 #!/usr/bin/env python3
-"""Inject the one-line goal and current task acceptance at session start."""
+"""Inject the accepted North Star or its pre-Research fallback plus task acceptance."""
 
 from _common import current_task, emit_context, markdown_section, project_root, read_payload, task_sections
 
 
+def settled_section(text: str) -> str:
+    """Return an explicitly populated section, not a packaged unresolved marker."""
+    if not text or "[NEEDS CLARIFICATION]" in text or "not yet defined" in text.lower():
+        return ""
+    return text.strip()
+
+
+def read_text(file) -> str:
+    try:
+        return file.read_text(encoding="utf-8")
+    except OSError:
+        return ""
+
+
 def main() -> int:
     payload = read_payload()
     root = project_root(payload)  # Idle guard: no `.ultra/` means silent exit.
     if root is None:
         return 0
-    try:
-        north_star = (root / ".ultra" / "north-star.md").read_text(encoding="utf-8")
-    except OSError:
-        north_star = ""
+    ultra = root / ".ultra"
+    north_star = read_text(ultra / "north-star.md")
+    project_brief = read_text(ultra / "project-brief.md")
     parts = []
-    one_line = markdown_section(north_star, "One-line")
-    if one_line:
-        parts.append(f"Ultra north star:\n{one_line}")
+    direction = settled_section(markdown_section(north_star, "Project Direction"))
+    if direction:
+        baseline = [f"Project Direction:\n{direction}"]
+        for heading in ("North Star Outcome", "Hard Constraints"):
+            section = settled_section(markdown_section(north_star, heading))
+            if section:
+                baseline.append(f"{heading}:\n{section}")
+        baseline_text = "\n\n".join(baseline)
+        parts.append(f"Ultra accepted north star:\n{baseline_text}")
+    else:
+        brief_line = settled_section(markdown_section(project_brief, "One-line"))
+        legacy_line = settled_section(markdown_section(north_star, "One-line"))
+        if brief_line:
+            parts.append(f"Ultra project brief (Research not yet accepted):\n{brief_line}")
+        elif legacy_line:
+            parts.append(f"Ultra legacy project intent:\n{legacy_line}")
     task = current_task(root)
     if task:
         acceptance = task_sections(root, task)["acceptance"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultra-builder-pro-cli",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "File-first Ultra Builder Pro workflows for Claude Code, OpenCode, Codex CLI, Kimi Code, and Grok Build.",
   "bin": {
     "ultra-builder-pro-cli": "bin/install.js",

package/skills/ultra-change/SKILL.md

@@ -1,59 +1,56 @@
 ---
 name: ultra-change
-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.
+description: Open or reconcile one bounded unit of work by comparing specification promises with actual code, then writing the intent that closes the gap. Use when no Change is active and a feature, fix, redesign, or incident response is requested, or when an active Change's draft, researched evidence, or accepted boundary must be reconciled.
 ---
 
 # 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.
+A Change connects research, plan, implementation, verification, review, and delivery.
+Reconcile first so new intent does not bury an existing specification/code conflict.
 
 ## 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.
+1. List `.ultra/changes/active/`; more than one `intent.md` is a conflict, not a choice.
+   One directory name is the stable `change_id`. Read `.ultra/tasks.json`, then only its
+   unfinished `context_file` values. Update the same `change_id`; never open a second active Change.
+2. Read `.ultra/project-brief.md`, `CONTEXT.md`, relevant `.ultra/decisions/`, and
+   `.ultra/north-star.md` for raw provenance, accepted language, and direction.
+3. Grep archive and abandoned Changes that touched this area. Prefer archived
+   `delivery.md`; otherwise read `archive-summary.md`, `verification.md`, `intent.md`,
+   and remaining Markdown. Read abandoned Changes as history of rejected boundaries and
+   reusable evidence, never current intent. A missing `delivery.md` does not mean no history;
+   repeated modules are 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 |
+| No active Change, and a new bounded request exists | Here — create one stable id |
+| One active Change needs its draft, Research evidence, or accepted boundary reconciled | Here — update the same `change_id` |
+| A separate request arrives while one Change remains active | Do not create a second Change; finish or deliver the current one, abandon it with owner authority, or explicitly fold the request into its boundary |
 | 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 |
+| The change makes no sentence in the specifications false | Outside the Ultra lifecycle — use ordinary repository TDD and verification |
 
-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.
+If no specification sentence becomes untrue, there is nothing to reconcile. Use
+`../ultra-tdd/SKILL.md` when helpful, but create no Change artifacts or Ultra
+Test/Deliver claim for that micro change.
 
 ## 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.
+- Active `intent.md` states outcome, executable acceptance, non-goals, public seams,
+  and Research Disposition.
+- Every reconciliation bucket is empty or dispositioned with the owner's answer.
+- The draft remains editable until owner acceptance makes it authority.
 
 ## Reconcile against a bounded scope
 
-A whole-repository diff is unusable, so derive the scope with four steps anyone
-can rerun:
+A Change does not rebuild the project baseline; reconcile only the touched specification sections
+and leave unrelated gaps visible with four rerunnable steps:
 
 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.
+2. Collect past tasks whose `trace_to` points there and the code files they changed.
+3. Use `git log -- .ultra/specs/<file>` to find its last specification change.
+4. Inspect `git diff <that commit>..HEAD -- <those code files>`.
 
 Sort what you find into three buckets, each with your recommended disposition:
 
@@ -63,47 +60,39 @@ Sort what you find into three buckets, each with your recommended disposition:
 | 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.
+Take non-empty buckets to the owner because disposition can withdraw a commitment.
+Ask one recommended question per `HC-<n>` impact or removed promise; group remaining
+low-risk rows into one recommended list for confirmation.
 
 ## 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.
+Read `references/change-contract.md` and use its exact headings. Until planning or
+delivery, the active directory contains only this contract; add no parallel 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`.
+Use `../ultra-grilling/SKILL.md` to settle the boundary and
+`../ultra-domain-modeling/SKILL.md` for new domain terms.
 
-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.
+Use `../ultra-think/SKILL.md` only for one consequential evidenced trade-off. If the
+whole path is unclear, recommend Research instead of manufacturing tasks.
 
-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.
+Record `## Research Disposition` exactly. `none` needs enough evidence to plan;
+`bounded` or `required` names one question, selected lenses, and exit evidence. After
+Research, reconcile outputs here; an unverified path or bare claim is not evidence.
 
-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.
+A quick active Change still goes through one-task `ultra-plan`; once durable intent
+exists, that minimal task is what binds development, evidence, audit, and delivery to
+the stable `change_id`.
+
+Output active `intent.md` under a stable id, justified specification patches, qualifying
+decision or vocabulary updates. For an evidence gap recommend `ultra-research`; when
+evidenced recommend `ultra-plan`. Invoke neither.
 
 ## 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.
+Append the exact `## Abandonment` closure from `references/change-contract.md`, then
+`git mv .ultra/changes/active/<id> .ultra/changes/abandoned/<id>`. Keep completed-task
+evidence. Future Change and Status consume this history; it is neither current intent
+nor an orphan. Abandonment is the owner's call.
 
 ## When the owner decides