Dogfood

dogfood — explicit P11 reflex trigger (Dogfood Plan + Receipt)

Explicit trigger for bstack P11 reflex 7+16 for: $ARGUMENTS

Inheritance from bstack (declared)

This skill is downstream of broomva/bstack. It implements P11 reflex 7 (Dogfood Plan keyed to detected stack) and reflex 16 (Dogfood Receipt) explicitly, where /autonomous fires them implicitly inside its 21-reflex pipeline. Full inheritance contract: references/bstack-inheritance.md.

• Cookbook source: bstack/references/dogfood-patterns.md (loaded on demand; not duplicated here)
• Discipline source: bstack/references/primitives.md §P11
• Stack-detection algorithm: mirrors bstack/scripts/doctor.sh §13
• Minimum bstack version: 0.13.0

If bstack isn't installed, the skill still works — it carries its own detection logic and inlines the minimum surfaces matrix. The cookbook (deep per-stack reference) lives upstream in bstack.

Purpose

P11 (Empirical Feedback Loop) mandates "before claiming work complete, the agent has interacted with the deployed/running version… reasoning isn't validation; interaction is." This skill makes the two binding reflexes (Plan + Receipt) explicitly triggerable when you don't want the full /autonomous pipeline.

When to invoke /dogfood instead of /autonomous:

• Single-file change with user-visible effect
• Exploration: "what does dogfooding look like for this stack"
• Pre-merge verification gate on someone else's PR
• First time seeing a tech stack you're new to (cookbook entry is the answer)
• Receipt-only after manual execution

Usage

/dogfood                        # full sequence: plan → execute prompt → receipt
/dogfood plan                   # plan only — produce the six-row plan
/dogfood execute                # execute — fire the surfaces named in the plan
/dogfood receipt                # receipt only — produce the evidence table
/dogfood --stack=tauri-sidecar  # override detection
/dogfood --ticket=BRO-1234      # anchor evidence path to ticket
/dogfood --evidence-dir=/tmp/dogfood/<slug>

CLI fallback (no Claude session required):

./scripts/dogfood.sh detect              # echo detected stack
./scripts/dogfood.sh plan --stack=nextjs # emit plan template stub
./scripts/dogfood.sh receipt --plan=plan.md

Workflow

Phase 1 — Detect stack

Mirror bstack/scripts/doctor.sh §13 detection. If --stack=<name> was passed, use that instead. If detection returns unknown, the agent declares the stack explicitly in the plan (no silent default).

./scripts/dogfood.sh detect
# → tauri-sidecar | nextjs | expo-rn | rust-cli | rest-api | mcp-server | unknown

The detection logic mirrors what bstack doctor §13 does. If bstack doctor is installed and recent, prefer its output:

if command -v bstack >/dev/null 2>&1; then
    bstack doctor 2>&1 | grep "^  \[ok\] stack detected:" | sed 's/.*stack detected: //; s/ .*//'
fi

Phase 2 — Load cookbook entry

Read the matching pattern section from bstack/references/dogfood-patterns.md:

# Section IDs in the cookbook:
#   Pattern A — Tauri + sidecar
#   Pattern B — Next.js
#   Pattern C — Expo / React Native
#   Pattern D — Rust CLI
#   Pattern E — REST API
#   Pattern F — MCP server / Tool provider

BSTACK_REF=$(npx skills path broomva/bstack 2>/dev/null || echo "$HOME/.agents/skills/bstack")
COOKBOOK="$BSTACK_REF/references/dogfood-patterns.md"

If the cookbook isn't reachable (bstack not installed or older than v0.13.0), fall back to the minimum surfaces table inlined below in Phase 2 — fallback (no bstack). The agent surfaces a one-line warning recommending bstack installation for the deep cookbook.

Phase 2 — fallback (no bstack ≥ 0.13.0 available)

Minimum surfaces table (covers ~80% of cases without the deep cookbook):

Stack	Primary surfaces	Mandatory
tauri-sidecar	curl+jq engine API · cliclick+screencapture · Interceptor at :1420	Interceptor for visual verification
nextjs	dev server log-tail · Interceptor · curl+jq for routes	Interceptor for authenticated flows
expo-rn	expo start --ios · xcrun simctl io booted screenshot	Simulator screenshots
rust-cli	direct invocation · --help smoke · trycmd/assert_cmd	Exit code 0 + output capture
rest-api	curl+jq · log-tail · OpenAPI diff if applicable	Response body assertion
mcp-server	npx @modelcontextprotocol/inspector or direct LLM invoke	Tool-call response capture

For deeper detail (canonical arc, bash snippets, gotchas, receipt template): install bstack ≥ 0.13.0.

Phase 3 — Produce the Dogfood Plan

Surface the plan in the agent's response, and (if a PR is active) into the PR body via gh pr edit <pr> --body-file or gh pr comment <pr>. Six rows, all mandatory:

**Dogfood Plan** (stack: <detected>, ticket: <id-or-none>)

- **Entry surface**: <URL / window / CLI command the user touches>
- **Driver**: <Interceptor / gstack / cliclick+screencapture / curl+jq / xcrun simctl>
- **Evidence**: <screenshot path / response body path / log line / recording>
- **Smoke**: <one-line "didn't obviously break" check>
- **End-to-end**: <multi-step user flow that catches regression a smoke test misses>
- **Receipt anchor**: <file / line / PR comment ID where the receipt lives>

The plan rows MUST be concrete — file paths, URLs, commands, not vibes. Rows that genuinely don't apply are marked ⊘ with explicit reason ("backend mocked in this PR; real cloud creds not available — smoke-only this run"). Silent omission is the failure mode this contract closes.

Phase 4 — Execute (only if subcommand is execute / explore or full sequence)

For each plan row, fire the named driver. The explore subcommand (v0.2.0+) emits the per-stack execution recipe; for web stacks it composes with the agent-browser exploratory workflow.

Exploratory web QA mode (v0.2.0+)

For web stacks (nextjs, rest-api-with-frontend, or any --url= target), /dogfood explore --url=... produces an agent-browser session-based exploration recipe: initialize → authenticate → orient → explore → document issues → wrap up. Each issue logged with screenshots / video / repro-steps to ./dogfood-output/<slug>/. The exploratory output's report.md becomes the parent Dogfood Plan's Evidence row.

dogfood explore --url=https://staging.example.com --session=billing-page --ticket=BRO-1234
# → emits a recipe: agent-browser open · snapshot · screenshot · errors · console
# → mkdir -p ./dogfood-output/staging-example-com/{screenshots,videos}
# → cp templates/exploratory-report.md → output dir

Composition with the upstream dogfood skill: the agent-browser workflow + issue taxonomy + report template are adapted from the pre-existing dogfood skill at ~/.agents/skills/dogfood/ (agent-skills catalog). See references/bstack-inheritance.md for attribution + references/exploratory-issue-taxonomy.md for what to look for.

Per-stack execution snippets

tauri-sidecar:

osascript -e 'tell application "Houston" to activate'
cliclick c:1662,1090
cliclick t:"My test mission"
cliclick kp:return
sleep 1
screencapture -x -t png -R 1480,200,470,980 "$EVIDENCE_DIR/after-input.png"

nextjs:

interceptor open "http://localhost:3000/<route>"
interceptor read --max-tokens 4000
interceptor act --click "Submit"
interceptor wait-stable
interceptor screenshot "$EVIDENCE_DIR/after-submit.png"

rest-api:

curl -sS -X POST "$BASE/api/<route>" \
  -H 'content-type: application/json' \
  -d '{"foo":"bar"}' | jq . | tee "$EVIDENCE_DIR/response.json"

Capture the exit status of each driver invocation. Failed invocations are surfaced before producing the receipt.

Phase 5 — Produce the Dogfood Receipt

After execution (or after the user reports manual execution), produce the evidence table:

**Dogfood Receipt** — <ticket> · <date>

| Plan row | Executed | Evidence |
|---|---|---|
| Smoke | ✅ | <evidence>: <path / output line> |
| End-to-end | ✅ | Screenshots: <paths> |
| API contract | ✅ | <response captured in PR comment #N> |
| Side-effect | ✅ | <DB query / log / state assertion> |
| Deploy preview | ✅ | <preview URL> — Interceptor screenshot <path> |
| <row that wasn't applicable> | ⊘ | Reason: <explicit> |

**Anti-rationalization check**: did I actually click the app like a user would? <yes/no>
**Surfaces driven**: <Interceptor / cliclick / curl / etc.>
**Time-to-receipt**: <duration> from first write to receipt complete.

The anti-rationalization line is binary and mandatory. If the honest answer is no, the receipt isn't complete — the plan goes back into execution.

Phase 6 — Persist the receipt

Anchor the receipt at the location named in the plan's Receipt anchor row:

• PR body — gh pr comment <pr> --body "$(cat receipt.md)" OR include in PR description
• Repo file — docs/dogfood-receipts/<date>-<ticket>.md for repos with substantial dogfood history
• Bridge (P1) auto-capture — bstack's Stop hook captures the session-end receipt to Obsidian automatically; no explicit action needed if bstack is installed

Composition with /autonomous

/autonomous fires this skill at reflex 7 (Plan) and reflex 16 (Receipt). When invoked directly, /dogfood runs in isolation. Both produce the same artifacts; the difference is scope.

Scope	Use
Full feature work (multi-file, public contract, deploy-impacting)	/autonomous
Single-file change with user-visible effect	/dogfood directly
Pre-merge verification of someone else's PR	/dogfood --ticket=<id>
First time seeing a new tech stack	/dogfood plan
Receipt-only after manual execution	/dogfood receipt

Anti-patterns this skill closes

Anti-pattern	Why it fails	What /dogfood enforces
"Compile-time pass = shipping"	Compile ≠ deploy correctness	Plan rows require evidence beyond exit codes
"CI green = shipping"	CI tests what CI was told; user flow is broader	Receipt requires deploy-verification screenshot
"I dogfooded mentally"	Ritual without artifact	Receipt table is the artifact; anti-rationalization line is binary
"I'll dogfood after merge"	Post-merge = bug found by user	Plan precedes substantive work; receipt precedes claiming complete
Agent-browser for visual deploy verification	Bot detection + missed visual state	Interceptor mandatory per cookbook

Cross-references

• Cookbook (per-stack patterns): bstack/references/dogfood-patterns.md (loaded on demand)
• P11 reflex contract: bstack/references/primitives.md §P11
• Inheritance declaration: references/bstack-inheritance.md
• Interceptor skill: ~/.claude/skills/Interceptor/SKILL.md
• /autonomous skill: broomva/autonomous (composes this skill at reflex 7+16)

Voice notification (optional, for environments that support it)

If a local voice-notification daemon is running on port 31337:

curl -s -X POST http://localhost:31337/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the dogfood skill — producing P11 plan + receipt for the detected stack"}' \
  > /dev/null 2>&1 &

Skip silently if the daemon isn't running.