ultra-builder-pro-cli 0.26.1 → 0.26.2

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

@@ -3,6 +3,10 @@
 Create one contract before planning. Keep every field specific enough to verify and
 stable enough to survive a fresh session.
 
+The directory id is globally unique across active, archive, and abandoned Changes and
+matches `[A-Za-z0-9][A-Za-z0-9._-]*`. It is the stable `change_id`; moving the directory
+never changes it.
+
 ## Exact `intent.md` structure
 
 ```markdown
@@ -10,6 +14,8 @@ stable enough to survive a fresh session.
 
 > **Status**: draft | accepted
 > **Profile**: quick | standard | major | incident
+> **Profile rationale**: <why the smallest selected profile covers the blast radius>
+> **Risk flags**: <applicable flags, or none>
 
 ## Outcome
 <one externally observable result>
@@ -29,6 +35,14 @@ stable enough to survive a fresh session.
 ### Built and Unpromised
 ### Contradictory
 
+## Research Disposition
+- Disposition: none | bounded | required
+- Question: <the exact load-bearing unknown, or none>
+- Selected lenses: <reference ids, or none>
+- Existing evidence: <repository-relative paths and claims>
+- Required exit evidence: <what must exist or be resolved before planning>
+- Rationale: <why this is sufficient for this Change boundary>
+
 ## Planning Posture
 <EXPAND | SELECTIVE | HOLD | REDUCE, rationale, and owner confirmation>
 <!-- Scope for this Change only. Not the commitment classification: REDUCE here
@@ -93,9 +107,27 @@ acceptance set undecidable.
 Record a profile rationale and every applicable risk flag. Select the smallest profile
 whose guarantees cover the real blast radius; never use profile labels as estimates.
 
-## Research disposition
+## Research Disposition
+
+The `Disposition` value is exactly `none | bounded | required`. Use `none` with a
+rationale when accepted evidence is sufficient. Use `bounded` for one already-framed
+question whose smallest sufficient lenses are known; it skips Wayfinding. Use `required`
+when several load-bearing claims or the evidence path itself remain unclear, so Research
+may Wayfind before selecting lenses. Both name the exact question, selected or candidate
+Research lenses, existing evidence, and required exit evidence.
+The host model evaluates whether the named evidence exists and supports the claim; do
+not add a `research_complete` bit, score, or workflow state. Planning waits while the
+recorded exit evidence is unsatisfied.
+
+## Exact abandonment closure
 
-Use `none` with a rationale when accepted evidence is sufficient. Use `bounded` or
-`required` with a supported mode and the exact selected semantic steps when product,
-behavior, architecture, deployment, or risk facts remain load-bearing. The recorded
-selection is the planning gate.
+Before moving an owner-abandoned Change, append this exact structure to `intent.md`:
+
+```markdown
+## Abandonment
+- Date:
+- Owner decision:
+- Reason:
+- Reusable evidence:
+- Recovery or successor:
+```

package/skills/ultra-delegate/SKILL.md

@@ -10,7 +10,16 @@ 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`.
+1. Resolve exactly one active `change_id`, then select one scope and name it in
+   `instruction.md`:
+   - **task execution or continuation** — select one matching task and read its full
+     `context_file` and `## Resume Note`;
+   - **scoped Research evidence** — read the active intent's Research Disposition,
+     named question, sources, and required exit evidence;
+   - **aggregate Change review or verification** — read the exact matching task ids,
+     relevant contexts, current report or review summary, and Change diff.
+   Research and aggregate read-only scopes do not require a task. An archived or
+   abandoned task cannot be delegated as current work.
 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.
@@ -24,13 +33,15 @@ semantic synthesis and remains the only writer of `.ultra/tasks.json`.
 - 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.
+- The primary host verifies the result against the selected scope's task acceptance,
+  Research exit evidence, or aggregate review/verification question.
 
 ## Prepare and run
 
 Write under `.ultra/.runtime/delegations/<id>/`:
 
-- `instruction.md`: bounded goal, sources, acceptance and forbidden effects;
+- `instruction.md`: scope type, stable `change_id`, optional task id, bounded goal,
+  sources, acceptance or exit evidence, and forbidden effects;
 - `permission.json`: the exact file-local boundary in the contract reference;
 - `result.json`: launcher-published terminal artifact only.
 

package/skills/ultra-deliver/SKILL.md

@@ -1,25 +1,24 @@
 ---
 name: ultra-deliver
-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.
+description: Reconcile one Change whose matching tasks are complete, run aggregate review and refactoring, refresh release documentation, and archive the local workflow record. Use when the owner wants a delivery handoff or separately authorized release effects for the active Change.
 ---
 
 # 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.
+Delivery closes the local Change; readiness grants no commit, push, tag, publish, or deploy authority.
 
 ## Before you start
 
-1. Read `.ultra/tasks.json` and each completed task's `context_file`, Completion and
-   closing `## Resume Note`.
+1. Resolve exactly one active `change_id`. Read `.ultra/tasks.json`; every matching task
+   must be complete. Read each `context_file`'s 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.
+3. Read `.ultra/test-report.json`, then run the Test Skill's `worktree_digest.cjs` with
+   project root and `--change-id`. Require report `task_ids` for the current Change plus
+   matching `change_id`, `git_commit`, worktree digest, and intent digest; otherwise stop.
 
 ## 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.
+- Outcome, specs, tests, aggregate review, and every document match the actual diff.
 - 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.
@@ -27,32 +26,41 @@ separate effects; local readiness grants none of them automatically.
 
 ## 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.
+Follow `../ultra-review/SKILL.md` across the aggregate Change; refactor only observed
+duplication, coupling, or boundary defects. Rerun affected checks and refresh the report.
 
 ## 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.
+3. List documentation, compare every file with the full Change diff, and repair stale
+   behavior, examples, flags, or fields. Record bounded debt only in active
+   `delivery.md` under `## Technical Debt`.
+4. Defer build, non-publishing package inspection, version selection, and the canonical
+   `delivery.md` until the fresh-snapshot finalization pass below. Reconciliation that
+   changed files must return through Test first.
+
+Entry reconciliation prevents inherited drift; this exit reconciliation prevents the
+Change from leaving new document drift.
+
+## Reconcile, then finalize on a fresh snapshot
+
+Delivery has two observable passes, not a hidden state machine:
+
+1. Reconcile and review. If this pass changes source, tests, task/context/evidence,
+   specifications, maintained documentation, or `intent.md`, stop after writing the
+   reconciled files. The existing report is stale; recommend `ultra-test` and make no
+   delivery or release claim.
+2. After an unchanged pass or fresh Test, recheck Change/task/HEAD/product/intent
+   identities. Apply the gate, run build and non-publishing package inspection, determine
+   version impact, and use `references/baseline-reconciliation.md` for canonical
+   `delivery.md`. Archive the Change. Excluded delivery metadata and the directory move
+   cannot self-invalidate the product digest; intent stays independently bound.
+
+Do not draft a success narrative around stale evidence. A current `passed: false`
+report may still reach finalization only after every finding has an explicit owner
+disposition and the one hard gate below is clear; `passed` is evidence summary, not a
+second mechanical release gate.
 
 ## The one delivery gate
 
@@ -62,27 +70,24 @@ 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.**
+**Do not produce a release 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 |
+| Fact source | The Wiring Verification finding and its owner disposition in `.ultra/test-report.json`, bound to the current Change id, task ids, intent, HEAD, and product-worktree digest — the audit already found these; this is not a fresh opinion |
+| Blocked effect | Release-package creation and the separately authorized release effects after it. A non-publishing package inspection is diagnostic; local commit and archival are untouched |
+| Repair | Wire the export to its caller, or record the owner's disposition on the finding in `.ultra/test-report.json`, then carry it into `delivery.md`. 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.
+"Written but never connected" can leave tests and review green while the feature is
+absent. Keep this gate at finalization, after the audit can distinguish unfinished 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.
+After the fresh check, `git mv` active `<id>` to archive. The id stays stable in task
+rows; never store a movable intent path or create a second delivery summary. Archived
+delivery, 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

package/skills/ultra-deliver/references/baseline-reconciliation.md

@@ -34,6 +34,8 @@ the Change is active and moves with the directory when archived.
 
 Every semantic update cites a repository-relative `path#anchor`. A reduction requires
 the owner decision before the affected specification changes. Exact command evidence
-must match the checkout identified by `.ultra/test-report.json`; stale results stay
-visible and never become a pass. Do not create a second JSON or Markdown delivery
-summary.
+must match the stable Change id, exact current task ids, intent digest, HEAD, and
+product-worktree digest identified by `.ultra/test-report.json`; stale results stay
+visible and never become a pass. Reconcile before finalizing. If reconciliation changes
+semantic or product files, obtain a fresh Test snapshot before writing final delivery
+metadata or archiving. Do not create a second JSON or Markdown delivery summary.

package/skills/ultra-dev/SKILL.md

@@ -5,13 +5,13 @@ description: Carry one planned task from a written implementation plan through r
 
 # Take one task from plan to recorded evidence
 
-The model owns the code reasoning and the edits. The repository owns the task
-contract, the evidence, and everything needed to resume.
+The model owns code reasoning and edits; repository files own the resumable contract.
 
 ## Before you start
 
-1. Read `.ultra/tasks.json` and pick the task; read its `context_file` end to
-   end, above all the closing `## Resume Note` — that line says where to pick up.
+1. Resolve exactly one active `change_id`; more than one is a repository conflict. Read
+   `.ultra/tasks.json`, choose one matching `in_progress` or dependency-ready task, then read
+   its full `context_file`, especially `## Resume Note`.
 2. Read `CONTEXT.md` for vocabulary, and the `.ultra/decisions/` entries the task
    context names.
 3. Read `.ultra/north-star.md` and the task's acceptance criteria. If you cannot
@@ -22,10 +22,9 @@ read `references/debugging.md` and establish the earliest incorrect state before
 
 ## Definition of done
 
-- All six evidence dimensions are answered for this task, each against the
-  checkable rule below rather than an impression.
-- `tasks.json` and the context file's header state the same status, each written
-  and then read back — a one-sided write breaks resume on another host.
+- All six evidence dimensions answer the checkable rules below.
+- `tasks.json` and context status agree after write/read-back.
+- The task still names the active `change_id`; historical unfinished work stays out.
 - The context file carries a Completion entry and a rewritten Resume Note.
 - A task-level review has run and its blocking findings are resolved.
 
@@ -46,6 +45,7 @@ because what is worth restructuring only becomes visible after several slices.
 
 Development ends when the task's acceptance commands pass, not when the code looks
 finished. Resolve the context's **Change Acceptance IDs** against the active `intent.md`
+for `<change_id>`
 and use each named row's executable `Verification`. Commands under the context's
 Acceptance Criteria may add task-local checks; they do not replace the Change mapping.
 

package/skills/ultra-grilling/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ultra-grilling
-description: Interrogate an owner request until every branch of its decision tree is resolved, one question per turn, each carrying a recommended answer. Use when another skill needs the owner's intent specific enough to build from — a new project's north star, a Change boundary, or an ask whose acceptance criteria are still implicit.
+description: Turn caller-named missing owner decisions into confirmed answers, one question per turn and each carrying a recommendation. Use when Init needs a raw brief field, Research needs an owner decision, or Change and Plan need an explicit boundary or acceptance criterion.
 ---
 
 # Turn a vague ask into a decision list the owner has explicitly confirmed
@@ -12,8 +12,8 @@ finished work proves otherwise. It serves Goal 1, Intent Fidelity.
 ## Before you start
 
 1. Reread what the owner said in the current request, verbatim.
-2. Read `.ultra/north-star.md` and `CONTEXT.md` where they exist. Established
-   wording and vocabulary are decisions that were already made.
+2. Read `.ultra/project-brief.md`, `.ultra/north-star.md`, and `CONTEXT.md` where they
+   exist. Raw intake is reusable input; accepted wording must not be re-asked.
 3. Look up every fact you can reach on your own: repository files, Git history,
    installed dependencies, tool output.
 
@@ -29,8 +29,8 @@ have answered by reading the repository spends the one input only they can give.
   never skipped because the original wording sounded clear.
 - Each answer carries the owner's confirmation, rather than something that
   sounded like agreement.
-- The calling skill holds a decision list it can write to a file: one line per
-  decision, each with the options rejected and why.
+- The caller owns the final artifact and receives a decision list it can write: one
+  line per decision, each with the options rejected and why.
 
 ## Extract, reframe, then ask
 
@@ -52,7 +52,7 @@ product. Offer the reframe, never assert it, and treat a correction as the bette
 outcome — "no, it really is just the briefing" is a constraint you did not have a
 minute ago. Read `references/reframing.md` for when it applies and how it fails.
 
-**Then ask** only what the confirmed reframe leaves open.
+**Then ask** only what the confirmed reframe leaves open; the caller sets the semantic depth, so Init stops at the raw outline and leaves baseline questions to Research.
 
 ## One question per turn
 
@@ -95,9 +95,9 @@ inferred consensus.
 
 ## How the loop ends
 
-Every ending hands back the same artifact: the decisions written one per line,
-each with the options rejected and the reason they lost. The caller chooses where
-it lands — `north-star.md`, `discovery.md`, a Change intent, or a decision file.
+Every ending hands back the same result: decisions written one per line, each with
+the options rejected and the reason they lost. The caller alone chooses the canonical
+destination; Grilling never promotes an answer into project authority by itself.
 
 - **Resolved** — every required field answered or explicitly deferred.
 - **Stalled** — two consecutive turns add no newly confirmed decision. Hand back

package/skills/ultra-init/SKILL.md

@@ -1,119 +1,94 @@
 ---
 name: ultra-init
-description: Establish a project's Ultra authority as files — the owner's one-line goal, hard constraints, the three specification skeletons, an empty task ledger, and Git. Use when a repository has no `.ultra` directory yet, or has a partial one left by an interrupted setup, whether the codebase is new or already carries years of history.
+description: Create or recover Ultra's repository-local skeleton and raw Project Brief without performing product research. Use when `.ultra` is absent or partial in a new or existing codebase and later workflows need stable file paths, preserved authority, and Git.
 ---
 
-# Build the skeleton the rest of the workflow writes into
+# Create the skeleton and capture only the initial project outline
 
-Initialization creates the repository-local authority and nothing else.
-It does not perform research, accept a product baseline, choose a Change, or
-start another capability — recommend the next one and stop; do not invoke it.
-
-The dividing line against research is **authorization versus claim**. What the
-owner authorizes comes out of their head and evidence cannot overturn it. What
-research collects is a claim about the outside world, which evidence can confirm
-or refute. A technology choice is a claim, so it is not initialization's business
-— and a new project has no configuration files to read anyway.
+Initialization establishes places for later authority and records raw owner intake. It
+does not validate the problem, establish a North Star, build a product or architecture
+baseline, settle domain language, choose a Change, or start another public workflow.
 
 ## Before you start
 
-1. Read `.ultra/tasks.json` if it exists, along with the `context_file` of any
-   task it names — a partial `.ultra/` means an earlier attempt stopped midway.
-2. Read `CONTEXT.md` at the repository root for vocabulary already settled, and
-   `.ultra/decisions/` for any entries preserved by a partial setup.
-3. Establish the route's facts from the filesystem, not by asking.
+1. If `.ultra/changes/active/` exists, resolve at most one active `change_id`. Read
+   `.ultra/tasks.json` if it exists, plus the `context_file` and closing `## Resume Note`
+   of unfinished tasks matching that id. Historical unfinished rows do not turn a
+   partial skeleton into current work. A partial `.ultra/` is recovery work.
+2. Read `.ultra/project-brief.md`, `.ultra/north-star.md`, `CONTEXT.md`, and relevant
+   `.ultra/decisions/` when they exist. Preserve accepted authority byte-for-byte.
+3. Establish the repository root, Git state, and whether meaningful code or maintained
+   documentation exists from the filesystem. Do not ask the owner for those facts.
 
 ## Definition of done
 
-- `.ultra/north-star.md` carries the owner's one-line goal in their own words.
-- Every `## Hard Constraints` entry has a stable `HC-<n>` id and can veto a
-  concrete technical decision. "Should be usable" vetoes nothing and is not yet a
-  constraint; "first paint under two seconds" is. Same bar for the success
-  metric: a threshold, not an aspiration. See
-  `../ultra-grilling/references/reframing.md` for what counts as an answer.
-- Every file listed under **What gets written** exists; you read each one back
-  after writing and stopped at the first one missing.
-- `.git` exists. Any initial commit is a separately authorized delivery effect.
-- Nothing is invented: what is unknown says `[NEEDS CLARIFICATION]`.
-
-## Which route
+- `.ultra/project-brief.md` contains raw owner intake: one line, a broad outline,
+  explicit inputs already supplied, and open questions handed to Research.
+- For a new skeleton, an empty North Star and the three specification skeletons exist.
+  Recovery preserves any populated authority; Init does not fill semantic sections or
+  create `CONTEXT.md`.
+- Every packaged path was read back after copying, while every pre-existing file stayed
+  byte-identical.
+- `.git` exists. Commit, push, remote creation, and publication remain separate effects.
 
-Check the filesystem in this order and take the first match:
+## Classify only for preservation
 
-| Check | Route | What changes |
-|---|---|---|
-| `docs/` holds two or more non-README `.md` files, or `docs/adr/` or `doc/` exists | Documented brownfield | Write everything; cite maintained documents as evidence and preserve their repository paths in `trace_to` when they remain authoritative |
-| A language configuration file exists and the row above did not match | Brownfield | Write everything; record what a code scan shows in `architecture.md` and `discovery.md`, marked as observed and unverified |
-| Neither | Greenfield | Write everything |
+Use `references/brownfield-adoption.md` when source, runtime configuration, tests, or
+maintained product documentation already exist. Classification changes what must be
+preserved and what Research should inspect; it never authorizes Init to write observed
+product behavior into a specification.
 
-For either brownfield route, read `references/brownfield-adoption.md`. Existing docs
-are evidence or an explicitly retained authority; they never justify omitting the
-canonical specification skeleton that downstream workflows require.
+## Draw out the brief, then stop
 
-## Draw out the intent
+Follow `../ultra-grilling/SKILL.md` with only these required fields:
 
-Follow `../ultra-grilling/SKILL.md`. It is a loop, not a questionnaire, because
-the owner cannot state what they want up front. Start from what they already said
-when invoking you, restate it for confirmation, and ask only about what is
-genuinely missing. Five things come out of it:
-
-| What you draw out | Where it lands |
+| Raw intake | Project Brief section |
 |---|---|
-| What you want to build, in one sentence, their words | `north-star.md`, `## One-line` |
-| What counts as success | `specs/product.md`, behavioral requirements and acceptance |
-| What must never happen | `north-star.md`, `## Hard Constraints`, one `HC-<n>` per line |
-| Who uses it, and how they cope today | `discovery.md`, marked as the owner's statement |
-| **What you already know you are unsure about** | `discovery.md` — research's priority queue |
+| What the owner wants to build, in one sentence and their words | `## One-line` |
+| What it is, broadly for whom or what, intended result, broad boundary | `## Initial Outline` |
+| Constraints, materials, and decisions the owner already volunteered | `## Explicit Inputs` |
+| Questions already visible but requiring evidence or deeper decisions | `## Open Questions for Research` |
 
-When the first domain terms appear, follow `../ultra-domain-modeling/SKILL.md`
-and create `CONTEXT.md` at the repository root.
+Ask only enough to distinguish materially different outlines. If an answer would define
+a problem, actor evidence, desired outcome, success measure, product strategy, accepted
+constraint, domain term, requirement, or architecture, record it as an input or open
+question and stop drilling. Research owns that maturation and must not re-ask an answer
+unless evidence conflicts with it.
 
-## What gets written
+## Write and recover the skeleton
 
 Resolve this loaded Skill's directory, then run
-`node <ultra-init-skill-dir>/scripts/init_project.cjs --project <repository-root>`. The script copies
-only missing files from `assets/project-template`, preserves every existing authority
-file byte-for-byte, and reads the resulting skeleton back. Then fill its semantic
-placeholders from verified facts and owner decisions.
+`node <ultra-init-skill-dir>/scripts/init_project.cjs --project <repository-root>`.
+The script copies only missing files from `assets/project-template`, preserves every
+existing file, and reads the complete result back.
 
 ```text
-.ultra/north-star.md                                ## One-line, ## Hard Constraints
-.ultra/specs/{product,architecture,discovery}.md    ## Observed, ## Decisions, ## Unknowns
-.ultra/tasks.json                                   {"tasks": []}
-.ultra/test-report.json                             not-yet-run report with git_commit
-.ultra/{contexts,decisions,evidence,research}/ and changes/{active,archive,abandoned}/
-CONTEXT.md                                          repository root, once a term is settled
+.ultra/project-brief.md                            raw intake and initial outline
+.ultra/north-star.md                               empty Research-owned steering contract
+.ultra/specs/{product,architecture,discovery}.md  empty specification skeletons
+.ultra/specs/research-distillate.md                empty Research synthesis skeleton
+.ultra/{tasks.json,test-report.json}               empty or not-yet-run ledgers
+.ultra/{contexts,decisions,evidence,research}/
+.ultra/changes/{active,archive,abandoned}/
 ```
 
-The copied `.ultra/.gitignore` excludes `.runtime/`, `progress/`, and `reviews/`
-without editing the owner's root ignore file. Those paths are exact — hooks and later
-skills read them by name. Every section left unfilled carries
-`[NEEDS CLARIFICATION]`, and which of those you resolve now has a checkable rule:
-**what can be read out of repository files, you fill; what needs investigation,
-research fills.**
+For a legacy `north-star.md` containing `## One-line`, keep that file byte-identical.
+When the new Project Brief is still unresolved, copy the legacy one-line verbatim into
+it and list legacy hard constraints under Explicit Inputs without assigning new IDs.
+Research later proposes the accepted North Star; it never rewrites history silently.
 
-Git is not a preference. Reconciliation reads `git log` and `git diff`, staleness
-detection compares against `HEAD`, archiving is a `git mv`, and rollback is Git.
-If `.git` is absent, run `git init`. Report the uncommitted initialized files and ask
-for commit authority only if the owner wants that separate effect now.
+Git supplies revision identity, history, comparison, archive moves, and rollback. Run
+`git init` only when `.git` is absent, then report the uncommitted scaffold.
 
 ## When the owner decides
 
-Only the five things above, and only through the grilling loop. Replacing
-authority that already exists and looks healthy is the owner's call, never a
-convenience on the way to a clean start — preserve it and report what you found.
-
-Where the host cannot ask at all, leave the one-line goal empty and say plainly
-that it is empty. Do not infer it from the directory name. An empty one-line goal
-is a **blocking** state, not a note: goal injection, boundary read-back and a
-Change's touched-constraints field all read from it, so planning and development
-must not start until it is filled. Say that too, and recommend rerunning this
-skill on a host that can ask.
+The owner confirms the one-line outline and any replacement of healthy authority. Where
+the host cannot ask, leave unresolved fields explicit and recommend resuming Init on a
+host that can; do not infer intent from the directory name. Recommend Research after a
+usable brief exists, but do not invoke it.
 
 ## References
 
-- `../ultra-grilling/SKILL.md` — the loop; read it before the first question.
-- `../ultra-domain-modeling/SKILL.md` — read when the first term needs writing.
-- `references/brownfield-adoption.md` — read for either existing-code route.
-- `../ultra-think/references/autonomy-boundary.md` — read before touching
-  authority that already exists.
+- `../ultra-grilling/SKILL.md` — read before the first missing brief field.
+- `references/brownfield-adoption.md` — read when maintained behavior already exists.
+- `../ultra-think/references/autonomy-boundary.md` — read before replacing authority.