@open-agent-toolkit/cli 0.0.10

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

@@ -0,0 +1,354 @@
+---
+name: oat-project-pr-progress
+version: 1.2.0
+description: Use when an active OAT project needs a mid-project PR for a completed phase (pNN). Generates a phase-scoped progress PR description from OAT artifacts and commit history, with optional PR creation.
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Write, Bash(git:*), Glob, Grep, AskUserQuestion
+---
+
+# Progress PR
+
+Create a progress PR description (typically at a plan phase boundary) and write it to disk.
+
+## Purpose
+
+Generate a PR-ready summary that is:
+
+- grounded in OAT artifacts (mode-aware: spec-driven uses spec/design; quick/import may use discovery/import reference)
+- scoped to a specific phase (pNN) or an explicit git range
+- easy to paste into GitHub (or used with `gh pr create` if desired)
+
+## Prerequisites
+
+**Required:**
+
+- `activeProject` in `.oat/config.local.json` points at an active project directory (or you can provide project name when prompted)
+- `{PROJECT_PATH}/plan.md` exists
+
+**Recommended:**
+
+- Phase code review is `passed` in `plan.md` `## Reviews` before opening a progress PR.
+
+## Mode Assertion
+
+**OAT MODE: PR (Progress)**
+
+**Purpose:** Create PR description and (optionally) open a PR.
+
+## Progress Indicators (User-Facing)
+
+When executing this skill, provide lightweight progress feedback so the user can tell what’s happening after they confirm.
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ PR PROGRESS
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Before multi-step work (scoping, reading artifacts, writing output), print 2–5 short step indicators, e.g.:
+  - `[1/5] Preflighting review artifacts…`
+  - `[2/5] Resolving scope…`
+  - `[3/5] Reading OAT artifacts…`
+  - `[4/5] Collecting git context…`
+  - `[5/5] Writing PR description…`
+- For long-running operations (git logs/diffs on large ranges), print a start line and a completion line (duration optional).
+- Keep it concise; don’t print a line for every shell command.
+
+**BLOCKED Activities:**
+
+- No implementation work
+- No changing requirements/design/plan
+
+**ALLOWED Activities:**
+
+- Reading artifacts and git history
+- Writing PR description file
+- Running `gh pr create` (optional, user-confirmed)
+
+## Usage
+
+### With arguments (if supported)
+
+```
+oat-project-pr-progress p02                 # progress PR for phase p02
+oat-project-pr-progress range=abc..def      # progress PR for explicit range
+oat-project-pr-progress base_sha=abc123     # progress PR for abc123..HEAD
+```
+
+### Without arguments
+
+Run the `oat-project-pr-progress` skill and it will ask:
+
+- which phase (pNN) or range to scope to
+- PR title + base branch (resolved from: explicit `base=` arg → `git.defaultBranch` in `.oat/config.json` → `git rev-parse --abbrev-ref origin/HEAD` → fallback `main`)
+
+## Process
+
+### Step 0: Resolve Active Project
+
+OAT stores active project context in `.oat/config.local.json` (`activeProject`, local-only).
+
+```bash
+PROJECT_PATH=$(oat config get activeProject 2>/dev/null || true)
+PROJECTS_ROOT="${OAT_PROJECTS_ROOT:-$(oat config get projects.root 2>/dev/null || echo ".oat/projects/shared")}"
+PROJECTS_ROOT="${PROJECTS_ROOT%/}"
+```
+
+If missing/invalid:
+
+- Ask the user for `{project-name}`
+- Set `PROJECT_PATH` to `${PROJECTS_ROOT}/{project-name}`
+- Write it:
+  ```bash
+  mkdir -p .oat
+  oat config set activeProject "$PROJECT_PATH"
+  ```
+
+### Step 0.5: Archive Residual Active Review Artifacts
+
+Before generating the PR, detect any leftover active review artifacts in the top level of `"$PROJECT_PATH/reviews/"`:
+
+```bash
+find "$PROJECT_PATH/reviews" -maxdepth 1 -type f -name "*.md" 2>/dev/null
+```
+
+If any active review artifacts exist:
+
+1. Create `"$PROJECT_PATH/reviews/archived"` if needed.
+2. For each active review file, rewrite any references touched during this preflight so they point to `reviews/archived/{filename}.md` instead of `reviews/{filename}.md`. At minimum, check:
+   - `"$PROJECT_PATH/plan.md"`
+   - `"$PROJECT_PATH/implementation.md"`
+   - `"$PROJECT_PATH/state.md"`
+3. Move the review artifact into `reviews/archived/`, adding a timestamp suffix if the archive target already exists.
+4. Report the archived paths before continuing.
+
+Rules:
+
+- Only archive top-level active review artifacts. Leave `reviews/archived/` untouched.
+- This preflight is bookkeeping only; do not change review statuses unless a rewritten artifact path requires it.
+
+### Step 1: Determine Scope (Phase or Range)
+
+Parse args if provided (otherwise prompt):
+
+- `pNN` (preferred for progress PRs)
+- `range=<sha1>..<sha2>`
+- `base_sha=<sha>` (meaning `<sha>..HEAD`)
+
+If scope is `pNN`, gather commits via commit convention grep:
+
+```bash
+PHASE="p02" # example
+git log --oneline --grep="\\(${PHASE}-" HEAD~500..HEAD
+```
+
+If the grep returns no commits:
+
+- Tell user commit conventions are missing/inconsistent for this phase
+- Ask user to provide:
+  - `base_sha=<sha>` or `range=<sha1>..<sha2>`
+  - or confirm a broad range (merge-base..HEAD)
+
+If scope is `range`/`base_sha`, set:
+
+- `SCOPE_RANGE` to the range string (e.g., `abc..HEAD`)
+
+### Step 2: Load Artifacts (Mode-Aware)
+
+Resolve workflow mode from `state.md` (default `spec-driven`):
+
+```bash
+WORKFLOW_MODE=$(grep "^oat_workflow_mode:" "$PROJECT_PATH/state.md" 2>/dev/null | head -1 | awk '{print $2}')
+WORKFLOW_MODE=${WORKFLOW_MODE:-spec-driven}
+```
+
+Read (as available):
+
+- `{PROJECT_PATH}/spec.md`
+- `{PROJECT_PATH}/design.md`
+- `{PROJECT_PATH}/plan.md`
+- `{PROJECT_PATH}/implementation.md` (if exists)
+- `{PROJECT_PATH}/discovery.md` (recommended for quick mode)
+- `{PROJECT_PATH}/references/imported-plan.md` (recommended for import mode)
+
+If `WORKFLOW_MODE != spec-driven` and spec/design are missing:
+
+- continue (do not block)
+- include an explicit note in PR summary that spec-driven requirements/design artifacts are absent for this scope
+
+### Step 3: Check Review Status (Recommended)
+
+If scope is `pNN`, check `plan.md` `## Reviews` table row:
+
+- If `| pNN | code | passed | ...` exists: good
+- Otherwise: warn that review has not been marked `passed` for this phase (e.g., it may be `received`, `fixes_added`, or `fixes_completed` pending re-review)
+
+Do not block PR generation; this is a progress PR.
+
+### Step 4: Collect Scope Data
+
+Produce:
+
+- commit list (for `pNN` grep or `SCOPE_RANGE`)
+- changed files (best-effort)
+
+For `SCOPE_RANGE`:
+
+```bash
+git log --oneline "$SCOPE_RANGE"
+git diff --name-only "$SCOPE_RANGE"
+git diff --shortstat "$SCOPE_RANGE"
+```
+
+For `pNN` (no reliable contiguous range):
+
+- include the commit list from grep
+- optionally include file lists per commit (only if needed; can be large)
+
+### Step 5: Write PR Description Artifact
+
+Write to:
+
+- `{PROJECT_PATH}/pr/progress-{scope}-YYYY-MM-DD.md`
+
+```bash
+mkdir -p "$PROJECT_PATH/pr"
+```
+
+Frontmatter policy:
+
+- Keep YAML frontmatter in the local artifact file for OAT metadata and traceability.
+- Do **not** include YAML frontmatter in the PR body submitted to GitHub.
+
+Reference links policy:
+
+- Prefer clickable blob links to the current branch for References.
+- Build links from `origin` + current branch when possible.
+- If remote URL cannot be resolved into a web URL, fall back to plain relative paths.
+
+Local path exclusion:
+
+- Read `.oat/config.json` and extract `localPaths` (glob patterns for gitignored directories).
+- Do **not** include References links to any path that matches a `localPaths` pattern — those paths are gitignored and will not exist on the remote.
+- Common matches: `.oat/projects/**/reviews/archived`, `.oat/projects/**/pr`. Active `reviews/` paths remain eligible for References when they are tracked; only archived review paths should be treated as local-only by default.
+
+Example link context:
+
+```bash
+ORIGIN_URL=$(git remote get-url origin 2>/dev/null || echo "")
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+PROJECT_REL="${PROJECT_PATH#./}"
+
+REPO_WEB=""
+case "$ORIGIN_URL" in
+  git@github.com:*) REPO_WEB="https://github.com/${ORIGIN_URL#git@github.com:}" ;;
+  https://github.com/*) REPO_WEB="$ORIGIN_URL" ;;
+esac
+REPO_WEB="${REPO_WEB%.git}"
+```
+
+Recommended template:
+
+```markdown
+---
+oat_generated: true
+oat_generated_at: YYYY-MM-DD
+oat_pr_type: progress
+oat_pr_scope: { pNN|range }
+oat_project: { PROJECT_PATH }
+---
+
+# {project-name} ({scope})
+
+## Summary
+
+{1-3 sentence summary of what this phase delivered}
+
+## Goals / Non-Goals
+
+{goals addressed by this phase, from available requirement artifacts: spec in spec-driven mode, discovery/import reference in quick/import mode}
+
+## Changes
+
+- Project: `{PROJECT_PATH}`
+- Scope: `{scope}`
+- Commits:
+  {bulleted list}
+
+## Verification
+
+- Tests: {what was run / expected}
+- Lint/Types/Build: {what was run / expected}
+
+## Reviews
+
+{phase review row from plan.md Reviews table, if available}
+
+## References
+
+Only include links to artifacts that actually exist in the project. Omit any that are absent.
+
+- Spec: `[spec.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/spec.md)`
+- Design: `[design.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/design.md)`
+- Plan: `[plan.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/plan.md)` (fallback: `{PROJECT_PATH}/plan.md`)
+- Implementation: `[implementation.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/implementation.md)` (fallback: `{PROJECT_PATH}/implementation.md`)
+- Discovery: `[discovery.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/discovery.md)`
+- Imported Source: `[references/imported-plan.md]({REPO_WEB}/blob/{BRANCH}/{PROJECT_REL}/references/imported-plan.md)`
+- Reviews: `[reviews/]({REPO_WEB}/tree/{BRANCH}/{PROJECT_REL}/reviews)` (fallback: `{PROJECT_PATH}/reviews/`) — include when active `reviews/` is tracked; omit archived review paths and any target that still matches a `localPaths` pattern
+```
+
+### Step 6: Optional - Open PR
+
+Ask the user:
+
+```
+PR description written to {path}.
+
+Do you want to open a PR now?
+1) Yes (use gh CLI if available)
+2) No (I will open manually)
+```
+
+If user chooses (1), provide best-effort guidance:
+
+- Strip YAML frontmatter from the local artifact into a temporary body file:
+  ```bash
+  BODY_FILE="{path}"
+  TMP_BODY="$(mktemp -t oat-pr-body.XXXXXX.md)"
+  awk 'NR==1 && $0=="---" {infm=1; next} infm && $0=="---" {infm=0; next} !infm {print}' "$BODY_FILE" > "$TMP_BODY"
+  ```
+- Resolve the base branch:
+
+  ```bash
+  # Resolution chain: explicit arg > OAT config > git remote > fallback
+  BASE_BRANCH="{base_arg if provided}"
+  if [ -z "$BASE_BRANCH" ]; then
+    BASE_BRANCH=$(oat config get git.defaultBranch 2>/dev/null || true)
+  fi
+  if [ -z "$BASE_BRANCH" ]; then
+    BASE_BRANCH=$(git rev-parse --abbrev-ref origin/HEAD 2>/dev/null | sed 's|origin/||' || true)
+  fi
+  BASE_BRANCH="${BASE_BRANCH:-main}"
+  ```
+
+- Use the stripped body file with `gh`:
+
+  ```bash
+  git push -u origin "$(git rev-parse --abbrev-ref HEAD)"
+  gh pr create --base "$BASE_BRANCH" --title "{title}" --body-file "$TMP_BODY"
+  ```
+
+- Optionally clean up temp file:
+  ```bash
+  rm -f "$TMP_BODY"
+  ```
+
+Do not assume `gh` is installed; if missing, instruct manual PR creation using the file contents and note the resolved base branch.
+
+## Success Criteria
+
+- Residual active review artifacts are archived before PR generation continues
+- Scope determined (phase or explicit range)
+- PR description artifact written to `{PROJECT_PATH}/pr/`
+- User has clear next step to open PR (manual or gh)

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

@@ -0,0 +1,342 @@
+---
+name: oat-project-progress
+version: 1.2.0
+description: Use when resuming work, checking status, or unsure which OAT skill to run next. Evaluates project progress and routes to the appropriate next step.
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash(git:*), AskUserQuestion
+---
+
+# Progress Router
+
+Check knowledge base status, project progress, and get recommendations for next steps.
+
+## Progress Indicators (User-Facing)
+
+When executing this skill, provide lightweight progress feedback so the user can tell what’s happening after they confirm.
+
+- Print a phase banner once at start using horizontal separators, e.g.:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ PROGRESS
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Before multi-step work, print step indicators, e.g.:
+  - `[1/4] Checking knowledge base…`
+  - `[2/4] Scanning project status…`
+  - `[3/4] Determining next steps…`
+  - `[4/4] Refreshing dashboard…`
+
+## Usage
+
+Run `oat-project-progress` at any time to:
+
+- Check if knowledge base exists and is fresh
+- See current project status
+- Get recommended next skill
+
+## Process
+
+### Step 1: Check Knowledge Base Exists
+
+```bash
+EXISTING_MD=$(find .oat/repo/knowledge -name "*.md" -type f 2>/dev/null | head -1)
+```
+
+**If `$EXISTING_MD` is empty:**
+
+```
+⚠️  No knowledge base found.
+
+Run the oat-repo-knowledge-index skill first to generate codebase analysis.
+```
+
+**Exit here.**
+
+### Step 2: Check Knowledge Staleness
+
+Extract frontmatter from `.oat/repo/knowledge/project-index.md`:
+
+```bash
+SOURCE_MERGE_BASE_SHA=$(grep "^oat_source_main_merge_base_sha:" .oat/repo/knowledge/project-index.md | awk '{print $2}')
+GENERATED_AT=$(grep "^oat_generated_at:" .oat/repo/knowledge/project-index.md | awk '{print $2}')
+```
+
+**Calculate staleness:**
+
+1. **Age check:**
+
+```bash
+# Skip if date is missing or invalid
+if [ -n "$GENERATED_AT" ] && echo "$GENERATED_AT" | grep -qE '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'; then
+  if date -j -f "%Y-%m-%d" "$GENERATED_AT" +%s >/dev/null 2>&1; then
+    GENERATED_TS=$(date -j -f "%Y-%m-%d" "$GENERATED_AT" +%s)
+  else
+    GENERATED_TS=$(date -d "$GENERATED_AT" +%s 2>/dev/null || echo "")
+  fi
+  if [ -n "$GENERATED_TS" ]; then
+    DAYS_OLD=$(( ($(date +%s) - $GENERATED_TS) / 86400 ))
+  fi
+fi
+```
+
+2. **Git diff check:**
+
+```bash
+if [ -n "$SOURCE_MERGE_BASE_SHA" ]; then
+  FILES_CHANGED=$(git diff --numstat "$SOURCE_MERGE_BASE_SHA..HEAD" 2>/dev/null | wc -l | tr -d ' ')
+  CHANGES_SUMMARY=$(git diff --shortstat "$SOURCE_MERGE_BASE_SHA..HEAD" 2>/dev/null)
+fi
+```
+
+**Staleness thresholds:**
+
+- Age: >7 days old
+- Changes: >20 files changed
+
+**If stale:**
+
+```
+⚠️  Knowledge base may be stale.
+
+Generated: {GENERATED_AT} ({DAYS_OLD} days ago)
+Changes since: {FILES_CHANGED} files changed
+{CHANGES_SUMMARY}
+
+Consider running the oat-repo-knowledge-index skill to refresh.
+```
+
+### Step 3: List Projects (Highlight Active Project)
+
+OAT stores active project context in `.oat/config.local.json` (`activeProject`, local-only).
+
+```bash
+ACTIVE_PROJECT_PATH=$(oat config get activeProject 2>/dev/null || true)
+PROJECTS_ROOT="${OAT_PROJECTS_ROOT:-$(oat config get projects.root 2>/dev/null || echo ".oat/projects/shared")}"
+PROJECTS_ROOT="${PROJECTS_ROOT%/}"
+```
+
+**If `ACTIVE_PROJECT_PATH` is set and valid (directory exists):**
+
+```
+Active Project: {basename(ACTIVE_PROJECT_PATH)} ({ACTIVE_PROJECT_PATH})
+```
+
+**If `ACTIVE_PROJECT_PATH` is missing/invalid:** show:
+
+```
+Active Project: (not set)
+```
+
+```bash
+ls -d "$PROJECTS_ROOT"/*/ 2>/dev/null
+```
+
+**If no projects:**
+
+```
+No active projects.
+
+Start a new project:
+  oat-project-new - Create a spec-driven project scaffold
+  oat-project-quick-start - Start a quick workflow project
+  oat-project-import-plan - Import an external markdown plan into OAT
+```
+
+**Continue to Step 6 (show available skills).**
+
+### Step 4: For Each Project, Show Status
+
+Read `{project}/state.md` frontmatter:
+
+- `oat_phase` - Current phase
+- `oat_phase_status` - in_progress or complete
+- `oat_workflow_mode` - spec-driven | quick | import
+- `oat_blockers` - Any blockers
+- `oat_hill_checkpoints` - Configured gates (e.g., `["discovery", "spec", "design"]`)
+- `oat_hill_completed` - Completed HiLL checkpoints
+
+**Display format:**
+
+```
+📁 {project-name}
+   Active: {yes/no}
+   Mode: {oat_workflow_mode}
+   Phase: {oat_phase} ({oat_phase_status})
+   HiLL Gates: {oat_hill_checkpoints}
+   Completed: {oat_hill_completed as checkmarks}
+   HiLL Pending: {yes/no for current phase}
+   Blockers: {oat_blockers or "None"}
+   Next: {recommended_skill}
+```
+
+### Step 5: Determine Next Skill
+
+Based on project state, recommend next action.
+
+Read `oat_workflow_mode` from `state.md` frontmatter:
+
+- `spec-driven` (default if missing)
+- `quick`
+- `import`
+
+Read `oat_execution_mode` from `state.md` frontmatter:
+
+- `single-thread` (default if missing)
+- `subagent-driven`
+
+**HiLL override (apply before phase routing):**
+
+- If current `oat_phase` is listed in `oat_hill_checkpoints` **and** not listed in `oat_hill_completed`, the phase's HiLL gate is still pending.
+- In that case, do **not** advance to the next phase even if `oat_phase_status: complete`.
+- Recommend continuing the current phase skill to capture explicit approval:
+  - discovery gate pending -> `oat-project-discover`
+  - spec gate pending -> `oat-project-spec`
+  - design gate pending -> `oat-project-design`
+
+**Drift detection (apply before routing `implement | in_progress`):**
+
+When `oat_phase: implement` and `oat_phase_status: in_progress`, check for artifact drift before recommending next skill:
+
+```bash
+# Use the project path from Step 4's per-project loop (or ACTIVE_PROJECT_PATH for single-project)
+# Count planned tasks
+PLAN_TASKS=$(grep -cE '^### Task p[0-9]+-t[0-9]+:' "$ACTIVE_PROJECT_PATH/plan.md" 2>/dev/null || echo 0)
+
+# Count completed tasks in implementation.md
+IMPL_COMPLETED=$(grep -cE '^\*\*Status:\*\* completed' "$ACTIVE_PROJECT_PATH/implementation.md" 2>/dev/null || echo 0)
+
+# Check for commits since last tracked SHA
+LAST_SHA=$(grep "^oat_last_commit:" "$ACTIVE_PROJECT_PATH/state.md" 2>/dev/null | awk '{print $2}')
+if [ -n "$LAST_SHA" ]; then
+  UNTRACKED_COMMITS=$(git rev-list --count "$LAST_SHA"..HEAD 2>/dev/null || echo 0)
+else
+  UNTRACKED_COMMITS=0
+fi
+```
+
+**Drift indicators (any one is sufficient):**
+
+- `PLAN_TASKS` > `IMPL_COMPLETED` and `UNTRACKED_COMMITS` > 0 (plan has more tasks than completed entries, and there are untracked commits — most direct signal)
+- `IMPL_COMPLETED` < number of task-convention commits on branch (tasks implemented but not logged)
+- `UNTRACKED_COMMITS` > 3 and `oat_current_task_id` is null or stale
+- Commits exist that match `feat(pNN-tNN):` pattern but lack corresponding completed entries in `implementation.md`
+
+If drift is detected, recommend `oat-project-reconcile` alongside the normal implementation skill.
+
+Routing matrix by mode:
+
+**Spec-Driven mode (`oat_workflow_mode: spec-driven`):**
+
+| oat_phase | oat_phase_status | Next Skill                                                                                                                                                                                                                                                                                                  |
+| --------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| discovery | in_progress      | Continue `oat-project-discover`                                                                                                                                                                                                                                                                             |
+| discovery | complete         | `oat-project-spec`                                                                                                                                                                                                                                                                                          |
+| spec      | in_progress      | Continue `oat-project-spec`                                                                                                                                                                                                                                                                                 |
+| spec      | complete         | `oat-project-design`                                                                                                                                                                                                                                                                                        |
+| design    | in_progress      | Continue `oat-project-design`                                                                                                                                                                                                                                                                               |
+| design    | complete         | `oat-project-plan`                                                                                                                                                                                                                                                                                          |
+| plan      | in_progress      | Continue `oat-project-plan`                                                                                                                                                                                                                                                                                 |
+| plan      | complete         | `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`                                                                                                                                                                                              |
+| implement | in_progress      | Continue `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`. If artifacts appear out of sync with recent commits (e.g., `implementation.md` has fewer completed tasks than commits suggest), also mention `oat-project-reconcile` as an option. |
+| implement | complete         | Ready for final review / PR                                                                                                                                                                                                                                                                                 |
+
+**Quick mode (`oat_workflow_mode: quick`):**
+
+| oat_phase | oat_phase_status | Next Skill                                                                                                                                                                                                                 |
+| --------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| discovery | in_progress      | Continue `oat-project-discover`                                                                                                                                                                                            |
+| discovery | complete         | `oat-project-plan`                                                                                                                                                                                                         |
+| plan      | in_progress      | Continue `oat-project-plan`                                                                                                                                                                                                |
+| plan      | complete         | `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`                                                                                                             |
+| implement | in_progress      | Continue `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`. If drift detected (see drift detection above), also mention `oat-project-reconcile` as an option. |
+| implement | complete         | Ready for final review / PR                                                                                                                                                                                                |
+
+**Import mode (`oat_workflow_mode: import`):**
+
+| oat_phase | oat_phase_status | Next Skill                                                                                                                                                                                                                 |
+| --------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| plan      | in_progress      | Continue `oat-project-import-plan`                                                                                                                                                                                         |
+| plan      | complete         | `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`                                                                                                             |
+| implement | in_progress      | Continue `oat-project-subagent-implement` when `oat_execution_mode: subagent-driven`, otherwise `oat-project-implement`. If drift detected (see drift detection above), also mention `oat-project-reconcile` as an option. |
+| implement | complete         | Ready for final review / PR                                                                                                                                                                                                |
+
+**If blockers exist:**
+
+```
+⚠️  Blocker: {blocker description}
+
+Address blocker before continuing.
+```
+
+Execution-mode note:
+
+- Keep `oat_ready_for` in `plan.md` canonical (`oat-project-implement`).
+- Runtime routing at plan completion is controlled by `oat_execution_mode` in `state.md`.
+
+### Step 6: Show Available Skills
+
+```
+OAT Workflow Skills:
+
+Knowledge:
+  oat-repo-knowledge-index             - Generate/refresh codebase knowledge base
+
+Workflow:
+  oat-project-quick-start       - Start a quick workflow (discover -> plan -> implement)
+  oat-project-import-plan       - Import an external markdown plan and normalize plan.md
+  oat-project-promote-spec-driven - Promote quick/import project to spec-driven lifecycle
+  oat-project-discover          - Start discovery phase (requirements gathering)
+  oat-project-spec              - Create specification from discovery
+  oat-project-design            - Create technical design from spec
+  oat-project-plan              - Create implementation plan from design (spec-driven mode)
+  oat-project-implement         - Execute implementation plan
+  oat-project-subagent-implement - Execute implementation plan with subagent orchestration
+  oat-project-reconcile         - Reconcile manual/human commits with plan tasks
+
+Status:
+  oat-project-progress          - Check project progress (this skill)
+  oat-project-next              - Continue working — routes to the correct next skill automatically
+
+Reviews:
+  oat-project-review-provide    - Request a fresh-context code/artifact review (writes review artifact)
+  oat-project-review-receive    - Convert review findings into plan tasks (gap closure)
+
+PRs:
+  oat-project-pr-progress       - Create a progress PR description (phase-scoped)
+  oat-project-pr-final          - Create the final project PR description (after final review)
+```
+
+### Step 7: Output Summary
+
+Combine all information:
+
+```
+OAT Progress Report
+===================
+
+Knowledge Base:
+  Status: {✓ Fresh / ⚠️ Stale / ❌ Missing}
+  Generated: {date}
+  Changes since: {N} files
+
+Active Projects:
+{project summaries}
+
+Next Step: {recommendation}
+```
+
+### Step 8: Regenerate Dashboard
+
+After all progress checks, regenerate the repo state dashboard:
+
+```bash
+oat state refresh
+```
+
+## Success Criteria
+
+- Knowledge base status clearly shown
+- All active projects listed with status
+- Clear next-step recommendations
+- Blockers highlighted prominently