@open-agent-toolkit/cli 0.3.15 → 0.3.17

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

@@ -6,13 +6,17 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.4.2
+  version: 1.4.3
 ---
 
 # New OAT Project
 
 Create a new OAT project directory, scaffold standard artifacts from the resolved templates (repository `.oat/templates/`, then user `~/.oat/templates/`, then bundled), and set `activeProject` in local config. New projects default to `synced`; pass `--scope shared|local|synced` to override the resolved `projects.defaultScope` setting.
 
+## Hook-safe exact-path commits
+
+Before a parent-branch commit, verify `oat internal commit-paths --help` succeeds. If unavailable, stop and update the OAT CLI; never fall back to a staged-index or pathspec-only commit. Set `COMMIT_IDENTITY` to a unique operation/artifact identity before the first attempt and retain it for every retry; use a new identity for a new operation. Pass only the exact produced file list, including tracked removals and both names of a rename. A blocked/failed result stops the workflow; retain its receipt and follow its diagnostics. Hooks remain enabled. Synced project artifacts continue through `oat project push`.
+
 ## Progress Indicators (User-Facing)
 
 - Print a phase banner once at start using horizontal separators, e.g.:
@@ -34,7 +38,7 @@ Create a new OAT project directory, scaffold standard artifacts from the resolve
 Before scaffolding, surface the working tree state so unrelated changes don't get carried into the project workflow's bookkeeping commits.
 
 1. Run `git status --porcelain`. If empty, continue silently to the next step.
-2. If `.oat/sync/manifest.json` is the only entry **and** its two-character status code is either `??` or made up solely of the letter `M` and blanks — a plain modification, staged, unstaged, or both — commit it without asking: `git add -- .oat/sync/manifest.json` then `git commit -m "chore: run sync"`. Report the commit in one line and continue to the next step. That file is `oat sync` output and carries no user content, so the prompt below was always answered "commit now" for it. Every other code falls through to the prompt below, including any code that pairs `M` with something else: `MD` (deleted in the worktree), `MT` (type change), `AM`, `RM`, `CM`, and every unmerged state. Auto-staging one of those would commit a deletion, a retyped file, or a half-resolved merge. Any other dirty path, in any combination, also falls through.
+2. If `.oat/sync/manifest.json` is the only entry **and** its two-character status code is either `??` or made up solely of the letter `M` and blanks — a plain modification, staged, unstaged, or both — commit it without asking: `oat internal commit-paths --identity "${COMMIT_IDENTITY:?set once and retain for retries}:oat-project-new:1" --message "chore: run sync" -- .oat/sync/manifest.json`. Report the commit in one line and continue to the next step. That file is `oat sync` output and carries no user content, so the prompt below was always answered "commit now" for it. Every other code falls through to the prompt below, including any code that pairs `M` with something else: `MD` (deleted in the worktree), `MT` (type change), `AM`, `RM`, `CM`, and every unmerged state. Auto-staging one of those would commit a deletion, a retyped file, or a half-resolved merge. Any other dirty path, in any combination, also falls through.
 3. Otherwise, present the dirty list to the user.
 4. If `.oat/sync/manifest.json` or paths under `.claude/`, `.cursor/`, `.codex/` appear in the list, note: "These are generated by `oat sync` (often by `pnpm run worktree:init` or `oat-worktree-bootstrap-auto`) and are typically safe to commit as `chore: run sync`."
 5. Offer three choices via `AskUserQuestion`:

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

@@ -5,7 +5,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Glob, Grep, Bash(git:*), Bash(oat:*), Skill
 metadata:
-  version: 1.1.4
+  version: 1.1.5
 ---
 
 # Project Next
@@ -135,6 +135,7 @@ Read `"$PROJECT_PATH/state.md"` frontmatter and extract:
 | `oat_hill_completed`      | Which HiLL gates have been passed                                                            |
 | `oat_blockers`            | Informational warnings (not routing gates)                                                   |
 | `oat_implement_exit_gate` | Whether the implementation exit gate is allowed and fresh                                    |
+| `oat_quick_start_gate`    | Reported only in the Step 6 announcement; never a routing input                              |
 | `oat_lifecycle`           | Terminal status (active, paused, complete). `complete` is the terminal signal Step 5.2 reads |
 
 **If state.md is missing or unreadable:** Report error and suggest running the relevant phase skill directly. STOP.
@@ -331,7 +332,10 @@ Apply the following checks in priority order. Stop at the first match:
 **5.0: Unresolved implementation exit gate**
 
 Before every other post-implementation route, inspect
-`oat_implement_exit_gate` in project state. If
+`oat_implement_exit_gate` in project state. Its `status`, `disposition`,
+`config_fingerprint`, `reviewed_head`, and `decided_at` fields are the shared
+lifecycle gate record core in `references/docs/gate-approval-record.md`; the
+freshness rules below are this record's own. If
 `oat_implement_exit_gate` is absent, `pending`, `blocked`, `stale`, malformed,
 or not fresh, route to `oat-project-implement`.
 
@@ -562,6 +566,19 @@ Routing: → {target-skill-name}
 Reason: {one-line explanation}
 ```
 
+**Quick-start gate record:** When `oat_quick_start_gate` exists, read it as
+`references/docs/gate-approval-record.md` describes, without recomputing its
+fingerprint, and add one line after the `Current:` line:
+
+```
+Quick-start gate: {status}/{disposition}, decided {decided_at}, fingerprint {config_fingerprint} (as recorded)
+```
+
+Write `malformed` in place of the values when the fields do not form a valid
+record. The record adds no route and no warning. The quick plan readiness
+predicate stays the single routing rule for quick plans, and an absent record
+(no record written) adds no line.
+
 **Blocker warning:** If `oat_blockers` is non-empty, add before the routing line:
 
 ```

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

@@ -0,0 +1,80 @@
+# Lifecycle Gate Approval Record
+
+A configured lifecycle gate ends in an outcome the operator or a later session
+needs to see again: it passed, it warned, the operator explicitly continued
+past a failure, the project disabled it, or it blocked. Chat output does not
+survive the session, so the skill that runs the gate persists the outcome in
+project `state.md`. This document defines the record's shared core once; each
+carrier names where it lives and what it adds.
+
+## Core record
+
+```yaml
+<carrier>:
+  status: allowed # allowed | blocked
+  disposition: passed # passed | warned | prompt_approved | project_disabled; null when blocked
+  config_fingerprint: '<stable hash of the resolved gate declaration>'
+  reviewed_head: '<full SHA of the commit the gate reviewed>'
+  decided_at: '2026-10-02T15:20:00Z'
+```
+
+- `status`: `allowed` | `blocked`.
+- `disposition`: `passed`, `warned`, `prompt_approved`, or `project_disabled`
+  when `status` is `allowed`; `null` when `status` is `blocked`.
+- `config_fingerprint`: the writer's stable hash of the resolved gate
+  declaration it ran (command, description, `onFailure`, `maxAttempts`, and the
+  project override state), recorded as provenance. Implement recomputes its own
+  carrier's fingerprint under its Step 14 rules; quick-start readers do not.
+- `reviewed_head`: the full 40-character SHA of the commit the gate reviewed,
+  recorded as provenance. `null` when no gate ran.
+- `decided_at`: the ISO 8601 UTC time the outcome was decided. A record written
+  before `decided_at` existed is not malformed for that reason alone.
+
+## Write rules
+
+| Gate outcome                                                    | Record                                                      |
+| --------------------------------------------------------------- | ----------------------------------------------------------- |
+| Passed its threshold                                            | `allowed` / `passed`                                        |
+| Failed under `onFailure: warn`                                  | `allowed` / `warned`                                        |
+| Failed under `onFailure: prompt`, operator explicitly continued | `allowed` / `prompt_approved`                               |
+| Failed under `onFailure: prompt`, operator declined or deferred | `blocked` / `null`                                          |
+| `block` still failing after `maxAttempts`                       | `blocked` / `null`                                          |
+| Configured but disabled by project override (no launch)         | `allowed` / `project_disabled`                              |
+| Launch, transport, validation, or receive failure               | `blocked` / `null`                                          |
+| Not configured                                                  | no record (quick-start); implement writes `allowed/no_gate` |
+
+Only an explicit operator continuation writes `prompt_approved`. Declining,
+deferring, giving no response, or running under `OAT_AUTONOMOUS=1` writes
+`blocked`, never anything that reads as approval. A rerun of the same gate
+replaces the record.
+
+## Carriers
+
+- **`oat_implement_exit_gate`** (`oat-project-implement`,
+  `references/completion-and-closeout.md` Step 14) uses this core and keeps its
+  additional values and fields there: the `pending` and `stale` statuses, the
+  `no_gate` disposition, and the resolution, attempt, launch, receive, waiver,
+  and freshness fields. Its own effective-delta freshness rule decides whether a
+  record is current.
+- **`oat_quick_start_gate`** (`oat-project-quick-start`, Gate Execution) carries
+  exactly the core.
+
+## Reading a quick-start record
+
+Readers report a quick-start record as recorded and do not recompute
+`config_fingerprint`: no CLI emits a canonical fingerprint for the quick-start
+gate, so a recomputation could not be reproduced across sessions. They do not
+route on the record either.
+
+- Report `status`, `disposition`, `decided_at`, and `config_fingerprint` (as
+  provenance) exactly as stored.
+- Report the record as malformed when `status` and `disposition` do not form
+  one of the combinations in the write rules, or when a present `decided_at` is
+  not a valid ISO 8601 UTC time.
+- `reviewed_head` is provenance only and is not compared with `HEAD`, because
+  the quick-start completion step commits after the gate.
+- An absent record means none was written: no gate was configured, the gate
+  has not reached an outcome, or the plan predates the record. Readers do not
+  infer which.
+
+Readers never write, repair, or infer a record.

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

@@ -6,13 +6,17 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash(git:*), Bash(oat template:*), Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.4.16
+  version: 1.4.17
 ---
 
 # Planning Phase
 
 Transform detailed design into an executable implementation plan with bite-sized tasks.
 
+## Hook-safe exact-path commits
+
+Before a parent-branch commit, verify `oat internal commit-paths --help` succeeds. If unavailable, stop and update the OAT CLI; never fall back to a staged-index or pathspec-only commit. Set `COMMIT_IDENTITY` to a unique operation/artifact identity before the first attempt and retain it for every retry; use a new identity for a new operation. Pass only the exact produced file list, including tracked removals and both names of a rename. A blocked/failed result stops the workflow; retain its receipt and follow its diagnostics. Hooks remain enabled. Synced project artifacts continue through `oat project push`.
+
 ## Prerequisites
 
 This skill is the plan authoring path for **spec-driven** projects only. Quick,
@@ -301,6 +305,10 @@ For each phase, create bite-sized tasks.
 - Create: `{path/to/new.ts}`
 - Modify: `{path/to/existing.ts}`
 
+Before the first edit, initialize `TASK_OWNED_FILES=()` and append each exact
+created, modified or removed file at its producer, including both rename sides.
+Retain the task list and its unique task identity for commit/retry.
+
 **Step 1: Write test (RED)**
 {Test code or test case description}
 
@@ -317,8 +325,8 @@ Expected: {output}
 **Step 5: Commit**
 
 ```bash
-git add {files}
-git commit -m "feat(p{NN}-t{NN}): {description}"
+OWNED_COMMIT_PATHS=("${TASK_OWNED_FILES[@]}")
+oat internal commit-paths --identity "${COMMIT_IDENTITY:?set once and retain for retries}:oat-project-plan:p{NN}-t{NN}" --message "feat(p{NN}-t{NN}): {description}" -- "${OWNED_COMMIT_PATHS[@]}" || exit 1
 ```
 ````
 
@@ -740,8 +748,8 @@ Total: {N} tasks
 Ready for implementation" || { echo "oat: project push failed; run oat project pull, resolve the reported state, and retry" >&2; exit 1; }
 else
   PROJECT_OUTPUT_PATHS=("$PROJECT_PATH/plan.md" "$PROJECT_PATH/state.md")
-  git add -- "${PROJECT_OUTPUT_PATHS[@]}"
-  git commit -m "docs: complete implementation plan for {project-name}
+  OWNED_COMMIT_PATHS=("${PROJECT_OUTPUT_PATHS[@]}")
+  oat internal commit-paths --identity "${COMMIT_IDENTITY:?set once and retain for retries}:oat-project-plan:2" --message "docs: complete implementation plan for {project-name}
 
 Phases:
 - Phase 1: {description} ({N} tasks)
@@ -749,7 +757,7 @@ Phases:
 
 Total: {N} tasks
 
-Ready for implementation"
+Ready for implementation" -- "${OWNED_COMMIT_PATHS[@]}" || exit 1
 fi
 ```
 

package/assets/skills/oat-project-pr-final/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Bash(awk:*), Bash(gh:*), Bash(git:*), Bash(mktemp:*), Bash(oat:*), Bash(rm:*), Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.6.7
+  version: 1.6.9
 ---
 
 # Project PR (Final)
@@ -194,7 +194,8 @@ echo "$FINAL_ROW"
 ```
 
 `REVIEWS_SECTION` is strictly the `## Reviews` section through the next
-level-two heading. Use the latest appended event in that ledger whose Scope is
+level-two heading other than `## Reviews` itself; `###` and level-one headings
+do not end it. Use the latest appended event in that ledger whose Scope is
 `final` and Type is `code`. Earlier final-review events remain history and do
 not determine the current gate.
 
@@ -420,7 +421,7 @@ Only include links to artifacts that actually exist in the project. Omit any tha
 
 After writing the PR artifact, push and create the PR automatically.
 
-**Ledger-path guard (both PR paths).** Before either `gh pr create` path runs, validate every artifact path in the project's `## Reviews` ledger. Parse each row's Artifact cell rather than grepping the section as free text, and skip a `-` placeholder. The ledger is the table rows of `## Reviews`: the scan starts at the first exact `## Reviews` heading and ends at the next level-two heading — a `###` subsection inside that section is still scanned, exactly as Step 2 reads the ledger — and a blockquoted line or a fenced block inside the section is a note or an event example, never an event. Columns are split on `|`, so an escaped `\|` anywhere in a ledger header or ledger row stops rather than shifting the Artifact column onto a neighbouring cell: no ledger value needs a literal pipe, and reading one cell while naming another is exactly the silent skip this gate exists to prevent. Every other cell must normalize — `..` segments and symlinks resolved physically — to a regular file inside `$PROJECT_PATH`. The ledger is the table inside `## Reviews` whose header carries `Scope`, `Type`, and `Artifact` columns, matched after emphasis is stripped and in whatever order the header declares; a section that holds table rows but no such header, or an unclosed fenced block, stops rather than validating nothing. Processed review artifacts live in the gitignored `reviews/archived/`, so when that directory does not exist in this checkout at all — a fresh clone, a remote workspace, or a lane worktree — an absent path inside it is a local-only artifact: report it and continue. Once `reviews/archived/` exists, a file missing from it is a dangling row, usually an archive interrupted between the reference rewrite and the move, and it stops like any other absent path. That excuse covers a location that was never materialized, so it requires the path to be absent outright: a regular file, a dangling symlink, or any other non-directory at `reviews/archived` is an anomaly, not a fresh checkout, and it stops rather than excusing the row. Every other absent path fails, in every project scope — git ignores whole project directories for `local`, `synced`, and `archived` projects, so ignore state says nothing about whether a row resolves. A missing file in a tracked location, a directory, a path that escapes the project, a non-directory at `reviews/archived`, an unreadable ledger, a plan with no `## Reviews` section, an escaped pipe in a ledger header or row, a row the parser cannot read, or a ledger the guard could not check row for row stops this skill at gate `PRFINAL-05`, naming the offending row by scope, type, and artifact filename. Every stop fails closed. Both the synced flow below and the non-synced flow run after this block, so no PR is created from a ledger whose artifact paths do not resolve.
+**Ledger-path guard (both PR paths).** Before either `gh pr create` path runs, validate every artifact path in the project's `## Reviews` ledger. Parse each row's Artifact cell rather than grepping the section as free text, and skip a `-` placeholder. The ledger is the table rows of `## Reviews`: the scan starts at the first exact `## Reviews` heading and ends at the next level-two heading other than `## Reviews` itself; `###` and deeper subsections and level-one headings inside the section do not end it and are still scanned, exactly as Step 2 reads the ledger. A blockquoted line or a fenced block inside the section is a note or an event example, never an event. Columns are split on `|`, so an escaped `\|` anywhere in a ledger header or ledger row stops rather than shifting the Artifact column onto a neighbouring cell: no ledger value needs a literal pipe, and reading one cell while naming another is exactly the silent skip this gate exists to prevent. The escaped-pipe stop stands until a real review ledger contains an escaped pipe; that ledger, not a hypothetical one, is the evidence that would justify teaching the parser to unescape a cell. Every other cell must normalize — `..` segments and symlinks resolved physically — to a regular file inside `$PROJECT_PATH`. The ledger is the table inside `## Reviews` whose header carries `Scope`, `Type`, and `Artifact` columns, matched after emphasis is stripped and in whatever order the header declares; a section that holds table rows but no such header, or an unclosed fenced block, stops rather than validating nothing. Processed review artifacts live in the gitignored `reviews/archived/`, so when that directory does not exist in this checkout at all — a fresh clone, a remote workspace, or a lane worktree — an absent path inside it is a local-only artifact: report it and continue. Once `reviews/archived/` exists, a file missing from it is a dangling row, usually an archive interrupted between the reference rewrite and the move, and it stops like any other absent path. That excuse covers a location that was never materialized, so it requires the path to be absent outright: a regular file, a dangling symlink, or any other non-directory at `reviews/archived` is an anomaly, not a fresh checkout, and it stops rather than excusing the row. Every other absent path fails, in every project scope — git ignores whole project directories for `local`, `synced`, and `archived` projects, so ignore state says nothing about whether a row resolves. A missing file in a tracked location, a directory, a path that escapes the project, a non-directory at `reviews/archived`, an unreadable ledger, a plan with no `## Reviews` section, an escaped pipe in a ledger header or row, a row the parser cannot read, or a ledger the guard could not check row for row stops this skill at gate `PRFINAL-05`, naming the offending row by scope, type, and artifact filename. Every stop fails closed. Both the synced flow below and the non-synced flow run after this block, so no PR is created from a ledger whose artifact paths do not resolve.
 
 ````bash
 LEDGER_PROJECT_ROOT=$(cd -P "$PROJECT_PATH" 2>/dev/null && pwd -P) || {