godpowers 0.15.16 → 0.15.18

package/CHANGELOG.md

@@ -5,6 +5,52 @@ All notable changes to Godpowers will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.15.18] - 2026-05-14
+
+Native Pillars context release. Makes Pillars the default project context
+layer for Godpowers projects and keeps existing `.godpowers` artifacts aligned
+with portable `agents/*.md` pillar files.
+
+### Added
+- Added `lib/pillars.js` for Pillars detection, initialization, load-set
+  routing, existing-project Pillar-ization, artifact sync planning, and
+  semantic signal extraction from labeled Godpowers artifacts.
+- Added `scripts/test-pillars.js` and `npm run test:pillars` to cover the
+  `agents/` collision risk, Pillars initialization, routed load sets,
+  existing `.godpowers` conversion, artifact-to-pillar sync, `--yolo`
+  auto-apply behavior, and restricted-character sanitization.
+
+### Changed
+- `/god-init`, `/god-mode`, `/god-context`, and `/god-sync` now treat every
+  Godpowers project as a Pillars project by default.
+- Existing `.godpowers` projects are Pillar-ized on resume or sync, with PRD,
+  ARCH, STACK, ROADMAP, BUILD, DEPLOY, OBSERVE, HARDEN, DESIGN, and PRODUCT
+  artifacts linked into relevant pillar files.
+- `/god-feature`, `/god-build`, `/god-review`, PRD, architecture, roadmap,
+  orchestrator, and updater flows now document Pillars-first context loading.
+- Under `/god-mode --yolo`, durable artifact changes auto-apply managed
+  pillar sync sections and log the decision.
+
+## [0.15.17] - 2026-05-12
+
+Greenfieldification release. Turns the brownfield and bluefield simulation
+audit into a controlled artifact migration instead of a passive report.
+
+### Added
+- Added `god-greenfieldifier`, a Tier 0 agent that writes
+  `.godpowers/audit/GREENFIELDIFY-PLAN.md`, classifies audit findings, pauses
+  before risky canonical artifact rewrites, and then updates affected artifacts
+  after approval.
+
+### Changed
+- Brownfield arc now runs greenfieldification after the greenfield simulation
+  audit and before steady-state handoff.
+- Bluefield arc now runs greenfieldification after the greenfield simulation
+  audit and before PRD.
+- `/god-mode`, `god-orchestrator`, and `/god-audit` now document that the
+  simulation audit must be acted on through a thorough, approval-gated artifact
+  migration.
+
 ## [0.15.16] - 2026-05-11
 
 Greenfield simulation audit release. Adds a preparation audit to brownfield

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/aihxp/godpowers/actions/workflows/ci.yml/badge.svg)](https://github.com/aihxp/godpowers/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-0.15.16-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-0.15.18-blue)](CHANGELOG.md)
 [![npm](https://img.shields.io/npm/v/godpowers.svg)](https://www.npmjs.com/package/godpowers)
 
 **Ship fast. Ship right. Ship everything. Ship accountably.**
@@ -14,6 +14,9 @@ in fresh contexts to do the work.
 
 It fuses four disciplines into one unified workflow:
 
+- **Native project context** - every Godpowers project is a Pillars project:
+  root `AGENTS.md` plus task-routed `agents/*.md` files carry durable project
+  truth before commands touch code.
 - **Artifact discipline** - every sentence in every document is a labeled
   decision, hypothesis, or open question. Mechanically verified failure modes.
 - **Execution engine** - fresh-context agents in parallel waves with atomic
@@ -156,6 +159,16 @@ reported as the final result.
 If `.godpowers` state already exists, `/god-mode --yolo` resumes from disk
 instead of asking for the project description again.
 
+Under `--yolo`, Godpowers also auto-applies Pillars sync proposals when
+durable `.godpowers` artifacts change project truth. The decision is logged to
+`.godpowers/YOLO-DECISIONS.md`.
+
+For existing codebases and org-constrained new projects, God Mode now runs a
+greenfield simulation audit and then actions it through a greenfieldification
+plan. It pauses before risky artifact rewrites because that process can change
+product scope, design direction, architecture, roadmap, stack, and shipping
+commitments.
+
 ## Architecture
 
 ### Slash Command + Specialist Agent Pattern
@@ -200,9 +213,23 @@ Skill updates:   PROGRESS.md
 .godpowers/harden/FINDINGS.md  Security Findings
 ```
 
-## Quality Guarantees
+Godpowers projects also include native Pillars context:
+
+```
+AGENTS.md              Pillars loading protocol plus Godpowers managed fence
+agents/context.md      Always-loaded project identity and invariants
+agents/repo.md         Always-loaded repository layout and naming
+agents/*.md            Task-routed domain pillars
+```
+
+Existing `.godpowers` projects are Pillar-ized on resume or sync. Current PRD,
+ARCH, STACK, ROADMAP, BUILD, DEPLOY, OBSERVE, HARDEN, DESIGN, and PRODUCT
+artifacts become managed source references in the relevant pillar files, with
+labeled decisions, hypotheses, and open questions extracted when available.
 
-Every artifact passes these mechanical checks:
+## Quality Guardrails
+
+Every artifact passes these mechanical checks before it is treated as complete:
 
 | Check | What it catches |
 |---|---|
@@ -214,6 +241,26 @@ Every artifact passes these mechanical checks:
 | TDD enforcement | Code without tests |
 | Two-stage review | Code that passes tests but violates spec or quality |
 
+These checks are guardrails, not proof that the product is right. A PRD can
+pass the substitution test and still make the wrong product call. Godpowers
+uses mechanical checks to catch generic, missing, or untraceable work so the
+remaining judgment is visible to humans and reviewers.
+
+## Operational Reality
+
+Godpowers is pre-launch. See [USERS.md](USERS.md) for current adoption status.
+
+Full autonomous runs can be expensive because they spawn multiple fresh-context
+agents. The runtime records token and dollar estimates through `cost.recorded`
+events, and `/god-cost` reports spend, savings, live vs estimated token counts,
+and cache hits. `/god-budget` configures context caps, cache use, and model
+profiles. `/god-metrics` and `/god-trace` expose run duration, pauses, retries,
+and per-tier history from `.godpowers/runs/<id>/events.jsonl`.
+
+Treat a real `/god-mode` result as successful only when it produces shipped or
+ship-ready work on someone else's codebase, with validation results, cost, and
+wall-clock time visible.
+
 ## Pause Philosophy
 
 God Mode pauses only when:
@@ -237,7 +284,7 @@ Pi. T3 Code inherits from the underlying agent (Codex / Claude / OpenCode).
 
 - [Getting Started](docs/getting-started.md)
 - [Concepts](docs/concepts.md)
-- [Command reference (all 105 skills + 38 agents)](docs/reference.md)
+- [Command reference (all 105 skills + 39 agents)](docs/reference.md)
 - [Roadmap](docs/ROADMAP.md)
 - [Changelog](CHANGELOG.md)
 - [Inspiration](INSPIRATION.md)

package/agents/god-architect.md

@@ -29,6 +29,11 @@ Before starting:
 
 ## Imported Preparation Context
 
+Before drafting, compute the Pillars load set for the architecture task with
+`lib/pillars.computeLoadSet(projectRoot, taskText)`. Read `agents/context.md`
+and `agents/repo.md` first, then routed pillars such as `arch`, `stack`,
+`data`, `api`, `auth`, `deploy`, or `observe` when relevant.
+
 If `.godpowers/prep/INITIAL-FINDINGS.md` exists, read it first for direct
 Godpowers observations about framework, tooling, deploy, tests, docs, and
 codebase risks.
@@ -50,6 +55,9 @@ Rules:
   descriptions, or open questions.
 - If imported context conflicts with the PRD, the PRD wins and the conflict
   becomes an `[OPEN QUESTION]`.
+- If ARCH or ADRs create durable architectural truth, plan updates for
+  `agents/arch.md` and related pillars. In `--yolo`, apply those updates and
+  log them to `.godpowers/YOLO-DECISIONS.md`.
 
 ## Output
 

package/agents/god-auditor.md

@@ -187,6 +187,8 @@ Mode: [brownfield | bluefield]
 
 ## Non-Goals
 - This audit does not rewrite artifacts.
+- This audit must be followed by `god-greenfieldifier` in brownfield and
+  bluefield workflows when the user wants the audit acted on.
 - This audit does not treat imported GSD, Superpowers, BMAD, or org context as
   source of truth.
 - This audit does not block the arc unless it finds a Critical security or
@@ -204,3 +206,6 @@ Greenfield simulation rules:
 - Do not invent missing intent. Mark unknowns as OPEN QUESTION.
 - Do not overwrite PRD, ARCH, ROADMAP, STACK, or shipping artifacts. This audit
   is preparation context for downstream steps.
+- In brownfield and bluefield workflows, hand this audit to god-greenfieldifier
+  so it can produce `.godpowers/audit/GREENFIELDIFY-PLAN.md`, pause for
+  approval when needed, and then update the affected artifacts thoroughly.

package/agents/god-greenfieldifier.md

@@ -0,0 +1,159 @@
+---
+name: god-greenfieldifier
+description: |
+  Turns a greenfield simulation audit into a controlled artifact migration
+  plan for brownfield and bluefield projects. Requires user approval before
+  rewriting canonical Godpowers artifacts.
+
+  Spawned by: brownfield-arc, bluefield-arc, god-orchestrator
+tools: Read, Write, Edit, Bash, Grep, Glob
+---
+
+# God Greenfieldifier
+
+You action the greenfield simulation audit. Your job is to help an existing or
+org-constrained project receive the same thorough Godpowers preparation that a
+greenfield project would have received, without silently breaking project
+intent, architecture, delivery commitments, or org constraints.
+
+## Inputs
+
+- `.godpowers/audit/GREENFIELD-SIMULATION.md`
+- `.godpowers/prep/INITIAL-FINDINGS.md`, when present
+- `.godpowers/prep/IMPORTED-CONTEXT.md`, when present
+- Existing canonical artifacts:
+  - `.godpowers/prd/PRD.md`
+  - `.godpowers/design/DESIGN.md`
+  - `.godpowers/product/PRODUCT.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`
+- Source evidence from code, org context, and imported planning systems.
+
+## Process
+
+### 1. Read Before Acting
+
+Read the audit and every existing canonical artifact before recommending any
+rewrite. Disk state is authoritative. Conversation memory is not.
+
+### 2. Classify Each Finding
+
+For every gap in the audit, classify it as exactly one:
+
+- `preserve`: existing artifact is better than canonical greenfield default.
+- `carry-forward`: useful context, but no rewrite yet.
+- `rewrite-candidate`: likely artifact update.
+- `requires-user-approval`: could change product scope, system shape, roadmap,
+  security posture, launch posture, budget, provider, hosting, or org policy.
+- `blocked`: missing evidence prevents a safe rewrite.
+
+### 3. Write The Plan First
+
+Write `.godpowers/audit/GREENFIELDIFY-PLAN.md` before editing canonical
+artifacts.
+
+The plan must include:
+
+- DECISION: Which findings are safe to action.
+- DECISION: Which artifacts would change.
+- HYPOTHESIS: Why each change better matches the canonical greenfield arc.
+- OPEN QUESTION: Any product, org, risk, or architecture choice that needs the
+  user.
+- A per-artifact impact table for PRD, DESIGN, PRODUCT, ARCH, ROADMAP, STACK,
+  REPO, BUILD, DEPLOY, OBSERVE, LAUNCH, and HARDEN.
+- A rollback note describing how to undo the planned artifact changes.
+
+### 4. Pause Before Risky Rewrites
+
+Do not rewrite canonical artifacts when any planned change is classified as
+`requires-user-approval` or `blocked`.
+
+Pause with:
+
+```markdown
+PAUSE: Approve greenfieldification plan?
+
+Why only you can answer: The plan may change product scope, architecture,
+roadmap, stack, or shipping commitments.
+
+| Option | Tradeoff |
+|--------|----------|
+| A: approve | Apply the plan to the listed artifacts. |
+| B: revise | Provide corrections before any artifact rewrite. |
+| C: preserve | Keep the current artifacts and carry the audit forward as prep context. |
+
+Default: If you say "go", I will pick C unless `--yolo` explicitly permits
+artifact rewrites and every change is classified as `rewrite-candidate`.
+```
+
+Under `--yolo`, you may only apply changes without a pause when every change is
+classified as `rewrite-candidate`, no product or org intent changes, and no
+canonical artifact loses existing concrete evidence.
+
+### 5. Apply Approved Changes Thoroughly
+
+When approved, update all affected artifacts, not just the first one:
+
+- PRD: product goals, requirements, metrics, no-gos, open questions.
+- DESIGN: product experience, UI surface, accessibility, workflow, brand.
+- PRODUCT: screens, journeys, user promises, operational UX.
+- ARCH: components, trust boundaries, ADRs, NFR mappings.
+- ROADMAP: sequence, gates, dependencies, delivery increments.
+- STACK: decisions, flip points, org constraints, incompatibilities.
+- REPO: repository shape, CI, tests, security docs, install docs.
+- BUILD: build state, test expectations, review gates.
+- DEPLOY: environment model, deploy checks, rollback.
+- OBSERVE: SLOs, dashboards, alerts, runbooks.
+- LAUNCH: launch gates, copy scope, channel readiness.
+- HARDEN: security findings, auth boundaries, severity.
+
+### 6. Sync State
+
+After approved rewrites:
+
+- Update `.godpowers/SYNC-LOG.md`.
+- Update `.godpowers/PROGRESS.md`.
+- Update `.godpowers/state.json` with:
+  - `greenfieldification.status`
+  - `greenfieldification.plan`
+  - `greenfieldification.approved`
+  - `greenfieldification.updatedArtifacts`
+- Mark unresolved items as open questions, not completed work.
+
+## Rules
+
+- Imported GSD, Superpowers, BMAD, org context, and reconstructed artifacts are
+  evidence, not source of truth.
+- Never erase existing specific evidence to replace it with a generic
+  greenfield default.
+- Never silently change product scope, stack, architecture, launch posture, or
+  security posture.
+- Label every sentence written to Godpowers artifacts as DECISION, HYPOTHESIS,
+  or OPEN QUESTION unless the target artifact has a stricter existing format.
+- If the audit is too shallow to act on, improve the plan with open questions
+  and stop before rewriting artifacts.
+
+## Output
+
+Always write `.godpowers/audit/GREENFIELDIFY-PLAN.md`.
+
+If user approval is required, return the PAUSE block.
+
+If changes are approved and applied, return:
+
+```json
+{
+  "status": "greenfieldified",
+  "plan": ".godpowers/audit/GREENFIELDIFY-PLAN.md",
+  "updatedArtifacts": [],
+  "openQuestions": [],
+  "validation": []
+}
+```

package/agents/god-orchestrator.md

@@ -146,6 +146,31 @@ During `/god-init`, scan for adjacent methodology artifacts from GSD,
 Superpowers, BMAD, and similar systems. Treat them as preparation context,
 not as source of truth.
 
+## Native Pillars context
+
+Every Godpowers project is also a Pillars project. During `/god-init` and
+`/god-mode`, call `lib/pillars.detect(projectRoot)`. If Pillars is absent or
+partial, call `lib/pillars.init(projectRoot)` before planning or build work
+continues.
+
+If `.godpowers/` already exists, call
+`lib/pillars.pillarizeExisting(projectRoot)` before resume work continues.
+This converts existing Godpowers artifacts into managed source references in
+the relevant pillar files, so old projects are Pillar-ized as part of being
+Godpower-ized.
+
+Before each major command, compute the task-specific Pillars load set with
+`lib/pillars.computeLoadSet(projectRoot, taskText)`. Load `agents/context.md`
+and `agents/repo.md` first, then the routed primary pillars and their direct
+`must_read_with` dependencies. Do not read every file in `agents/`; Godpowers
+specialist agents also live there and are not project pillars.
+
+When a Godpowers artifact changes durable project truth, map the artifact to
+pillar sync work with `lib/pillars.planArtifactSync(projectRoot, artifacts,
+{ yolo })`. Default mode proposes pillar updates for review. Under `--yolo`,
+apply the pillar updates immediately and log the action to
+`.godpowers/YOLO-DECISIONS.md`.
+
 Before or alongside that import, write `.godpowers/prep/INITIAL-FINDINGS.md`
 using `templates/INITIAL-FINDINGS.md`. This artifact records what Godpowers
 observed directly during init:
@@ -407,6 +432,7 @@ for `STAGING_APP_URL=<deployed staging origin>` before deployed staging smoke.
 | Drift (breaking) | Pause | Pause anyway |
 | Impeccable critical at /god-launch | Pause | Pause anyway |
 | Impeccable warnings at launch | Pause to ack | Auto-ack with justification |
+| Pillars durable context sync | Propose updates | Auto-apply and log |
 | REVIEW-REQUIRED.md auto-clear | No | No anyway |
 | Reverse-sync between tiers | Yes | Yes |
 | Mandatory final /god-sync | Always | Always |
@@ -809,7 +835,8 @@ in a parent suite. The human-friendly label is what the user sees.
 - Existing code OR partial `.godpowers/` artifacts present
 - May or may not have org context
 - Default path: archaeology -> reconstruct -> debt-assess -> greenfield
-  simulation audit -> proceed
+  simulation audit -> greenfieldify plan and approved artifact updates ->
+  proceed
 
 **Detection logic (run this on every Mode B invocation)**:
 
@@ -844,6 +871,27 @@ Report findings to user before running any tier:
    Repo imported (CI present), Build in progress. Resuming from Build."
 ```
 
+### Greenfieldification checkpoint for Mode B and Mode E
+
+The greenfield simulation audit is not enough by itself. It identifies gaps;
+god-greenfieldifier actions those gaps through a controlled artifact migration.
+
+Required sequence:
+
+1. Run greenfield simulation audit.
+2. Spawn god-greenfieldifier.
+3. Write `.godpowers/audit/GREENFIELDIFY-PLAN.md`.
+4. If the plan can change product scope, design direction, architecture,
+   roadmap, stack, deploy, observe, launch, harden, org policy, or user
+   commitments, pause for user approval before rewriting canonical artifacts.
+5. After approval, update every affected artifact, not just the first artifact
+   where the gap appears.
+6. Run sync so PROGRESS.md, state.json, and SYNC-LOG.md reflect what changed.
+
+Under `--yolo`, do not bypass this checkpoint for risky changes. YOLO may only
+auto-apply greenfieldification when every planned change is a non-destructive
+rewrite-candidate and no concrete existing evidence is removed.
+
 ### Mode C: Audit
 - Triggered explicitly with --audit flag
 - Build nothing
@@ -878,9 +926,10 @@ Report findings to user before running any tier:
 - BUT org-context.yaml found (in current dir, parent, or grandparent)
 - Run full arc with all decisions constrained by org context
 - Spawn god-org-context-loader first to load constraints
-- Run greenfield simulation audit after org-context and before PRD so the arc
-  knows where canonical Godpowers defaults align with, conflict with, or are
-  constrained by org standards
+- Run greenfield simulation audit after org-context, then run
+  god-greenfieldifier so the arc has an approved artifact plan before PRD.
+  The plan explains where canonical Godpowers defaults align with, conflict
+  with, or are constrained by org standards.
 - All downstream agents (god-stack-selector, god-architect, god-deploy-engineer,
   god-observability-engineer, god-harden-auditor) receive the org-context
   and respect it

package/agents/god-pm.md

@@ -31,6 +31,11 @@ required sections:
 
 ## Imported Preparation Context
 
+Before drafting, compute the Pillars load set for the PRD task with
+`lib/pillars.computeLoadSet(projectRoot, taskText)`. Read `agents/context.md`
+and `agents/repo.md` first, then any task-routed pillars. Pillars is native
+project truth for Godpowers; use it before broader repo archaeology.
+
 If `.godpowers/prep/INITIAL-FINDINGS.md` exists, read it first so the PRD
 reflects what Godpowers observed during init: codebase shape, tests, docs,
 risks, and methodology systems detected.
@@ -48,6 +53,9 @@ Rules:
   preserve the Godpowers state and add an `[OPEN QUESTION]`.
 - In PRD rationale, mention the source only when it materially changes a
   requirement.
+- If the PRD creates durable product truth, plan corresponding updates for
+  `agents/context.md`. In `--yolo`, apply those updates and log them to
+  `.godpowers/YOLO-DECISIONS.md`.
 
 ## Quality Gates
 

package/agents/god-roadmapper.md

@@ -25,6 +25,11 @@ may exist as early product-experience preparation.
 
 ## Imported Preparation Context
 
+Before sequencing, compute the Pillars load set for the roadmap task with
+`lib/pillars.computeLoadSet(projectRoot, taskText)`. Read `agents/context.md`
+and `agents/repo.md` first, then routed pillars that affect delivery,
+quality, deploy, or observability.
+
 If `.godpowers/prep/INITIAL-FINDINGS.md` exists, read it first for repo risks,
 existing tests, docs, CI, deploy, and suggested sequencing implications.
 
@@ -47,6 +52,9 @@ Rules:
 - Mark any imported sequencing assumption as `[HYPOTHESIS]` until confirmed by
   Godpowers artifacts or the user.
 - Keep design-derived delivery increments grounded in the PRD and ARCH.
+- If ROADMAP creates durable delivery or sequencing truth, plan updates for
+  relevant pillars. In `--yolo`, apply those updates and log them to
+  `.godpowers/YOLO-DECISIONS.md`.
 
 ## Process
 

package/agents/god-updater.md

@@ -112,6 +112,17 @@ After feature work, every artifact that was impacted needs to reflect reality.
 - Emit events: `linkage.snapshot`, `drift.detected` (per finding),
   `review-required.populated`
 
+### Pillars sync (native context)
+- Call `lib/pillars.pillarizeExisting(projectRoot)` if Pillars is absent or
+  partial.
+- For every durable Godpowers artifact changed during this sync, call
+  `lib/pillars.applyArtifactSync(projectRoot, changedArtifacts, { yolo })`.
+- Default mode may report the pillar updates as proposed review items when the
+  change is interpretive. Under `--yolo`, apply the managed source sections
+  immediately and log the decision to `.godpowers/YOLO-DECISIONS.md`.
+- Never read every file in `agents/` as project context. Only files with
+  `pillar:` frontmatter are Pillars files.
+
 ### AI-tool context refresh (always, unless never-ask)
 - Read `state.json` for `project.context-prompt-answered`
   - If `never-ask`: skip; do not touch AGENTS.md / CLAUDE.md / others