@open-agent-toolkit/cli 0.3.18 → 0.3.20

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.9
+  version: 1.6.11
 ---
 
 # Receive Review
@@ -385,6 +385,109 @@ Applies to `code` reviews only. (`artifact` reviews are handled via Step 2.6, th
 3. If scope is `pNN-pMM` (contiguous phase range): add fix tasks to the last phase in the range (`pMM`)
 4. If scope is `final` or SHA/range review: add fix tasks to a new "Review Fixes" phase or the last phase
 
+**Brief modes (`oat_workflow_mode: brief`).** The brief never carries planned
+tasks, so fix work becomes execution records in the journal and
+`oat-project-brief/references/brief-contract.md` (sections 3, 7, and 10) wins
+where this skill differs. Resolve the target phase and apply the late-fix rule:
+
+1. **Reviewed phase.** For `pNN` or `p-revN`, the reviewed phase is that
+   phase. For `pNN-pMM`, `final`, or an explicit SHA range, it is the last
+   phase in the artifact's ordered `oat_review_phase_ids`; when that field is
+   absent or empty, it is the last phase in document order whose journal
+   section has a `**Base:**`.
+2. **Late-fix rule.** If no later phase in document order has a `**Base:**`
+   in `implementation.md`, the fixes go under the reviewed phase, whose
+   journal `**Status:** completed` line is rewritten to `**Status:** in_progress`
+   (an `in_progress` phase stays `in_progress`). Its `**Base:**` never changes;
+   the fix commits advance its `**Head:**` when the phase ends again.
+3. Otherwise a later phase has started: append a revision phase with the next
+   unused `p-revN` ID. In `plan.md`, add it after the last phase block (before
+   `## Parallelism` when present) in the exact phase grammar plus the marker:
+
+   ```markdown
+   ## Phase p-revN: Review fixes for pNN
+
+   **Intent:** resolve {finding IDs} from reviews/archived/{REVIEW_FILENAME}
+   **Exit evidence:** a passing re-review of p-revN that re-evaluates pNN's findings
+   **Provisional:** no
+   **Corrects:** pNN
+   ```
+
+   In `implementation.md`, add the matching `## Phase p-revN: Review fixes for pNN`
+   section after the last phase section with `**Status:** pending` and
+   `**Corrects:** pNN` directly under the heading, and a Progress Overview row.
+   Add a pending `p-revN` `code` row to the brief's `## Reviews` table and
+   update the `## Implementation Complete` phase total. The corrected phase
+   keeps its original anchors and status.
+
+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:
@@ -414,6 +517,12 @@ Derive `TASK_PREFIX` from scope:
 - Find highest task number in target phase using the correct `TASK_PREFIX` (e.g., `prev1-t02`)
 - New tasks continue sequentially: `prev1-t03`, `prev1-t04`, etc.
 
+In brief modes read the execution records under the target phase's section of
+`implementation.md` instead of `plan.md`
+(`^### Task ${TASK_PREFIX}-t[0-9]+:` inside that section). Record IDs take the
+next free ordinal and are never reused, including failed, cancelled, and
+no-change records. A new revision phase starts at `prevN-t01`.
+
 ### Step 5: Convert Findings to Tasks
 
 Each generated fix task initializes `TASK_OWNED_FILES=()` before its first
@@ -462,6 +571,26 @@ guard instead of the branch commit template above.
 - Prefix with `(review)` to indicate review-generated task
 - Use active verb: "Fix...", "Add...", "Update..."
 
+**Brief modes:** record each Critical, High, and Medium finding (and each Low
+the disposition converts) as an execution record under the target phase in
+`implementation.md`, after that phase's existing records, instead of a plan
+task:
+
+```markdown
+### Task {task_id}: (review) {Finding title}
+
+**Status:** pending
+**Source review:** reviews/archived/{REVIEW_FILENAME} ({finding IDs})
+
+Intent: {issue description and fix guidance from the review}
+Files: `{file from finding}`
+Proof: `{verification command from review or standard test command}`
+```
+
+The executor fills `**Executor:**`, the live handle, and the closing
+`**Commit:**` when the work runs, and commits with `fix({task_id}): …` so the
+message keeps `(pNN-tNN)`. Queued records never change phase totals.
+
 ### Step 6: Update Plan.md
 
 Add new tasks to plan.md in the target phase. When adding or editing tasks, preserve/restore shared `plan.md` invariants per the `oat-project-plan-writing` contract (stable task IDs, required sections, review table preservation, accurate `## Implementation Complete` totals).
@@ -484,6 +613,19 @@ Add new tasks to plan.md in the target phase. When adding or editing tasks, pres
   - Update `## Implementation Complete` totals (phase counts + total task count) so downstream PR/review summaries don’t go stale.
   - If the plan includes any phase rollups that reference task counts, update those too.
 
+In brief modes `plan.md` changes only in its `## Reviews` table and, under the
+late-fix rule, by an appended `## Phase p-revN:` block; there are no task
+totals to update. The Reviews event update below is unchanged: the same
+artifact-identified event moves to `fixes_added` with its `Reviewed Head`,
+`Invocation`, and `Gate Target` provenance preserved, and the archived
+artifact keeps its brief anchor record fields (`oat_review_requested_scope`,
+`oat_review_phase_ids`, `oat_review_base_sha`, `oat_review_scope_source`, and
+any `oat_review_fallback_reason`, `oat_review_integration_commits`, and
+`oat_review_narrowed_from`) unchanged. When a `p-revN` review is received with
+no fixes needed, its own event moves to `passed` and the event of the phase
+named by its `**Corrects:**` line that this skill set to `fixes_added` also
+moves to `passed`, citing the revision review in the implementation note.
+
 **Keep plan runnable:**
 
 - Do NOT leave plan.md in a state that blocks `oat-project-implement`.
@@ -563,6 +705,13 @@ After the fix tasks are complete:
     - `oat_phase_status: in_progress`
     - `oat_current_task: {first_fix_task_id}` (or next incomplete)
     - `oat_project_state_updated: "{ISO 8601 UTC timestamp}"`
+  - In brief modes, write the `### Review Received: {scope}` note inside the
+    target phase's journal section after its markers, list the queued
+    execution-record IDs as the new tasks, set both `oat_current_task_id` in
+    `implementation.md` and `oat_current_task` in `state.md` to the target
+    phase ID (the reviewed phase, or the new `p-revN`), and update that phase's
+    Progress Overview row status. The phase-unit totals change only when a
+    revision phase was appended.
 
 ### Step 7.5: Archive the Consumed Review Artifact
 
@@ -742,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.5
+  version: 1.0.7
 ---
 
 # Project Revise
@@ -199,13 +199,54 @@ Fix tasks that edit synced artifacts use `oat project push` under the scope
 guard instead of the branch commit template above.
 ````
 
+**Brief modes (`oat_workflow_mode: brief`):** the brief never carries tasks.
+Insert the revision phase after the last phase block of `plan.md` (before
+`## Parallelism` when present), with Intent and Exit evidence and no
+`### Task` headings:
+
+```markdown
+## Phase p-rev{N}: Revision {N}
+
+**Intent:** {the feedback items, one clause each} (source: inline feedback, {today})
+**Exit evidence:** {verification that shows each item is addressed, and a passing review of p-rev{N}}
+**Provisional:** no
+```
+
+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`).
 
 #### 4d: Update plan.md Totals
 
-Update `## Implementation Complete` section to include the new revision phase and tasks in the totals.
+Update `## Implementation Complete` section to include the new revision phase and tasks in the totals. In brief modes the total counts phases only.
 
 #### 4e: Update implementation.md
 
@@ -216,6 +257,12 @@ Update frontmatter to point at the first revision task so `oat-project-implement
 
 Update the Progress Overview table to include the new revision phase (e.g., add a `Phase p-rev{N}` row with task count and `in_progress` status).
 
+In brief modes point the journal at the phase instead of a task: set
+`oat_current_task_id: p-rev{N}`, add a `## Phase p-rev{N}: Revision {N}`
+section after the last phase section with `**Status:** pending` directly under
+the heading (the root writes `**Base:**` when the phase starts), and add a
+`p-rev{N}` Progress Overview row with one unit, `0/1` accepted.
+
 Add a "Revision Received" entry:
 
 ```markdown
@@ -237,7 +284,7 @@ Add a "Revision Received" entry:
 #### 4f: Update state.md
 
 - `oat_phase_status: in_progress`
-- `oat_current_task: prev{N}-t01`
+- `oat_current_task: prev{N}-t01` (brief modes: `p-rev{N}`)
 - `oat_project_state_updated: "{ISO 8601 UTC timestamp}"`
 
 #### 4g: Route to Implement
@@ -265,7 +312,7 @@ This is the key value revise adds: state transition management so agents know th
 - **Review artifact feedback:** Delegate to `oat-project-review-receive`
 - Delegating means loading the selected skill's current `SKILL.md` and following it, or dispatching a child that carries it, if environment supports skill chaining; otherwise tell the user which skill to run and stop. Never act from a remembered delegation outcome.
 
-These skills use their existing conventions: `(review)` task prefix, severity classification, standard task IDs appended to the last plan phase. This is correct — structured review feedback should go through the structured triage model.
+These skills use their existing conventions: `(review)` task prefix, severity classification, standard task IDs appended to the last plan phase. This is correct — structured review feedback should go through the structured triage model. In brief modes `oat-project-review-receive` records the fixes as `(review)` execution records in the journal under its brief-mode late-fix rule, never as plan tasks.
 
 #### 5c: Post-Delegation State
 

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.8
+  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).
+**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
 
@@ -120,6 +120,12 @@ test -f "$PROJECT_PATH/implementation.md"
 
 **If exists:** Read the file. Check for at least one task with `**Status:** completed`. If no completed tasks, warn: "No completed tasks found. Summary will be minimal."
 
+In brief modes the prerequisite is one accepted phase-unit instead: a
+`**Status:** completed` line directly under a `## Phase` heading of the
+journal, before that phase's first `### Task` record (a completed execution
+record is not an accepted unit). If no phase-unit is accepted, warn: "No
+accepted phase-units found. Summary will be minimal."
+
 ### Step 2: Read Project Artifacts
 
 For `oat_workflow_mode: lite`, use the reduced artifact contract and skip the
@@ -131,6 +137,27 @@ project accepts `discovery.md`, `spec.md`, and `design.md` as absent; do not
 read or require them. Ground the summary in what actually shipped, with
 `implementation.md` taking precedence over the plan.
 
+For `oat_workflow_mode: brief`, read the brief's sources instead of the
+ordinary list below; `discovery.md`, `spec.md`, and `design.md` are absent by
+design:
+
+| Source                                                                             | Use                                                                                                   |
+| ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `plan.md` Goal, Outcomes, Approach                                                 | Overview and what the project set out to do; audit What Was Implemented against the numbered Outcomes |
+| `plan.md` Decisions, Constraints and Out of Scope                                  | Key Decisions and Tradeoffs Made                                                                      |
+| `plan.md` phases and `## Reviews`                                                  | Phase intent and review dispositions                                                                  |
+| `implementation.md` phase sections                                                 | Accepted phases, anchors, execution records, verification evidence, deviations, and `Brief deltas`    |
+| `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
@@ -231,6 +258,99 @@ test -f "$PROJECT_PATH/summary.md"
 
 Copy template: `oat template resolve summary --output "$PROJECT_PATH/summary.md"`
 
+**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
+`Status` of the latest `## Reviews` `code` row for that phase; and the brief's
+Goal, Outcomes, and Decisions sections with whitespace normalized. Compute it
+in bash from the project root with `PROJECT_PATH` set:
+
+````bash
+brief_summary_marker() {
+  awk -v id="$1" -v key="$2" '
+    /^[ \t]*(```|~~~)/ { fence = !fence; next }
+    fence { next }
+    /^#/ { owner = (index($0, "## Phase " id ": ") == 1); next }
+    !owner || found { next }
+    index($0, "**" key ":** ") == 1 {
+      v = substr($0, length("**" key ":** ") + 1); sub(/[ \t]+$/, "", v); print v; found = 1
+    }
+  ' "$PROJECT_PATH/implementation.md"
+}
+
+brief_summary_fingerprint() {
+  local plan="$PROJECT_PATH/plan.md" id status head review section
+  {
+    for id in $(awk '
+      /^[ \t]*(```|~~~)/ { fence = !fence; next }
+      fence { next }
+      /^## Phase (p[0-9]+|p-rev[0-9]+): / { id = $3; sub(/:$/, "", id); print id }
+    ' "$plan"); do
+      status=$(brief_summary_marker "$id" Status)
+      [ "$status" = completed ] || continue
+      head=$(brief_summary_marker "$id" Head)
+      review=$(awk -v id="$id" '
+        /^## Reviews[ \t]*$/ { in_reviews = 1; next }
+        in_reviews && /^## / { exit }
+        !in_reviews || !/^\|/ { next }
+        {
+          n = split($0, cells, "|")
+          for (i = 2; i < n; i++) { c = cells[i]; gsub(/^[ \t]+|[ \t]+$/, "", c); cells[i] = c }
+          if (!sc) { for (i = 2; i < n; i++) { if (cells[i] == "Scope") sc = i; if (cells[i] == "Type") ty = i; if (cells[i] == "Status") st = i }; next }
+          if (cells[sc] == id && cells[ty] == "code") last = cells[st]
+        }
+        END { print (last == "" ? "-" : last) }
+      ' "$plan")
+      printf 'phase=%s head=%s status=%s review=%s\n' "$id" "${head:--}" "$status" "$review"
+    done
+    for section in Goal Outcomes Decisions; do
+      printf 'section=%s ' "$section"
+      awk -v heading="## $section" '
+        /^## / { in_section = ($0 == heading); next }
+        in_section { print }
+      ' "$plan" | tr -s ' \t\n' '   ' | sed 's/^ //; s/ $//'
+      printf '\n'
+    done
+  } | { command -v sha256sum >/dev/null 2>&1 && sha256sum || shasum -a 256; } | cut -d' ' -f1
+}
+
+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 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.
+
 ### Step 4: Generate / Update Summary Sections
 
 For each section, synthesize content from the relevant artifacts. Apply these rules:
@@ -403,12 +523,38 @@ oat_summary_includes_revisions: [{ list of p-revN IDs reflected }]
 ---
 ```
 
+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.
+
 ### Step 6: Roll Up Project Observations and Offer Backlog Graduation
 
 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:
 
@@ -471,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.7
+  version: 1.9.9
 ---
 
 # Execute a Wave of External Plans
@@ -200,7 +200,8 @@ writes and stay on the orchestrator's own model class, the same rule
    `oat project new wave-N-execution --mode quick --no-commit`. If the flag is
    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).
+   a follow-up commit (Orc W1 scaffold evidence). The wrapper stays in quick
+   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