godpowers 0.15.0

package/skills/god-sprint.md

@@ -0,0 +1,77 @@
+---
+name: god-sprint
+description: |
+  Sprint ceremonies. Plan a sprint from the roadmap, run sprint status checks,
+  and conduct retrospectives. Optional layer for teams that want agile cadence.
+
+  Triggers on: "god sprint", "/god-sprint", "sprint plan", "retrospective",
+  "sprint status", "standup"
+---
+
+# /god-sprint
+
+Optional sprint ceremonies. Activates only at scale `large` or `enterprise`,
+or when explicitly invoked.
+
+## Subcommands
+
+### `/god-sprint plan [--days=14]`
+Plan the next sprint from the roadmap:
+1. Read ROADMAP.md and current progress
+2. Identify slices that fit in the sprint window based on past velocity
+3. Create `.godpowers/sprints/sprint-<N>/PLAN.md`:
+   - Goal (substitution-tested)
+   - Slices committed
+   - Capacity (engineers x days x focus factor)
+   - Dependencies and risks
+4. Each committed slice becomes a tracked item
+
+### `/god-sprint status`
+Show sprint progress:
+```
+Sprint 3 (Day 8 of 14)
+
+Committed: 8 slices
+Done: 5 slices
+In flight: 2 slices
+At risk: 1 slice (Slice 3.4: blocked on third-party API)
+
+Burn-down:
+  Day 1-7: [####          ] 50%
+  Day 8:   [#####         ] 60% (today)
+  Target:  [############  ] 100% by Day 14
+
+Velocity: 0.625 slices/day (within target)
+```
+
+### `/god-sprint retro`
+Conduct a retrospective at sprint end:
+1. Spawn the **god-retrospective** agent (fresh context)
+2. Review:
+   - What was committed vs delivered
+   - Slices that took longer than estimated (and why)
+   - Slices that came in faster (and why)
+   - Blockers encountered
+3. Write `.godpowers/sprints/sprint-<N>/RETRO.md`:
+   - What went well
+   - What didn't
+   - Specific actions for next sprint (concrete, not "communicate better")
+4. Update velocity baseline for future sprint planning
+
+## When to use
+
+- Team of 3+ engineers
+- Project running 3+ months
+- External stakeholders need predictable cadence
+
+## When NOT to use
+
+- Solo developer (just use /god-mode)
+- Project under 4 weeks (sprints add overhead)
+
+## On Completion
+
+```
+Sprint [N] [planned/status/retro] complete.
+Artifact: .godpowers/sprints/sprint-<N>/[file]
+```

package/skills/god-stack.md

@@ -0,0 +1,74 @@
+---
+name: god-stack
+description: |
+  Pick the technology stack. Spawns the god-stack-selector agent in a fresh
+  context. Gated on Architecture.
+
+  Triggers on: "god stack", "/god-stack", "pick the stack", "what stack"
+---
+
+# /god-stack
+
+Spawn the **god-stack-selector** agent in a fresh context via Task tool.
+
+## Setup
+
+1. Verify `.godpowers/arch/ARCH.md` exists. If not, tell user to run `/god-arch` first.
+2. Spawn god-stack-selector with the ARCH path.
+3. The agent writes `.godpowers/stack/DECISION.md`.
+
+## Verification
+
+After god-stack-selector returns:
+1. Verify DECISION.md exists on disk
+2. Update `.godpowers/PROGRESS.md`: Stack status = done
+
+## On Completion
+
+```
+Stack decision complete: .godpowers/stack/DECISION.md
+
+Suggested next: /god-repo (scaffold the repo with the chosen stack)
+```
+
+
+## Re-invocation contract
+
+What happens if `/god-stack` is run when `.godpowers/stack/DECISION.md` already exists:
+
+| Existing state | Behavior |
+|---|---|
+| File does not exist | Spawn god-stack-selector; 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-stack-selector 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-stack --force` to re-run. |
+| `--force` flag passed | Snapshot existing file to `.godpowers/.trash/god-stack-<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-stack invocation as `op:god-stack` for `/god-undo`.
+
+### Idempotency guarantees
+
+- Running `/god-stack` twice with no user input between them is a no-op
+  (second call detects the artifact and pauses).
+- Running `/god-stack --dry-run` is always read-only.
+- An interrupted `/god-stack` (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-standards.md

@@ -0,0 +1,62 @@
+---
+name: god-standards
+description: |
+  Run artifact standards check on a specific artifact. Verifies
+  substitution test, three-label test, and tier-specific have-nots. Use
+  manually for spot-checks or invoke as a gate between commands.
+
+  Triggers on: "god standards", "/god-standards", "check standards",
+  "verify quality", "run substitution test"
+---
+
+# /god-standards
+
+Run quality gate check on an artifact.
+
+## When to use
+
+- Suspect an artifact has drifted from quality standards
+- Before committing to a downstream tier
+- After manual edits to an artifact (which bypass the producing agent)
+- Spot check at any time
+
+## Process
+
+1. Identify the artifact to check (user provides, or auto-detect from PROGRESS.md)
+2. Look up the routing for the relevant tier (lib/router.js getStandards)
+3. Spawn god-standards-check in fresh context with:
+   - artifact-path
+   - tier
+   - have-nots-list (from routing)
+   - gate-on-failure: pause-for-user (default for manual runs)
+
+## Output
+
+Display the standards-check verdict:
+
+```
+Standards check: .godpowers/prd/PRD.md
+
+Substitution test:    PASS
+Three-label test:     PASS
+Have-nots (15):       13 PASS / 2 FAIL
+
+Failures:
+  - P-02 (line 14): Target user is "developers" with no specificity
+    Fix: Replace with specific persona
+
+  - P-04 (line 28): Success metric "1000 users" has no timeline
+    Fix: Add timeline ("within 60 days of launch")
+
+Verdict: PARTIAL (87%)
+
+Suggested next:
+  /god-redo prd to address failures with feedback
+  /god-skip prd --reason "..." to accept-as-is
+```
+
+## Auto-invocation
+
+This skill is also invoked automatically by the routing system between stages
+when `standards.gate-on-failure` is configured. The user-facing version (this
+skill) is for manual spot-checks.

package/skills/god-status.md

@@ -0,0 +1,99 @@
+---
+name: god-status
+description: |
+  Re-derive project state from disk. Never from memory. Scans all artifact
+  paths and reports what exists, what passes, and what's missing.
+
+  Triggers on: "god status", "where are we", "project status", "what's done"
+---
+
+# God Status
+
+Re-derive state from disk. Your memory is not authoritative. The file system is.
+
+## Process
+
+1. Check if `.godpowers/PROGRESS.md` exists
+   - If not: "No Godpowers project found. Run `god init` to start."
+2. Read PROGRESS.md for recorded state
+3. Scan ALL artifact paths on disk:
+   - `.godpowers/prd/PRD.md`
+   - `.godpowers/arch/ARCH.md`
+   - `.godpowers/roadmap/ROADMAP.md`
+   - `.godpowers/stack/DECISION.md`
+   - `.godpowers/repo/AUDIT.md`
+   - `.godpowers/build/STATE.md`
+   - `.godpowers/deploy/STATE.md`
+   - `.godpowers/observe/STATE.md`
+   - `.godpowers/launch/STATE.md`
+   - `.godpowers/harden/FINDINGS.md`
+4. For each artifact found: run a lightweight have-nots check
+5. Compare disk state to PROGRESS.md state:
+   - If PROGRESS.md says "done" but artifact is missing: FLAG as phantom resume
+   - If artifact exists but PROGRESS.md says "pending": FLAG as untracked work
+6. Report:
+   - Current mode and scale
+   - Per-tier status (with disk verification)
+   - Any inconsistencies between PROGRESS.md and disk
+   - Suggested next action
+7. If inconsistencies found: offer to repair PROGRESS.md to match disk truth
+
+## Output Format
+
+```
+Godpowers Status
+
+Mode: A (greenfield)    Scale: medium
+Started: 2026-05-09
+
+Tier 1: Planning
+  + PRD           done     .godpowers/prd/PRD.md (lint clean: 0 errors)
+  + Architecture  done     .godpowers/arch/ARCH.md (lint clean: 0 errors)
+  - Roadmap       pending
+  - Stack         pending
+  - Design        not-required (backend-only project)
+  - Product       not-required (backend-only project)
+
+Tier 2: Building
+  - Repo          pending
+  - Build         pending
+
+Tier 3: Shipping
+  - Deploy        pending
+  - Observe       pending
+  - Launch        pending
+  - Harden        pending
+
+Linkage status (from .godpowers/links/):
+  Coverage: 87% (15 of 17 declared IDs implemented)
+  Orphans: 2 (P-MUST-09, P-SHOULD-03)
+  Drift: 1 (colors.removed referenced in src/old.css but missing in DESIGN.md)
+  Pending reviews: 5 (see REVIEW-REQUIRED.md)
+  Last scan: 2026-05-10T14:23:11Z
+
+Suite (Mode D) status:
+  This repo is a sibling of suite "my-products" (hub: ../hub)
+  Run /god-suite-status to see all 3 repos and meta-linter findings.
+
+Next: god roadmap
+```
+
+## Mode D awareness
+
+If `lib/multi-repo-detector.detect(projectRoot)` returns
+`isMultiRepo: true`, /god-status appends a "Suite (Mode D) status"
+section showing:
+- Suite name and our role (hub or sibling)
+- Hub path
+- Suggestion to run /god-suite-status for the aggregate view
+
+For the hub itself, this section becomes:
+```
+Suite (Mode D) status:
+  This repo IS the hub for suite "my-products" (3 siblings).
+  Aggregate: 42 artifacts done, 1 drift, 5 pending reviews.
+  Last suite refresh: 2026-05-10T16:45:00Z
+```
+
+The suite section is omitted entirely when the project is not part of
+a registered suite.

package/skills/god-stories.md

@@ -0,0 +1,60 @@
+---
+name: god-stories
+description: |
+  List all STORY.md files grouped by status (pending, in-progress,
+  blocked, done). Useful for "what am I working on" overview.
+
+  Triggers on: "god stories", "/god-stories", "list stories",
+  "show stories", "what stories are open"
+---
+
+# /god-stories
+
+Show all stories with status, owner, deps. Read-only; no agent spawn.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-stories` | All stories grouped by status |
+| `/god-stories --status pending` | Filter to one status |
+| `/god-stories --feature <slug>` | Stories for one feature |
+| `/god-stories --json` | Structured output |
+
+## Process
+
+1. Verify `.godpowers/` exists.
+2. Call `lib/story-validator.listStories(projectRoot)`.
+3. Group by status; render.
+
+## Output (default)
+
+```
+Stories (12 total)
+
+In progress (2)
+  STORY-auth-001  [alice]  Add OAuth flow
+    deps: STORY-auth-000
+
+Pending (5)
+  STORY-billing-001  [bob]    Stripe webhook handler
+  STORY-billing-002  [bob]    MRR calculator
+  ...
+
+Blocked (1)
+  STORY-search-001  [alice]  Indexing - waiting on SearchKit upgrade
+
+Done (4)
+  STORY-auth-000  Connect button
+  ...
+
+Cycles detected: none
+```
+
+If dep cycles exist, surface them at the end.
+
+## What this does NOT do
+
+- Modify any STORY.md (use /god-story-close, /god-story-block to change status)
+- Spawn agents (read-only)
+- Trigger reverse-sync

package/skills/god-story-build.md

@@ -0,0 +1,76 @@
+---
+name: god-story-build
+description: |
+  Implement a single story. Reads STORY.md, spawns the standard build
+  pipeline (god-planner + god-executor + reviewers) scoped to the
+  story's slice plan and acceptance criteria.
+
+  Triggers on: "god story build", "/god-story-build", "build story",
+  "implement story"
+---
+
+# /god-story-build
+
+Run the build pipeline for ONE story.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-story-build <STORY-id>` | Build the named story |
+| `/god-story-build --next` | Build the first pending story (next eligible by deps) |
+| `/god-story-build --status` | Show build status of in-progress stories |
+
+## Process
+
+1. Verify story exists; parse via `lib/story-validator.parseStory`.
+2. Validate dependencies are done:
+   - For each dep: check that story's status === 'done'
+   - If any dep is not done: pause and ask user (proceed anyway, or
+     start the dep first)
+3. Set story status to `in-progress` via `lib/story-validator.setStatus`.
+4. Spawn `god-planner` with directive:
+   "Plan a vertical slice for STORY-{id}. Slice plan from STORY.md:
+   [steps]. Acceptance criteria from STORY.md: [criteria]. Don't
+   exceed 7 commits."
+5. Spawn `god-executor` to implement (TDD, atomic commits, code
+   annotated `// Implements: STORY-{id}`).
+6. Spawn `god-spec-reviewer` + `god-quality-reviewer` (two-stage).
+7. On success: trigger `lib/reverse-sync.run()` (per Phase 6 pattern).
+8. Story stays `in-progress` until user runs `/god-story-verify` AND
+   `/god-story-close`. Build completion alone doesn't auto-close.
+
+## Output
+
+Code commits annotated with `// Implements: STORY-{id}`.
+Reverse-sync writes Implementation Linkage footer to ROADMAP.md
+(milestone-level credit) and the story's `Notes` section gets a
+"Implemented in:" footer.
+
+## Suggested next
+
+- `/god-story-verify <id>` to runtime-test acceptance criteria
+- `/god-story-close <id>` after verify passes
+
+## What this does NOT do
+
+- Auto-close the story (must explicitly /god-story-close)
+- Run /god-test-runtime (that's /god-story-verify's job)
+- Bypass design-reviewer if STORY changes UI (the standard gate
+  still fires)
+
+
+## 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-story-close.md

@@ -0,0 +1,82 @@
+---
+name: god-story-close
+description: |
+  Mark a STORY done after build + verify pass. Updates status,
+  appends to roadmap milestone, triggers reverse-sync to update
+  Implementation Linkage footers across artifacts.
+
+  Triggers on: "god story close", "/god-story-close", "close story",
+  "mark story done"
+---
+
+# /god-story-close
+
+Final step in the story lifecycle. Sets status to `done`, propagates
+linkage updates.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-story-close <STORY-id>` | Close the named story |
+| `/god-story-close <STORY-id> --skip-verify` | Close without requiring /god-story-verify (use sparingly) |
+
+## Process
+
+1. Parse STORY.md via `lib/story-validator.parseStory`.
+2. Pre-flight checks:
+   - Status is `in-progress` (not pending, not blocked)
+   - At least one commit exists with `// Implements: STORY-{id}`
+   - Unless `--skip-verify`: a /god-story-verify run exists in
+     `.godpowers/runtime/` and ALL acceptance bullets passed
+3. If pre-flight fails: surface specific reason; do not close.
+4. Update status to `done` via `lib/story-validator.setStatus`.
+5. Append to STORY.md `## Notes`: "Closed: <ISO date>".
+6. Trigger `lib/reverse-sync.run()`:
+   - Updates ROADMAP.md milestone with story credit
+   - Refreshes Implementation Linkage footers
+   - May update parent feature's PRD if the feature directory exists
+7. Emit `story.closed` event to events.jsonl.
+
+## Output
+
+- STORY.md `status: done`
+- Notes section gets "Closed: YYYY-MM-DD" appended
+- ROADMAP milestone footer updated (if story was tied to a milestone)
+- Linkage Implementation footers refreshed
+
+## Suggested next
+
+- `/god-stories` to see the updated board
+- `/god-story --feature <slug>` to write the next story in the feature
+- `/god-story-build --next` for the next eligible pending story
+
+## Backward compatibility
+
+- Stories not tied to a milestone close cleanly without affecting
+  ROADMAP.md
+- /god-feature workflow continues to work without ever using stories
+- /god-story-close on a story without an annotated commit warns but
+  can be forced via --skip-verify (logged to events as a yolo decision)
+
+## What this does NOT do
+
+- Run /god-story-verify (must already have run; pre-flight checks)
+- Modify the implementation code
+- Trigger any other workflow automatically
+
+
+## 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-story-verify.md

@@ -0,0 +1,71 @@
+---
+name: god-story-verify
+description: |
+  Run the story's acceptance criteria as headless browser tests.
+  Reuses Phase 11's runtime-test pipeline (parseFlow + headless
+  browser via agent-browser or Playwright).
+
+  Triggers on: "god story verify", "/god-story-verify", "verify story",
+  "test story acceptance"
+---
+
+# /god-story-verify
+
+Validate that the implemented story actually meets its acceptance
+criteria. Headless browser test of each `## Acceptance Criteria` bullet.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-story-verify <STORY-id>` | Run acceptance flows for one story |
+| `/god-story-verify <STORY-id> --url <url>` | Override target URL |
+| `/god-story-verify --all-in-progress` | Verify all in-progress stories |
+
+## Process
+
+1. Parse STORY.md.
+2. Extract `## Acceptance Criteria` bullets.
+3. For each bullet, run `lib/runtime-test.parseFlow(text)`:
+   - If parsable: add to runnable flows
+   - If not: warn and skip (per locked Q4: parseFlow is recommended,
+     not required)
+4. Spawn `god-browser-tester` in `test-only` mode with the parsed flows
+   and the resolved URL.
+5. Aggregate per-bullet pass/fail.
+6. Write report to `.godpowers/runtime/<run-id>/story-{id}-verify.json`.
+7. Surface findings to user.
+
+## Output
+
+```
+Verifying STORY-auth-001
+
+Acceptance criteria (3 bullets):
+  + User clicks Connect, sees Stripe OAuth page
+  + User completes OAuth, lands on dashboard within 30s
+  x User without account is offered signup
+       Reason: "signup link" not visible after expected click
+
+Result: 2/3 passed.
+```
+
+## Backward compatibility
+
+- Acceptance bullets that can't be parsed by parseFlow are warned
+  but not blocked. Some acceptance is inherently human-judged.
+- Stories without `## Acceptance Criteria` warn but don't block;
+  the validator already flagged this.
+- /god-story-verify is opt-in; the story workflow doesn't require it.
+
+## Suggested next
+
+- If all pass: `/god-story-close <id>`
+- If some fail: address findings; possibly revise STORY.md acceptance
+  to be more precise; re-run
+
+## What this does NOT do
+
+- Modify code (verification only)
+- Auto-close passing stories (explicit /god-story-close required)
+- Run design audit (that's `/god-test-runtime audit`)

package/skills/god-story.md

@@ -0,0 +1,55 @@
+---
+name: god-story
+description: |
+  Write a new STORY.md - a fine-grained slice of work, smaller than
+  /god-feature. Story-file workflow for incremental delivery. Spawns
+  god-storyteller in fresh context.
+
+  Triggers on: "god story", "/god-story", "write a story", "user story",
+  "story file"
+---
+
+# /god-story
+
+Add a new story under `.godpowers/stories/<feature-slug>/`.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-story <description>` | Auto-generate ID, write story |
+| `/god-story --feature <slug>` | Attach to a feature (chains to roadmap milestone) |
+| `/god-story --deps STORY-x-001,STORY-y-002` | Declare deps |
+
+## Process
+
+1. Verify `.godpowers/PROGRESS.md` exists. If not: `/god-init` first.
+2. Spawn `god-storyteller` agent in fresh context.
+3. Storyteller reads PRD/ARCH for context, validates user-story format,
+   writes the file.
+4. Report back to user with the new story ID and path.
+
+## Output
+
+`.godpowers/stories/<feature-slug>/STORY-{slug}-{NNN}.md`
+
+## Suggested next
+
+- `/god-story-build <id>` to start implementation
+- `/god-stories` to see all stories
+
+
+## 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.