godpowers 0.15.0

package/skills/god-roadmap.md

@@ -0,0 +1,77 @@
+---
+name: god-roadmap
+description: |
+  Sequence the work into milestones. Spawns the god-roadmapper agent in a
+  fresh context. Gated on Architecture.
+
+  Triggers on: "god roadmap", "/god-roadmap", "sequence the work", "milestone plan"
+---
+
+# /god-roadmap
+
+Spawn the **god-roadmapper** 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-auditor briefly to verify ARCH passes have-nots.
+3. Spawn god-roadmapper with PRD and ARCH paths.
+4. The agent writes `.godpowers/roadmap/ROADMAP.md`.
+
+## Verification
+
+After god-roadmapper returns:
+1. Verify ROADMAP.md exists on disk
+2. Spawn god-auditor to verify have-nots pass
+3. Update `.godpowers/PROGRESS.md`: Roadmap status = done
+
+## On Completion
+
+```
+Roadmap complete: .godpowers/roadmap/ROADMAP.md
+
+Suggested next: /god-stack (pick the tech) if not already done,
+                otherwise /god-repo (scaffold the repo)
+```
+
+
+## Re-invocation contract
+
+What happens if `/god-roadmap` is run when `.godpowers/roadmap/ROADMAP.md` already exists:
+
+| Existing state | Behavior |
+|---|---|
+| File does not exist | Spawn god-roadmapper; 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-roadmapper 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-roadmap --force` to re-run. |
+| `--force` flag passed | Snapshot existing file to `.godpowers/.trash/god-roadmap-<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-roadmap invocation as `op:god-roadmap` for `/god-undo`.
+
+### Idempotency guarantees
+
+- Running `/god-roadmap` twice with no user input between them is a no-op
+  (second call detects the artifact and pauses).
+- Running `/god-roadmap --dry-run` is always read-only.
+- An interrupted `/god-roadmap` (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-rollback.md

@@ -0,0 +1,88 @@
+---
+name: god-rollback
+description: |
+  Walk back a tier and everything downstream. Moves affected artifacts
+  to .godpowers/.trash/ and marks tier statuses as pending. Heavier
+  than /god-undo (which is single-operation). Use when a tier is
+  fundamentally wrong and downstream cleanup is needed.
+
+  Triggers on: "god rollback", "/god-rollback", "roll back tier", "undo
+  the architecture and everything that depends on it"
+---
+
+# /god-rollback
+
+Walk back a tier + every downstream tier in one atomic operation.
+
+## Usage
+
+### `/god-rollback <tier>`
+
+Examples:
+- `/god-rollback arch` - moves ARCH.md, ROADMAP.md, STACK.md,
+  build/, deploy/, observe/, launch/, harden/ to `.trash/rollback-<id>/`.
+  Marks each tier `pending` in state.json.
+- `/god-rollback deploy` - moves deploy/, observe/, launch/, harden/.
+- `/god-rollback build` - moves build/, deploy/, observe/, launch/,
+  harden/. Resets the linkage map for code under those tiers.
+
+## Process
+
+1. Identify the tier from the argument.
+2. Compute the dependency closure: every tier whose `needs:` includes
+   the target tier (transitively).
+3. Show the user what will move and ask for confirmation. This is
+   destructive (recoverable via `/god-restore`, but disruptive).
+4. Move all affected artifacts to `.godpowers/.trash/rollback-<id>/`
+   preserving directory structure.
+5. Mark each tier `status: pending` in state.json.
+6. Append a `op:rollback` event to the reflog with the full closure.
+7. Truncate the linkage map entries belonging to rolled-back artifacts.
+8. Update PROGRESS.md.
+
+## Difference from /god-undo
+
+- `/god-undo`: revert the single most recent operation
+- `/god-rollback`: revert a tier and all downstream work in one atomic op
+
+## Difference from /god-skip
+
+- `/god-skip`: record a decision not to do the work; nothing moves
+- `/god-rollback`: undo work that was already done
+
+## Subcommands
+
+### `/god-rollback --dry-run`
+Show what would move; do nothing.
+
+### `/god-rollback --to=<tier>`
+Roll back to (but not including) a specific tier. Equivalent to rolling
+back the tier immediately after.
+
+## Recovery
+
+Everything goes to `.godpowers/.trash/rollback-<id>/`. Use:
+- `/god-restore` to recover specific files
+- `/god-undo` to undo the rollback as a whole (within reflog window)
+
+## Implementation
+
+Built-in. Reads workflow graph from state.json `tiers` + workflow YAML.
+Writes via `lib/reverse-sync.js` (for linkage truncation) and standard
+fs operations (for artifact move).
+
+
+## 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-scan.md

@@ -0,0 +1,106 @@
+---
+name: god-scan
+description: |
+  Manually trigger a full reverse-sync of the codebase. Scans for
+  linkage annotations, updates the linkage map, runs drift detection,
+  appends fenced footers to artifacts, and surfaces findings to
+  REVIEW-REQUIRED.md.
+
+  Triggers on: "god scan", "/god-scan", "rescan code", "rebuild linkage",
+  "scan codebase"
+---
+
+# /god-scan
+
+Manual full-codebase scan + reverse-sync. Runs the same pipeline that
+god-build, god-feature, god-hotfix etc. trigger automatically (per
+Phase 7 workflow integration). Useful when you want to refresh state
+between automatic triggers, or after manual code edits.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-scan` | Full pipeline: scan + linkage + drift + footers + REVIEW-REQUIRED |
+| `/god-scan --linkage-only` | Just scan + update linkage map (no footers, no drift) |
+| `/god-scan --drift-only` | Just drift detection, using existing linkage |
+| `/god-scan --footers-only` | Just rewrite fenced footers from existing linkage |
+| `/god-scan --json` | JSON summary of the run |
+
+## Process
+
+1. Verify `.godpowers/` exists.
+2. Call `lib/reverse-sync.run(projectRoot)`:
+   - Scan via `lib/code-scanner.scan` (annotations, filenames, style refs)
+   - Apply to linkage map via `lib/code-scanner.applyScan`
+   - Run drift detection via `lib/drift-detector.detectAll`
+   - If impeccable installed and UI files touched: run `npx impeccable detect`
+   - Append fenced footers to PRD, ARCH, ROADMAP, STACK, DESIGN via
+     `lib/reverse-sync.appendFooters`
+   - Surface drift + impeccable findings to REVIEW-REQUIRED.md
+3. Report:
+   - Files scanned, links discovered/added
+   - Drift findings (errors, warnings, infos)
+   - Footers updated
+   - REVIEW-REQUIRED items added
+
+## Fence rules
+
+Fenced footers are wrapped in:
+
+```
+<!-- godpowers:linkage:begin -->
+... auto-generated content ...
+<!-- godpowers:linkage:end -->
+```
+
+Anything outside the fence is yours. /god-scan never touches it.
+Re-running /god-scan replaces the fence with current linkage state
+(idempotent).
+
+## What gets appended where
+
+| Artifact | Footer content |
+|---|---|
+| PRD.md | Each requirement (P-MUST, P-SHOULD, P-COULD) lists implementing files |
+| ARCH.md | Each container lists Source: directories; each ADR lists Pattern: files |
+| ROADMAP.md | Each milestone lists implementing files |
+| STACK/DECISION.md | Each S- decision shows usage count |
+| DESIGN.md | Each token shows usage count; each component shows Implements: files |
+
+## Output
+
+Updates:
+- `.godpowers/links/{artifact-to-code,code-to-artifact}.json`
+- `.godpowers/links/LINKAGE-LOG.md` (append)
+- Fenced sections in PRD.md / ARCH.md / ROADMAP.md / STACK/DECISION.md / DESIGN.md
+- `REVIEW-REQUIRED.md` (append, if drift / impeccable findings)
+- `.godpowers/events.jsonl` (append: linkage events)
+
+User content outside fences is never modified.
+
+## Output to events.jsonl
+
+```json
+{ "name": "scan.start" }
+{ "name": "linkage.snapshot", "coverage-pct": 0.87, "drift-count": 1 }
+{ "name": "drift.detected", "kind": "design-token-drift", ... }
+{ "name": "review-required.populated", "items": 5 }
+{ "name": "scan.end" }
+```
+
+
+## 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-set-profile.md

@@ -0,0 +1,58 @@
+---
+name: god-set-profile
+description: |
+  Switch model profile for Godpowers agents. Different profiles balance
+  quality vs cost vs speed differently. Updates intent.yaml.
+
+  Triggers on: "god set profile", "/god-set-profile", "model profile",
+  "switch model"
+---
+
+# /god-set-profile
+
+Switch the model profile for Godpowers agents.
+
+## Profiles
+
+### quality
+Optimized for output quality. Use the strongest model available.
+- Slower, more expensive
+- Best for production-bound work
+
+### balanced (default)
+Strong model for orchestration and review; cheaper for implementation.
+- Good cost/quality tradeoff for most projects
+
+### budget
+Cheaper model where possible. Quality is acceptable but not maximum.
+- Best for hobby projects or early prototyping
+
+### inherit
+Use whatever the AI tool's default is. No override.
+
+## Process
+
+1. Show current profile (from intent.yaml config.model-profile)
+2. Ask which to set
+3. Update intent.yaml
+4. Confirm
+
+## Output
+
+```
+Model profile: balanced -> quality
+
+Updated .godpowers/intent.yaml.
+
+Effect on next agent spawn:
+  - Orchestrator: opus (was sonnet)
+  - Reviewers: opus (was sonnet)
+  - Executor: sonnet (unchanged)
+
+Override per-command via flags if needed.
+```
+
+## Notes
+
+This is a hint to the AI tool, not a hard contract. Some tools may not
+honor every profile; check tool's docs.

package/skills/god-settings.md

@@ -0,0 +1,44 @@
+---
+name: god-settings
+description: |
+  View or modify project settings stored in .godpowers/intent.yaml.
+  Get/set yolo mode, conservative mode, executor preferences, etc.
+
+  Triggers on: "god settings", "/god-settings", "config", "preferences"
+---
+
+# /god-settings
+
+View or modify project configuration.
+
+## Subcommands
+
+### `/god-settings list`
+Show all settings from intent.yaml.
+
+### `/god-settings get <key>`
+Show a specific setting.
+Example: `/god-settings get config.yolo`
+
+### `/god-settings set <key> <value>`
+Set a value. Validates against schema before writing.
+Example: `/god-settings set config.yolo true`
+
+## Available settings
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| config.yolo | boolean | false | Auto-resolve pauses by default |
+| config.conservative | boolean | false | Pause more often |
+| config.trash-retention-days | int | 30 | When to gc .trash/ |
+| executors.default | string | claude-code | Preferred AI tool |
+| executors.fallback | string | -- | Backup AI tool |
+
+## Output
+
+```
+Settings updated: config.yolo = true
+.godpowers/intent.yaml saved.
+
+Note: this is the project default. Per-command flags still override.
+```

package/skills/god-skip.md

@@ -0,0 +1,78 @@
+---
+name: god-skip
+description: |
+  Explicitly skip a tier or sub-step with an audit reason. The skip is
+  logged so /god-audit and /god-doctor can flag it later. Different
+  from just not running the command: a skip is a recorded decision.
+
+  Triggers on: "god skip", "/god-skip", "skip harden", "skip deploy
+  for now"
+---
+
+# /god-skip
+
+Mark a tier or sub-step as explicitly skipped, with a reason that
+becomes part of the audit trail.
+
+## Usage
+
+### `/god-skip <tier-or-substep> --reason "..."`
+
+Examples:
+- `/god-skip harden --reason "internal-only POC, no public exposure"`
+- `/god-skip deploy --reason "shipping as a library, no deploy needed"`
+- `/god-skip observe --reason "tracked in parent platform's observability"`
+
+The reason is required. Skips without reason are rejected.
+
+## Process
+
+1. Identify the tier or sub-step.
+2. Verify the skip is allowed by the workflow (some sub-steps are
+   mandatory; e.g. /god-mode rejects skipping the final /god-sync).
+3. Mark the sub-step `status: skipped` in state.json with `skipped-reason`.
+4. Append a `op:skip` event to the reflog.
+5. Update PROGRESS.md so the user sees the skip annotated.
+
+## What skip does NOT do
+
+- Skip does not delete or move artifacts; if an artifact was partially
+  produced, use `/god-undo` first then `/god-skip`.
+- Skip does not silence audit findings. `/god-audit` still flags the
+  skip with severity = info (or higher if the skip is risky, e.g.
+  skipping harden in a public-facing project).
+
+## Mandatory non-skippable steps
+
+These cannot be skipped:
+- The final `/god-sync` at end of arc
+- `/god-harden` for projects with `public-facing: true` in intent.yaml
+- Standards gates between tiers (use `/god-standards --override` to bypass with reason)
+
+## Subcommands
+
+### `/god-skip --list`
+Show all currently-skipped sub-steps in the project.
+
+### `/god-skip --unskip <tier-or-substep>`
+Reverse a previous skip. Marks the sub-step `pending` again.
+
+## Implementation
+
+Built-in. Reads + writes `state.json` and PROGRESS.md. Appends to reflog.
+
+
+## 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-smite.md

@@ -0,0 +1,86 @@
+---
+name: god-smite
+description: |
+  Hard reset of the project's node-style dependency cache: delete
+  node_modules / .venv / vendor / target / .next / dist / .nuxt /
+  .turbo / .nx as applicable, then reinstall. For when "have you tried
+  turning it off and on again" applies to the dependency layer.
+
+  Triggers on: "god smite", "/god-smite", "nuke node_modules", "clean
+  reinstall", "dep cache is broken"
+---
+
+# /god-smite
+
+Nuke the dependency cache. Reinstall fresh.
+
+## What it deletes
+
+Stack-aware. Detects from `package.json` / `pyproject.toml` / `go.mod`
+/ `Cargo.toml` / etc., then nukes the appropriate caches:
+
+| Stack | Deletes |
+|---|---|
+| Node (npm) | `node_modules/`, `package-lock.json` (if `--lock` flag) |
+| Node (pnpm) | `node_modules/`, `pnpm-lock.yaml` (if `--lock`) |
+| Node (yarn) | `node_modules/`, `yarn.lock` (if `--lock`) |
+| Python | `.venv/`, `__pycache__/`, `*.egg-info/` |
+| Go | `vendor/` (if present) |
+| Rust | `target/` |
+| Next.js | also `.next/` |
+| Nuxt | also `.nuxt/` |
+| Turborepo | also `.turbo/` |
+| Nx | also `.nx/cache/` |
+
+Also clears common build outputs: `dist/`, `build/`, `out/` (only if
+they're not git-tracked).
+
+## What it does NOT delete
+
+- Source code (anything tracked by git)
+- `.godpowers/` artifacts
+- `node_modules/` inside `.godpowers/` if any
+- Lock files (unless `--lock` is passed)
+- Anything matched by `.gitignore` exclusions outside the cache list
+
+## Process
+
+1. Detect the stack from config files.
+2. Build the deletion list. Show it to the user.
+3. Confirm. This step is destructive (recoverable only from git).
+4. Delete each path with progress output.
+5. Run the corresponding install command:
+   - `npm install` / `pnpm install` / `yarn install`
+   - `python -m venv .venv && pip install -r requirements.txt`
+   - `cargo build` (rebuilds target/)
+6. Report final disk space reclaimed and time elapsed.
+
+## Subcommands
+
+### `/god-smite --dry-run`
+Show what would be deleted; do nothing.
+
+### `/god-smite --lock`
+Also delete the lock file (forces version re-resolution).
+
+### `/god-smite --no-install`
+Delete but don't reinstall.
+
+### `/god-smite --gentle`
+Don't delete `node_modules/`; just run `npm ci` or equivalent.
+
+## Difference from /god-update-deps
+
+- `/god-smite`: hard reset because something is broken
+- `/god-update-deps`: deliberate update with CVE awareness and bisect-able commits
+
+## Safety
+
+- Never runs in a dir without a recognized stack file (refuses early).
+- Never deletes anything tracked by git.
+- Appends `op:smite` event to reflog (lists what was deleted).
+
+## Implementation
+
+Built-in. Reads package.json / pyproject.toml / Cargo.toml / etc. for
+stack detection. Uses `child_process` to run the install command.

package/skills/god-spike.md

@@ -0,0 +1,120 @@
+---
+name: god-spike
+description: |
+  Time-boxed research spike. Builds a minimal proof of concept to answer one
+  specific technical question, documents findings, then stops. Spike code
+  does NOT merge to main; it answers a question, then either gets deleted or
+  rewritten cleanly in a real feature workflow.
+
+  Triggers on: "god spike", "/god-spike", "research spike", "prototype",
+  "proof of concept", "POC", "explore feasibility"
+---
+
+# /god-spike
+
+Time-boxed research spike.
+
+## When to use
+
+- You have a specific technical question to answer
+- A 1-day proof of concept would resolve it
+- You don't want to commit to building until you know more
+
+Examples:
+- "Can our existing schema handle multi-tenancy?"
+- "Will this third-party API meet our latency budget?"
+- "Does the new framework let us delete the auth middleware?"
+
+## When NOT to use
+
+- The question is too broad ("should we use GraphQL?"): narrow it first via
+  /god-explore
+- You already know the answer: just /god-feature it
+- Time-box would exceed 3 days: that's a feature, scope it down
+
+## Setup
+
+Ask the user:
+- The specific question (one sentence)
+- The time-box (default: 1 day)
+- What evidence would answer it (so the spike knows what to measure)
+
+## Orchestration
+
+### Phase 1: Run the spike (god-spike-runner)
+Spawn **god-spike-runner** in fresh context with:
+- The exact question
+- The time-box
+- The success criteria
+
+The agent:
+- Builds the smallest possible proof
+- Hard-codes inputs, no real interface
+- Measures or tests as needed
+- Documents findings honestly
+
+### Phase 2: No further phases
+- No build pipeline
+- No deploy
+- No observe
+- No harden
+- No launch
+
+The spike answers a question. That's it.
+
+## After the Spike
+
+The user reviews the SPIKE.md and decides:
+- **Proceed**: route to /god-feature with the spike's recommendation
+- **Reject**: archive the spike, document why
+- **Follow-up spike**: another /god-spike with a narrower question
+
+## On Completion
+
+```
+Spike complete: .godpowers/spikes/<question-slug>/SPIKE.md
+
+Time-boxed: [N hours]
+Time spent: [actual]
+
+Recommendation: [DECISION from spike]
+
+Suggested next:
+  - If proceeding: /god-feature with this recommendation
+  - If rejecting: archive .godpowers/spikes/<question-slug>/
+  - If unclear: /god-spike with narrower question
+
+REMINDER: spike code is throwaway. Do NOT merge to main.
+```
+
+## Have-Nots
+
+Spike FAILS if:
+- Built a feature instead of a proof
+- No measurable evidence in findings
+- "It depends" with no decision support
+- Spike code merged to main
+- Time-boxed exceeded without escalation
+
+## 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`.