STOP -- DO NOT READ THIS FILE. You are already reading it. This prompt was injected into your context by Claude Code's plugin system. Using the Read tool on this SKILL.md file wastes ~7,600 tokens. Begin executing Step 0 immediately.

/pbr:quick -- Quick Ad-Hoc Task Execution

You are running the quick skill. Your job is to execute a small, self-contained task outside the normal plan/build/review cycle. Quick tasks get their own tracking, atomic commits, and state integration, but skip the overhead of full planning.

This skill spawns a single Task(subagent_type: "pbr:executor") for execution.

Dual-mode flow: This skill has two execution paths controlled by the features.zero_friction_quick config toggle (default: true). The zero-friction path reaches the executor in 2 tool calls. The legacy path preserves the full pre-planning ceremony.

Step 0 -- Immediate Output

Before ANY tool calls, display this banner:

╔══════════════════════════════════════════════════════════════╗
║  PLAN-BUILD-RUN ► QUICK TASK                                ║
╚══════════════════════════════════════════════════════════════╝

Then proceed to Step 1.

References

• references/questioning.md -- Questioning philosophy and progressive depth patterns
• references/ui-brand.md -- Status symbols, banners, checkpoint boxes, progress display

Context Budget

Reference: skills/shared/context-budget.md for the universal orchestrator rules. Reference: skills/shared/agent-type-resolution.md for agent type fallback when spawning Task() subagents.

Additionally for this skill:

• Never implement the task yourself -- you are a router, not a builder. ALL code changes go through a spawned Task(subagent_type: "pbr:executor")
• Minimize reading executor output into main context -- read only SUMMARY.md frontmatter

Composable Flags

Parse $ARGUMENTS for optional flags before extracting the task description:

• --discuss: Before spawning the executor, ask 2-3 clarifying questions about the approach. Write the Q&A results to .planning/quick/{NNN}-{slug}/CONTEXT.md as a lightweight decision record. Pass this CONTEXT.md to the executor via files_to_read.
• --research: Spawn a Task(subagent_type: "pbr:researcher") to investigate the task domain before execution. The researcher writes findings to .planning/quick/{NNN}-{slug}/RESEARCH.md. Pass this RESEARCH.md to the executor via files_to_read.
• --full: Enable plan-checker validation (max 2 iterations) before executor spawn AND post-execution verification via verifier agent. Creates VERIFICATION.md in the quick task directory. Does NOT escalate to /pbr:plan -- stays in quick pipeline.

Strip these flags from $ARGUMENTS before using the remainder as the task description.

Flag combinations:

• --discuss alone: Quick task with discussion + CONTEXT.md
• --research alone: Quick task with research + RESEARCH.md
• --full alone: Quick task with plan-checking + verification
• --discuss --research: Discussion + research before execution
• --discuss --full: Discussion + plan-checking + verification
• --research --full: Research + plan-checking + verification
• --discuss --research --full: All quality layers
• No flags: Standard quick task flow (zero-friction or legacy based on config)

Note: --full converts the zero-friction path to use a PLAN.md so plan-checker can validate it. The executor then reads the PLAN.md instead of inline instructions. This adds 1-2 tool calls but enables structured validation.

Core Principle

Quick tasks are for small, well-defined work. If the user describes something that would take more than 3-5 tasks or touches multiple subsystems, suggest using the full plan/build cycle instead.

Flow

Step 1: Init + Route Decision (1 tool call)

Init-first pattern: Run the init command to get config + state in a single call:

node plugins/pbr/scripts/pbr-tools.js init quick "{description}"

From the init output:

1. Check if .planning/ directory exists
   • If no: create both .planning/ and .planning/quick/ directories, then warn "No Plan-Build-Run project found. This will create a standalone quick task. Consider running /pbr:new-project first for full project tracking."
2. If .planning/ exists but .planning/quick/ does not: create .planning/quick/ now
3. Read features.zero_friction_quick from config (default: true)

Route decision:

• If --full flag: continue with the selected path below (plan-checker and verifier steps will activate later). Do NOT escalate to Skill({ skill: "pbr:plan" }).
• If --discuss flag: go to Step 1c (ask clarifying questions, write CONTEXT.md), then continue.
• If --research flag: go to Step 1d (spawn researcher, write RESEARCH.md), then continue.
• If both --discuss and --research: run Step 1c first, then Step 1d.
• If features.zero_friction_quick is true (default): go to Step 2 (zero-friction path)
• If features.zero_friction_quick is false: go to Step 5 (legacy path)

DO NOT fall back to the legacy flow when zero_friction_quick is true. The zero-friction path is the intended default experience.

Step 1b: Get Task Description (if needed)

If $ARGUMENTS is provided and non-empty (after stripping flags):

• Use it as the task description

If $ARGUMENTS is empty:

• Ask the user: "What do you need done? Describe the task in a sentence or two." This is a freeform text prompt -- do NOT use AskUserQuestion here. Task descriptions require arbitrary text input, not option selection.

Step 1c: Discussion (only if --discuss flag is set)

Ask 2-3 clarifying questions about the approach, constraints, and edge cases. Use plain text prompts (not AskUserQuestion -- these require freeform answers).

After receiving answers, write the Q&A to .planning/quick/{NNN}-{slug}/CONTEXT.md:

# Quick Task Context

**Task:** {description}
**Date:** {YYYY-MM-DD}

## Discussion

{Q&A content -- each question and answer}

## Decisions

{Key decisions derived from the discussion}

Note: The task directory .planning/quick/{NNN}-{slug}/ must be created before writing CONTEXT.md. In the zero-friction path, create it now (it will be reused in Step 3). In the legacy path, it is created in Step 5e.

Continue to Step 1d if --research is also set, otherwise continue to the selected path (Step 2 or Step 5).

Step 1d: Research (only if --research flag is set)

Spawn a Task(subagent_type: "pbr:researcher") with the following prompt:

Research the following task domain for a quick task.
Task: {description}
Write findings to: .planning/quick/{NNN}-{slug}/RESEARCH.md
Focus on: existing patterns in the codebase, potential risks, recommended approach.
Keep it concise (under 500 tokens).

Note: The task directory .planning/quick/{NNN}-{slug}/ must exist before the researcher writes to it. Create it if not already created by Step 1c.

After the researcher completes, verify .planning/quick/{NNN}-{slug}/RESEARCH.md exists. If missing, log a warning and continue without research context.

Continue to the selected path (Step 2 or Step 5).

Zero-Friction Path (Steps 2-4)

This path executes the task in 2 tool calls: init (Step 1) + spawn executor (Step 2). No PLAN.md is written before execution. No .active-skill is set. Artifacts are created AFTER execution completes.

Step 2: Spawn Executor Immediately (1 tool call)

Generate slug via CLI (or use blob.slug from initQuick if available):

pbr-tools slug-generate "{description}"

Parse the JSON output to get the slug field. If blob.slug is available from the initQuick response, use it directly instead of calling slug-generate.

Find next task number from .planning/quick/ listing (from init output if available, else quick ls):

1. Scan .planning/quick/ directory for existing quick task directo