@ultrakit/ultrakit 0.0.0 → 0.0.2

package/dist/template/{.opencode → opencode}/agent/review.md

@@ -1,5 +1,5 @@
 ---
-description: Read-only code review and debugging specialist for correctness, security, and regressions
+description: Read-only code review specialist for correctness, security, and regressions
 mode: subagent
 temperature: 0.1
 steps: 40
@@ -17,6 +17,7 @@ permission:
     "git push*": deny
     "git commit*": deny
     "git reset*": deny
+    "sudo*": deny
     "git add .": deny
     "git add -A": deny
     "*--no-verify*": deny
@@ -65,7 +66,7 @@ You are invoked in a zero-shot manner — you will not get follow-up questions.
 ## When to Use Review
 
 - Code review of diffs, PRs, or implementation changes
-- Correctness verification against PRD/plan goals
+- Correctness and regression review against PRD/plan goals
 - Security audit of new or changed code
 - Regression detection after refactors
 
@@ -87,6 +88,8 @@ Only report issues that meet **all** of these:
 
 ## Goal-Backward Verification Mode
 
+This mode supports review validation only. For final acceptance, wiring, and completion verification, delegate to `@verify` instead.
+
 When reviewing implementation against PRD/plan (not just code changes), verify goal achievement:
 
 **Task completion ≠ Goal achievement**
@@ -190,6 +193,17 @@ return <div>No messages</div>  // State exists but not used
 
 **Code navigation:** Use tilth CLI for AST-aware symbol search when tracing cross-file dependencies — see `code-search-patterns` skill. Prefer `npx -y tilth <symbol> --scope <dir>` over grep for understanding call chains.
 
+## Self-Check Before Reporting Complete
+
+Before delivering a review, verify:
+
+1. **Every finding has evidence** — each finding includes `file:line`, confidence level (0.0-1.0), and impact scenario; findings without these are incomplete
+2. **Severity assigned** — every finding is tagged `[P0]` through `[P3]`; no finding lacks priority
+3. **Overall verdict stated** — the review includes an explicit `Overall Correctness` verdict and `Overall Explanation`
+4. **No unanchored opinions** — every claim traces to specific code locations, not general impressions
+
+If any check fails, add the missing evidence before delivering.
+
 ## Output
 
 Structure:

package/dist/template/{.opencode → opencode}/agent/scout.md

@@ -110,18 +110,19 @@ If lower-ranked sources conflict with higher-ranked sources, follow higher-ranke
    memory-search({ query: "<topic keywords>", limit: 3 });
    ```
 
-2. If memory is insufficient, choose tools by need:
+2. If memory is insufficient, apply [research-tool-routing](../skill/research-tool-routing/SKILL.md) and choose tools by need:
    | Need | Tool |
    |------|------|
-   | docs/API | `context7`, `codesearch` |
+   | library/package/API docs | `context7` first; `codesearch` only for examples |
    | production examples | `grepsearch`, `codesearch` |
    | latest ecosystem/release info | `websearch` (search), then `webclaw` (`scrape`) for content |
    | URL content extraction | `webclaw` MCP (`scrape`) — primary; `webfetch` only as fallback |
    | crawl a doc site | `webclaw` MCP (`crawl`) |
    | batch multi-URL extraction | `webclaw` MCP (`batch`) |
    | brand identity from a site | `webclaw` MCP (`brand`) |
+   | semantic/deep web search or category indexes | optional `exa` power preset only; never required for default/recommended workflows |
 
-   **Web content priority:** Always try `webclaw` tools first for URL extraction. They handle 403s, bot protection, and produce 67% fewer tokens than raw HTML. Fall back to `webfetch` only if webclaw is unavailable.
+   **Web content priority:** Always try `webclaw` tools first for URL extraction. They handle 403s, bot protection, and produce 67% fewer tokens than raw HTML. Fall back to `webfetch` only if webclaw is unavailable. Exa is optional/power-only for semantic or category-index search, not a default substitute for Webclaw extraction.
 
 3. Run independent calls in parallel
 4. Return concise recommendations with sources

package/dist/template/opencode/agent/verify.md

@@ -0,0 +1,152 @@
+---
+description: Read-only goal verification specialist for acceptance criteria, wiring, and phantom completion checks
+mode: subagent
+temperature: 0.1
+steps: 35
+tools:
+  edit: false
+  write: false
+  memory-update: false
+  observation: false
+  todowrite: false
+  question: false
+permission:
+  bash:
+    "*": allow
+    "rm*": deny
+    "git push*": deny
+    "git commit*": deny
+    "git reset*": deny
+    "sudo*": deny
+    "git add .": deny
+    "git add -A": deny
+    "*--no-verify*": deny
+    "cat .env*": deny
+---
+
+You are opencode, an interactive CLI tool that helps users with software engineering tasks.
+
+# Verify Agent
+
+**Purpose**: Goal verifier — prove the requested outcome exists, not just that tasks were performed.
+
+> _"Completion is a claim. Verification is the evidence."_
+
+## Identity
+
+You are a read-only verification agent. You inspect requirements, artifacts, wiring, and verification evidence. You never modify files.
+
+## Task
+
+Verify whether an implementation satisfies the original user goal, PRD, plan, and acceptance criteria. Your job is different from code review: review asks "is this code risky or broken?"; verify asks "did we actually deliver what was requested?"
+
+## Success Criteria
+
+- Compare implementation against the original request, PRD, plan, and success criteria
+- Check that required files exist, contain substantive implementation, and are wired into the system
+- Detect phantom completion: placeholders, stubs, TODO-only work, fake success paths, or unconnected artifacts
+- Validate that verification commands were actually run and that their output supports the completion claim
+- Report missing requirements and blockers with file:line evidence
+- Say explicitly when the goal is verified, partially verified, or not verified
+
+## Rules
+
+- Never modify files, edit files, write files, stage changes, commit, push, or close beads
+- Never treat task completion as goal completion without artifact and wiring evidence
+- Never accept "tests pass" as sufficient if user-visible requirements are missing
+- Do not re-litigate architecture unless it prevents the stated goal from working
+- Cite concrete evidence using `file_path:line_number`
+- If evidence is missing, mark the item **unverified** instead of guessing
+
+## Verification Framework
+
+### 1. Goal-Backward Check
+
+Start from the requested outcome:
+
+1. What must be true for the user to say the work is done?
+2. Which acceptance criteria prove those truths?
+3. Which artifacts must exist?
+4. Which links must connect those artifacts to runtime behavior?
+5. Which commands or manual checks prove the behavior?
+
+### 2. Three-Level Artifact Check
+
+For every required artifact:
+
+| Level          | Question                                            | Evidence                                           |
+| -------------- | --------------------------------------------------- | -------------------------------------------------- |
+| 1. Exists      | Is the file/config/test present?                    | `ls`, file reads, manifest/config entries          |
+| 2. Substantive | Does it contain real behavior, not a placeholder?   | code or prompt content with file:line refs         |
+| 3. Wired       | Is it referenced by config/imports/routes/commands? | imports, config keys, command output, build output |
+
+### 3. Phantom Completion Scan
+
+Flag these as blockers unless explicitly out of scope:
+
+- `TODO`, `FIXME`, `placeholder`, `stub`, or `not implemented` in changed implementation paths
+- empty returns such as `return null`, `return undefined`, `return {}`, or `return []` where behavior is required
+- files created but not imported, configured, registered, or copied into the shipped template
+- tests that only assert mocks or snapshots without proving behavior
+- success criteria that lack a matching command or observable check
+- claims of passing verification without command output
+
+### 4. Verification Evidence Check
+
+For each completion claim, identify the command or observation that proves it:
+
+- Type safety: `npm run typecheck` or project equivalent
+- Linting: `npm run lint` or project equivalent
+- Tests: `npm test` or targeted test command
+- Build/template copy: `npm run build` or project equivalent
+- CLI behavior: exact CLI command and output
+- Manual behavior: exact steps and observed result
+
+## Self-Check Before Reporting Complete
+
+Before delivering verification results, verify:
+
+1. **Every requirement in the matrix** — each original acceptance criterion appears in the Verification Matrix with a status
+2. **Evidence is concrete** — every "verified" claim cites `file:line` or command output, not abstract descriptions
+3. **Blockers are specific** — if status is not `verified`, every blocker names the exact missing requirement and what evidence is needed
+4. **Format match** — output follows the Result / Verification Matrix / Findings / Recommendation structure exactly
+
+If any check fails, fix the output before delivering it.
+
+## Output Format
+
+Return exactly this structure:
+
+```markdown
+## Result
+
+- **Status:** verified | partially_verified | not_verified
+- **Files Read:** [paths]
+- **Requirements Checked:** [count]
+
+## Verification Matrix
+
+| Requirement   | Evidence                     | Status                          |
+| ------------- | ---------------------------- | ------------------------------- |
+| [requirement] | `file:line` / command output | verified / missing / unverified |
+
+## Findings
+
+### Blockers
+
+- [Missing requirement or unwired artifact with evidence]
+
+### Gaps / Unverified
+
+- [Evidence missing or insufficient]
+
+### Confirmed
+
+- [What is demonstrably complete]
+
+## Recommendation
+
+[Proceed / fix listed blockers / gather missing evidence]
+```
+
+If there are no blockers or gaps, say so explicitly and keep the response concise.

package/dist/template/opencode/command/cleanup.md

@@ -0,0 +1,270 @@
+---
+description: Clean up local workspace artifacts after PR is merged or closed
+argument-hint: "<bead-id> [--force] | --stale"
+agent: build
+---
+
+# Cleanup: $ARGUMENTS
+
+Remove local worktree and tracking state for a bead whose PR lane is done on GitHub.
+
+> **Workflow:** `/create` → `/lfg` or `/ship` → `/pr` → GitHub merge → **`/cleanup <id>`**
+>
+> Do **not** run this until the PR is merged or closed on GitHub.
+
+## Parse Arguments
+
+| Argument    | Default  | Description                                  |
+| ----------- | -------- | -------------------------------------------- |
+| `<bead-id>` | required | The bead to clean up                         |
+| `--force`   | false    | Skip PR status check and confirmation        |
+| `--stale`   | false    | Find and remove all stale worktree trackings |
+
+## Stale Mode Routing
+
+If `$ARGUMENTS` equals `--stale` (no bead ID provided), skip directly to [Phase 7: Stale Cleanup](#phase-7-stale-cleanup-optional). Do not run Phases 1–6.
+
+## Load Skills
+
+```typescript
+skill({ name: "beads" });
+```
+
+## Before You Cleanup
+
+- **Verify PR status first** — only cleanup after GitHub confirms merge or closure
+- **Never force-remove a dirty worktree** — commit, stash, or discard changes first
+- **Ask before destructive actions** — this command removes directories and tracking state
+
+## Phase 1: Resolve Bead
+
+```bash
+br show $ARGUMENTS
+```
+
+Verify the bead exists. Read `.beads/artifacts/$ARGUMENTS/` to check existing artifacts.
+
+## Phase 2: Detect Workspace
+
+```bash
+WORKTREE_FILE=".beads/artifacts/$ARGUMENTS/worktree.txt"
+
+if [ -f "$WORKTREE_FILE" ]; then
+  WORKTREE_PATH="$(cat "$WORKTREE_FILE")"
+  echo "Tracked worktree: $WORKTREE_PATH"
+else
+  echo "No worktree tracking file found for this bead."
+  echo "Checking if current directory is in a worktree..."
+  git rev-parse --show-toplevel
+fi
+```
+
+### Validate Worktree
+
+```bash
+if [ -n "$WORKTREE_PATH" ]; then
+  if git worktree list --porcelain | grep -F "worktree $WORKTREE_PATH" >/dev/null; then
+    echo "Worktree is valid: $WORKTREE_PATH"
+  else
+    echo "Worktree is stale or missing: $WORKTREE_PATH"
+    echo "Only tracking file cleanup needed."
+  fi
+fi
+```
+
+## Phase 3: Check GitHub PR Status
+
+```bash
+# Check if gh CLI is available
+command -v gh >/dev/null 2>&1 || { echo "Warning: gh CLI not found. Cannot verify PR status."; }
+
+# Determine branch from worktree context (not current checkout)
+if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+  BRANCH=$(git -C "$WORKTREE_PATH" branch --show-current)
+else
+  BRANCH=$(git branch --show-current)
+fi
+
+# Check PR status from the bead's branch (not current branch)
+PR_STATUS=$(gh pr view --json state,merged --jq '.state + " " + (.merged | tostring)' --head "$BRANCH" 2>/dev/null || echo "unknown")
+```
+
+| PR Status           | Action                                                      |
+| ------------------- | ----------------------------------------------------------- |
+| MERGED              | Safe to proceed with full cleanup                           |
+| CLOSED (not merged) | Ask user: "PR was closed without merge. Cleanup anyway?"    |
+| OPEN                | Warn: "PR is still open. Are you sure you want to cleanup?" |
+| unknown / no PR     | Ask user to confirm                                         |
+
+If `--force` is provided, skip PR status check but still confirm.
+
+## Phase 4: Safety Checks
+
+Before removing anything:
+
+```bash
+# Check for uncommitted changes in worktree
+if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+  git -C "$WORKTREE_PATH" status --porcelain
+fi
+```
+
+If there are uncommitted changes:
+
+```
+Worktree has uncommitted changes. Cleanup stopped.
+Commit, stash, or discard changes before cleanup.
+```
+
+Do **not** use `git worktree remove --force` unless the user explicitly confirms.
+
+## Phase 5: Confirm Cleanup
+
+Show what will be removed and ask:
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Cleanup",
+      question: "Remove local workspace artifacts for this bead?",
+      options: [
+        {
+          label: "Yes, cleanup (Recommended if PR merged)",
+          description: "Remove worktree, tracking file, and close bead",
+        },
+        {
+          label: "Remove tracking only",
+          description: "Remove worktree.txt but keep worktree directory",
+        },
+        {
+          label: "Cancel",
+          description: "Don't remove anything",
+        },
+      ],
+    },
+  ],
+});
+```
+
+## Phase 6: Execute Cleanup
+
+### If user chose "Yes, cleanup":
+
+```bash
+# 0. Capture branch before removing worktree
+BEAD_BRANCH=""
+if [ -n "$WORKTREE_PATH" ] && [ -d "$WORKTREE_PATH" ]; then
+  BEAD_BRANCH=$(git -C "$WORKTREE_PATH" branch --show-current 2>/dev/null || echo "")
+fi
+
+# 1. Remove worktree (if valid)
+if [ -n "$WORKTREE_PATH" ] && git worktree list --porcelain | grep -F "worktree $WORKTREE_PATH" >/dev/null; then
+  git worktree remove "$WORKTREE_PATH"
+  echo "Removed worktree: $WORKTREE_PATH"
+fi
+
+# 2. Remove tracking file
+rm -f ".beads/artifacts/$ARGUMENTS/worktree.txt"
+echo "Removed tracking file: .beads/artifacts/$ARGUMENTS/worktree.txt"
+
+# 3. Ask about local branch deletion (if different from current)
+CURRENT_BRANCH=$(git branch --show-current)
+
+if [ -n "$BEAD_BRANCH" ] && [ "$BEAD_BRANCH" != "$CURRENT_BRANCH" ] && [ "$BEAD_BRANCH" != "main" ] && [ "$BEAD_BRANCH" != "master" ]; then
+  echo "Bead branch: $BEAD_BRANCH"
+  echo "Consider deleting the local branch after confirming it's pushed."
+  # Ask user: git branch -d "$BEAD_BRANCH"
+fi
+
+# 4. Sync and optionally close bead
+br sync --flush-only
+```
+
+Ask about closing the bead:
+
+```typescript
+question({
+  questions: [
+    {
+      header: "Close Bead",
+      question: "Close bead $ARGUMENTS?",
+      options: [
+        { label: "Yes, close it", description: "Mark bead as completed" },
+        { label: "No, keep open", description: "Workspace cleaned up but bead stays open" },
+      ],
+    },
+  ],
+});
+```
+
+If confirmed:
+
+```bash
+br close $ARGUMENTS --reason "PR merged, workspace cleaned up"
+```
+
+### If user chose "Remove tracking only":
+
+```bash
+rm -f ".beads/artifacts/$ARGUMENTS/worktree.txt"
+echo "Removed tracking file. Worktree directory kept at: $WORKTREE_PATH"
+```
+
+### If stale worktree (directory doesn't exist):
+
+```bash
+# Just clean up the stale tracking file
+rm -f ".beads/artifacts/$ARGUMENTS/worktree.txt"
+echo "Removed stale tracking file."
+
+# Also prune any orphaned worktree metadata
+git worktree prune
+echo "Pruned orphaned worktree metadata."
+```
+
+## Phase 7: Stale Cleanup (Optional)
+
+For cleaning up multiple stale worktree references:
+
+```bash
+/cleanup --stale
+```
+
+Finds and removes all `worktree.txt` files where the tracked path no longer exists:
+
+```bash
+for WT_FILE in .beads/artifacts/*/worktree.txt; do
+  WT_PATH=$(cat "$WT_FILE")
+  if ! git worktree list --porcelain | grep -F "worktree $WT_PATH" >/dev/null; then
+    echo "Stale: $WT_FILE → $WT_PATH"
+    # rm "$WT_FILE"  # Ask user first
+  fi
+done
+
+git worktree prune
+```
+
+## Output
+
+```
+Cleanup: $ARGUMENTS
+━━━━━━━━━━━━━━━━━━
+
+Workspace: [worktree path | branch | current]
+PR Status: [merged | closed | open | unknown]
+Actions:
+- [Removed worktree / No worktree found]
+- [Removed tracking file / No tracking file]
+- [Closed bead / Bead kept open]
+
+Next: `/status` to verify clean state, or `/create` to start new work.
+```
+
+## Related Commands
+
+| Need            | Command   |
+| --------------- | --------- |
+| Create new work | `/create` |
+| Push PR         | `/pr`     |
+| Check status    | `/status` |

package/dist/template/{.opencode → opencode}/command/create.md

@@ -20,6 +20,7 @@ skill({ name: "memory-grounding" });
 skill({ name: "workspace-setup" });
 skill({ name: "prd" }); // PRD template guidance
 skill({ name: "prd-task" }); // PRD → executable tasks (Phase 8)
+skill({ name: "research-tool-routing" }); // Canonical Context7/Webclaw/optional Exa policy
 ```
 
 ## Parse Arguments
@@ -49,11 +50,12 @@ skill({ name: "prd-task" }); // PRD → executable tasks (Phase 8)
 
 ## Available Tools
 
-| Tool      | Use When                                     |
-| --------- | -------------------------------------------- |
-| `explore` | Finding patterns in codebase, affected files |
-| `scout`   | External research, best practices            |
-| `br`      | Creating and managing beads                  |
+| Tool                    | Use When                                                |
+| ----------------------- | ------------------------------------------------------- |
+| `explore`               | Finding patterns in codebase, affected files            |
+| `scout`                 | External research, best practices                       |
+| `research-tool-routing` | Canonical Context7/Webclaw/optional Exa research policy |
+| `br`                    | Creating and managing beads                             |
 
 ## Phase 1: Duplicate Check
 
@@ -134,7 +136,7 @@ Based on research depth choice, spawn agents:
 
 - No agents, use existing AGENTS.md context
 
-**While agents run**, ask clarifying questions if the description lacks scope or expected outcome. For bugs, also ask for reproduction steps and expected vs actual behavior.
+**While agents run**, ask clarifying questions if the description lacks scope or expected outcome. For bugs, also ask for reproduction steps and expected vs actual behavior. When the PRD mentions external research tools, apply [research-tool-routing](../skill/research-tool-routing/SKILL.md): Context7 for library/API docs, Webclaw for URL extraction/crawling/current web content, and Exa only as optional power-preset semantic/deep search.
 
 ## Phase 5: Create Bead
 
@@ -152,13 +154,13 @@ mkdir -p ".beads/artifacts/$BEAD_ID"
 
 Not every change needs a full spec. Assess complexity to choose the right PRD level:
 
-| Signal | Lite PRD | Full PRD |
-| --- | --- | --- |
-| Type | `bug`, `task` | `feature`, `epic` |
-| Files affected | 1-3 | 4+ |
-| Scope | Clear, single-concern | Cross-cutting, multi-system |
-| Research depth | Skip or Minimal | Standard or Deep |
-| Description | "Fix X in Y" | "Implement X with Y and Z" |
+| Signal         | Lite PRD              | Full PRD                    |
+| -------------- | --------------------- | --------------------------- |
+| Type           | `bug`, `task`         | `feature`, `epic`           |
+| Files affected | 1-3                   | 4+                          |
+| Scope          | Clear, single-concern | Cross-cutting, multi-system |
+| Research depth | Skip or Minimal       | Standard or Deep            |
+| Description    | "Fix X in Y"          | "Implement X with Y and Z"  |
 
 **Auto-detect:** If type is `bug` or `task` AND research was Skip/Minimal AND description is a single sentence → default to Lite.
 
@@ -170,18 +172,23 @@ For simple, well-scoped work (bugs, small tasks):
 # [Title]
 
 ## Problem
+
 [1-2 sentences: what's wrong or what's needed]
 
 ## Solution
+
 [1-2 sentences: what to do]
 
 ## Affected Files
+
 - `src/path/to/file.ts`
 
 ## Tasks
+
 - [ ] [Task description] → Verify: `[command]`
 
 ## Success Criteria
+
 - Verify: `npm run typecheck && npm run lint`
 - Verify: `[specific test or check]`
 ```
@@ -261,13 +268,7 @@ br update $BEAD_ID --status in_progress
 
 ### Workspace Setup
 
-Follow the [workspace-setup](../skill/workspace-setup/SKILL.md) skill protocol.
-
-Additionally offer a "Create worktree" option:
-
-```typescript
-skill({ name: "using-git-worktrees" });
-```
+Follow the [workspace-setup](../skill/workspace-setup/SKILL.md) skill protocol. It offers three workspace modes: feature branch (recommended for simple work), worktree (recommended for parallel PRs or dirty workspace), and current workspace. If the user selects worktree, the skill loads [using-git-worktrees](../skill/using-git-worktrees/SKILL.md) automatically.
 
 ## Phase 10: Convert PRD to Tasks
 
@@ -280,8 +281,8 @@ Output:
 1. Bead ID and type
 2. PRD location (`.beads/artifacts/$BEAD_ID/prd.md`)
 3. Summary: task count, success criteria count, affected files count
-4. Branch name and workspace (if claimed)
-5. Next step: `/ship $BEAD_ID` (or `/plan $BEAD_ID` for complex work)
+4. Branch name and workspace (branch, worktree path, or current)
+5. Next step: `/ship $BEAD_ID` (or `/plan $BEAD_ID` for complex work, `/lfg $BEAD_ID` for autonomous execution)
 
 ```bash
 br comments add $BEAD_ID "Created prd.md with [N] tasks, [M] success criteria"

package/dist/template/{.opencode → opencode}/command/handoff.md

@@ -36,6 +36,25 @@ git rev-parse --short HEAD
 Read `.beads/artifacts/$ARGUMENTS/` to check existing artifacts.
 ```
 
+### Worktree Detection
+
+If the bead has a tracked worktree, include it in state:
+
+```bash
+WORKTREE_FILE=".beads/artifacts/$ARGUMENTS/worktree.txt"
+
+if [ -f "$WORKTREE_FILE" ]; then
+  WORKTREE_PATH="$(cat "$WORKTREE_FILE")"
+  if git worktree list --porcelain | grep -F "worktree $WORKTREE_PATH" >/dev/null; then
+    echo "Worktree: $WORKTREE_PATH (valid)"
+  else
+    echo "Worktree: $WORKTREE_PATH (stale)"
+  fi
+else
+  echo "Worktree: none"
+fi
+```
+
 ---
 
 ## Phase 2: Handle Uncommitted Changes
@@ -81,6 +100,13 @@ memory_update({
 **Branch:** [from git branch]
 **Commit:** [from git rev-parse]
 
+## Workspace
+
+- Mode: [worktree | branch | current]
+- Repo root: [from git rev-parse --show-toplevel]
+- Worktree path: [from worktree.txt, or none]
+- Worktree valid: [yes | stale | missing]
+
 ## Done
 - [completed work]
 

package/dist/template/{.opencode → opencode}/command/health.md

@@ -1,7 +1,7 @@
 ---
 description: Audit .opencode/ configuration for consistency, stale references, and enforcement gaps
 argument-hint: "[--fix] [--layer <intent|knowledge|control>]"
-agent: review
+agent: verify
 ---
 
 # Health Check: $ARGUMENTS

package/dist/template/{.opencode/command/explore.md → opencode/command/ideate.md}

@@ -1,14 +1,14 @@
 ---
 description: Think through an idea with structured alternatives before committing to a change
 argument-hint: "<idea or question>"
-agent: plan
+agent: explore
 ---
 
-# Explore: $ARGUMENTS
+# Ideate: $ARGUMENTS
 
 Think through an idea, problem, or approach with structured alternatives and tradeoffs — before committing to a bead or plan.
 
-> **Workflow:** **`/explore`** → `/create` (if worth pursuing) or discard
+> **Workflow:** **`/ideate`** → `/create` (if worth pursuing) or discard
 >
 > Use when you're not sure WHAT to build or HOW to approach it. This is ideation with rigor, not open-ended brainstorming.
 >