godpowers 0.15.0

package/skills/god-lifecycle.md

@@ -0,0 +1,119 @@
+---
+name: god-lifecycle
+description: |
+  Show where the project is in its lifecycle and what workflows make sense
+  next. Distinguishes: pre-init, planning, building, shipping, steady state,
+  in-incident, in-migration. Suggests appropriate workflows for each.
+
+  Triggers on: "god lifecycle", "/god-lifecycle", "where am I", "what now",
+  "project phase"
+---
+
+# /god-lifecycle
+
+Show project phase and contextually appropriate workflows.
+
+## Process
+
+1. Detect lifecycle phase from disk:
+   - **No `.godpowers/`** -> Pre-init
+   - **`.godpowers/PROGRESS.md` exists, not all tiers done** -> In-arc
+   - **All tiers done, no special markers** -> Steady state
+   - **`.godpowers/postmortems/<id>/` exists with no POSTMORTEM.md** -> Post-incident pending
+   - **`.godpowers/migrations/<slug>/MIGRATION.md` exists, status != complete** -> In-migration
+   - **`.godpowers/spikes/` has any inconclusive entries** -> Spike pending follow-up
+
+2. Display the phase with context.
+
+3. Suggest workflows appropriate to the phase.
+
+## Output Format
+
+### Pre-init
+```
+Lifecycle: Pre-init (no Godpowers project here)
+
+Available actions:
+  /god-init     Initialize a Godpowers project
+  /god-explore  Brainstorm before committing
+  /god-mode     Run full autonomous arc (will init first)
+```
+
+### In-arc
+```
+Lifecycle: In-arc (planning/building/shipping)
+
+Current state:
+  PRD:          [done/pending]
+  Architecture: [done/pending]
+  ...
+
+Suggested next: [via /god-next logic]
+
+Or run /god-mode to autonomously continue from here.
+```
+
+### Steady state
+```
+Lifecycle: Steady state (full-arc complete, in maintenance)
+
+Last full audit: [N days ago]
+Last dep audit: [N days ago]
+Last docs check: [N days ago]
+
+For ongoing work:
+  Adding features:        /god-feature
+  Production bugs:        /god-hotfix
+  Code cleanup:           /god-refactor
+  Research questions:     /god-spike
+  Framework upgrades:     /god-upgrade
+  Documentation:          /god-docs
+  Dependency updates:     /god-update-deps
+
+Periodic (recommended cadence):
+  /god-hygiene every 30 days
+  /god-audit before milestones
+
+Or describe what you want; /god-next will route.
+```
+
+### Post-incident pending
+```
+Lifecycle: Post-incident pending
+
+Incident detected: [.godpowers/postmortems/<id>/]
+No POSTMORTEM.md yet.
+
+REQUIRED next: /god-postmortem
+This is overdue if hotfix was >48 hours ago.
+```
+
+### In-migration
+```
+Lifecycle: In-migration
+
+Migration: [from -> to]
+Status: [expanding / migrating / contracting]
+Slices done: N/M
+
+Continue with: /god-upgrade
+Or pause and switch context: /god-pause-work
+```
+
+### Spike pending follow-up
+```
+Lifecycle: Spike pending follow-up
+
+Inconclusive spike: .godpowers/spikes/<slug>/SPIKE.md
+Recommended follow-up: [from spike's recommendation]
+
+Suggested next: /god-spike with narrower question
+Or: archive the spike if no longer relevant
+```
+
+## Have-Nots
+
+Lifecycle check FAILS if:
+- Multiple lifecycle phases detected without resolution (data inconsistency)
+- Lifecycle phase doesn't match disk reality (drift)
+- Suggestions don't match phase

package/skills/god-link.md

@@ -0,0 +1,90 @@
+---
+name: god-link
+description: |
+  Manually add or remove a code-artifact link in the linkage map. Most
+  links are discovered automatically by /god-scan and reverse-sync via
+  comment annotations; this skill handles cases where annotations are
+  awkward or impossible.
+
+  Triggers on: "god link", "/god-link", "manually link", "associate file with"
+---
+
+# /god-link
+
+Add or remove a manual link between an artifact ID and a code file.
+
+## Forms
+
+| Form | Action |
+|---|---|
+| `/god-link <artifact-id> <path>` | Add link |
+| `/god-link --remove <artifact-id> <path>` | Remove link |
+| `/god-link --query-artifact <artifact-id>` | List files linked to this ID |
+| `/god-link --query-file <path>` | List artifact IDs linked to this file |
+| `/god-link --orphans` | List artifact IDs with no linked files |
+
+## Stable ID format
+
+| Artifact | ID format | Example |
+|---|---|---|
+| PRD requirement | `P-{MUST,SHOULD,COULD}-NN` | `P-MUST-01` |
+| ADR | `ADR-NNN` | `ADR-007` |
+| ARCH container | `C-{slug}` | `C-auth-service` |
+| ROADMAP milestone | `M-{slug}` | `M-launch-v1` |
+| STACK decision | `S-{slug}` | `S-postgres-15` |
+| DESIGN token | YAML path | `colors.primary` |
+| DESIGN component | `D-{slug}` | `D-button-primary` |
+
+## Process
+
+1. Verify `.godpowers/` exists.
+2. Validate the artifact ID matches one of the stable ID patterns. If
+   not: refuse with a hint about the format.
+3. Resolve the file path relative to project root.
+4. Call `lib/linkage.addLink(projectRoot, artifactId, filePath)` or
+   `removeLink(...)`.
+5. Append to `.godpowers/links/LINKAGE-LOG.md`.
+6. Report.
+
+## When to use this vs comment annotations
+
+Prefer comment annotations:
+
+```ts
+// Implements: P-MUST-01
+function login(...) { }
+```
+
+This is the primary path. The scanner picks it up automatically.
+
+Use `/god-link` when:
+
+- The file is generated (e.g., compiled output) and cannot host a comment
+- The link is conceptual (e.g., "this template implements P-MUST-03")
+- You're adding a link discovered through another tool that doesn't
+  modify source files
+
+## Output
+
+Updates:
+- `.godpowers/links/artifact-to-code.json`
+- `.godpowers/links/code-to-artifact.json`
+- `.godpowers/links/LINKAGE-LOG.md` (append)
+
+No source files are modified by this skill.
+
+
+## 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-lint.md

@@ -0,0 +1,128 @@
+---
+name: god-lint
+description: |
+  Mechanically validate Godpowers artifacts against the have-nots catalog.
+  Returns structured findings (errors, warnings, info) with line numbers
+  and remediation suggestions. Backed by lib/artifact-linter.js.
+
+  Triggers on: "god lint", "/god-lint", "lint artifact", "validate prd",
+  "check artifact", "validate artifact", "artifact errors"
+---
+
+# /god-lint
+
+Mechanically validate one or more Godpowers artifacts against the
+have-nots catalog. Real validation, not self-attestation. Catches:
+
+- Em/en dashes (U-08), decorative emoji (U-09)
+- Unlabeled sentences (U-02)
+- Phantom references (U-10)
+- Future-dated timestamps in body content (U-11)
+- Generic claims that fail the substitution test (U-01)
+- PRD have-nots: metric without timeline / method, empty no-gos, open
+  questions without owner / due date (P-04, P-05, P-07, P-08, P-09)
+- ARCH have-nots: NFR not mapped to architectural choice (A-04)
+
+More mechanical have-nots wired in over time. Interpretive checks (e.g.,
+"is the architecture actually good") remain agent-mediated.
+
+## Forms
+
+| Form | What it does |
+|---|---|
+| `/god-lint` | Lint every known artifact in `.godpowers/` and project root |
+| `/god-lint <path>` | Lint one specific file (e.g., `.godpowers/prd/PRD.md`) |
+| `/god-lint --json` | Output structured JSON instead of human report |
+| `/god-lint --errors-only` | Show only error-severity findings |
+
+## Process
+
+1. Verify `.godpowers/` exists. If not: "Run `/god-init` first."
+2. Resolve target paths:
+   - With argument: just that file
+   - Without: scan `.godpowers/{prd,arch,roadmap,stack,design}/` plus
+     `DESIGN.md` and `PRODUCT.md` at project root
+3. For each target:
+   - Detect artifact type from path
+   - Load file content
+   - Call `lib/artifact-linter.lintFile(path, opts)`
+   - Aggregate findings
+4. Format output (human-readable by default, JSON if `--json`)
+5. Exit with non-zero if any errors
+
+## Output (human format)
+
+```
+/god-lint report
+
+.godpowers/prd/PRD.md
+  Type: prd
+  Errors: 2, Warnings: 1, Info: 0
+  [P-04] ERROR line 24: Success metric without timeline.
+         -> Add a time bound to make the metric measurable.
+  [P-08] ERROR line 67: Open question "Pricing model?" has no named owner.
+         -> Assign a named owner.
+  [U-02] WARNING line 12: Unlabeled sentence: "We will build the best..."
+         -> Tag with [DECISION], [HYPOTHESIS], or [OPEN QUESTION].
+
+.godpowers/arch/ARCH.md
+  Type: arch
+  Errors: 0, Warnings: 0, Info: 0
+  Clean: no findings.
+
+Aggregate: 2 errors, 1 warning, 0 info across 2 files.
+```
+
+## Output (JSON format)
+
+```json
+{
+  "results": [
+    {
+      "path": ".godpowers/prd/PRD.md",
+      "type": "prd",
+      "summary": { "errors": 2, "warnings": 1, "infos": 0 },
+      "findings": [
+        {
+          "code": "P-04",
+          "severity": "error",
+          "line": 24,
+          "message": "Success metric without timeline.",
+          "suggestion": "Add a time bound to make the metric measurable."
+        }
+      ]
+    }
+  ],
+  "aggregate": { "errors": 2, "warnings": 1, "infos": 0, "files": 2 }
+}
+```
+
+## Integration with workflows
+
+Every Tier 1+ agent must call `/god-lint` (or invoke the linter directly
+via `lib/artifact-linter.js`) before declaring its sub-step done. If
+errors exist, the agent must address them before advancing. Warnings
+are surfaced but do not block.
+
+`/god-mode --yolo` does not bypass lint errors. Errors are mechanical
+signal that something is structurally wrong; auto-resolving them would
+violate the system's quality contract.
+
+## Mechanical vs interpretive
+
+This skill catches the mechanical have-nots only. Interpretive checks
+("is the problem statement actually clear", "do these decisions make
+sense") remain the responsibility of `god-auditor` (retroactive scoring)
+and `god-spec-reviewer` / `god-quality-reviewer` (per-artifact two-stage
+review).
+
+The catalog of 99 have-nots is split:
+- ~30 mechanical (cataloged in `lib/have-nots-validator.js`)
+- ~69 interpretive (delegated to agents)
+
+This split is published in `references/HAVE-NOTS.md` per check.
+
+## Output
+
+No new artifacts. Findings go to stdout (or JSON). Exit code reflects
+error count.

package/skills/god-list-assumptions.md

@@ -0,0 +1,56 @@
+---
+name: god-list-assumptions
+description: |
+  Surface Claude's assumptions about a phase approach before planning.
+  Lists what's being taken for granted so the user can flag wrong ones
+  before they cement into decisions.
+
+  Triggers on: "god list assumptions", "/god-list-assumptions", "what assumptions",
+  "what are you assuming"
+---
+
+# /god-list-assumptions
+
+Surface assumptions before they harden into decisions.
+
+## When to use
+
+- Before /god-feature: what's Claude assuming about the existing system?
+- Before /god-build: what's Claude assuming about the user's preferences?
+- Before /god-upgrade: what's Claude assuming about current state?
+
+## Process
+
+1. Read the active context (what command is queued, what artifacts exist)
+2. Spawn god-explorer in fresh context with focus="assumptions-only":
+   - List 5-10 assumptions you're operating under
+   - Tag each: [HIGH-CONFIDENCE] / [MEDIUM] / [LOW-CONFIDENCE]
+   - For [LOW-CONFIDENCE]: flag explicitly for user verification
+3. Present to user; ask which (if any) are wrong
+
+## Output
+
+```
+Assumptions Claude is operating under:
+
+[HIGH-CONFIDENCE]
+1. The existing codebase uses TypeScript (verified: package.json)
+2. Tests live in tests/ directory (verified: filesystem)
+
+[MEDIUM]
+3. The team has experience with React (inferred from existing code)
+4. Production runs on Node 20 (inferred from .nvmrc)
+
+[LOW-CONFIDENCE]
+5. The team prefers monolith over microservices (no evidence either way)
+6. The product target is B2C (no PRD specifies)
+
+Any of these wrong? Flag them now before they cement into decisions.
+```
+
+## Have-Nots
+
+- Assumptions are too vague to verify ("we're building a good product")
+- Confidence labels missing
+- Assumptions you can't articulate (always fail; if you can't list it,
+  you don't know what you're assuming)

package/skills/god-locate.md

@@ -0,0 +1,97 @@
+---
+name: god-locate
+description: |
+  Orient a new chat session or new AI tool. Reads CHECKPOINT.md +
+  state.json + events.jsonl tail + intent.yaml + reflog tail and
+  produces a single-screen "you are here" summary. Run this FIRST
+  in any new session; it's the disk-authoritative orientation.
+
+  Triggers on: "god locate", "/god-locate", "where am i", "what's
+  going on here", "orient me", "I'm new here"
+---
+
+# /god-locate
+
+Orient a new session against disk reality. Single-screen output.
+
+## When to use
+
+- **Always run as the FIRST command in a new chat session** that
+  enters a Godpowers project.
+- When switching from Claude Code to Codex (or any tool change) so
+  the new tool inherits state.
+- When you (the AI) think you've lost track of where things are.
+- When `/god-status` output is overwhelming and you just want the
+  pin.
+
+## What it reads (in priority order)
+
+1. `.godpowers/CHECKPOINT.md` (the pin)
+2. `.godpowers/state.json` (authoritative facts)
+3. `.godpowers/runs/<latest>/events.jsonl` last 20 events
+4. `.godpowers/log` last 5 reflog entries
+5. `.godpowers/intent.yaml` (project intent)
+6. `.godpowers/HANDOFF.md` if it exists (paused-work context)
+
+## Output (single screen)
+
+```
+GODPOWERS LOCATE
+
+Project: <name>  Mode: <A/B/C/E>  Suite: <yes/no>
+Lifecycle: <phase>  Current: <tier>/<substep>
+
+Last action: <name> by <actor> at <ts>
+Last user instruction: <if available>
+
+Held facts (top 5):
+- <fact 1>
+- <fact 2>
+- <fact 3>
+- ...
+
+Recent events (last 5):
+- <event>
+- <event>
+- ...
+
+Next suggested: <command>
+  Reason: <why>
+
+Drift check:
+- CHECKPOINT.md last-update: <ts> (<age>)
+- state.json last-update: <ts> (<age>)
+- If gap > 1 hour, run /god-context-scan
+```
+
+## Process
+
+1. If `.godpowers/` does not exist: report "no Godpowers project here"
+   and suggest `/god-init`.
+2. If CHECKPOINT.md is missing: synthesize from state.json + reflog;
+   produce CHECKPOINT.md as a side effect (so the next session sees it).
+3. If state.json is missing: project is broken; run `/god-doctor`.
+4. Compute age of CHECKPOINT last-update; flag staleness if > 1 hour
+   or > 100 events since last checkpoint write.
+5. Produce single-screen orientation summary.
+6. Append `op:locate` event to events.jsonl.
+
+## Difference from /god-status
+
+- `/god-status`: full state report with every artifact's status.
+  Comprehensive, dense, ~50 lines.
+- `/god-locate`: orient-a-new-session pin. Single screen, ~20 lines.
+  Designed to be read by an AI that has no prior context.
+
+## Implementation
+
+Built-in. Reads `lib/checkpoint.js`, `lib/state.js`,
+`lib/events.js`, `lib/intent.js`. No agent spawn (orientation is too
+fast to justify fresh-context overhead).
+
+## Related
+
+- `/god-status` - full state report
+- `/god-next` - propose the next command
+- `/god-context-scan` - detect drift between AI's model and disk
+- `/god-doctor` - diagnose install + state integrity

package/skills/god-logs.md

@@ -0,0 +1,57 @@
+---
+name: god-logs
+description: |
+  View events.jsonl as a readable timeline. Each line: timestamp,
+  event name, tier, agent, duration if available. Use to inspect
+  what happened during a run, debug a stuck arc, or audit
+  retroactively.
+
+  Triggers on: "god logs", "/god-logs", "show logs", "what happened",
+  "run timeline"
+---
+
+# /god-logs
+
+Render events.jsonl as a readable timeline.
+
+## Usage
+
+### `/god-logs`
+Show timeline for the most recent run.
+
+### `/god-logs <run-id>`
+Show timeline for a specific run.
+
+### `/god-logs --since=<duration>`
+Examples: `--since=2h`, `--since=30m`, `--since=2026-05-10T12:00:00Z`.
+
+### `/god-logs --filter=<regex>`
+Filter event names by regex. E.g. `--filter=agent` for agent-only.
+
+### `/god-logs --tail=N`
+Show only the last N events.
+
+### `/god-logs --json`
+Machine-readable.
+
+## Output
+
+```
+2026-05-10T21:42:00.000Z workflow.run
+2026-05-10T21:42:01.234Z agent.start [tier-1] god-pm
+2026-05-10T21:42:18.456Z tool.call
+2026-05-10T21:42:42.789Z agent.end [tier-1] god-pm (41.55s)
+2026-05-10T21:42:43.012Z gate.pass [tier-1] standards
+2026-05-10T21:42:44.111Z agent.start [tier-1] god-architect
+...
+```
+
+## Implementation
+
+Built-in. Calls `lib/event-reader.js timeline(...) + formatTimeline(...)`.
+
+## Related
+
+- `/god-metrics` - aggregate stats
+- `/god-trace <tier>` - deep dive on one tier
+- `/god-status` - current project state

package/skills/god-map-codebase.md

@@ -0,0 +1,45 @@
+---
+name: god-map-codebase
+description: |
+  Analyze codebase with parallel mapper agents. Produces structured analysis
+  documents in .godpowers/codebase/ covering tech stack, architecture, code
+  quality, and concerns.
+
+  Triggers on: "god map codebase", "/god-map-codebase", "analyze codebase",
+  "codebase intelligence", "map the code"
+---
+
+# /god-map-codebase
+
+Spawn parallel mappers to understand an existing codebase.
+
+## When to use
+
+- Joining an existing codebase
+- Inheriting code from another team
+- Pre-flight before /god-feature or /god-upgrade in unfamiliar code
+
+## Process
+
+Spawn 4 mapper agents in parallel, each in fresh context:
+
+1. **Tech mapper**: language, framework, dependencies, build tooling
+2. **Architecture mapper**: directory structure, modules, data flow
+3. **Quality mapper**: test coverage, lint warnings, complexity hotspots
+4. **Concerns mapper**: security risks, performance hotspots, technical debt
+
+Each writes to `.godpowers/codebase/<focus>.md`.
+
+After all 4 return, optionally synthesize into `.godpowers/codebase/SUMMARY.md`.
+
+## On Completion
+
+```
+Codebase mapped.
+  + .godpowers/codebase/tech.md
+  + .godpowers/codebase/architecture.md
+  + .godpowers/codebase/quality.md
+  + .godpowers/codebase/concerns.md
+
+Suggested next: /god-init Mode B (gap-fill) or /god-feature
+```

package/skills/god-metrics.md

@@ -0,0 +1,51 @@
+---
+name: god-metrics
+description: |
+  Aggregate per-tier statistics across runs: agent count, duration,
+  pauses, errors. Useful for spotting slow tiers, frequent pause
+  points, or error-prone steps.
+
+  Triggers on: "god metrics", "/god-metrics", "stats", "how long
+  does tier-1 take", "performance"
+---
+
+# /god-metrics
+
+Per-tier aggregate stats across one or all runs.
+
+## Usage
+
+### `/god-metrics`
+All runs in the project.
+
+### `/god-metrics <run-id>`
+Single run.
+
+### `/god-metrics --since=<duration>`
+Only runs that started within the duration.
+
+### `/god-metrics --json`
+Machine-readable.
+
+## Output
+
+```
+GODPOWERS METRICS  (3 runs)
+
+Per tier:
+  tier-0  count=3   avg=0.4s   total=1.2s   pauses=0  errors=0
+  tier-1  count=12  avg=44.2s  total=8.8m   pauses=2  errors=0
+  tier-2  count=9   avg=2.1m   total=18.9m  pauses=1  errors=1
+  tier-3  count=12  avg=18.5s  total=3.7m   pauses=0  errors=0
+
+Totals: 3 runs, 36 agent spawns, 3 pauses, 1 error, 32.6m elapsed
+```
+
+## Implementation
+
+Built-in. Calls `lib/event-reader.js metrics(...)`.
+
+## Related
+
+- `/god-logs` - readable event timeline
+- `/god-trace <tier>` - one tier in detail