@open-agent-toolkit/cli 0.3.19 → 0.3.20

package/assets/skills/oat-project-quick-start/references/docs/gate-approval-record.md

@@ -62,6 +62,15 @@ replaces the record.
   core, written and read under the same rules as `oat_quick_start_gate`. It is
   absent when no gate is configured, and nothing routes on it: it is provenance
   only.
+- **`oat_milestone_gates[mNN].plan` and `.exit`** (goal mode;
+  `oat-project-goal` writes `plan` after each milestone's approval, and
+  `oat-project-implement`'s milestone closeout writes `exit`) carry the core
+  plus `resolution` (`configured`, `no_gate`, or `project_disabled`), a
+  `subject` binding (`plan` or `code` and the milestone's ordered phase set),
+  and derived `freshness` with `freshness_reason`. `reviewed_head` is `null`
+  for `no_gate` and `project_disabled`, and `no_gate` is written rather than
+  omitted because routing reads these carriers. `oat-project-brief`'s
+  `references/brief-contract.md` section 12.4 is their contract.
 
 ## Reading a quick-start record
 

package/assets/skills/oat-project-reconcile/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.0.5
+  version: 1.0.6
 ---
 
 # Reconcile Manual Implementation
@@ -188,6 +188,35 @@ replacements:
   phase ID, never an extracted or accepted unit), or `null` when every unit is
   accepted.
 
+**Goal-mode branch (`WORKFLOW_MODE=goal`).** The brief-mode branch applies,
+with `oat-project-brief/references/brief-contract.md` section 12 winning where
+this skill differs:
+
+- **Pointer scope.** The pointer is the first incomplete unit within the
+  active milestone's ordered phase set (the shared Milestones reader), never a
+  phase of another milestone.
+- **Interrupted recovery.** When `oat_goal_recovery` is set, repair only that
+  record: check that its `milestone` has a `## Milestones` row, that its
+  `phase_ids` are that row's phases (plus any appended `p-revN` assigned to
+  it), that a non-null `delivery_id` names a registry entry of that milestone,
+  and that a non-null `review_artifact` exists in `reviews/` or
+  `reviews/archived/`. Then set `stage` from the evidence on disk by the
+  section 12.5 missing-evidence order (open fix records → `implementing`; a
+  missing, blocked or stale exit carrier → `exit_gate`; no integrated review
+  of the set → `reviewing`; a produced, unreceived artifact → `receiving`;
+  a received `passed` review with a fresh carrier → `delivering`). Reconcile
+  confirms the repaired record with the user in Step 4. Older-delivery
+  recovery leaves `oat_milestone`, `oat_milestone_status`,
+  `oat_current_task_id`, and `oat_current_task` untouched.
+- **Never for the active milestone.** Reconcile never creates an
+  `oat_goal_recovery` record for the active milestone and never creates one
+  at all: only `oat-project-review-receive`, `oat-project-revise`, and
+  `oat-project-pr-progress` open recovery records.
+- **Registration ambiguity.** A `registering` delivery whose lookup matched
+  more than one pull request is routed here by its registration owner: report
+  the matches and attach the one the user confirms in Step 4; reconcile never
+  creates a pull request.
+
 ### Step 1: Find Checkpoint
 
 Identify the last commit that OAT has already tracked. Everything after this commit is "untracked human work" that needs reconciliation.
@@ -694,7 +723,7 @@ oat_current_task_id: { next_pending_task_id } # or null if all complete
 oat_last_updated: { today }
 ```
 
-Find the next pending task by scanning plan order: first task with status not `completed`. In brief modes the pointer is the first incomplete phase-unit, per the brief-mode branch above.
+Find the next pending task by scanning plan order: first task with status not `completed`. In brief modes the pointer is the first incomplete phase-unit, per the brief-mode branch above; in goal mode, within the active milestone's phase set, per the goal-mode branch.
 
 In `state.md`:
 

package/assets/skills/oat-project-review-provide/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Glob, Grep, Write, Edit, Bash(git:*), Bash(oat:*), Bash(pnpm:*), Bash(mkdir:*), Bash(date:*), Bash(realpath:*), Bash(awk:*), AskUserQuestion
 metadata:
-  version: 1.5.14
+  version: 1.5.15
 ---
 
 # Request Review
@@ -188,6 +188,12 @@ accepted unit to the first incomplete unit in document order. A brief code
 scope is always a phase-unit (`pNN`, `p-revN`, `pNN-pMM`, or `final`), never an
 execution record.
 
+When `WORKFLOW_MODE` is `goal`, the same pointer rule applies within the active
+milestone's ordered phase set, and an integrated milestone or delivery review
+takes its scope from the router's `code` context (`code mNN: pAA, pBB` or
+`code mNN/dNN: …`) or from a pending `oat_goal_recovery` record, never from the
+phase table (Step 3.0g).
+
 If inference produces a result, propose it and proceed unless the user overrides:
 
 ```
@@ -321,6 +327,7 @@ WORKFLOW_MODE=$(oat project status --project-path "$PROJECT_PATH" --field projec
 - `import`: `plan.md` (`references/imported-plan.md` recommended, `spec.md`/`design.md` optional)
 - `lite`: `plan.md`, `implementation.md` (`discovery.md`/`spec.md`/`design.md` are absent by design)
 - `brief`: `plan.md` (the Project Brief) and `implementation.md` (the per-phase journal, which carries the `**Base:**`/`**Head:**` anchors); `discovery.md`, `spec.md`, and `design.md` are absent by design, and research under `references/` is optional
+- `goal`: the same as `brief`, plus the `## Milestones` table in `plan.md` and the goal state in `state.md` (milestone, recovery record, milestone gate carriers, delivery registry)
 
 **Required for artifact review:**
 
@@ -334,6 +341,7 @@ WORKFLOW_MODE=$(oat project status --project-path "$PROJECT_PATH" --field projec
   - reviewing `plan` in `quick/import` mode may use `discovery.md` and/or `references/imported-plan.md` instead; lite uses the separate rule below
   - reviewing `plan` in `lite` mode requires only `plan.md`; its Summary, Decisions, Assumptions, Out of Scope, and Validation Criteria sections are the complete upstream contract
   - reviewing `plan` in `brief` mode requires only `plan.md`; the brief and `oat-project-brief/references/brief-contract.md` are the complete upstream contract. `discovery`, `spec`, and `design` are not reviewable artifacts in brief mode
+  - reviewing `plan` in `goal` mode follows the `brief` rule; for an amendment the request names the milestone under review and its ordered phase set
 
 **If missing:** Report missing required artifacts for the current mode and stop if requirements are not met.
 
@@ -347,13 +355,14 @@ If review type is `artifact`:
 
 If review type is `code`, use the scope resolution below.
 
-**Step 3.0: Brief-Mode Anchor Resolution (`brief` only)**
+**Step 3.0: Brief-Family Anchor Resolution (`brief` and goal phase-unit reviews)**
 
-When `WORKFLOW_MODE` is `brief` and the review type is `code`, the review range
-comes from the phase anchors recorded in the journal, not from commit-message
-inference. `oat-project-brief/references/brief-contract.md` section 10 is
-authoritative where this step and the contract differ. This step is inert for
-every other workflow mode.
+When `WORKFLOW_MODE` is `brief` — or `goal` for a phase-unit review routed
+here by Step 3.0g — and the review type is `code`, the review range comes from
+the phase anchors recorded in the journal, not from commit-message inference.
+`oat-project-brief/references/brief-contract.md` section 10 is authoritative
+where this step and the contract differ. This step is inert for every other
+workflow mode and for goal integrated reviews (Step 3.0g).
 
 Resolution order for brief code reviews:
 
@@ -609,6 +618,51 @@ and, when they apply, `oat_review_fallback_reason`,
 them to the reviewer and Step 8 writes them; `oat-project-review-receive`
 preserves them.
 
+**Step 3.0g: Goal Explicit Review Scope (`goal` only)**
+
+When `WORKFLOW_MODE` is `goal`, a phase-unit code review (`pNN`, `p-revN`)
+runs Step 3.0 unchanged. An integrated milestone or delivery review follows
+`oat-project-brief/references/brief-contract.md` section 12.6 (explicit goal
+review scopes) and section 12.5 (the goal exception to the shared ladder):
+
+1. **Explicit identity only.** Accept only a milestone or delivery identity
+   with its ordered phase set: the router's `code mNN: pAA, pBB` or
+   `code mNN/dNN: …` context, a pending `oat_goal_recovery` record
+   (`milestone`, `delivery_id`, `phase_ids`), or the same form typed by the
+   user. Refuse a `pNN-pMM` or `final` token for an integrated goal review, and
+   never expand membership first to last or derive it from commit labels.
+2. **Validate the set.** It must equal the milestone's ordered phase set from
+   the shared Milestones reader (`oat project status --json`), the recovery
+   record's `phase_ids`, or a registered delivery's frozen scope with any
+   recorded correction phases. A mismatch stops with the two sets; membership
+   errors route to `oat-project-goal`.
+3. **Exit gate first.** Before dispatch, run
+   `oat project delivery check --project "$PROJECT_PATH" --subject <mNN|dNN> --json`
+   and read only its `exit` result (`source: milestone-carrier`); the command
+   exits 1 here because no passed integrated review exists yet. A missing,
+   blocked or stale exit carrier stops and routes to `oat-project-implement`
+   scoped closeout: the milestone exit gate precedes the integrated review.
+4. **Range.** Resolve each set member's anchors with the Step 3.0 per-phase
+   checks (existence, ancestry). The aggregate head is the last set member's
+   head in document order and must contain every member head; the range is the
+   first member's base through the aggregate head. Delivery evidence uses
+   integration heads: a parallel group member's pre-fan-in review is member
+   evidence only. Missing anchors widen to the merge-base range exactly as in
+   Step 3.0; invalid anchors route to `oat-project-reconcile`.
+5. **Disclose, never relabel.** The range may be wider than the set. Name every
+   phase whose anchored commits fall inside the range but outside the set
+   (for example `p03` of m02 between `p02` and `p-rev1`) under an
+   `Intervening changes:` line in the Review Scope, so the reviewer judges only
+   the set and treats the rest as context.
+6. **Record.** Write the brief artifact record with
+   `oat_review_requested_scope: mNN` (or `mNN/dNN`) and `oat_review_phase_ids`
+   equal to the exact ordered set; the semantic set survives in provenance even
+   when the Git range is wider.
+7. **No narrowing below the set.** Step 3a may narrow a re-review's Git range,
+   but a narrowed or revision-only goal review is never recorded as the full
+   integrated review without the prior review it builds on; its
+   `oat_review_phase_ids` stays the full set.
+
 **Step 3a: Detect Re-Review Context**
 
 After parsing the requested scope, distinguish an explicit range override from a
@@ -791,8 +845,8 @@ case "$SCOPE_TOKEN" in
       FILES_CHANGED=$(printf "%s\n" "$PROJECT_PATH/plan.md" "$PROJECT_PATH/spec.md" "$PROJECT_PATH/design.md")
     elif [[ "$WORKFLOW_MODE" == "quick" ]]; then
       FILES_CHANGED=$(printf "%s\n" "$PROJECT_PATH/plan.md" "$PROJECT_PATH/discovery.md")
-    elif [[ "$WORKFLOW_MODE" == "lite" || "$WORKFLOW_MODE" == "brief" ]]; then
-      # brief: the reviewer also receives oat-project-brief/references/brief-contract.md
+    elif [[ "$WORKFLOW_MODE" == "lite" || "$WORKFLOW_MODE" == "brief" || "$WORKFLOW_MODE" == "goal" ]]; then
+      # brief and goal: the reviewer also receives oat-project-brief/references/brief-contract.md
       # as the contract reference (Step 5), not as a file in scope.
       FILES_CHANGED=$(printf "%s\n" "$PROJECT_PATH/plan.md")
     else
@@ -878,8 +932,8 @@ Build the "Review Scope" metadata for the reviewer:
 
 **Artifact Paths:**
 
-- Spec: {PROJECT_PATH}/spec.md (required in spec-driven mode; optional in quick/import/lite; absent in brief)
-- Design: {PROJECT_PATH}/design.md (required in spec-driven mode; optional in quick/import/lite; absent in brief)
+- Spec: {PROJECT_PATH}/spec.md (required in spec-driven mode; optional in quick/import/lite; absent in brief and goal)
+- Design: {PROJECT_PATH}/design.md (required in spec-driven mode; optional in quick/import/lite; absent in brief and goal)
 - Plan: {PROJECT_PATH}/plan.md
 - Implementation: {PROJECT_PATH}/implementation.md
 - Discovery: {PROJECT_PATH}/discovery.md
@@ -951,7 +1005,7 @@ artifact-plan and code Review Scope explicitly as:
 - Import reference: not required
 - Plan: `{PROJECT_PATH}/plan.md` (the Project Brief: Goal, Outcomes, Approach, Constraints and Out of Scope, Decisions, and the in-scope phases' `**Intent:**` and `**Exit evidence:**` are the requirements contract)
 - Implementation: `{PROJECT_PATH}/implementation.md` (the per-phase journal: anchors, execution records, verification evidence)
-- Brief contract: `oat-project-brief/references/brief-contract.md`
+- Brief contract: `oat-project-brief/references/brief-contract.md` (goal: sections 1–11 and section 12)
 
 and append the brief anchor record to every brief code Review Scope:
 
@@ -1298,7 +1352,7 @@ If running inline (Tier 3), execute the review and write artifact.
 **Review checklist (from oat-reviewer):**
 
 1. Verify scope (don't review out-of-scope changes)
-2. If code review: verify alignment to available requirements sources (`spec`/`design` for spec-driven mode; `discovery`/import reference for quick/import; plan.md Summary, Decisions, Assumptions, Out of Scope, and Validation Criteria for lite; the brief's Outcomes, Constraints and Out of Scope, Decisions, and the in-scope phases' Intent and Exit evidence for brief)
+2. If code review: verify alignment to available requirements sources (`spec`/`design` for spec-driven mode; `discovery`/import reference for quick/import; plan.md Summary, Decisions, Assumptions, Out of Scope, and Validation Criteria for lite; the brief's Outcomes, Constraints and Out of Scope, Decisions, and the in-scope phases' Intent and Exit evidence for brief and goal)
 3. If code review: verify code quality (correctness, tests, security, maintainability)
 4. If artifact review: verify completeness/clarity/readiness of the artifact and its alignment with upstream artifacts
 5. Categorize findings (Critical/High/Medium/Low)
@@ -1470,6 +1524,7 @@ Record this artifact as one append-ordered review event:
 
 - `Scope`: `{scope}` (examples: `p02`, `final`, `spec`, `design`)
   - Phase-range examples such as `p02-p03` are valid code-review scopes and should be preserved exactly.
+  - Goal integrated reviews: exactly the milestone ID (`m01`) or, for a registered delivery, the delivery ID (`d01`); the ordered phase set lives in `oat_review_phase_ids`, never in the Scope cell (brief contract section 12.6).
 - `Type`: `code` or `artifact`
 - `Status`: `received` (receive-review will decide `fixes_added` vs `passed`; `passed` now requires no unresolved Critical/High/Medium and final deferred-medium disposition when applicable)
 - `Date`: `{today}`
@@ -1497,6 +1552,14 @@ eight columns.
 
 If plan.md is missing (e.g., spec/design review before planning), skip this update and rely on the review artifact + next-step routing.
 
+**Goal mode.** Review-provide records the event as `received` and never writes
+`passed`, `delivering`, or any milestone status: `oat-project-review-receive`
+owns the transition to `delivering`. When a pending `oat_goal_recovery` record
+names this scope at stage `reviewing`, advance it to `stage: receiving` and set
+`review_artifact: reviews/{filename}.md` in `state.md`; leave `oat_milestone`,
+`oat_milestone_status`, and the execution pointer unchanged. Step 9.5 then
+commits `state.md` with the review bookkeeping.
+
 ### Step 9.5: Commit Review Bookkeeping Atomically (Required)
 
 **If `INLINE_ONLY=true`:** skip this step — no artifact was written to disk.
@@ -1509,6 +1572,7 @@ After writing the review artifact and applying the Step 9 Reviews-table update,
 
 - Always include the active review artifact file: `reviews/{filename}.md`
 - Include `plan.md` when Step 9 updated the Reviews table
+- Include `state.md` when Step 9 advanced a goal recovery record (`GOAL_RECOVERY_ADVANCED=true`)
 - Do not write or commit new review artifacts directly into `reviews/archived/`
 - Do not include unrelated implementation/code files in this commit
 
@@ -1533,6 +1597,8 @@ if [ "$PROJECT_SCOPE" = "synced" ]; then
 else
   OWNED_COMMIT_PATHS=("$ACTIVE_REVIEW_PATH")
   [ -f "$PROJECT_PATH/plan.md" ] && OWNED_COMMIT_PATHS+=("$PROJECT_PATH/plan.md")
+  # goal: Step 9 advanced a pending oat_goal_recovery record
+  [ "${GOAL_RECOVERY_ADVANCED:-false}" = true ] && OWNED_COMMIT_PATHS+=("$PROJECT_PATH/state.md")
   oat internal commit-paths --identity "${COMMIT_IDENTITY:?set once and retain for retries}:oat-project-review-provide:1" --message "chore(oat): record {scope} review artifact" -- "${OWNED_COMMIT_PATHS[@]}" || exit 1
 fi
 ```

package/assets/skills/oat-project-review-receive/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Bash(oat:*), Glob, Grep, AskUserQuestion, Task
 metadata:
-  version: 1.6.10
+  version: 1.6.11
 ---
 
 # Receive Review
@@ -424,6 +424,70 @@ Never write `### Task` headings into the brief, and never write `**Base:**` or
 `**Head:**`: `oat-project-implement` records anchors when the phase starts and
 ends.
 
+**Goal mode (`oat_workflow_mode: goal`).** The brief-mode rules above apply,
+with `oat-project-brief/references/brief-contract.md` section 12 winning where
+this skill differs (12.3 transitions, 12.5 the goal ladder exception, 12.6
+explicit scopes and recovery, 12.7 the registry). A phase-unit review (`pNN`,
+`p-revN`) is received exactly as in brief mode. For an integrated milestone or
+delivery review:
+
+1. **Identity.** The target is the artifact's `oat_review_requested_scope`
+   (`mNN` or `mNN/dNN`) with its ordered `oat_review_phase_ids`, or the
+   pending `oat_goal_recovery` record whose `review_artifact` names this
+   artifact. A recovery record that names a different artifact is never
+   satisfied by this one. The target is **older** when its milestone is not
+   `oat_milestone`, or its delivery belongs to an earlier milestone;
+   otherwise it is the **active** milestone.
+2. **Queued fixes.** Place the fixes by the late-fix rule above, with the
+   reviewed phase being the last phase of the explicit set. An appended
+   `p-revN` joins the **target** milestone's `## Milestones` row (append it to
+   that row's phase list); a frozen delivery scope is never edited. Then
+   invalidate the evidence: run
+   `oat project delivery check --project "$PROJECT_PATH" --subject <mNN|dNN> --json`,
+   confirm the report's `exit.source` is `milestone-carrier` and its `status`
+   is `undeliverable`, and write `oat_milestone_gates[mNN].exit.freshness: stale`
+   with `freshness_reason: "fixes queued from reviews/archived/{REVIEW_FILENAME}"`
+   followed by the report's `exit.reason` when present; for a registered
+   delivery also write its `integrated_review.disposition: stale`. Queued fixes
+   invalidate the review and exit-gate evidence even when the check would
+   still report them fresh, so the exit gate runs again before the next
+   integrated review.
+   - **Active target:** update the execution pointer as in brief mode and
+     write `oat_milestone_status: implementing` (from `reviewing` or
+     `delivering`).
+   - **Older target:** write only `oat_goal_recovery: { milestone,
+delivery_id, phase_ids, stage: implementing, review_artifact: null }`,
+     with `phase_ids` the explicit set plus any appended `p-revN` (create the
+     record, or move an existing one for this target back to `implementing`).
+     Leave `oat_milestone`, `oat_milestone_status`, `oat_current_task_id`, and
+     `oat_current_task` unchanged; Step 7's brief pointer write is skipped.
+3. **Clean receive.** `fixes_completed` is not a passed review. When no fixes
+   are queued, write the Reviews event `passed` (Step 6) and persist the
+   authoritative evidence in tracked records before Step 7.5 archives the file:
+   the Reviews row keeps its `Reviewed Head`; for a registered delivery the
+   same write rewrites `integrated_review` (`artifact:
+reviews/archived/{REVIEW_FILENAME}`, `scope` from `oat_review_phase_ids`,
+   `bound_revisions` from the reviewed member base and head,
+   `disposition: passed`), writes each `members[i].reviewed_head` to the
+   reviewed member head that `bound_revisions` binds for it, and replaces
+   `exit_gate` with the current allowed milestone exit carrier. The delivery's
+   `exit_gate` and `members[].reviewed_head` are set once and may change only
+   in the commit that records a review naming a different artifact of this
+   delivery (section 12.8), so never split these writes. Commit them (Step 7.6), then
+   re-validate scope, revisions and the exit carrier with
+   `oat project delivery check --project "$PROJECT_PATH" --subject <mNN|dNN> --json`:
+   - `status: ok` → **active target:** write `oat_milestone_status: delivering`
+     (`reviewing → delivering`); **older target:** advance the recovery record
+     to `stage: delivering`. Only review-receive writes this transition.
+   - `status: undeliverable` with a not-fresh `exit` → write
+     `exit.freshness: stale` with the report's `exit.reason`; the router
+     sends the scoped closeout back to `oat-project-implement`.
+   - `status: undeliverable` with a not-fresh `review` → write no transition
+     and route to `oat-project-review-provide` for a new integrated review of
+     the same explicit set.
+
+   Commit the transition or invalidation as its own bookkeeping commit.
+
 ### Step 4: Determine Next Task IDs
 
 Read plan.md to find the last task ID in the target phase:
@@ -827,6 +891,11 @@ Low findings handling is scope-aware:
 
 ### Step 10: Route to Next Action
 
+**Goal mode:** report the router's next skill (`oat project status --json`)
+instead of offering a task list when the receive wrote `delivering`, advanced a
+recovery record, or routed to review-provide or scoped closeout; older-target
+fixes resume through the recovery record, never through the active milestone.
+
 **Ask user:**
 
 ```

package/assets/skills/oat-project-revise/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.0.6
+  version: 1.0.7
 ---
 
 # Project Revise
@@ -216,6 +216,30 @@ Add a pending `p-rev{N}` `code` row to the brief's `## Reviews` table. The
 executor opens `prev{N}-tNN` execution records in `implementation.md` when the
 work starts and commits them as `fix(prev{N}-tNN): …`; revise writes none.
 
+**Goal mode (`oat_workflow_mode: goal`):** the brief-mode rules apply, with
+`oat-project-brief/references/brief-contract.md` section 12.6 winning. Inline
+feedback requires an explicit target before any write: a milestone or
+delivery identity (`mNN` or `mNN/dNN`), named by the user or by the open
+delivery the feedback is about. Ask for it when it is not stated; never infer
+it from the open PR's commit labels or a first–last phase range.
+
+- **Phase-only `p-rev{N}`.** The revision phase is a phase-unit with no
+  execution records, as in brief mode, and it joins the **target** milestone:
+  append `p-rev{N}` to that milestone's `## Milestones` row, so its membership
+  is exact. A registered delivery's frozen scope is never edited.
+- **Invalidate the target's evidence.** Write
+  `oat_milestone_gates[mNN].exit.freshness: stale` with
+  `freshness_reason: "revision p-rev{N} (inline feedback)"`, and for a
+  registered target delivery its `integrated_review.disposition: stale`.
+- **Active target** (the milestone is `oat_milestone`): write the ordinary
+  pointer (4e, 4f) and `oat_milestone_status: implementing`.
+- **Older target** (an earlier milestone or its delivery): create or advance
+  `oat_goal_recovery: { milestone, delivery_id, phase_ids: [the target's
+ordered set plus p-rev{N}], stage: implementing, review_artifact: null }`
+  instead, and skip the 4e/4f pointer and status writes: `oat_milestone`,
+  `oat_milestone_status`, `oat_current_task_id`, and `oat_current_task` stay
+  unchanged.
+
 **Task naming:** Prefix with `(revision)` — following the `(review)` convention in review-receive.
 
 **Task IDs:** `prev{N}-t{NN}` format (e.g., `prev1-t01`, `prev1-t02`).

package/assets/skills/oat-project-summary/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Bash(jq:*), Bash(oat config:*), Bash(oat decision:*), Bash(oat pjm:*), Bash(oat project log:*), Bash(oat project push:*), Bash(oat project scope:*), Bash(oat template:*), Bash(oat tools:*), Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.5.9
+  version: 1.5.10
 ---
 
 # Project Summary
@@ -22,7 +22,7 @@ Produce a `summary.md` that serves as institutional memory — capturing what wa
 
 ## Prerequisites
 
-**Required:** Active project with `implementation.md` that has meaningful progress (at least one completed task; in brief modes, at least one accepted phase-unit).
+**Required:** Active project with `implementation.md` that has meaningful progress (at least one completed task; in brief and goal modes, at least one accepted phase-unit).
 
 ## Mode Assertion
 
@@ -150,6 +150,14 @@ design:
 | `implementation.md` Final Summary                                                  | Shipped results; takes precedence over the brief's plans                                              |
 | `state.md`, `project-log.md`, `oat-execution-learnings.md`, `references/research/` | Same roles as below, when present                                                                     |
 
+For `oat_workflow_mode: goal`, read the brief sources above, plus the
+`## Milestones` table (organize What Was Implemented by milestone), the
+`state.md` delivery registry (`oat_deliveries`: each delivery's scope, members
+and endpoint observation are shipped results), and, after a declaration, the
+outcome audit (`oat_goal_outcome_audit`) as the authoritative per-outcome
+disposition, with deferred and retired obligations listed under Follow-up
+Items.
+
 For every other workflow mode, read all available artifacts for synthesis:
 
 - `"$PROJECT_PATH/discovery.md"` — initial request, decisions, constraints
@@ -250,7 +258,7 @@ test -f "$PROJECT_PATH/summary.md"
 
 Copy template: `oat template resolve summary --output "$PROJECT_PATH/summary.md"`
 
-**Brief modes (`oat_workflow_mode: brief`): freshness by phase fingerprint.**
+**Brief modes (`oat_workflow_mode: brief` or `goal`): freshness by phase fingerprint.**
 Replace the task and revision comparison above with
 `oat_summary_phase_fingerprint`, a stable hash of the ordered accepted phase
 IDs; for each accepted phase its `**Head:**`, its `**Status:**` line, and the
@@ -310,13 +318,36 @@ brief_summary_fingerprint() {
 CURRENT_PHASE_FINGERPRINT=$(brief_summary_fingerprint)
 ````
 
+**Goal fragment.** In goal mode the fingerprint also covers the delivery IDs
+at endpoint, so a delivery newly observed at its agreed endpoint requires a
+refresh. Append one `delivery=<dNN>` line per registry entry with
+`status: at_endpoint` or a recorded `endpoint_attainment`, in registry order,
+to the hashed input:
+
+```bash
+goal_summary_deliveries() {
+  oat project status --project-path "$PROJECT_PATH" --field project.deliveries 2>/dev/null |
+    node -e 'let s = ""; process.stdin.on("data", (d) => (s += d)).on("end", () => {
+      for (const d of JSON.parse(s.trim() || "null") ?? [])
+        if (d.status === "at_endpoint" || d.endpoint_attainment) console.log(`delivery=${d.delivery_id}`);
+    })'
+}
+
+if [ "$(oat project status --project-path "$PROJECT_PATH" --field project.workflowMode 2>/dev/null)" = goal ]; then
+  CURRENT_PHASE_FINGERPRINT=$(
+    { printf '%s\n' "$CURRENT_PHASE_FINGERPRINT"; goal_summary_deliveries; } |
+      { command -v sha256sum >/dev/null 2>&1 && sha256sum || shasum -a 256; } | cut -d' ' -f1
+  )
+fi
+```
+
 - No existing summary, or `oat_summary_phase_fingerprint` differs from
   `CURRENT_PHASE_FINGERPRINT`: refresh. Update What Was Implemented from the
   newly accepted phases, Revision History when an accepted `p-revN` is new, and
   Follow-up Items from review dispositions.
 - Fingerprint unchanged: no phase-driven update. The autonomous-learnings and
   project-log triggers above stay independent and can still require a refresh.
-- A brief summary never reads or writes `oat_summary_last_task`; execution
+- A brief or goal summary never reads or writes `oat_summary_last_task`; execution
   records are not units. `oat-project-complete` recomputes the same
   fingerprint with this fragment to decide whether `summary.md` is stale.
 
@@ -492,7 +523,7 @@ oat_summary_includes_revisions: [{ list of p-revN IDs reflected }]
 ---
 ```
 
-In brief modes write `oat_summary_phase_fingerprint: {CURRENT_PHASE_FINGERPRINT}`
+In brief and goal modes write `oat_summary_phase_fingerprint: {CURRENT_PHASE_FINGERPRINT}`
 (Step 3) and omit `oat_summary_last_task`; keep `oat_summary_revision_count`
 and `oat_summary_includes_revisions` as informational fields.
 
@@ -502,6 +533,28 @@ Run this step after `summary.md` has been authored or refreshed, including the
 distinct `## Autonomous Execution Learnings` section when its source artifact
 exists.
 
+**Goal terminal deferral.** When `oat_workflow_mode` is `goal`, this run
+comes before `pr` in the post-implement sequence (`oat_post_implement_sequence`
+lists `pr` but not yet among its completed steps), and
+`oat project closeout-check "$PROJECT_PATH" --json` (read-only) still reports
+`phase-uncovered` (a terminal delivery is still to be registered), write only
+files under `$PROJECT_PATH`: skip the `oat project log rollup` call below (it
+appends to the repository ledger and also writes the `## Workflow Observations`
+section, which the later run supplies) and all of Step 7 (decision-record
+promotion and the regenerated decisions index). Report them as deferred with:
+`Deferred: ledger roll-up and decision promotion run in the completion summary refresh; do not decline it.`
+A repo-level commit after the terminal milestone's reviewed revision is not
+bookkeeping (brief contract 12.8), so it would make the terminal subject
+undeliverable for the terminal registration in the PR skill's Step 1.5.
+Without `phase-uncovered` there is nothing to defer (delivery coverage already
+holds and `pr` registers nothing): run Steps 6 and 7 as usual. Perform the
+deferred writes in the next summary run after `phase-uncovered` clears: a
+`summary` step configured after `pr`, or the summary refresh at completion,
+which the goal fingerprint fragment (Step 3) marks stale once the terminal
+delivery reaches its endpoint. Both writes are idempotent, so the later run
+needs no extra state. Registered deliveries are unaffected: they are judged
+against their observed member revisions.
+
 Before the roll-up or decision promotion mutates repository-wide outputs,
 preflight the owned paths and snapshot unrelated staged state:
 
@@ -564,6 +617,8 @@ append-based `project` → `general` promotion in Step 2.5.
 
 ### Step 7: Promote Key Decisions to Canonical Decision Records
 
+Under the goal terminal deferral (Step 6), skip this step and report it deferred.
+
 Run this step **after** `summary.md` (including its `## Key Decisions` section) has been written/refreshed and its frontmatter updated. It promotes the project's Key Decisions out of per-project prose and into the canonical, repo-wide `reference/decisions/` log so they stop being siloed in `summary.md`. This step is **additive and non-interactive** — it never prompts.
 
 **7.1 — PJM capability and adoption gate (auto, no prompt).** Check capability

package/assets/skills/oat-wave-execute/SKILL.md

@@ -6,7 +6,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Edit, Bash, Grep, Glob, Task
 metadata:
-  version: 1.9.8
+  version: 1.9.9
 ---
 
 # Execute a Wave of External Plans
@@ -201,7 +201,7 @@ writes and stay on the orchestrator's own model class, the same rule
    absent because of version skew, run the command without it, expect the scaffold
    to auto-commit, record that generated commit, and land the wrapper artifacts in
    a follow-up commit (Orc W1 scaffold evidence). The wrapper stays in quick
-   mode: its lanes need task-level plans, so lite and brief do not apply.
+   mode: its lanes need task-level plans, so lite, brief, and goal do not apply.
 2. **Verify scaffold substitution AND advance the lifecycle** in `state.md`.
    On oat ≥0.1.65, verify that the basic scaffold placeholders
    (`{ OAT_HILL_CHECKPOINTS }`, `{ OAT_PHASE }`, `{ OAT_WORKFLOW_MODE }`) were

package/assets/templates/state.md

@@ -34,7 +34,7 @@ oat_phase_status: in_progress # Status: in_progress | complete | pr_open
 #         - { harness: cursor, model: gpt-5.5-xhigh }
 #   source: project-state
 # oat_dispatch_ceiling: # legacy compatibility alias for capped managed provider targets
-oat_workflow_mode: { OAT_WORKFLOW_MODE } # spec-driven | quick | import | lite | brief
+oat_workflow_mode: { OAT_WORKFLOW_MODE } # spec-driven | quick | import | lite | brief | goal
 oat_workflow_origin: native # native | imported
 # oat_skill_gate_overrides: # optional; per-project posture for configured lifecycle gates
 #   oat-project-implement: disabled # only the literal value `disabled`; absence means follow configuration