godpowers 0.15.0

package/skills/god-design.md

@@ -0,0 +1,275 @@
+---
+name: god-design
+description: |
+  Design lifecycle commands. Owns DESIGN.md (Google Labs spec) and
+  PRODUCT.md (impeccable strategic file). Detects impeccable; bridges
+  to its 23 commands when present. Falls back to a minimal builder when
+  not.
+
+  Triggers on: "god design", "/god-design", "design system", "visual identity",
+  "polish design", "critique design", "audit design", "design tokens",
+  "brand register", "design.md", "product.md"
+---
+
+# /god-design
+
+Front door for all design work in a Godpowers project. Bridges to
+[Impeccable](https://github.com/pbakaus/impeccable) when installed,
+producing DESIGN.md in the
+[Google Labs design.md format](https://github.com/google-labs-code/design.md).
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-design` | Run the full setup flow (delegates to /impeccable teach if installed) |
+| `/god-design teach` | Strategic interview + DESIGN.md + PRODUCT.md (impeccable teach) |
+| `/god-design document` | Regenerate DESIGN.md from existing code (impeccable document) |
+| `/god-design refresh` | Alias for document |
+| `/god-design suggest [text]` | Look for known site references and suggest matching DESIGN.md from awesome-design-md catalog |
+| `/god-design from <site>` | Fetch curated DESIGN.md from awesome-design-md and use as starter |
+| `/god-design from <url>` | If <url> is not in catalog, fall back to skillui static analysis |
+| `/god-design reference <site>` | Use a known site as a named reference in PRODUCT.md without copying its DESIGN.md |
+| `/god-design catalog` | List the 71 known sites with categories and short descriptions |
+| `/god-design scan <url> [--ultra]` | Scan a website / repo / dir with skillui and extract DESIGN.md |
+| `/god-design scan-repo <git-url>` | Clone repo and scan via skillui dir mode |
+| `/god-design extract` | Pull components into design system (impeccable extract) |
+| `/god-design shape` | Plan UX/UI before code (impeccable shape) |
+| `/god-design critique [scope]` | UX design review (impeccable critique) |
+| `/god-design audit [scope]` | a11y / perf / responsive (impeccable audit) |
+| `/god-design polish [scope]` | Final pass before shipping (impeccable polish) |
+| `/god-design harden` | Error handling, i18n, edge cases (impeccable harden) |
+| `/god-design onboard` | First-run flows, empty states (impeccable onboard) |
+| `/god-design bolder` | Amplify boring designs (impeccable bolder) |
+| `/god-design quieter` | Tone down overly bold (impeccable quieter) |
+| `/god-design distill` | Strip to essence (impeccable distill) |
+| `/god-design animate` | Add purposeful motion (impeccable animate) |
+| `/god-design colorize` | Strategic color (impeccable colorize) |
+| `/god-design typeset` | Fix font choices, hierarchy (impeccable typeset) |
+| `/god-design layout` | Fix layout, spacing (impeccable layout) |
+| `/god-design delight` | Add moments of joy (impeccable delight) |
+| `/god-design overdrive` | Technically extraordinary effects (impeccable overdrive) |
+| `/god-design clarify` | Improve unclear UX copy (impeccable clarify) |
+| `/god-design adapt` | Adapt for different devices (impeccable adapt) |
+| `/god-design optimize` | Performance improvements (impeccable optimize) |
+| `/god-design live` | Visual variant mode (impeccable live) |
+| `/god-design status` | Lint findings + drift report |
+| `/god-design impact "<change>"` | What-if analysis (delegates to god-impact-analyzer) |
+
+## Process
+
+1. Verify `.godpowers/` exists. If not: "Run `/god-init` first."
+2. Read `.godpowers/state.json` for project state.
+3. Detect:
+   - `lib/design-detector.isUiProject()` - is UI required?
+   - `lib/design-detector.isImpeccableInstalled()` - is impeccable available?
+4. If UI not required: warn that DESIGN is unusual for this project type;
+   confirm before proceeding.
+5. Spawn `god-designer` with the requested subcommand.
+6. After god-designer returns: surface any lint findings, suggest
+   `/god-design polish` if warnings exist.
+
+## Detection-driven behavior
+
+- **UI + impeccable installed**: bridges to impeccable's commands
+  through `lib/impeccable-bridge.js`. All 23 commands available.
+- **UI + impeccable NOT installed**: prompts to install impeccable; if
+  declined, falls back to god-designer's minimal builder. A subset of
+  commands (teach, document, status, impact) work in fallback.
+- **No UI**: tries to dissuade. If user insists, fallback builder runs
+  but recommends skipping the DESIGN tier entirely.
+
+## Two-stage review on changes
+
+When DESIGN.md or PRODUCT.md change as a result of any subcommand:
+
+1. `god-design-reviewer` runs in two-stage gate (spec + quality)
+2. PASS: change applied; downstream propagation runs (impact, REVIEW-REQUIRED)
+3. WARN: change applied with warnings logged
+4. BLOCK: change rejected; appended to `.godpowers/design/REJECTED.md`;
+   user told why and what to fix
+
+This pattern mirrors code review (god-spec-reviewer + god-quality-reviewer)
+applied to design.
+
+## Output
+
+Project root:
+- `DESIGN.md` (Google Labs format, lint-clean)
+- `PRODUCT.md` (impeccable strategic file, when impeccable installed)
+
+Inside `.godpowers/design/`:
+- `STATE.md` (lint history, version, impeccable command log)
+- `HISTORY.md` (append-only log of design changes; populated by god-design-updater)
+- `REJECTED.md` (append-only log of blocked changes; populated by god-design-reviewer)
+
+## Output to events.jsonl
+
+For every subcommand dispatch:
+
+```json
+{ "name": "impeccable.dispatch", "command": "polish", "scope": "header" }
+{ "name": "design.review-verdict", "verdict": "PASS|WARN|BLOCK" }
+{ "name": "design.lint-result", "errors": 0, "warnings": 1 }
+```
+
+## Awesome DESIGN.md catalog integration
+
+When the user mentions a known site (in PRD body, brand description, or
+free-text intent), the catalog from
+[VoltAgent's awesome-design-md](https://github.com/VoltAgent/awesome-design-md)
+(MIT licensed, 71 curated DESIGN.md files at time of writing) provides
+ready-to-use starting points.
+
+### Detection
+
+`lib/awesome-design.extractSiteReferences(text)` scans text for known
+site mentions. Triggers include:
+
+- Direct mention: "Linear", "Stripe", "Notion"
+- Phrasal mention: "feel like Linear", "similar to Stripe", "Apple-style"
+- Slug mention: "linear.app", "x.ai"
+
+The catalog covers 71 sites across 9 categories: AI/LLM, dev-tools,
+backend-data, productivity, design-tools, fintech, ecommerce,
+media-consumer, automotive.
+
+### Behaviors
+
+- **`/god-design suggest`**: scan PRD + PRODUCT (if present) for site
+  mentions, surface matches with their preview URLs. Non-destructive.
+- **`/god-design from linear`**: fetch `linear.app/DESIGN.md` from the
+  catalog and use as starter. Cached at
+  `.godpowers/cache/awesome-design/<slug>.md`. After fetch, runs through
+  god-design-reviewer's two-stage gate before applying.
+- **`/god-design reference linear`**: adds Linear as a named brand
+  reference in PRODUCT.md without copying its DESIGN.md. Useful when
+  you want "the feeling of Linear" without their tokens verbatim.
+- **`/god-design catalog`**: prints the full list with categories and
+  descriptions.
+
+### Cache + license
+
+DESIGN.md files are fetched lazily from raw.githubusercontent.com and
+cached per-project under `.godpowers/cache/awesome-design/`. Source repo
+is MIT-licensed; tokens represent publicly visible CSS values.
+
+If the user wants to refresh a stale cache:
+```
+/god-design from linear --refresh
+```
+
+### When the catalog is consulted automatically
+
+- During `/god-design teach` flow: god-designer scans PRD/PRODUCT for
+  site mentions and offers suggestions before drafting from scratch
+- During `/god` (front door): if the user's free text mentions a known
+  site, the recipe matcher includes a "use awesome-design DESIGN.md"
+  recipe option
+
+## SkillUI fallback (when site is not in catalog)
+
+When a user references a site that isn't in the awesome-design-md
+catalog (e.g., a competitor not yet curated, a private app, or any
+arbitrary URL), fall back to
+[SkillUI](https://www.npmjs.com/package/skillui) (MIT licensed): a CLI
+that statically analyzes a website / git repo / local directory and
+extracts a complete design system including a DESIGN.md.
+
+### Detection cascade
+
+```
+User mentions a site reference (e.g., "feel like Acme.com")
+  -> lib/awesome-design.lookupSite(name)
+       hit:  use the curated DESIGN.md from the catalog
+       miss: fall through
+  -> lib/skillui-bridge.isInstalled()
+       installed:     run skillui --url <best-guess-URL>; produces DESIGN.md
+       not installed: prompt user to `npm install -g skillui` or skip
+```
+
+### Forms
+
+| Form | Behavior |
+|---|---|
+| `/god-design from <slug>` | Catalog lookup (Linear, Stripe, etc.); fast |
+| `/god-design from <url>` | Catalog lookup, falls through to SkillUI |
+| `/god-design scan <url>` | Always uses SkillUI; bypasses catalog |
+| `/god-design scan <url> --ultra` | SkillUI ultra mode (Playwright + screenshots) |
+| `/god-design scan-repo <git-url>` | Clone + scan via SkillUI dir mode |
+| `/god-design scan-dir <path>` | Scan a local project (e.g., for migration) |
+
+### Output flow
+
+```
+1. SkillUI runs; output cached at .godpowers/cache/skillui/<slug>/
+2. The generated DESIGN.md is found via findFirstDesignMd
+3. Validated by lib/design-spec.lint
+4. Reviewed by god-design-reviewer (two-stage gate)
+5. If PASS: promoted to project-root DESIGN.md
+6. Reverse-sync wires component implementations as usual
+```
+
+### Cost / install
+
+SkillUI default mode is pure static analysis (no browser, no API key).
+For ultra mode, requires Playwright + Chromium (one-time install).
+Both modes are local; no telemetry.
+
+The bridge layer is `lib/skillui-bridge.js`. Detect-and-delegate; never
+vendored. If SkillUI isn't installed, the bridge returns
+`{ error: 'not-installed' }` with the install command for the user.
+
+## See also
+
+- `lib/design-detector.js` - UI and impeccable detection
+- `lib/design-spec.js` - Google Labs format parser and linter
+- `lib/impeccable-bridge.js` - command dispatch layer
+- `lib/awesome-design.js` - 71-site catalog + lookup + fetch
+- `agents/god-designer.md` - lifecycle owner
+- `agents/god-design-reviewer.md` - two-stage review gate
+- `references/design/DESIGN-ANATOMY.md` - what good DESIGN.md looks like
+- `references/design/DESIGN-ANTIPATTERNS.md` - what to avoid
+- [awesome-design-md](https://github.com/VoltAgent/awesome-design-md) - upstream catalog
+
+
+## Re-invocation contract
+
+What happens if `/god-design` is run when `.godpowers/design/DESIGN.md` already exists:
+
+| Existing state | Behavior |
+|---|---|
+| File does not exist | Spawn god-designer; produce file; mark sub-step done |
+| File exists, passes lint, state.json says `done` | Pause: ask user (A) re-run anyway with diff preview, (B) treat as imported (no-op), (C) cancel |
+| File exists, fails lint or have-nots | Spawn god-designer in update mode with current file + findings as input. Diff preview before overwrite. |
+| File exists, state.json says `pending` | Treat as imported: hash + register, no agent spawn. User can `/god-design --force` to re-run. |
+| `--force` flag passed | Snapshot existing file to `.godpowers/.trash/god-design-<ts>/`. Spawn agent fresh. |
+| `--dry-run` flag passed | Show what would happen; touch nothing |
+
+Snapshots in `.trash/` are recoverable via `/god-restore` for 30 days.
+The reflog records every god-design invocation as `op:god-design` for `/god-undo`.
+
+### Idempotency guarantees
+
+- Running `/god-design` twice with no user input between them is a no-op
+  (second call detects the artifact and pauses).
+- Running `/god-design --dry-run` is always read-only.
+- An interrupted `/god-design` (agent crashes mid-run) leaves state.json
+  with `status: failed` and the artifact path either missing or marked
+  for `/god-repair` review. Re-running picks up cleanly.
+
+
+## Locking
+
+The orchestrator acquires a state-lock before this skill mutates anything,
+scoped to the smallest affected unit (e.g. `tier-1.prd` for `/god-prd`,
+`linkage` for `/god-scan`). Lock TTL is 5 minutes; reentrant for the
+same holder; force-reclaimable if stale via `/god-repair`.
+
+Read-only inspection commands (`/god-status`, `/god-doctor`,
+`/god-locate`) do NOT block on the lock. Concurrent writers on
+non-overlapping scopes are allowed; on overlapping scopes, the second
+writer pauses or routes elsewhere via `/god-next`.
+
+See [ARCHITECTURE.md "Concurrency contract"](../ARCHITECTURE.md) for
+the full contract.

package/skills/god-discuss.md

@@ -0,0 +1,46 @@
+---
+name: god-discuss
+description: |
+  Adaptive Socratic discussion before planning. Surfaces hidden assumptions,
+  identifies open questions, and produces a brief that gets fed into the
+  next planning command. Different from /god-explore: this is for a specific
+  next phase, not an open-ended idea.
+
+  Triggers on: "god discuss", "/god-discuss", "discuss this", "think through"
+---
+
+# /god-discuss
+
+Pre-planning Socratic discussion.
+
+## When to use
+
+- Before /god-feature: scope the feature with the user
+- Before /god-refactor: clarify what's changing
+- Before /god-upgrade: nail down the migration target
+- Generally: any time the next command's input is fuzzy
+
+## Process
+
+Spawn god-explorer in fresh context with focus="next-phase-scoping".
+
+The agent:
+1. Reads the active workflow context
+2. Asks targeted (not open-ended) questions
+3. Surfaces 2-3 hidden assumptions
+4. Identifies what's [DECISION] vs [HYPOTHESIS] vs [OPEN QUESTION]
+5. Drafts a brief in `.godpowers/discussions/<topic>.md`
+
+The brief gets passed to the next planning command.
+
+## Output
+
+```
+Discussion complete: .godpowers/discussions/<topic>.md
+
+Key findings:
+  - [assumption surfaced]
+  - [open question that needs human decision]
+
+Suggested next: [the planning command this discussion was for]
+```

package/skills/god-docs.md

@@ -0,0 +1,81 @@
+---
+name: god-docs
+description: |
+  Write or update project documentation. Verifies every claim against the
+  codebase. Detects docs that lie. Substitution test on every claim,
+  three-label test on every sentence.
+
+  Triggers on: "god docs", "/god-docs", "update docs", "write docs",
+  "documentation", "fix readme", "verify docs"
+---
+
+# /god-docs
+
+Documentation work. Docs that don't lie.
+
+## When to use
+
+- README is out of date
+- API docs missing or stale
+- New feature shipped, docs need updating
+- Onboarding new contributors and docs are insufficient
+- Verifying existing docs for drift
+
+## Orchestration
+
+Spawn **god-docs-writer** in fresh context.
+
+The agent:
+1. Inventories existing docs vs code surface
+2. Verifies every claim in existing docs against code
+3. Identifies gaps and drift
+4. Writes/updates docs
+5. Substitution test + three-label test on every claim
+6. Writes UPDATE-LOG.md summarizing changes
+
+## On Completion
+
+```
+Docs updated.
+
+Verified: N claims across M docs
+Drift found and corrected: N
+New docs created: N
+Existing docs updated: N
+
+Update log: .godpowers/docs/UPDATE-LOG.md
+
+Suggested next: /god-status or continue with feature work
+```
+
+## Have-Nots
+
+Docs FAIL if:
+- Any claim contradicts the code
+- Examples don't actually run
+- Substitution test passes (reads generic)
+- Runbooks not tested before commit
+- Diagrams represent past or future state, not current
+
+## Linkage and reverse-sync
+
+Per Phase 13 of the production-ready plan, this workflow participates
+in the linkage system:
+
+- On completion of any code change, `lib/reverse-sync.run(projectRoot)`
+  is called via god-updater. This:
+  - Scans new/modified code for linkage annotations (// Implements: P-MUST-NN, etc.)
+  - Updates `.godpowers/links/{artifact-to-code,code-to-artifact}.json`
+  - Detects drift via `lib/drift-detector`
+  - Appends fenced footers to PRD/ARCH/ROADMAP/STACK/DESIGN
+  - Surfaces drift findings to REVIEW-REQUIRED.md
+
+- Stable IDs MUST be used in artifact deltas (P-MUST-NN, ADR-NNN,
+  C-{slug}, M-{slug}, S-{slug}, D-{slug}, token paths). The scanner
+  picks them up automatically via comment annotations.
+
+- For UI work: agent-browser audit may run as part of /god-build
+  post-wave or /god-launch gate (see `/god-test-runtime`).
+
+- Findings flow into the standard REVIEW-REQUIRED.md walkthrough
+  via `/god-review-changes`.

package/skills/god-doctor.md

@@ -0,0 +1,94 @@
+---
+name: god-doctor
+description: |
+  Diagnose Godpowers install state and project state. Reports installed
+  runtimes, version mismatches, missing files, broken artifact paths,
+  unwired skills, and orphan routing. Suggests fixes.
+
+  Triggers on: "god doctor", "/god-doctor", "diagnose godpowers", "what's
+  broken", "is godpowers ok"
+---
+
+# /god-doctor
+
+Run a system-state diagnostic. Build nothing. Touch nothing. Report only.
+
+## What it checks
+
+### Install integrity (per runtime)
+1. Is the runtime config dir present? (e.g. `~/.claude/`)
+2. Is `<runtime>/skills/god-*.md` populated?
+3. Is `<runtime>/agents/god-*.md` populated?
+4. Is `<runtime>/godpowers-references/` populated?
+5. Does `<runtime>/GODPOWERS_VERSION` match `bin/install.js` VERSION?
+6. Are all referenced agents present in `agents/`?
+7. Are all routing YAMLs paired with skill files?
+
+### Project state integrity
+1. Is `.godpowers/` present?
+2. Is `state.json` valid against `schema/state.v1.json`?
+3. Is `intent.yaml` valid against `schema/intent.v1.yaml.json`?
+4. Do declared artifact paths exist on disk?
+5. Is the reflog (`.godpowers/log`) parseable?
+6. Are there entries in `.godpowers/.trash/`?
+7. Do declared linkage entries point at real code files?
+
+### External integration health
+1. Is impeccable present? `node_modules/impeccable` or `~/.claude/skills/impeccable`?
+2. Is agent-browser installed and reachable on PATH?
+3. Is SkillUI present?
+
+## Output
+
+Plain-text report grouped by severity:
+
+```
+GODPOWERS DOCTOR
+
+Install: claude (~/.claude/)
+  [OK] 82 skills installed
+  [OK] 38 agents installed
+  [OK] VERSION matches (0.12.0)
+  [WARN] routing/god-doctor.yaml exists but skill file did not until now
+
+Project: /Users/.../my-project/.godpowers/
+  [OK] state.json valid
+  [WARN] PRD declared but .godpowers/prd/PRD.md missing -> run /god-prd
+  [INFO] 2 entries in .trash/; run /god-restore to review
+
+External integrations:
+  [OK] impeccable found via npx
+  [WARN] agent-browser not installed -> /god-test-runtime falls back to Playwright
+
+Suggested next steps:
+  1. /god-prd  (fill missing artifact)
+  2. /god-restore  (review trash)
+```
+
+## Subcommands
+
+### `/god-doctor`
+Full diagnostic across install + project + integrations.
+
+### `/god-doctor --install-only`
+Skip project checks.
+
+### `/god-doctor --project-only`
+Skip install checks. Useful inside the project.
+
+### `/god-doctor --fix`
+Attempt to repair detected issues automatically (only for safe categories: regenerate missing routing YAMLs, repair PROGRESS.md from state.json, etc.). Pauses before any destructive change.
+
+## Implementation
+
+Built-in, no spawned agent. Reads:
+- `<runtime>/GODPOWERS_VERSION` (compare to package.json)
+- `<runtime>/skills/` and `<runtime>/agents/` listings
+- `.godpowers/state.json`, `intent.yaml`, `log`, `linkage.json`
+- `bin/install.js` VERSION constant
+
+## Exit codes
+
+- 0: everything green
+- 1: warnings present, but functional
+- 2: errors present, manual repair needed

package/skills/god-explore.md

@@ -0,0 +1,50 @@
+---
+name: god-explore
+description: |
+  Socratic ideation. Think through an idea before committing to plans. Spawn
+  the god-explorer agent in a fresh context to ask clarifying questions and
+  surface assumptions before /god-init runs.
+
+  Triggers on: "god explore", "/god-explore", "explore an idea", "think through",
+  "brainstorm", "ideate"
+---
+
+# /god-explore
+
+Pre-init Socratic ideation. Use this when you're not sure what to build yet.
+
+## When to use
+
+- Idea is fuzzy
+- Multiple directions seem possible
+- You need a sounding board before committing to PRD
+
+## Process
+
+1. Ask the user to describe the idea in any form (rambling is fine)
+2. Spawn **god-explorer** agent in a fresh context to:
+   - Ask Socratic questions (not "tell me more"; specific probes)
+   - Surface hidden assumptions
+   - Identify the core problem (vs the proposed solution)
+   - List 2-3 alternative framings
+   - Suggest which framing is strongest with rationale
+3. Output: a clarified problem statement ready for /god-init -> /god-prd
+
+## What this is NOT
+
+- Writing the PRD (that's /god-prd)
+- Picking technology (that's /god-stack)
+- Committing to a direction
+
+This is exploratory. The goal is clarity, not commitment.
+
+## On Completion
+
+```
+Idea explored. Suggested framing:
+
+[One-paragraph problem statement, ready to feed into /god-init]
+
+Suggested next: /god-init (commit to this framing) or /god-explore again
+                (if you want to try another angle)
+```

package/skills/god-export-otel.md

@@ -0,0 +1,87 @@
+---
+name: god-export-otel
+description: |
+  Export godpowers events.jsonl to an OpenTelemetry collector as OTLP/JSON
+  trace data. Lets you pipe godpowers runs into Honeycomb, Datadog, Jaeger,
+  Tempo, or any OTLP-compatible backend. Opt-in: nothing exports until you
+  invoke this skill.
+
+  Triggers on: "god export otel", "/god-export-otel", "export to honeycomb",
+  "send traces to collector", "pipe events to datadog"
+---
+
+# /god-export-otel
+
+Convert one (or all) godpowers run events into OTLP/JSON ResourceSpans
+and POST them to an OpenTelemetry collector.
+
+## Usage
+
+### `/god-export-otel`
+Export the most recent run to the endpoint in `OTEL_EXPORTER_OTLP_ENDPOINT`
+(or `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`). With no endpoint set, prints the
+OTLP JSON payload to stdout.
+
+### `/god-export-otel <run-id>`
+Export a specific run.
+
+### `/god-export-otel --all`
+Export every run in the project. Use sparingly: a large history can push a
+lot of spans at once.
+
+### `/god-export-otel --endpoint=<url>`
+Override the env var. The path `/v1/traces` is appended if not present.
+
+### `/god-export-otel --stdout`
+Print OTLP JSON without POSTing. Useful for inspecting the payload or
+piping through `jq` into a file collector.
+
+### `/god-export-otel --service-name=<name>`
+Override `service.name` in the resource. Defaults to `godpowers`.
+
+## Environment
+
+- `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` - takes precedence
+- `OTEL_EXPORTER_OTLP_ENDPOINT` - fallback; `/v1/traces` is appended
+- `OTEL_EXPORTER_OTLP_HEADERS` - comma-separated `key=value` pairs for
+  auth headers (e.g. `x-honeycomb-team=YOUR_KEY`)
+
+## Event -> span mapping
+
+- `workflow.run` + `workflow.complete` -> root span
+- `agent.start` + `agent.end` (matched by `span_id`) -> child span,
+  parented to the workflow root
+- Other events (`cost.recorded`, `gate.fail`, `error`, `decision.route`,
+  `tool.call`, etc.) attach as span events on the span sharing their
+  `span_id`
+- Events whose span has no start/end become zero-duration spans so no
+  data is dropped
+- An `error` or `gate.fail` event flips the parent span's status to
+  `ERROR`
+
+Timestamps in events.jsonl are ISO strings; OTLP wants nanoseconds since
+epoch as numeric strings (JS numbers cannot hold 64-bit nanos). The
+exporter converts on the fly with millisecond precision.
+
+## Output
+
+```
+Exported run 2026-05-10T22-15-31-3f6827a1
+  spans:    12
+  endpoint: https://api.honeycomb.io/v1/traces
+  status:   200
+```
+
+In stdout mode, prints the raw OTLP JSON payload.
+
+## Implementation
+
+Built-in. `lib/otel-exporter.js` does the conversion and HTTP POST. No
+external dependencies; uses Node's built-in `http` / `https`.
+
+## Related
+
+- `/god-logs` - human-readable timeline (no export)
+- `/god-metrics` - per-tier durations + pause / error counts
+- `/god-trace` - filter a run by tier
+- `/god-cost` - token + dollar accounting from `cost.recorded` events