@open-agent-toolkit/cli 0.0.10

package/assets/skills/oat-worktree-bootstrap-auto/SKILL.md

@@ -0,0 +1,245 @@
+---
+name: oat-worktree-bootstrap-auto
+version: 1.2.0
+description: Use when an orchestrator/subagent needs autonomous worktree bootstrap. Non-interactive companion to oat-worktree-bootstrap.
+argument-hint: '<branch-name> [--base <ref>] [--path <root>] [--baseline-policy <strict|allow-failing>]'
+disable-model-invocation: true
+user-invocable: false
+allowed-tools: Read, Write, Bash, Glob, Grep
+---
+
+# Autonomous Worktree Bootstrap
+
+Non-interactive worktree bootstrap for orchestrator and subagent execution flows. Creates or reuses a worktree, runs baseline checks, and reports structured status — all without user prompts.
+
+## Relationship to oat-worktree-bootstrap
+
+This skill is the **autonomous companion** to `oat-worktree-bootstrap`. Key differences:
+
+| Concern          | oat-worktree-bootstrap (manual)      | oat-worktree-bootstrap-auto (autonomous) |
+| ---------------- | ------------------------------------ | ---------------------------------------- |
+| Invocation       | User-invocable, interactive          | Agent-only, non-interactive              |
+| Prompts          | Uses `AskUserQuestion` for decisions | Never uses `AskUserQuestion`             |
+| Failure handling | Asks user to abort/proceed           | Policy-driven (strict or allow-failing)  |
+| Status output    | Human-readable banners               | Structured machine-parseable output      |
+| Logging          | Console + optional artifact          | Artifact-first, console fallback         |
+
+Both skills share the same worktree root resolution precedence and branch naming conventions.
+
+## Progress Indicators (User-Facing)
+
+When this skill is executed, provide concise status updates:
+
+- Print a phase banner once at start:
+
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  OAT ▸ WORKTREE BOOTSTRAP AUTO
+  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+- Before major phases, print compact indicators, for example:
+  - `[1/5] Resolving worktree root…`
+  - `[2/5] Creating/reusing worktree…`
+  - `[3/5] Running baseline checks…`
+  - `[4/5] Syncing provider directories…`
+  - `[5/5] Returning structured status…`
+
+## Inputs
+
+### Required
+
+- `<branch-name>` — Target branch for the worktree.
+
+### Optional
+
+| Parameter                    | Default                 | Description                     |
+| ---------------------------- | ----------------------- | ------------------------------- |
+| `--base <ref>`               | `origin/main`           | Base ref to branch from         |
+| `--path <root>`              | Resolved via precedence | Explicit worktree root override |
+| `--baseline-policy <policy>` | `strict`                | Baseline check failure policy   |
+
+### Baseline Policy
+
+| Policy          | Behavior                                                                                                   |
+| --------------- | ---------------------------------------------------------------------------------------------------------- |
+| `strict`        | Fail fast on any baseline check failure. Return error status immediately.                                  |
+| `allow-failing` | Continue on baseline failures. Emit structured warnings. Log failures to project artifacts when available. |
+
+## Process
+
+### Step 1: Resolve Worktree Root
+
+Use the same resolution precedence as `oat-worktree-bootstrap`:
+
+1. Explicit `--path <root>` (highest priority)
+2. `OAT_WORKTREES_ROOT` environment variable
+3. `.oat/config.json` → `worktrees.root`
+4. First existing directory (ordered):
+   a. `${REPO_ROOT}/.worktrees`
+   b. `${REPO_ROOT}/worktrees`
+   c. `../${REPO_NAME}-worktrees`
+5. Fallback: `../${REPO_NAME}-worktrees`
+
+If the resolved root is project-local (`.worktrees` or `worktrees`), verify it is gitignored.
+
+### Step 2: Create or Reuse Worktree
+
+- Validate branch name: `^[a-zA-Z0-9._/-]+$`
+- Resolve target path: `{root}/{branch-name}`
+- If branch exists locally: `git worktree add "{target-path}" "{branch-name}"`
+- If branch does not exist: `git worktree add "{target-path}" -b "{branch-name}" "{base-ref}"`
+- If worktree already exists at target path: reuse it (validate branch matches)
+
+On failure: return structured error, do not prompt.
+
+### Step 2.5: Propagate Local-Only Config + Local Paths
+
+After the worktree is created or reused, copy gitignored local-only config and sync configured local paths.
+
+**Config propagation:**
+
+```bash
+SRC="$REPO_ROOT/.oat/config.local.json"
+DST="$TARGET_PATH/.oat/config.local.json"
+if [[ -f "$SRC" && ! -f "$DST" ]]; then
+  cp "$SRC" "$DST"
+fi
+```
+
+- Only copy if source exists and destination does not (never overwrite).
+- `activeIdea` is stored in `config.local.json`, so it propagates automatically.
+
+**Local paths sync:**
+
+```bash
+oat local sync "$TARGET_PATH" 2>/dev/null || true
+```
+
+- Copies configured `localPaths` (e.g., `.oat/ideas/`, `.oat/projects/local/`) into the worktree.
+- Non-blocking: if sync fails or no `localPaths` are configured, bootstrap continues.
+
+### Step 3: Run Baseline Checks
+
+Execute in the target worktree directory:
+
+```bash
+pnpm run worktree:init          # install + build + sync
+oat status --scope project
+pnpm test
+git status --porcelain
+```
+
+Check behavior per baseline policy:
+
+**strict mode:**
+
+- Any check failure → immediately return error status with failure details.
+
+**allow-failing mode:**
+
+- Check failure → emit structured warning, continue to next check.
+- Collect all warnings and include in final status output.
+- Log failure context:
+  - If active project with `implementation.md` exists → append timestamped baseline-failure note.
+  - Otherwise → console output only (no fallback file creation).
+
+### Step 4: Create Provider Directories
+
+Worktrees do not inherit gitignored provider directories. Create them if missing:
+
+```bash
+mkdir -p "{target-path}/.claude/skills"
+mkdir -p "{target-path}/.cursor/rules"
+```
+
+Then re-run sync to establish symlinks:
+
+```bash
+oat sync --scope all
+```
+
+### Step 5: Return Structured Status
+
+Return a structured status object (for orchestrator consumption):
+
+```yaml
+status: success | error | warning
+worktree_path: '{absolute-path}'
+branch: '{branch-name}'
+base_ref: '{base-ref}'
+checks:
+  worktree_init: pass | fail | skip
+  project_status: pass | fail | skip
+  tests: pass | fail | skip
+  git_clean: pass | fail | skip
+  provider_sync: pass | fail | skip
+warnings: [] # List of warning messages (allow-failing mode)
+error: null # Error message (strict mode failure)
+baseline_policy: strict | allow-failing
+```
+
+**Status determination:**
+
+- `success`: All checks passed.
+- `warning`: Some checks failed under `allow-failing` policy.
+- `error`: A check failed under `strict` policy, or worktree creation failed.
+
+## Error Handling
+
+| Scenario                             | Behavior                                        |
+| ------------------------------------ | ----------------------------------------------- |
+| Worktree creation fails              | Return error status with git error message      |
+| Branch already checked out elsewhere | Return error with worktree location info        |
+| Baseline check fails (strict)        | Return error with check name and failure output |
+| Baseline check fails (allow-failing) | Add to warnings, continue, log to artifacts     |
+| No active project                    | Skip artifact logging, use console only         |
+| Invalid branch name                  | Return error before attempting creation         |
+
+## Artifact Logging
+
+When baseline failures occur under `allow-failing` policy and an active project exists:
+
+Append to `implementation.md` under `## Implementation Log`:
+
+```markdown
+### {YYYY-MM-DD} — Baseline Warning (autonomous bootstrap)
+
+**Worktree:** {path}
+**Branch:** {branch-name}
+**Policy:** allow-failing
+**Failures:**
+
+- {check_name}: {failure summary}
+```
+
+## Policy Flags
+
+| Flag                | Type                        | Default  | Description                                  |
+| ------------------- | --------------------------- | -------- | -------------------------------------------- |
+| `--baseline-policy` | `strict` \| `allow-failing` | `strict` | Controls behavior when baseline checks fail. |
+
+**Policy details:**
+
+| Policy          | On Failure                          | Logging                                    | Status Output     |
+| --------------- | ----------------------------------- | ------------------------------------------ | ----------------- |
+| `strict`        | Fail fast, return error immediately | Error in status output                     | `status: error`   |
+| `allow-failing` | Continue, collect warnings          | Append to `implementation.md` (or console) | `status: warning` |
+
+**Orchestrator integration:**
+
+- When invoked by `oat-project-subagent-implement`, the baseline policy is passed through from the orchestration run policy.
+- The orchestrator may set `--baseline-policy allow-failing` for exploratory runs and `strict` for production-quality execution.
+- The bootstrap skill does not interpret HiLL checkpoints — that responsibility belongs to the orchestrator.
+
+## Constraints
+
+- **Never** use `AskUserQuestion` — all decisions are policy-driven.
+- **Never** create fallback artifact files — log to existing artifacts or console only.
+- **Never** modify implementation code — bootstrap and checks only.
+- **Never** override or conflict with `oat-worktree-bootstrap` manual-safe behavior.
+
+## Success Criteria
+
+- Worktree exists and is on the correct branch.
+- Baseline checks executed per policy.
+- Structured status returned for orchestrator consumption.
+- Failures logged to appropriate destination without user interaction.

package/assets/skills/oat-worktree-bootstrap-auto/scripts/bootstrap.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# oat-worktree-bootstrap-auto: Autonomous worktree bootstrap
+#
+# Usage: bootstrap.sh <branch-name> [--base <ref>] [--path <root>] [--baseline-policy <strict|allow-failing>]
+#
+# This script is a reference implementation for agent execution.
+# Agents may execute it directly or follow its logic step-by-step.
+
+set -euo pipefail
+
+# ─── Defaults ───────────────────────────────────────────────────────────────
+BRANCH_NAME=""
+BASE_REF="origin/main"
+WORKTREE_ROOT=""
+BASELINE_POLICY="strict"
+
+# ─── Parse Arguments ────────────────────────────────────────────────────────
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --base)       BASE_REF="$2"; shift 2 ;;
+    --path)       WORKTREE_ROOT="$2"; shift 2 ;;
+    --baseline-policy) BASELINE_POLICY="$2"; shift 2 ;;
+    -*)           echo "error: unknown flag $1" >&2; exit 1 ;;
+    *)            BRANCH_NAME="$1"; shift ;;
+  esac
+done
+
+if [[ -z "$BRANCH_NAME" ]]; then
+  echo "error: branch name required" >&2
+  exit 1
+fi
+
+# Validate branch name
+if ! [[ "$BRANCH_NAME" =~ ^[a-zA-Z0-9._/-]+$ ]]; then
+  echo "error: invalid branch name '$BRANCH_NAME' (must match ^[a-zA-Z0-9._/-]+\$)" >&2
+  exit 1
+fi
+
+# ─── Step 1: Resolve Worktree Root ──────────────────────────────────────────
+REPO_ROOT=$(git rev-parse --show-toplevel)
+REPO_NAME=$(basename "$REPO_ROOT")
+
+if [[ -z "$WORKTREE_ROOT" ]]; then
+  # Precedence 2: environment variable
+  if [[ -n "${OAT_WORKTREES_ROOT:-}" ]]; then
+    WORKTREE_ROOT="$OAT_WORKTREES_ROOT"
+  # Precedence 3: .oat/config.json
+  elif [[ -f "$REPO_ROOT/.oat/config.json" ]]; then
+    CONFIG_ROOT=$(node -e "try{const c=JSON.parse(require('fs').readFileSync('$REPO_ROOT/.oat/config.json','utf8'));console.log(c.worktrees?.root||'')}catch{}" 2>/dev/null || true)
+    if [[ -n "$CONFIG_ROOT" ]]; then
+      # Resolve relative to REPO_ROOT
+      if [[ "$CONFIG_ROOT" = /* ]]; then
+        WORKTREE_ROOT="$CONFIG_ROOT"
+      else
+        WORKTREE_ROOT="$REPO_ROOT/$CONFIG_ROOT"
+      fi
+    fi
+  fi
+
+  # Precedence 4: discover existing directories (ordered)
+  if [[ -z "$WORKTREE_ROOT" ]]; then
+    if [[ -d "$REPO_ROOT/.worktrees" ]]; then
+      WORKTREE_ROOT="$REPO_ROOT/.worktrees"
+    elif [[ -d "$REPO_ROOT/worktrees" ]]; then
+      WORKTREE_ROOT="$REPO_ROOT/worktrees"
+    elif [[ -d "$(dirname "$REPO_ROOT")/${REPO_NAME}-worktrees" ]]; then
+      WORKTREE_ROOT="$(dirname "$REPO_ROOT")/${REPO_NAME}-worktrees"
+    else
+      # Precedence 5: fallback
+      WORKTREE_ROOT="$(dirname "$REPO_ROOT")/${REPO_NAME}-worktrees"
+    fi
+  fi
+fi
+
+# Verify gitignore for project-local roots
+RELATIVE_ROOT="${WORKTREE_ROOT#"$REPO_ROOT"/}"
+if [[ "$RELATIVE_ROOT" == ".worktrees" || "$RELATIVE_ROOT" == "worktrees" ]]; then
+  if ! git check-ignore -q "$WORKTREE_ROOT" 2>/dev/null; then
+    echo "warning: $RELATIVE_ROOT is not in .gitignore" >&2
+  fi
+fi
+
+# ─── Step 2: Create or Reuse Worktree ──────────────────────────────────────
+TARGET_PATH="$WORKTREE_ROOT/$BRANCH_NAME"
+
+# Check if worktree already exists at target
+if [[ -d "$TARGET_PATH/.git" ]] || git worktree list --porcelain | grep -q "worktree $TARGET_PATH$"; then
+  # Reuse: validate branch matches
+  EXISTING_BRANCH=$(git -C "$TARGET_PATH" branch --show-current 2>/dev/null || true)
+  if [[ "$EXISTING_BRANCH" != "$BRANCH_NAME" ]]; then
+    echo "error: worktree at $TARGET_PATH is on branch '$EXISTING_BRANCH', expected '$BRANCH_NAME'" >&2
+    exit 1
+  fi
+  echo "info: reusing existing worktree at $TARGET_PATH"
+else
+  mkdir -p "$(dirname "$TARGET_PATH")"
+
+  # Check if branch exists
+  if git show-ref --verify --quiet "refs/heads/$BRANCH_NAME" 2>/dev/null; then
+    git worktree add "$TARGET_PATH" "$BRANCH_NAME"
+  else
+    git worktree add "$TARGET_PATH" -b "$BRANCH_NAME" "$BASE_REF"
+  fi
+fi
+
+# ─── Step 2.5: Propagate Local-Only Config + Local Paths ──────────────────
+SRC_CONFIG="$REPO_ROOT/.oat/config.local.json"
+DST_CONFIG="$TARGET_PATH/.oat/config.local.json"
+if [[ -f "$SRC_CONFIG" && ! -f "$DST_CONFIG" ]]; then
+  mkdir -p "$TARGET_PATH/.oat"
+  cp "$SRC_CONFIG" "$DST_CONFIG"
+fi
+
+# Sync localPaths into the worktree (non-blocking)
+oat local sync "$TARGET_PATH" 2>/dev/null || true
+
+# ─── Step 3: Run Baseline Checks ───────────────────────────────────────────
+cd "$TARGET_PATH"
+
+declare -A CHECK_RESULTS
+WARNINGS=()
+HAS_ERROR=false
+
+run_check() {
+  local name="$1"
+  shift
+  if "$@" >/dev/null 2>&1; then
+    CHECK_RESULTS["$name"]="pass"
+  else
+    CHECK_RESULTS["$name"]="fail"
+    if [[ "$BASELINE_POLICY" == "strict" ]]; then
+      HAS_ERROR=true
+      echo "error: baseline check '$name' failed (strict policy)" >&2
+    else
+      WARNINGS+=("$name: check failed")
+    fi
+  fi
+}
+
+run_check "worktree_init" pnpm run worktree:init
+if [[ "$HAS_ERROR" == true ]]; then
+  cat <<YAML
+status: error
+worktree_path: "$TARGET_PATH"
+branch: "$BRANCH_NAME"
+base_ref: "$BASE_REF"
+error: "worktree_init failed under strict policy"
+baseline_policy: $BASELINE_POLICY
+YAML
+  exit 1
+fi
+
+run_check "project_status" oat status --scope project
+run_check "tests" pnpm test
+run_check "git_clean" test -z "$(git status --porcelain)"
+
+# ─── Step 4: Create Provider Directories ────────────────────────────────────
+mkdir -p "$TARGET_PATH/.claude/skills"
+mkdir -p "$TARGET_PATH/.cursor/rules"
+if oat sync --scope all >/dev/null 2>&1; then
+  CHECK_RESULTS["provider_sync"]="pass"
+else
+  CHECK_RESULTS["provider_sync"]="fail"
+  if [[ "$BASELINE_POLICY" == "strict" ]]; then
+    HAS_ERROR=true
+  else
+    WARNINGS+=("provider_sync: sync failed")
+  fi
+fi
+
+# ─── Step 5: Return Structured Status ───────────────────────────────────────
+if [[ "$HAS_ERROR" == true ]]; then
+  STATUS="error"
+elif [[ ${#WARNINGS[@]} -gt 0 ]]; then
+  STATUS="warning"
+else
+  STATUS="success"
+fi
+
+cat <<YAML
+status: $STATUS
+worktree_path: "$TARGET_PATH"
+branch: "$BRANCH_NAME"
+base_ref: "$BASE_REF"
+checks:
+  worktree_init: ${CHECK_RESULTS[worktree_init]:-skip}
+  project_status: ${CHECK_RESULTS[project_status]:-skip}
+  tests: ${CHECK_RESULTS[tests]:-skip}
+  git_clean: ${CHECK_RESULTS[git_clean]:-skip}
+  provider_sync: ${CHECK_RESULTS[provider_sync]:-skip}
+warnings: [$(IFS=','; echo "${WARNINGS[*]:-}")]
+error: ${HAS_ERROR:+baseline check failed under strict policy}
+baseline_policy: $BASELINE_POLICY
+YAML

package/assets/skills/skeptic/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: skeptic
+version: 0.2.0
+description: Use when the user questions or suspects an agent claim is wrong. Adversarially gathers evidence to verify or refute the claim using the best sources available in the current environment.
+argument-hint: '[claim to question — optional, defaults to most recent agent assertion]'
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, WebSearch, WebFetch, AskUserQuestion, Agent, mcp__*
+---
+
+# /skeptic
+
+Adversarially evaluates a claim made by the agent. Dispatches a Skeptical Evaluator sub-agent (or self-evaluates when unavailable) to find contradicting evidence first, then supporting evidence. Returns an inline verdict with a confidence score and cited sources.
+
+## When to Use
+
+Use when:
+
+- The user questions or suspects an agent claim may be wrong
+- A claim about code behavior, library versions, or documentation needs evidence backing
+- You need to verify a factual assertion before proceeding
+
+## When NOT to Use
+
+Don't use when:
+
+- The user is asking a new question (not doubting an existing claim)
+- The claim is a matter of preference or opinion with no verifiable ground truth
+- Verification would require information genuinely unavailable in any environment
+
+## Arguments
+
+Parse from `$ARGUMENTS`:
+
+- **claim**: (optional) The specific claim to evaluate. If omitted, infer from the most recent agent assertion in the conversation.
+
+## Progress Indicators (User-Facing)
+
+Print this banner once at start:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+/skeptic
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Then print step indicators before beginning work:
+
+- `[1/5] Identifying claim…`
+- `[2/5] Scanning environment…`
+- `[3/5] Checking sub-agent availability…`
+- `[4/5] Gathering evidence…`
+- `[5/5] Synthesizing verdict…`
+
+For long-running operations (large codebase search, multiple web fetches), print a start line and a completion line:
+
+```
+  → Searching codebase for contradicting evidence…
+  → Complete. (Contradicting: N · Supporting: N)
+```
+
+Keep it concise; don't print a line for every shell command.
+
+## Workflow
+
+### Step 1: Identify the claim
+
+`[1/5] Identifying claim…`
+
+If `$ARGUMENTS` is provided, use it as the claim. Otherwise, identify the most recent factual assertion made by the agent in the conversation. State the claim explicitly — evaluation must be anchored to something precise.
+
+If the claim is ambiguous, ask the user to clarify before proceeding:
+
+- **Claude Code**: use `AskUserQuestion`
+- **Codex**: use structured user-input tooling when available in the current host/runtime
+- **Fallback**: ask in plain text
+
+The prompt should ask: _"Which claim should I evaluate? Please describe or quote it."_
+
+---
+
+### Step 2: Scan environment and classify claim
+
+`[2/5] Scanning environment…`
+
+Assess available evidence sources based on current environment:
+
+| Environment           | Available sources                                           |
+| --------------------- | ----------------------------------------------------------- |
+| Claude Code (in repo) | Local files, Grep/Glob, Bash, git history, tests, lockfiles |
+| Claude Code (general) | Filesystem, Bash, web search if enabled                     |
+| Cursor                | Filesystem access, web search if enabled                    |
+| Codex                 | Filesystem, web search if enabled                           |
+| Claude.ai             | Web search if enabled, conversation context only            |
+
+Classify the claim type to determine evidence priority:
+
+- **code_behavior** → tests, type signatures, implementation, git history
+- **library_specific** → lockfile, `package.json`, installed module source, docs MCP, npm registry
+- **documentation** → docs MCP (if available), web search, official docs URL
+- **factual** → web search, cited references
+- **architectural** → web search, authoritative references, first-principles reasoning
+
+---
+
+### Step 3: Check sub-agent availability
+
+```
+[3/5] Checking sub-agent availability…
+  → skeptical-evaluator: {available | not resolved} ({reason})
+  → Selected: Execution Tier {1|2|3} — {Sub-agent | Self-evaluation (recommended) | Inline evaluation}
+```
+
+**Detection logic:**
+
+- **Execution Tier 1 — Sub-agent dispatch (preferred):**
+  - **Claude Code**: `Agent` tool is available → dispatch with `subagent_type: "skeptical-evaluator"`, resolved from `.agents/agents/skeptical-evaluator.md` (synced to `.claude/agents/`)
+  - **Cursor**: invoke via `/skeptical-evaluator` or natural mention, resolved from `.cursor/agents/skeptical-evaluator.md` (synced from `.agents/agents/`)
+  - **Codex multi-agent**: verify `[features] multi_agent = true` is enabled in active Codex config. Codex may also auto-select and spawn agents without explicit role pinning.
+
+- **Execution Tier 2 — Self-evaluation (recommended fallback):**
+  - Sub-agent dispatch not available or agent definition not resolved
+  - Orchestrator performs adversarial evaluation directly with same logic and output format
+  - Log: `→ skeptical-evaluator: not resolved — falling back to Execution Tier 2 self-evaluation`
+
+- **Execution Tier 3 — Inline evaluation:**
+  - User explicitly requests inline, or confirms they are already in a fresh session
+
+---
+
+### Step 4: Gather evidence adversarially
+
+`[4/5] Gathering evidence…`
+
+The evaluator (or orchestrator in Execution Tier 2/3) receives this context package:
+
+```
+CLAIM: [exact claim]
+BASIS: [original reasoning/sources/assumptions]
+CLAIM_TYPE: [code_behavior | library_specific | documentation | factual | architectural]
+AVAILABLE_SOURCES: [what's accessible]
+INSTRUCTION: Adversarial. Disprove first, then note supporting evidence.
+```
+
+Evidence priority by claim type:
+
+- **code_behavior**: tests → type signatures → implementation → comments → git history
+- **library_specific**: lockfile → `package.json` → installed module source → docs MCP → npm registry
+- **documentation**: docs MCP → web search → official docs URL
+- **factual**: web search → cited references
+- **architectural**: web search → authoritative references → first-principles reasoning
+
+Rules:
+
+1. **Adversarial first** — look for contradicting evidence before supporting
+2. **Cite specifically** — exact file paths + line numbers, URLs, package versions, or doc sections
+3. **Source-appropriate** — only use sources verifiably accessible in the current environment; never hallucinate
+4. **Note supporting evidence** only after exhausting the contradicting search
+
+---
+
+### Step 5: Synthesize verdict
+
+`[5/5] Synthesizing verdict…`
+
+Return one of four verdict frames inline. Always attempt a clear lean — only use "inconclusive" when evidence is genuinely ambiguous after thorough search.
+
+**Holds up**
+
+```
+✅ **This holds up** *(confidence: X%)*
+I adversarially reviewed this and still believe it to be accurate.
+[Key supporting evidence with citations]
+[Any caveats if relevant]
+```
+
+**You were right to be skeptical**
+
+```
+❌ **You were right to be skeptical** *(confidence: X%)*
+The evidence contradicts this claim.
+[Contradicting evidence with citations]
+[Corrected or more accurate version of the claim]
+```
+
+**Nuanced**
+
+```
+⚠️ **This is nuanced** *(confidence: X%)*
+[What's correct, what's incorrect, and under what conditions]
+[Both contradicting and supporting evidence with citations]
+```
+
+**Genuinely inconclusive**
+
+```
+❓ **I can't determine this with confidence** *(confidence: X%)*
+[What was found, what wasn't, and why a clear verdict isn't possible]
+[Suggested next steps if applicable]
+```
+
+---
+
+## Examples
+
+### Basic usage
+
+```
+/skeptic
+```
+
+_(evaluates most recent agent assertion)_
+
+```
+/skeptic you said React 18 introduced concurrent rendering — verify that
+```
+
+```
+/skeptic the claim that useCallback prevents child re-renders
+```
+
+### Conversational triggers
+
+The skill may also be invoked when the user says things like:
+
+```
+Are you sure about that?
+```
+
+```
+That doesn't sound right — can you check?
+```
+
+## Troubleshooting
+
+**Claim is ambiguous:**
+
+- Ask for clarification using `AskUserQuestion` (Claude Code), structured user-input tooling (Codex), or plain text (fallback)
+- Do not proceed until the claim is precisely anchored
+
+**No evidence sources available:**
+
+- Return "Genuinely inconclusive" and explain what sources would be needed
+- Never guess or hallucinate sources
+
+**Sub-agent dispatch fails:**
+
+- Log: `→ skeptical-evaluator: not resolved (dispatch failed) — falling back to Execution Tier 2`
+- Proceed with self-evaluation; output format is identical
+
+## Success Criteria
+
+- Phase banner printed at start
+- Step indicators printed before work begins
+- Claim explicitly identified and stated before evaluation starts
+- Environment scanned and claim type classified
+- Sub-agent tier selected and logged with reason
+- Contradicting evidence sought before supporting evidence
+- All evidence cited with specific references (files/lines/URLs/versions)
+- One of four verdict frames returned with confidence score
+- Output is inline — no file or artifact produced
+- "Inconclusive" returned honestly when evidence is genuinely ambiguous