godpowers 0.15.0

package/skills/god-pause-work.md

@@ -0,0 +1,64 @@
+---
+name: god-pause-work
+description: |
+  Pause work mid-task. Captures the current state, what was being worked on,
+  open threads, and next steps so a future session can resume cleanly.
+  Writes to .godpowers/HANDOFF.md.
+
+  Triggers on: "god pause", "/god-pause-work", "pause work", "save context",
+  "I need to stop"
+---
+
+# /god-pause-work
+
+Create a context handoff so you can resume cleanly later.
+
+## Process
+
+1. Read `.godpowers/PROGRESS.md` to capture current state
+2. Identify what was actively being worked on:
+   - Which slice? Which agent was running?
+   - What was the next step?
+   - What was blocked?
+3. Capture conversation context:
+   - Decisions made this session
+   - Open questions raised
+   - Things the user mentioned that aren't yet in artifacts
+4. Write `.godpowers/HANDOFF.md`:
+
+```markdown
+# Godpowers Handoff
+
+Paused: [timestamp]
+
+## Where We Were
+[Specific tier, sub-step, slice if applicable]
+
+## Active Work
+[What was in flight when we paused]
+
+## Open Threads
+- [Unresolved item 1]
+- [Unresolved item 2]
+
+## Decisions This Session
+- [Decision] (recorded in [artifact])
+- [Decision] (verbal, needs to be added to [artifact])
+
+## Next Steps
+- [Specific next action]
+- [Specific next action]
+
+## Resume With
+`/god-resume-work` to load this context, then continue.
+```
+
+5. Update PROGRESS.md to mark current sub-step as `in-flight` if not already
+
+## On Completion
+
+```
+Work paused. Handoff written: .godpowers/HANDOFF.md
+
+To resume: open a new session and run /god-resume-work
+```

package/skills/god-plant-seed.md

@@ -0,0 +1,59 @@
+---
+name: god-plant-seed
+description: |
+  Capture a forward-looking idea with trigger conditions. Surfaces
+  automatically when the trigger fires (e.g., "when MRR > $5k, revisit
+  pricing"). Stored in .godpowers/seeds/.
+
+  Triggers on: "god plant seed", "/god-plant-seed", "for the future",
+  "when X happens"
+---
+
+# /god-plant-seed
+
+Capture an idea that should surface later when conditions are right.
+
+## When to use
+
+- "When we hit 1000 users, we should revisit our database design"
+- "When the next major Node version drops, evaluate the new fetch API"
+- "When team size > 5, introduce sprint ceremonies"
+
+## Process
+
+1. Take the idea + trigger condition from the user
+2. Write to `.godpowers/seeds/<seed-id>.md`:
+
+```markdown
+# Seed: [short name]
+
+Date planted: [ISO 8601]
+Trigger: [specific condition]
+Idea: [what to do when triggered]
+Source: [conversation context]
+Status: dormant
+```
+
+3. The seed lies dormant until /god-status or another command checks if
+   the trigger condition is met.
+
+## Trigger types
+
+- **Metric-based**: "When MRR > $5k"
+- **Time-based**: "In 3 months, revisit"
+- **Event-based**: "After first major incident"
+- **Tool-based**: "When Node 24 is released"
+
+## Subcommands
+
+### `/god-plant-seed <description>`
+Plant a seed.
+
+### `/god-plant-seed list`
+Show all dormant seeds.
+
+### `/god-plant-seed check`
+Check all seeds against current state. Surface any with met triggers.
+
+### `/god-plant-seed harvest <id>`
+Mark a seed as acted upon (route to /god-feature or /god-add-todo).

package/skills/god-postmortem.md

@@ -0,0 +1,103 @@
+---
+name: god-postmortem
+description: |
+  Post-incident investigation. Builds timeline, identifies root cause AND
+  class-of-bug, produces action items with owners and due dates, updates
+  runbooks. Blameless framing.
+
+  Triggers on: "god postmortem", "/god-postmortem", "incident review",
+  "after-action", "root cause analysis", "what happened"
+---
+
+# /god-postmortem
+
+Investigate an incident after resolution.
+
+## When to use
+
+- An incident has been resolved (or is being resolved)
+- You need to prevent the class of bug, not just this instance
+- You're following up after /god-hotfix
+
+## When NOT to use
+
+- Incident is still active: use /god-debug or /god-hotfix
+- Bug found in dev (no incident): use /god-debug
+
+## Setup
+
+Ask the user:
+- Incident ID or short title
+- When it started (rough)
+- When it was resolved
+- Who responded
+- The hotfix commit SHA if applicable
+
+## Orchestration
+
+Spawn **god-incident-investigator** in fresh context with the incident metadata.
+
+The agent:
+1. Builds the timeline from logs, events, git history
+2. Identifies root cause via 5-whys or causal chain
+3. Identifies class-of-bug (broader pattern)
+4. Drafts blameless action items with owners and due dates
+5. Updates relevant runbooks
+6. Writes POSTMORTEM.md
+
+## After the Investigator Returns
+
+Optionally spawn **god-docs-writer** to:
+- Update relevant runbooks
+- Update on-call documentation if applicable
+- Update architecture docs if the incident revealed a structural issue
+
+## On Completion
+
+```
+Postmortem complete: .godpowers/postmortems/<incident-id>/POSTMORTEM.md
+
+Severity: SEV-[N]
+Root cause: [one line]
+Class of bug: [pattern]
+Action items: [N], with owners and due dates
+
+Suggested next:
+  - Schedule a blameless review meeting if multi-person team
+  - /god-status to see action items in PROGRESS.md
+  - /god-feature to prioritize the highest-priority action item
+```
+
+## Have-Nots
+
+Postmortem FAILS if:
+- Action items are vague ("communicate better", "more tests")
+- Action items have no owner or due date
+- Phrasing blames individuals instead of systems
+- Root cause is symptom-level
+- No class-of-bug identified
+- Runbooks not updated
+- Timeline has gaps without acknowledging unknowns
+
+## 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-pr-branch.md

@@ -0,0 +1,50 @@
+---
+name: god-pr-branch
+description: |
+  Create a clean PR branch by filtering out .godpowers/ commits. Useful when
+  shipping to a public repo where reviewers don't need the planning artifacts.
+
+  Triggers on: "god pr branch", "/god-pr-branch", "clean PR", "PR ready",
+  "filter planning"
+---
+
+# /god-pr-branch
+
+Create a code-only branch for PR review.
+
+## When to use
+
+- Open source repo where .godpowers/ shouldn't ship
+- Working repo separate from planning repo
+- PR reviewers complaining about noise
+
+## Process
+
+1. From current branch, identify commits since main
+2. For each commit:
+   - If it touches code only: cherry-pick to new branch
+   - If it touches both code and .godpowers/: split. Keep the code commit;
+     drop the .godpowers/ commit (already exists on the original branch).
+   - If it touches only .godpowers/: skip
+3. Create new branch `pr/<original-branch-name>`
+4. Push to remote
+5. Show the user the PR URL to create
+
+## Output
+
+```
+PR branch created: pr/feature-x
+Commits: N (filtered from M originals)
+Push: success
+
+Create PR: https://github.com/<repo>/compare/main...pr/feature-x
+
+Original branch (with planning artifacts): feature-x
+PR branch (code only): pr/feature-x
+```
+
+## Have-Nots
+
+- PR branch contains .godpowers/ files (filter failed)
+- PR branch is missing code changes that the original had
+- Force-pushed over an existing PR branch (must be a new branch each run)

package/skills/god-prd.md

@@ -0,0 +1,90 @@
+---
+name: god-prd
+description: |
+  Write a Product Requirements Document with mechanical quality enforcement.
+  Spawns the god-pm specialist agent in a fresh context.
+
+  Triggers on: "god prd", "/god-prd", "write the prd", "product requirements"
+---
+
+# /god-prd
+
+Spawn the **god-pm** agent in a fresh context via Task tool.
+
+## Setup
+
+1. If `.godpowers/PROGRESS.md` does not exist: tell the user to run `/god-init` first
+2. Otherwise: spawn god-pm with the user's project description from PROGRESS.md
+3. The agent writes `.godpowers/prd/PRD.md`
+4. The agent runs have-nots checks before declaring done
+5. If god-pm pauses for a human question: relay to user using pause format
+
+## Verification
+
+After god-pm returns:
+1. Verify `.godpowers/prd/PRD.md` exists on disk
+2. Spawn god-auditor briefly to verify have-nots pass
+3. Update `.godpowers/PROGRESS.md`: PRD status = done
+
+## Pause Format
+
+```
+PAUSE: [question]
+Why: [why only you can answer]
+Options:
+  A: ... -- [tradeoff]
+  B: ... -- [tradeoff]
+Default: [if you say "go", I'll pick X because Y]
+```
+
+## On Completion
+
+After PRD is written and have-nots pass, print:
+
+```
+PRD complete: .godpowers/prd/PRD.md
+
+Suggested next: /god-arch (design the architecture)
+```
+
+
+## Re-invocation contract
+
+What happens if `/god-prd` is run when `.godpowers/prd/PRD.md` already exists:
+
+| Existing state | Behavior |
+|---|---|
+| File does not exist | Spawn god-pm; 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-pm 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-prd --force` to re-run. |
+| `--force` flag passed | Snapshot existing file to `.godpowers/.trash/god-prd-<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-prd invocation as `op:god-prd` for `/god-undo`.
+
+### Idempotency guarantees
+
+- Running `/god-prd` twice with no user input between them is a no-op
+  (second call detects the artifact and pauses).
+- Running `/god-prd --dry-run` is always read-only.
+- An interrupted `/god-prd` (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-quick.md

@@ -0,0 +1,50 @@
+---
+name: god-quick
+description: |
+  Execute a small task with Godpowers atomic commits and TDD discipline, but
+  skip optional gates (no PRD, no ARCH, no roadmap). For tasks too big for
+  /god-fast but too small for /god-build.
+
+  Triggers on: "god quick", "/god-quick", "small task", "minor feature"
+---
+
+# /god-quick
+
+Run a focused task with TDD and atomic commits, but skip the full planning
+arc.
+
+## When to use
+
+- One small feature with clear scope (1-3 hours of work)
+- Refactor with regression risk (TDD matters here)
+- Bug fix that needs a regression test
+
+## Process
+
+1. Ask the user for the task description (one paragraph max)
+2. Skip PRD, ARCH, ROADMAP, STACK
+3. Spawn god-planner directly with the task description (treat it as a single slice)
+4. Spawn god-executor for the slice (TDD enforced)
+5. Spawn god-spec-reviewer + god-quality-reviewer
+6. Atomic commit on pass
+
+## What still applies
+
+- TDD enforcement
+- Two-stage review
+- Atomic commit
+- Have-nots check on the code
+
+## What's skipped
+
+- Planning tier (PRD/ARCH/ROADMAP/STACK)
+- Build planning into waves (single slice only)
+- PROGRESS.md updates if no `.godpowers/` exists
+
+## On Completion
+
+```
+Quick task complete.
+Test results: [N] passed
+Commit: [SHA]
+```

package/skills/god-reconcile.md

@@ -0,0 +1,90 @@
+---
+name: god-reconcile
+description: |
+  Comprehensive reconciliation across all impacted artifacts before doing
+  feature work. Checks PRD, ARCH, ROADMAP, STACK, REPO, DEPLOY, OBSERVE,
+  HARDEN, LAUNCH, BACKLOG, SEEDS, TODOS, THREADS in parallel. Replaces
+  /god-roadmap-check (kept for back-compat; this is the comprehensive version).
+
+  Triggers on: "god reconcile", "/god-reconcile", "check all", "full check",
+  "where does this fit", "what does this touch"
+---
+
+# /god-reconcile
+
+Multi-artifact reconciliation before feature work.
+
+## When auto-invoked
+
+When the user describes feature intent and the matched recipe is in the
+`feature-addition` category, /god-next automatically calls /god-reconcile
+before showing the recipe sequence.
+
+## When manually invoked
+
+User runs `/god-reconcile` with an intent description. Useful for:
+- Sanity check before starting any non-trivial work
+- "Where does this fit in the existing system?"
+- Resolving overlap between intent and existing artifacts
+
+## Setup
+
+1. Verify `.godpowers/` exists. If not: nothing to reconcile against; suggest /god-init.
+2. Spawn god-reconciler in fresh context with the intent.
+
+## Verification
+
+After god-reconciler returns:
+1. Verify all 13 artifact statuses are reported (no silent skips)
+2. Display structured verdict to user
+3. Present recommended sequence (preflight + main work + post-work)
+4. Await user decision
+
+## Output
+
+```
+Reconciliation: <intent>
+
+Where this intersects existing artifacts:
+
+Tier 1 (Planning):
+  PRD:        [status] [action if needed]
+  ARCH:       [status] [action if needed]
+  ROADMAP:    [status] [match if any]
+  STACK:      [status]
+
+Tier 2 (Building):
+  REPO:       [status]
+  BUILD:      [status]
+
+Tier 3 (Shipping):
+  DEPLOY:     [status]
+  OBSERVE:    [status]
+  HARDEN:     [status]
+  LAUNCH:     [status]
+
+Capture:
+  BACKLOG:    [status] [match if any]
+  SEEDS:      [status] [match if any]
+  TODOS:      [status] [match if any]
+  THREADS:    [status] [match if any]
+
+Recommended sequence:
+  Preflight:  [/god-redo prd, /god-arch delta-only]
+  Main work:  [/god-feature scoped to Milestone 2]
+  Post-work:  [/god-sync]
+
+Run? (yes / show alternatives / cancel)
+```
+
+## Difference from /god-roadmap-check
+
+| | /god-roadmap-check | /god-reconcile |
+|---|---|---|
+| Scope | ROADMAP only | All 13 artifacts |
+| Use | Quick check | Comprehensive |
+| Auto-invoked | by feature-addition recipes (legacy) | by feature-addition recipes (preferred) |
+| Replaces | -- | /god-roadmap-check (kept for back-compat) |
+
+For new projects, prefer /god-reconcile. /god-roadmap-check remains a
+narrower tool for when you only care about milestone overlap.

package/skills/god-reconstruct.md

@@ -0,0 +1,72 @@
+---
+name: god-reconstruct
+description: |
+  Reverse-engineer Godpowers planning artifacts (PRD, ARCH, ROADMAP, STACK)
+  from existing code. Lets brownfield projects use the full reconciliation
+  system without rewriting planning from scratch.
+
+  Triggers on: "god reconstruct", "/god-reconstruct", "reverse engineer",
+  "derive prd", "extract planning"
+---
+
+# /god-reconstruct
+
+Derive planning artifacts from existing code.
+
+## When to use
+
+- Brownfield project without `.godpowers/` planning artifacts
+- Need to use /god-reconcile or /god-feature on existing code
+- Want a starting point for stakeholder review of the project's "shape"
+
+## Setup
+
+1. Verify codebase exists (Mode B)
+2. Optional: run /god-archaeology first for richer input
+3. Spawn god-reconstructor in fresh context
+
+## Verification
+
+- All four artifacts created at `.godpowers/<tier>/`:
+  - prd/PRD.md
+  - arch/ARCH.md (+ adr/)
+  - roadmap/ROADMAP.md
+  - stack/DECISION.md
+- Each has reconstruction warning at top
+- Each section tagged with confidence level (HIGH/MEDIUM/LOW)
+- Open questions explicitly listed
+- `.godpowers/RECONSTRUCTION-LOG.md` written
+
+## On Completion
+
+```
+Reconstruction complete.
+
+Artifacts derived from code:
+  + prd/PRD.md            (HIGH/MEDIUM/LOW per section)
+  + arch/ARCH.md          (HIGH/MEDIUM/LOW per section)
+  + roadmap/ROADMAP.md    (Done section preserved)
+  + stack/DECISION.md     (flip points marked OPEN QUESTION)
+
+Open questions for stakeholder review: [N]
+Reconstruction log: .godpowers/RECONSTRUCTION-LOG.md
+
+CRITICAL: these are reconstructed, not authoritative. Schedule
+stakeholder review within 1-2 weeks. Treat as starting point.
+
+Suggested next:
+  /god-audit       - score the reconstructed artifacts
+  /god-feature     - now you can add features with reconciliation
+  /god-tech-debt   - assess what needs paying down
+```
+
+## Caveats
+
+Reconstruction is lossy:
+- Original intent may be wrong-inferred
+- Decisions never written down stay unknown
+- Future plans living in someone's head are absent
+- The reconstructed PRD may not match what stakeholders actually want NOW
+
+Always recommend stakeholder review before treating reconstructed artifacts
+as authoritative.

package/skills/god-redo.md

@@ -0,0 +1,73 @@
+---
+name: god-redo
+description: |
+  Re-run a tier or sub-step that already completed. Useful when an
+  upstream change invalidates downstream work, or when the user wants
+  a fresh pass with different parameters. Pairs with /god-undo for
+  full revert + rerun.
+
+  Triggers on: "god redo", "/god-redo", "rerun tier", "redo arch",
+  "regenerate the prd"
+---
+
+# /god-redo
+
+Re-run a tier or sub-step.
+
+## Usage
+
+### `/god-redo <tier-or-substep>`
+Examples:
+- `/god-redo prd` (re-run god-pm)
+- `/god-redo arch` (re-run god-architect; warn if downstream tiers exist)
+- `/god-redo build` (re-run god-planner + executor + reviewers)
+- `/god-redo tier-1` (re-run all of planning)
+
+## Process
+
+1. Identify the tier or sub-step from the argument.
+2. If it has downstream completed work in state.json: warn the user.
+   Options: A) `/god-rollback` first to clean state, B) overwrite in
+   place (downstream may go stale), C) cancel.
+3. Snapshot the current artifact to `.godpowers/.trash/redo-<id>/` so
+   `/god-undo` can revert.
+4. Re-spawn the producing agent in fresh context.
+5. Verify with `/god-standards` if a routing config exists for the
+   sub-step.
+6. Update state.json + append a `op:redo` event to the reflog.
+
+## Difference from /god-undo + run-again
+
+- `/god-undo` then run-again: two operations, easier to reason about.
+- `/god-redo`: single operation, atomic in the reflog. Use when you
+  know you want a redo.
+
+## Subcommands
+
+### `/god-redo --dry-run`
+Show what would be re-run and what downstream work would be marked stale.
+
+### `/god-redo --force`
+Skip the downstream-stale warning. Use with care.
+
+## Implementation
+
+Built-in. Reads state.json to find the sub-step. Spawns the same agent
+that originally produced the artifact. Updates the linkage map via
+`/god-scan` after the artifact is rewritten.
+
+
+## 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.