oh-my-customcode 0.69.0 → 0.71.0

package/templates/.claude/hooks/scripts/omcustom-auto-update.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+# SessionStart auto-update hook — interactive omcustom update check
+# Trigger: SessionStart (runs BEFORE session-env-check.sh)
+# Purpose: Check for oh-my-customcode updates, prompt user, optionally update
+# Protocol: stdin JSON -> stdout pass-through, exit 0 ALWAYS
+# Design: GitHub issue #752
+
+# Pass through stdin immediately — capture for later output
+input=$(cat)
+
+# --- Guard: skip conditions ---
+
+# Skip if explicitly disabled
+if [ "${OMCUSTOM_SKIP_AUTO_UPDATE:-}" = "true" ]; then
+  echo "$input"
+  exit 0
+fi
+
+# Skip if /dev/tty not available (CI, Docker, non-interactive)
+if ! [ -c /dev/tty ] 2>/dev/null; then
+  echo "$input"
+  exit 0
+fi
+
+# --- Configuration ---
+CACHE_DIR="$HOME/.oh-my-customcode"
+CACHE_FILE="${CACHE_DIR}/self-update-cache.json"
+CACHE_MAX_AGE=3600  # 1 hour in seconds
+NPM_TIMEOUT=3       # seconds for npm view
+INPUT_TIMEOUT=10     # seconds for user prompt
+PACKAGE_NAME="oh-my-customcode"
+
+# --- Helper: semantic version compare ---
+# Returns 0 if $1 < $2 (update available)
+version_lt() {
+  local older
+  older=$(printf '%s\n' "$1" "$2" | sort -V | head -1)
+  [ "$older" = "$1" ] && [ "$1" != "$2" ]
+}
+
+# --- Step 1: Get current installed version ---
+CURRENT_VERSION=""
+
+# Try .omcustomrc.json in current directory
+if [ -f ".omcustomrc.json" ]; then
+  CURRENT_VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' .omcustomrc.json 2>/dev/null | head -1 | grep -o '"[^"]*"$' | tr -d '"')
+fi
+
+# Fallback: try npm list
+if [ -z "$CURRENT_VERSION" ]; then
+  CURRENT_VERSION=$(npm list -g "$PACKAGE_NAME" --depth=0 2>/dev/null | grep -o "${PACKAGE_NAME}@[^ ]*" | cut -d'@' -f2)
+fi
+
+# Cannot determine current version — skip
+if [ -z "$CURRENT_VERSION" ]; then
+  echo "$input"
+  exit 0
+fi
+
+# --- Step 2: Get latest version (cache-first, network fallback) ---
+LATEST_VERSION=""
+CACHE_HIT=false
+
+# Ensure cache directory exists
+mkdir -p "$CACHE_DIR" 2>/dev/null
+
+# Check cache freshness
+if [ -f "$CACHE_FILE" ]; then
+  CACHE_TIMESTAMP=$(grep -o '"timestamp"[[:space:]]*:[[:space:]]*[0-9]*' "$CACHE_FILE" 2>/dev/null | grep -o '[0-9]*$')
+  CACHED_VERSION=$(grep -o '"version"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null | grep -o '"[^"]*"$' | tr -d '"')
+
+  if [ -n "$CACHE_TIMESTAMP" ] && [ -n "$CACHED_VERSION" ]; then
+    NOW=$(date +%s)
+    AGE=$((NOW - CACHE_TIMESTAMP))
+
+    if [ "$AGE" -lt "$CACHE_MAX_AGE" ]; then
+      LATEST_VERSION="$CACHED_VERSION"
+      CACHE_HIT=true
+    fi
+  fi
+fi
+
+# Cache miss or stale — fetch from npm registry
+if [ "$CACHE_HIT" = false ]; then
+  if command -v npm >/dev/null 2>&1; then
+    LATEST_VERSION=$(timeout "$NPM_TIMEOUT" npm view "$PACKAGE_NAME" version 2>/dev/null || echo "")
+
+    # Update cache on successful fetch
+    if [ -n "$LATEST_VERSION" ]; then
+      NOW=$(date +%s)
+      cat > "$CACHE_FILE" << EOF
+{
+  "version": "${LATEST_VERSION}",
+  "timestamp": ${NOW},
+  "source": "npm-registry"
+}
+EOF
+    fi
+  fi
+fi
+
+# Could not determine latest version — skip
+if [ -z "$LATEST_VERSION" ]; then
+  echo "$input"
+  exit 0
+fi
+
+# --- Step 3: Compare versions ---
+if ! version_lt "$CURRENT_VERSION" "$LATEST_VERSION"; then
+  # Already up to date
+  echo "$input"
+  exit 0
+fi
+
+# --- Step 4: Prompt user for update ---
+echo "" >&2
+echo "--- [oh-my-customcode Update Available] ---" >&2
+echo "  New version: v${LATEST_VERSION} (current: v${CURRENT_VERSION})" >&2
+echo "" >&2
+
+# Interactive prompt via /dev/tty (SessionStart stdin is JSON pipe)
+printf "  Update oh-my-customcode to v%s? [y/N] " "$LATEST_VERSION" >/dev/tty 2>/dev/null
+if read -r -t "$INPUT_TIMEOUT" answer </dev/tty 2>/dev/null; then
+  case "$answer" in
+    [yY]|[yY][eE][sS])
+      echo "  Installing oh-my-customcode@${LATEST_VERSION}..." >&2
+      if npm install -g "${PACKAGE_NAME}@latest" >&2 2>&1; then
+        echo "  ✓ Updated to v${LATEST_VERSION}" >&2
+
+        # Check if project harness should be updated too
+        if [ -f ".omcustomrc.json" ]; then
+          printf "  Update project harness too? [y/N] " >/dev/tty 2>/dev/null
+          if read -r -t "$INPUT_TIMEOUT" harness_answer </dev/tty 2>/dev/null; then
+            case "$harness_answer" in
+              [yY]|[yY][eE][sS])
+                echo "  Updating project harness..." >&2
+                if command -v omcustom >/dev/null 2>&1; then
+                  omcustom update --force >&2 2>&1 || echo "  ⚠ Harness update failed (non-blocking)" >&2
+                  echo "  ✓ Project harness updated" >&2
+                else
+                  echo "  ⚠ omcustom command not found after install" >&2
+                fi
+                ;;
+              *)
+                echo "  Skipped harness update" >&2
+                ;;
+            esac
+          else
+            echo "" >&2
+            echo "  Timed out — skipped harness update" >&2
+          fi
+        fi
+      else
+        echo "  ⚠ Update failed (non-blocking, continuing session)" >&2
+      fi
+      ;;
+    *)
+      echo "  Skipped update" >&2
+      ;;
+  esac
+else
+  echo "" >&2
+  echo "  Timed out — skipped update" >&2
+fi
+
+echo "------------------------------------" >&2
+
+# Always pass through and exit 0
+echo "$input"
+exit 0

package/templates/.claude/skills/claude-native/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: claude-native
+description: Monitor Claude Code releases and auto-generate GitHub issues for each new version
+scope: core
+user-invocable: true
+argument-hint: "[--backfill] [--dry-run]"
+version: 1.0.0
+---
+
+# Claude Native Skill
+
+Monitor Claude Code (the CLI tool) release history and auto-generate GitHub issues for each new version that has not yet been tracked. Replaces the deprecated customclaw Airflow-based monitoring (deprecated 2026-03-18).
+
+## Options
+
+```
+--backfill    Process ALL versions >= v2.1.86 (default behavior when flag is present)
+              Without flag: only check the latest 5 releases
+--dry-run     Show what issues would be created without actually creating them
+```
+
+## Workflow
+
+### Phase 1: Fetch CC Releases
+
+Fetch all Claude Code releases from the GitHub API:
+
+```bash
+gh api repos/anthropics/claude-code/releases \
+  --paginate \
+  --jq '.[] | {tag_name: .tag_name, published_at: .published_at, html_url: .html_url, body: .body}'
+```
+
+- Without `--backfill`: fetch only the latest 5 releases (`--limit 5` or first 5 results)
+- With `--backfill`: fetch all releases (use `--paginate`)
+- Filter: only process versions >= v2.1.86 (monitoring stopped after v2.1.85 / issue #683)
+
+### Phase 2: Check Existing Issues
+
+Search for existing tracking issues to avoid duplicates:
+
+```bash
+gh issue list \
+  --state all \
+  --search "[Claude Code v" \
+  --json number,title \
+  --limit 100
+```
+
+Build a set of already-tracked versions by extracting version strings from issue titles matching the pattern `[Claude Code v{version}]`.
+
+### Phase 3: Dedup
+
+For each fetched release version:
+- Parse the version string from `tag_name` (e.g., `v2.1.86`)
+- If a matching issue title already exists → skip (already tracked)
+- If no matching issue → add to "needs issue" list
+
+### Phase 4: Create Issues (or Dry-Run Report)
+
+#### Dry-Run Mode (`--dry-run`)
+
+Print a report of what would be created:
+
+```
+[Dry Run] Would create issues for:
+  - v2.1.86 (published: 2026-01-15)
+  - v2.1.87 (published: 2026-01-22)
+  ...
+No issues were created.
+```
+
+#### Live Mode
+
+For each version in the "needs issue" list, create a GitHub issue:
+
+```bash
+gh issue create \
+  --title "[Claude Code v{version}] New release detected" \
+  --label "automated,claude-code-release" \
+  --body "{body}"
+```
+
+Issue body format (matching the pattern established by issue #683):
+
+```markdown
+# Claude Code v{version}
+
+**Release:** v{version}
+**Published:** {published_at}
+**Link:** {html_url}
+
+## Release Summary
+
+{release_notes_body — truncated to first 2000 chars if too long}
+
+---
+
+## Action Items
+
+- [ ] Review release notes for impact on oh-my-customcode
+- [ ] Update agent definitions if new Claude Code features affect agents
+- [ ] Test compatibility with current oh-my-customcode version
+- [ ] Update CLAUDE.md if new capabilities are relevant
+
+---
+
+_This issue was created by the `/omcustom:claude-native` skill._
+```
+
+**Notes:**
+- If `body` from the release is empty, use `_No release notes provided._`
+- Truncate release body at 2000 characters and append `... (truncated)` if needed
+- The `automated` and `claude-code-release` labels must exist in the repository; create them if missing:
+  ```bash
+  gh label create "automated" --color "#0075ca" --description "Automated issue" 2>/dev/null || true
+  gh label create "claude-code-release" --color "#e4e669" --description "Claude Code release tracking" 2>/dev/null || true
+  ```
+
+### Phase 5: Report Results
+
+After processing all versions:
+
+```
+[claude-native] Scan complete
+
+Versions checked: {N}
+New issues created: {M}
+
+Created:
+  - #1234 [Claude Code v2.1.86] New release detected
+  - #1235 [Claude Code v2.1.87] New release detected
+
+Already tracked (skipped):
+  - v2.1.85 → #683
+```
+
+If no new releases found:
+
+```
+[claude-native] No new releases found. All versions >= v2.1.86 are already tracked.
+```
+
+## Version Filtering Logic
+
+```
+MIN_VERSION = "2.1.86"
+
+For each release:
+  version = strip_v_prefix(tag_name)   # "v2.1.86" → "2.1.86"
+  parts = split(version, ".")           # ["2", "1", "86"]
+  if compare_semver(version, MIN_VERSION) >= 0:
+    include
+  else:
+    skip
+```
+
+Semver comparison: major → minor → patch (all numeric). Pre-release suffixes (e.g., `-beta`) are included and compared lexicographically after numeric parts.
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| `gh` not authenticated | Report: "Error: gh CLI not authenticated. Run `gh auth login` first." |
+| Rate limit hit | Report current status, list remaining versions |
+| Label creation fails | Warn and continue (issue created without label) |
+| Release body parse error | Use empty body fallback, continue |
+
+## Integration Options
+
+### Manual
+
+```
+/omcustom:claude-native
+/omcustom:claude-native --backfill
+/omcustom:claude-native --dry-run
+```
+
+### Automatic (SessionStart Hook)
+
+Can be integrated into the SessionStart hook to check for new releases at session start:
+
+```json
+{
+  "SessionStart": [
+    {
+      "command": "bash .claude/hooks/scripts/claude-native-check.sh"
+    }
+  ]
+}
+```
+
+A lightweight wrapper script can run a `--dry-run` check and notify if new releases exist.
+
+### Scheduled (CronCreate)
+
+Can be set up as a scheduled remote agent using `/schedule`:
+
+```
+/schedule "daily at 9am: /omcustom:claude-native"
+```
+
+Or via CronCreate MCP tool for programmatic scheduling.
+
+## Prerequisites
+
+- `gh` CLI installed and authenticated (`gh auth status`)
+- Repository: `baekenough/oh-my-customcode` (default, detected from git remote)
+- Labels `automated` and `claude-code-release` (auto-created if missing)
+
+## Background
+
+- Last manually tracked release: v2.1.85 (issue #683)
+- Monitoring gap: v2.1.86 onwards (customclaw deprecated 2026-03-18)
+- This skill fills the monitoring gap and provides ongoing tracking

package/templates/.claude/skills/evaluator-optimizer/SKILL.md

@@ -379,7 +379,7 @@ When ecomode is active (R013), compress output:
 - The evaluator prompt MUST include the full rubric to ensure consistent scoring
 - Iteration state (best score, best output) is tracked by the orchestrator
 - The hard cap of 5 iterations prevents runaway refinement loops
-- For multi-sprint runs (5+ iterations), consider context reset: spawn a fresh evaluator agent rather than continuing with degraded context. The workflow-runner supports this via `context: fork` on individual steps. Anthropic's research confirms "context resets provide clean slates superior to compaction" for long-running evaluation.
+- For multi-sprint runs (5+ iterations), consider context reset: spawn a fresh evaluator agent rather than continuing with degraded context. The pipeline skill supports this via `context: fork` on individual steps. Anthropic's research confirms "context resets provide clean slates superior to compaction" for long-running evaluation.
 
 ## Domain Examples
 

package/templates/.claude/skills/omcustom-feedback/SKILL.md

@@ -9,11 +9,11 @@ argument-hint: "[description or leave empty for interactive] [--anonymous]"
 
 # Feedback Submitter
 
-Submit feedback about oh-my-customcode (bugs, features, improvements, questions) directly from the CLI session. Supports anonymous submission via Airflow DAG when gh CLI is unavailable or when anonymity is requested.
+Submit feedback about oh-my-customcode (bugs, features, improvements, questions) directly from the CLI session. Supports anonymous submission with `[Anonymous Feedback]` title prefix when `--anonymous` flag is used.
 
 ## Purpose
 
-Lowers the barrier for submitting feedback by allowing users to create GitHub issues or submit anonymously — without leaving their terminal session. All feedback is filed to the `baekenough/oh-my-customcode` repository.
+Lowers the barrier for submitting feedback by allowing users to create GitHub issues — without leaving their terminal session. All feedback is filed to the `baekenough/oh-my-customcode` repository.
 
 ## Usage
 
@@ -59,22 +59,13 @@ if [ "$GH_AVAILABLE" = "true" ]; then
 else
   GH_AUTHED=false
 fi
-
-# Check curl availability
-command -v curl >/dev/null 2>&1 && CURL_AVAILABLE=true || CURL_AVAILABLE=false
 ```
 
-**Route A**: `gh` available + authenticated + NOT anonymous
+**Route A**: `gh` available + authenticated
 - Use GitHub Issue creation (see Phase 4A)
+- If `--anonymous`: adds `[Anonymous Feedback]` prefix and `anonymous` label
 
-**Route B**: anonymous OR not authenticated (gh available)
-- Use `curl` to Airflow REST API (see Phase 4C)
-- Phase 4B (workflow_dispatch) reserved for future use
-
-**Route C**: `gh` NOT available (or Route B curl fallback)
-- Use `curl` to Airflow REST API (see Phase 4C)
-
-**Fallback**: Neither `gh` nor `curl` available
+**Fallback**: `gh` NOT available or not authenticated
 - Save feedback locally and inform the user (see Phase 4D)
 
 ### Phase 3: Environment Collection
@@ -102,24 +93,30 @@ For anonymous submissions, do NOT include the project name. Offer to include pro
 - Ask: "Include environment info (version, OS) in the anonymous report? [Y/n]"
 - If declined, set `PROJECT_CONTEXT=""`
 
-### Phase 4A: GitHub Issue Creation (Route A — gh + authenticated + not anonymous)
+### Phase 4A: GitHub Issue Creation (Route A — gh + authenticated)
 
-1. Show the user a preview of the issue to be created:
+1. If `ANONYMOUS=true`, prepend `[Anonymous Feedback] ` to the title and add `anonymous` to the label list.
+
+2. Show the user a preview of the issue to be created:
    ```
    [Preview]
    ├── Title: {title}
    ├── Category: {category}
-   ├── Labels: feedback, {category-label}
+   ├── Labels: feedback, {category-label}[, anonymous]
    └── Repo: baekenough/oh-my-customcode
    ```
-2. Ask for confirmation before creating
+3. Ask for confirmation before creating
 
-3. Ensure labels exist (defensive):
+4. Ensure labels exist (defensive):
    ```bash
    gh label create feedback --description "User feedback via /omcustom-feedback" --color 0E8A16 --repo baekenough/oh-my-customcode 2>/dev/null || true
+   # If anonymous, ensure the anonymous label exists
+   if [ "$ANONYMOUS" = "true" ]; then
+     gh label create anonymous --description "Anonymous feedback submission" --color C5DEF5 --repo baekenough/oh-my-customcode 2>/dev/null || true
+   fi
    ```
 
-4. Create the issue using `--body-file` for safe markdown handling:
+5. Create the issue using `--body-file` for safe markdown handling:
    ```bash
    # Write body to temp file to avoid shell escaping issues
    cat > /tmp/omcustom-feedback-body.md << 'FEEDBACK_EOF'
@@ -141,64 +138,28 @@ For anonymous submissions, do NOT include the project name. Offer to include pro
    *Submitted via `/omcustom-feedback`*
    FEEDBACK_EOF
 
+   # Build label string
+   LABELS="feedback,${CATEGORY_LABEL}"
+   if [ "$ANONYMOUS" = "true" ]; then
+     LABELS="${LABELS},anonymous"
+   fi
+
    # Create issue
    gh issue create \
      --repo baekenough/oh-my-customcode \
      --title "{title}" \
-     --label "feedback,{category_label}" \
+     --label "$LABELS" \
      --body-file /tmp/omcustom-feedback-body.md
 
    # Clean up
    rm -f /tmp/omcustom-feedback-body.md
    ```
 
-5. If label creation fails AND issue creation fails due to labels, retry without labels as fallback
-
-6. Return the issue URL to the user
-
-### Phase 4B: Anonymous via GitHub Actions (Route B — FUTURE)
-
-> **Note**: This route is reserved for future implementation. The `feedback-submission.yml` workflow does not yet exist. All anonymous/unauthenticated submissions currently fall through to Route C (Airflow REST API).
-
-```bash
-gh workflow run feedback-submission.yml \
-  --repo baekenough/oh-my-customcode \
-  -f title="$TITLE" \
-  -f body="$BODY" \
-  -f feedback_type="$TYPE" \
-  -f anonymous=true \
-  -f project_context="$PROJECT_CONTEXT"
-```
-
-On success, inform the user:
-```
-[Done] Anonymous feedback submitted via GitHub Actions workflow.
-```
-
-If `gh workflow run` fails (e.g., permissions), fall through to Route C.
-
-### Phase 4C: Anonymous via Airflow REST API (Route C — no gh)
-
-```bash
-# Build JSON payload safely with jq
-PAYLOAD=$(jq -n --arg title "$TITLE" --arg body "$BODY" --arg type "$TYPE" --arg ctx "$PROJECT_CONTEXT" \
-  '{"conf":{"title":$title,"body":$body,"feedback_type":$type,"anonymous":true,"submitter":"","project_context":$ctx}}')
-
-curl -X POST "https://airflow.baekenough.com/api/v2/dags/omc_feedback_collector/dagRuns" \
-  -H "Content-Type: application/json" \
-  -d "$PAYLOAD" \
-  --silent --show-error \
-  --max-time 15
-```
-
-On HTTP 200/201, inform the user:
-```
-[Done] Anonymous feedback submitted via Airflow.
-```
+6. If label creation fails AND issue creation fails due to labels, retry without labels as fallback
 
-On failure (non-2xx or network error), fall through to Fallback.
+7. Return the issue URL to the user
 
-### Phase 4D: Local Fallback (no gh, no curl, or all routes failed)
+### Phase 4D: Local Fallback (gh not available, not authenticated, or issue creation failed)
 
 ```bash
 mkdir -p ~/.omcustom/feedback
@@ -222,25 +183,23 @@ Inform the user:
 [Saved] Feedback saved locally to ~/.omcustom/feedback/{timestamp}.json
 Submit manually when connectivity is available:
   - GitHub Issues: https://github.com/baekenough/oh-my-customcode/issues/new
-  - Or run /omcustom:feedback again when gh or curl is available
+  - Or run /omcustom:feedback again when gh is available
 ```
 
 ### Category-to-Label Mapping
 
-| Category | GitHub Label | Airflow feedback_type |
-|----------|--------------|-----------------------|
-| bug | bug | bug |
-| feature | enhancement | feature |
-| improvement | enhancement | improvement |
-| question | question | question |
-| (auto-detect fails) | (none) | general |
+| Category | GitHub Label |
+|----------|--------------|
+| bug | bug |
+| feature | enhancement |
+| improvement | enhancement |
+| question | question |
+| (auto-detect fails) | (none) |
 
 ## Notes
 
 - Route A creates a visible GitHub issue attributed to the user's gh account
-- Routes B and C submit anonymously — submitter identity is not recorded
-- Route B requires `gh` but NOT authentication to the repo (public workflow)
-- Route C requires `curl` (available on macOS/Linux by default)
+- When `--anonymous` is used, the title is prefixed with `[Anonymous Feedback]` and the `anonymous` label is added
 - Fallback ensures no feedback is silently lost even in offline environments
 - `disable-model-invocation: true` ensures this skill only runs when explicitly invoked by the user
 - Target repo is hardcoded to `baekenough/oh-my-customcode` — feedback is always about omcustom itself

package/templates/.claude/skills/pipeline/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: pipeline
+description: Invoke and resume YAML-defined pipelines by name — /pipeline auto-dev runs the full release pipeline
+scope: harness
+user-invocable: true
+effort: high
+argument-hint: "<pipeline-name> | resume | (no args to list available)"
+source:
+  type: external
+  origin: github
+  url: https://github.com/baekenough/baekenough-skills
+  version: 1.0.0
+---
+
+# /pipeline — Pipeline Invocation
+
+## Usage
+
+```
+/pipeline auto-dev          # Run the auto-dev pipeline
+/pipeline                   # List available pipelines
+/pipeline resume            # Resume a halted pipeline
+```
+
+## Behavior
+
+### List Mode (no arguments or --list flag)
+
+Execute these steps to display available pipelines:
+
+1. **Scan built-in pipelines**: Use `Glob("workflows/*.yaml")` (NOT templates/) to find all pipeline definitions
+2. **Extract metadata**: For each YAML file found, use `Bash` to extract name and description:
+   ```bash
+   for f in workflows/*.yaml; do
+     name=$(grep -m1 '^name:' "$f" | sed 's/^name: *//' | tr -d '"')
+     desc=$(grep -m1 '^description:' "$f" | sed 's/^description: *//' | tr -d '"')
+     echo "  $name — $desc"
+   done
+   ```
+3. **Scan template pipelines**: Use `Glob("templates/workflows/*.yaml")` for template examples
+4. **Display formatted output**:
+   ```
+   Available pipelines:
+     {name} — {description}
+     {name} — {description}
+
+   Template pipelines (in templates/workflows/):
+     {name} — {description}
+   ```
+5. If no pipelines found, display: "No pipelines found in workflows/ directory."
+6. If YAML parsing fails for a file, skip it and show: `  {filename} — (parse error, skipped)`
+
+### Run Mode (with pipeline name)
+
+1. Validate pipeline exists: `workflows/{name}.yaml`
+2. Load and validate YAML structure:
+   - Required fields: `name`, `description`, `steps[]`
+   - Each step has either `skill:` or `prompt:` (not both)
+   - Referenced skills exist in `.claude/skills/`
+   - Skill names must match `^[a-z0-9-]+$` (kebab-case only) — reject path traversal attempts
+3. Announce: `[Pipeline] Starting {name} — {step_count} steps`
+4. Execute steps top-to-bottom:
+   - **Skill steps** (`skill: name`): Invoke via Skill tool — `Skill(skill: "{name}")`
+   - **Prompt steps** (`prompt: text`): Execute the described action using appropriate agents/tools
+   - **Foreach steps** (`foreach: collection`): Iterate over collection from previous step output
+5. Report completion or failure
+
+### Resume Mode (/pipeline resume)
+
+1. Scan `/tmp/.claude-pipeline-*-{PPID}.json` for state files
+2. If none found: "No halted pipelines found."
+3. If found: display pipeline name, failed step, error message
+4. Options:
+   - **Retry** — Re-execute the failed step
+   - **Skip** — Mark failed step as skipped, continue to next
+   - **Abort** — Delete state file, cancel pipeline
+5. On resume: execute from the failed step
+
+## State Tracking
+
+Track per-step state:
+```json
+{
+  "pipeline": "{name}",
+  "started": "ISO-8601",
+  "status": "running|completed|halted",
+  "current_step": 0,
+  "steps": [
+    {"name": "triage", "status": "completed", "duration_ms": 5000},
+    {"name": "plan", "status": "running"}
+  ]
+}
+```
+
+State saved to `/tmp/.claude-pipeline-{name}-{PPID}.json` on failure.
+
+## Error Handling
+
+- Pipeline not found → list available pipelines with suggestion
+- YAML parse error → report with line number
+- Step failure (error: halt-and-report) → stop execution, save state, report failure with context
+- All file writes delegated to subagents per R010