godpowers 1.0.0 → 1.6.0

package/lib/artifact-linter.js

@@ -6,7 +6,7 @@
  * findings.
  *
  * Public API:
- *   detectType(filePath) -> 'prd'|'arch'|'roadmap'|'stack'|'design'|'product'|null
+ *   detectType(filePath) -> 'prd'|'arch'|'roadmap'|'stack'|'design'|'product'|'domain'|null
  *   lintFile(filePath, opts) -> { type, findings, summary }
  *   lintAll(projectRoot, opts) -> [{ path, type, findings, summary }, ...]
  *
@@ -28,6 +28,7 @@ function detectType(filePath) {
   if (lower.includes('/arch/') || basename === 'arch.md') return 'arch';
   if (lower.includes('/roadmap/') || basename === 'roadmap.md') return 'roadmap';
   if (lower.includes('/stack/') || basename === 'stack-decision.md' || basename === 'decision.md') return 'stack';
+  if (lower.includes('/domain/') || basename === 'domain-glossary.md' || basename === 'glossary.md') return 'domain';
   if (basename === 'design.md') return 'design';
   if (basename === 'product.md') return 'product';
   if (basename === 'postmortem.md') return 'postmortem';
@@ -82,6 +83,7 @@ function lintAll(projectRoot, opts = {}) {
     '.godpowers/arch/ARCH.md',
     '.godpowers/roadmap/ROADMAP.md',
     '.godpowers/stack/DECISION.md',
+    '.godpowers/domain/GLOSSARY.md',
     '.godpowers/design/DESIGN.md',
     'DESIGN.md',
     'PRODUCT.md'

package/lib/have-nots-validator.js

@@ -22,6 +22,11 @@
  *   P-08 open-q without owner       mechanical (table column scan)
  *   P-09 open-q without due date    mechanical (table column scan)
  *   A-04 NFR not mapped              mechanical (PRD NFR vs ARCH map)
+ *   DG-01 term without avoid aliases mechanical (term block scan)
+ *   DG-02 implementation detail      partial mechanical (technical-word scan)
+ *   DG-03 ambiguity owner/due        mechanical (section scan)
+ *   DG-04 relationship undefined     mechanical (bold term cross-check)
+ *   DG-05 behavior definition        partial mechanical (verb scan)
  *
  * Substitution test (U-01) is a partial mechanical check: flags sentences
  * containing only generic nouns ('users', 'developers', 'scalable',
@@ -524,6 +529,163 @@ function checkArchNfrMap(content, opts = {}) {
   return findings;
 }
 
+/** DG-01: canonical term without avoided aliases */
+function checkDomainAvoidAliases(content) {
+  const findings = [];
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const match = line.match(/^\*\*([^*\]]+)\*\*:\s*(.+)/);
+    if (!match) continue;
+    const term = match[1].trim();
+    if (!term || term.startsWith('[')) continue;
+    let hasAvoid = false;
+    for (let j = i + 1; j < Math.min(lines.length, i + 5); j++) {
+      const next = lines[j].trim();
+      if (/^\*\*[^*]+\*\*:/.test(next) || /^#{1,6}\s/.test(next)) break;
+      const avoidMatch = next.match(/^_Avoid_:\s*(.+)/i);
+      if (avoidMatch && avoidMatch[1].trim() && !avoidMatch[1].includes('[')) {
+        hasAvoid = true;
+        break;
+      }
+    }
+    if (!hasAvoid) {
+      findings.push({
+        code: 'DG-01',
+        severity: 'warning',
+        line: i + 1,
+        column: 1,
+        message: `Glossary term "${term}" has no avoided aliases listed.`,
+        suggestion: 'Add an _Avoid_: line with non-canonical aliases or overloaded words.'
+      });
+    }
+  }
+  return findings;
+}
+
+/** DG-02: implementation detail in glossary */
+function checkDomainImplementationDetails(content) {
+  const findings = [];
+  const technicalWords = /\b(src\/|lib\/|\.js\b|\.ts\b|\.tsx\b|React|Vue|Svelte|Postgres|MySQL|Redis|Kafka|API endpoint|endpoint|function|class|module|component|database|ORM|queue|HTTP|GraphQL)\b/i;
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (technicalWords.test(line)) {
+      findings.push({
+        code: 'DG-02',
+        severity: 'warning',
+        line: i + 1,
+        column: 1,
+        message: 'Possible implementation detail in domain glossary.',
+        suggestion: 'Keep implementation details in PRD, ARCH, STACK, docs, or code-linked artifacts.'
+      });
+    }
+  }
+  return findings;
+}
+
+/** DG-03: unresolved ambiguity without owner or due date */
+function checkDomainAmbiguityOwners(content) {
+  const findings = [];
+  const section = extractSection(content, /^##\s*Flagged Ambiguities/im);
+  if (!section) return findings;
+  const lines = section.body.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line.startsWith('-')) continue;
+    const lineWithoutLabel = line.replace(/\[OPEN QUESTION\]/g, '');
+    if (lineWithoutLabel.includes('[')) continue;
+    const isOpen = line.includes('[OPEN QUESTION]') || /\bambigu/i.test(line);
+    if (!isOpen) continue;
+    if (!/\bOwner:\s*[^.\]]+/i.test(line)) {
+      findings.push({
+        code: 'DG-03',
+        severity: 'error',
+        line: section.startLine + i,
+        column: 1,
+        message: 'Glossary ambiguity has no owner.',
+        suggestion: 'Add Owner: [name] to the ambiguity.'
+      });
+    }
+    if (!/\bDue:\s*[^.\]]+/i.test(line)) {
+      findings.push({
+        code: 'DG-03',
+        severity: 'error',
+        line: section.startLine + i,
+        column: 1,
+        message: 'Glossary ambiguity has no due date.',
+        suggestion: 'Add Due: [date or command gate] to the ambiguity.'
+      });
+    }
+  }
+  return findings;
+}
+
+/** DG-04: relationship references undefined canonical term */
+function checkDomainRelationshipTerms(content) {
+  const findings = [];
+  const language = extractSection(content, /^##\s*Language/im);
+  const relationships = extractSection(content, /^##\s*Relationships/im);
+  if (!language || !relationships) return findings;
+
+  const canonical = new Set();
+  const languageLines = language.body.split('\n');
+  for (const line of languageLines) {
+    const match = line.trim().match(/^\*\*([^*\]]+)\*\*:/);
+    if (match && !match[1].startsWith('[')) {
+      canonical.add(match[1].trim());
+    }
+  }
+
+  const relLines = relationships.body.split('\n');
+  for (let i = 0; i < relLines.length; i++) {
+    const relLineWithoutLabels = relLines[i]
+      .replace(/\[DECISION\]/g, '')
+      .replace(/\[HYPOTHESIS\]/g, '')
+      .replace(/\[OPEN QUESTION\]/g, '');
+    if (relLineWithoutLabels.includes('[')) continue;
+    const boldTerms = [...relLines[i].matchAll(/\*\*([^*\]]+)\*\*/g)].map(m => m[1].trim());
+    for (const term of boldTerms) {
+      if (term.startsWith('[')) continue;
+      if (!canonical.has(term)) {
+        findings.push({
+          code: 'DG-04',
+          severity: 'warning',
+          line: relationships.startLine + i,
+          column: 1,
+          message: `Relationship references undefined glossary term "${term}".`,
+          suggestion: 'Define the term in Language or replace it with a canonical term.'
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+/** DG-05: definition describes behavior instead of identity */
+function checkDomainDefinitionBehavior(content) {
+  const findings = [];
+  const behaviorWords = /\b(handles|processes|manages|stores|renders|calls|sends|receives|creates|updates|deletes|calculates|syncs)\b/i;
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const match = line.match(/^\*\*([^*\]]+)\*\*:\s*(.+)/);
+    if (!match || match[1].startsWith('[')) continue;
+    const definition = match[2];
+    if (behaviorWords.test(definition)) {
+      findings.push({
+        code: 'DG-05',
+        severity: 'warning',
+        line: i + 1,
+        column: 1,
+        message: `Glossary definition for "${match[1]}" may describe behavior instead of identity.`,
+        suggestion: 'Define what the term is in one sentence. Put behavior in PRD, ARCH, or docs.'
+      });
+    }
+  }
+  return findings;
+}
+
 // ============================================================================
 // Helpers
 // ============================================================================
@@ -579,6 +741,13 @@ const ARTIFACT_CHECKS = {
   ],
   arch: [
     { code: 'A-04', fn: checkArchNfrMap }
+  ],
+  domain: [
+    { code: 'DG-01', fn: checkDomainAvoidAliases },
+    { code: 'DG-02', fn: checkDomainImplementationDetails },
+    { code: 'DG-03', fn: checkDomainAmbiguityOwners },
+    { code: 'DG-04', fn: checkDomainRelationshipTerms },
+    { code: 'DG-05', fn: checkDomainDefinitionBehavior }
   ]
 };
 
@@ -643,5 +812,10 @@ module.exports = {
   checkPrdNoGos,
   checkPrdOpenQuestions,
   checkArchNfrMap,
+  checkDomainAvoidAliases,
+  checkDomainImplementationDetails,
+  checkDomainAmbiguityOwners,
+  checkDomainRelationshipTerms,
+  checkDomainDefinitionBehavior,
   extractSection
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "godpowers",
-  "version": "1.0.0",
-  "description": "AI-powered development system: 105 slash commands and 39 specialist agents that take a project from raw idea to hardened production. Runs inside Claude Code, Codex, Cursor, Windsurf, Gemini, and 10+ other AI coding tools.",
+  "version": "1.6.0",
+  "description": "AI-powered development system: 106 slash commands and 39 specialist agents that take a project from raw idea to hardened production. Runs inside Claude Code, Codex, Cursor, Windsurf, Gemini, and 10+ other AI coding tools.",
   "bin": {
     "godpowers": "./bin/install.js"
   },

package/references/HAVE-NOTS.md

@@ -179,6 +179,30 @@ Choice motivated by "looks good on resume" rather than fit-for-PRD. Fail.
 Looks robust on paper but fails first real load. NFR validation must include
 worst-case analysis. Fail.
 
+#### A-13 ADR inflation
+An ADR records a decision that is easy to reverse, obvious without context, or
+not the result of a real tradeoff. Fail.
+
+### Domain Glossary Have-Nots
+
+#### DG-01 Canonical term without avoided aliases
+A glossary term names the canonical language but does not list avoided aliases.
+Fail.
+
+#### DG-02 Implementation detail in glossary
+The domain glossary stores implementation details, stack choices, code paths,
+or technical scratch notes. The glossary is domain language only. Fail.
+
+#### DG-03 Unresolved ambiguity without owner or due date
+An ambiguity is recorded without an owner or due date. Fail.
+
+#### DG-04 Relationship uses non-canonical term
+A relationship references a term that is not defined in the glossary language
+section. Fail.
+
+#### DG-05 Definition does behavior work
+A definition describes what the system does instead of what the term is. Fail.
+
 ### Roadmap Have-Nots
 
 #### R-01 Generic milestone goal

package/routing/god-mode.yaml

@@ -17,7 +17,8 @@ execution:
   reads:
     - .godpowers/prep/INITIAL-FINDINGS.md
     - .godpowers/prep/IMPORTED-CONTEXT.md
-  secondary-spawns: [god-pm, god-designer, god-architect, god-roadmapper, god-stack-selector, god-repo-scaffolder, god-planner, god-executor, god-spec-reviewer, god-quality-reviewer, god-deploy-engineer, god-observability-engineer, god-harden-auditor, god-launch-strategist]
+    - .godpowers/preflight/PREFLIGHT.md
+  secondary-spawns: [god-auditor, god-pm, god-designer, god-architect, god-roadmapper, god-stack-selector, god-repo-scaffolder, god-planner, god-executor, god-spec-reviewer, god-quality-reviewer, god-deploy-engineer, god-observability-engineer, god-harden-auditor, god-launch-strategist]
   writes:
     []
 

package/routing/god-preflight.yaml

@@ -0,0 +1,36 @@
+apiVersion: godpowers/v1
+kind: CommandRouting
+metadata:
+  command: /god-preflight
+  description: Read-only intake audit before arc-ready and pillars
+  tier: 0
+
+prerequisites:
+  required:
+    - check: codebase-present
+      human-required: true
+
+execution:
+  spawns: [god-auditor]
+  context: fresh
+  writes:
+    - .godpowers/preflight/PREFLIGHT.md
+
+success-path:
+  next-recommended: /god-archaeology
+  alternatives:
+    - command: /god-init
+      when: missing-basic-project-state
+    - command: /god-reconstruct
+      when: planning-artifacts-missing
+    - command: /god-tech-debt
+      when: debt-dominates-risk
+    - command: /god-audit
+      when: artifacts-exist
+
+failure-path:
+  on-error: /god-doctor
+
+endoff:
+  state-update: preflight completed
+  events: [agent.start, artifact.created, agent.end]

package/routing/recipes/bluefield-org-aware.yaml

@@ -19,6 +19,8 @@ sequences:
     steps:
       - command: "/god-org-context init"
         why: "Capture org-level standards and constraints"
+      - command: "/god-preflight"
+        why: "Inspect inherited context before arc-ready and pillars"
       - command: "/god-init"
         why: "Detect bluefield mode"
       - command: "/god-mode --bluefield"

package/routing/recipes/brownfield-onboarding.yaml

@@ -3,7 +3,7 @@ kind: Recipe
 metadata:
   name: brownfield-onboarding
   category: starting
-  description: "Inheriting an existing codebase; archaeology + reconstruction first"
+  description: "Inheriting an existing codebase; preflight before archaeology"
 
 triggers:
   intent-keywords:
@@ -16,8 +16,10 @@ triggers:
 
 sequences:
   default:
-    description: "Inheriting an existing codebase; archaeology + reconstruction first"
+    description: "Inheriting an existing codebase; preflight before archaeology"
     steps:
+      - command: "/god-preflight"
+        why: "Read-only intake audit before arc-ready and pillars"
       - command: "/god-archaeology"
         why: "Deep history, decisions, conventions, risks"
       - command: "/god-reconstruct"

package/skills/god-discuss.md

@@ -11,7 +11,7 @@ description: |
 
 # /god-discuss
 
-Pre-planning Socratic discussion.
+Pre-planning Socratic discussion with domain grilling.
 
 ## When to use
 
@@ -26,21 +26,45 @@ Spawn god-explorer in fresh context with focus="next-phase-scoping".
 
 The agent:
 1. Reads the active workflow context
-2. Asks targeted (not open-ended) questions
-3. Surfaces 2-3 hidden assumptions
-4. Identifies what's [DECISION] vs [HYPOTHESIS] vs [OPEN QUESTION]
-5. Drafts a brief in `.godpowers/discussions/<topic>.md`
+2. Reads `.godpowers/domain/GLOSSARY.md` if it exists
+3. Asks targeted questions one at a time, with a recommended answer for each
+4. Explores the codebase instead of asking when repo evidence can answer
+5. Challenges vague, overloaded, or conflicting terms against the glossary
+6. Stress-tests domain relationships with concrete scenarios and edge cases
+7. Surfaces 2-3 hidden assumptions
+8. Identifies what's [DECISION] vs [HYPOTHESIS] vs [OPEN QUESTION]
+9. Drafts a brief in `.godpowers/discussions/<topic>.md`
+10. Updates `.godpowers/domain/GLOSSARY.md` when a term or ambiguity is resolved
 
-The brief gets passed to the next planning command.
+The brief and glossary get passed to the next planning command. The glossary is
+preparation context, not a replacement for PRD, ARCH, ROADMAP, STACK, or Pillars
+files.
+
+## Domain Glossary Rules
+
+- Create `.godpowers/domain/GLOSSARY.md` lazily from `templates/DOMAIN-GLOSSARY.md`
+  only when the discussion resolves the first project-specific term.
+- Keep `.godpowers/domain/GLOSSARY.md` free of implementation details.
+- Use the glossary for canonical terms, avoided aliases, relationships, example
+  dialogue, flagged ambiguities, and source notes.
+- When the user uses a term that conflicts with the glossary, call out the
+  conflict immediately and ask which meaning should win.
+- When the user uses a fuzzy term, propose a precise canonical term and the
+  avoided aliases.
+- Offer ADRs only when all three are true: the decision is hard to reverse, a
+  future reader would find it surprising without context, and the choice came
+  from a real tradeoff.
 
 ## Output
 
 ```
 Discussion complete: .godpowers/discussions/<topic>.md
+Domain glossary: .godpowers/domain/GLOSSARY.md (created or updated if terms resolved)
 
 Key findings:
   - [assumption surfaced]
   - [open question that needs human decision]
+  - [term or ambiguity resolved]
 
 Suggested next: [the planning command this discussion was for]
 ```

package/skills/god-doctor.md

@@ -46,9 +46,9 @@ Plain-text report grouped by severity:
 GODPOWERS DOCTOR
 
 Install: claude (~/.claude/)
-  [OK] 105 skills installed
+  [OK] 106 skills installed
   [OK] 39 agents installed
-  [OK] VERSION matches (1.0.0)
+  [OK] VERSION matches (1.6.0)
   [WARN] routing/god-doctor.yaml exists but skill file did not until now
 
 Project: /Users/.../my-project/.godpowers/

package/skills/god-init.md

@@ -94,8 +94,8 @@ needs to specify a mode.
    - Write `.godpowers/prep/IMPORTED-CONTEXT.md` when useful context exists
    - Initialize native Pillars context and record Pillars health in
      `INITIAL-FINDINGS.md`
-   - For brownfield: schedule archaeology + reconstruction as preflight
-   - For bluefield: load org-context as constraint
+   - For brownfield: schedule preflight before archaeology + reconstruction
+   - For bluefield: load org-context, then schedule preflight as constraint intake
    - Create directory structure
    - Write PROGRESS.md with mode, scale, timestamp, tier states
    - Return mode/scale/announcement to this skill

package/skills/god-lint.md

@@ -22,6 +22,9 @@ have-nots catalog. Real validation, not self-attestation. Catches:
 - 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)
+- Domain glossary have-nots: missing avoided aliases, implementation details,
+  unresolved ambiguities, undefined relationship terms, behavior-heavy
+  definitions (DG-01..DG-05)
 
 More mechanical have-nots wired in over time. Interpretive checks (e.g.,
 "is the architecture actually good") remain agent-mediated.
@@ -40,7 +43,7 @@ More mechanical have-nots wired in over time. Interpretive checks (e.g.,
 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
+   - Without: scan `.godpowers/{prd,arch,roadmap,stack,domain,design}/` plus
      `DESIGN.md` and `PRODUCT.md` at project root
 3. For each target:
    - Detect artifact type from path

package/skills/god-mode.md

@@ -78,6 +78,8 @@ You are receiving a /god-mode invocation. Your job is to spawn the
    - Instruction to read `.godpowers/prep/INITIAL-FINDINGS.md` and
      `.godpowers/prep/IMPORTED-CONTEXT.md` if present before choosing the
      first planning or build step
+   - Instruction to read `.godpowers/preflight/PREFLIGHT.md` if present before
+     choosing the first brownfield or bluefield action
    - Instruction to compute and load the Pillars load set before every major
      command, because Pillars is the native project context layer
    - Instruction to run `/god-design` after `/god-prd` and before `/god-arch`
@@ -104,6 +106,9 @@ You are receiving a /god-mode invocation. Your job is to spawn the
      must be acted on by god-greenfieldifier. The greenfieldifier writes
      `.godpowers/audit/GREENFIELDIFY-PLAN.md`, pauses before risky canonical
      artifact rewrites, and updates every affected artifact after approval.
+   - Instruction that brownfield and bluefield arcs run `/god-preflight`
+     automatically when `.godpowers/preflight/PREFLIGHT.md` is absent.
+     Greenfield arcs skip preflight unless the user explicitly requests it.
 
 6. Keep the spawn payload private. Do not echo or summarize raw Task input,
    "Hard instructions", hidden orchestration rules, agent prompts, file
@@ -114,8 +119,8 @@ You are receiving a /god-mode invocation. Your job is to spawn the
 
 7. Orchestrator runs the appropriate workflow:
    - Greenfield -> full-arc
-   - Brownfield -> brownfield-arc (archaeology -> reconstruct -> debt-assess -> greenfield simulation audit -> greenfieldify plan and approved artifact updates -> proceed)
-   - Bluefield -> bluefield-arc (org-context -> greenfield simulation audit -> greenfieldify plan and approved artifact updates -> arc with constraints)
+   - Brownfield -> brownfield-arc (preflight -> archaeology -> reconstruct -> debt-assess -> greenfield simulation audit -> greenfieldify plan and approved artifact updates -> proceed)
+   - Bluefield -> bluefield-arc (org-context -> preflight -> greenfield simulation audit -> greenfieldify plan and approved artifact updates -> arc with constraints)
 
 8. Relay only the orchestrator's user-facing output to the user. If the
    platform displays raw spawn details automatically, immediately follow with a
@@ -172,6 +177,13 @@ and logs decisions to `.godpowers/YOLO-DECISIONS.md`. Pillar sync proposals
 generated from durable Godpowers artifact changes are auto-applied in this
 mode and logged as YOLO decisions.
 
+For brownfield and bluefield, `--yolo` still runs `/god-preflight` first when
+`.godpowers/preflight/PREFLIGHT.md` is absent. The orchestrator then follows
+the preflight report's safest recommended route automatically, logging that
+choice to `.godpowers/YOLO-DECISIONS.md`. Preflight may only pause under
+`--yolo` for Critical security findings or a contradiction that makes route
+selection impossible.
+
 ### --conservative
 Pass through. Orchestrator pauses at every tier boundary.
 

package/skills/god-next.md

@@ -251,9 +251,14 @@ When in steady state, match keywords to workflows:
 | upgrade, migrate, bump major | /god-upgrade |
 | docs, documentation, README | /god-docs |
 | deps, dependencies, audit | /god-update-deps |
+| preflight, intake, audit before arc-ready, audit before pillars | /god-preflight |
 | audit, score, quality check | /god-audit |
 | health check, hygiene | /god-hygiene |
 
+If mode detection indicates brownfield or bluefield and
+`.godpowers/preflight/PREFLIGHT.md` is missing, prefer `/god-preflight` before
+recommending archaeology, reconstruction, arc-ready, pillars, or refactor work.
+
 ## Output Format
 
 ```

package/skills/god-preflight.md

@@ -0,0 +1,147 @@
+---
+name: god-preflight
+description: |
+  Run a read-only intake audit before arc-ready, pillars, archaeology, or
+  reconstruction work. Inventory the codebase, surface blockers, and recommend
+  the safest next pass without changing project code.
+
+  Triggers on: "god preflight", "/god-preflight", "preflight audit",
+  "audit before arc-ready", "audit before pillars", "intake audit"
+---
+
+# /god-preflight
+
+Read-only intake audit for an existing codebase.
+
+## When to use
+
+- Before applying arc-ready direction to an existing repo
+- Before scoring the repo against pillars
+- Before brownfield archaeology or reconstruction
+- When deciding whether to restructure, refactor, initialize Godpowers, or pause
+
+## Purpose
+
+This command diagnoses the repo before stronger workflows touch it.
+
+It answers:
+
+- What kind of project is this?
+- What structure, tooling, tests, docs, CI, deploy paths, and agent instructions exist?
+- What is missing before arc-ready can make good decisions?
+- Which pillar weaknesses are already visible?
+- What areas are risky to refactor before more evidence exists?
+- What is the safest next pass?
+
+## Process
+
+1. Verify the target directory contains code or project configuration.
+2. Create `.godpowers/preflight/` if needed.
+3. Inspect the repo read-only:
+   - package manifests, lockfiles, build files, test config, CI config
+   - source tree shape, entry points, module boundaries, scripts
+   - README, docs, ADRs, architecture notes, env examples, AGENTS.md
+   - test presence, test command discoverability, coverage signals
+   - deploy, observability, security, dependency, and ownership signals
+4. Produce `.godpowers/preflight/PREFLIGHT.md`.
+5. Do not edit source files, planning artifacts, configs, or docs outside
+   `.godpowers/preflight/`.
+
+## Scoring
+
+Score only what can be supported by repo evidence.
+
+Use these dimensions:
+
+| Dimension | Looks for |
+|---|---|
+| Repo shape | Project type, framework, package manager, entry points, source layout |
+| Arc readiness | Product direction, architecture notes, roadmap, deploy story, decision records |
+| Pillar readiness | Tests, security, docs, observability, maintainability, UX, deployability |
+| Godpowers readiness | Disk artifacts, AGENTS.md, commands, progress state, safe agent boundaries |
+| Refactor risk | Coupling, missing tests, unclear ownership, ambiguous runtime paths |
+| Suite signals | Multi-package or multi-repo structure, shared packages, release coordination |
+
+Scores are directional, not final quality grades. The value is the evidence and
+the sequence.
+
+## Output
+
+The report must be plain and evidence-backed. Every recommendation must explain
+why it comes before the next one.
+
+Write `.godpowers/preflight/PREFLIGHT.md`:
+
+```markdown
+# Godpowers Preflight
+
+Date: [timestamp]
+Target: [path]
+
+## Snapshot
+
+- DECISION: Project type is [type] because [files or commands].
+- HYPOTHESIS: Primary runtime appears to be [runtime] because [evidence].
+- OPEN QUESTION: [question that blocks confident planning].
+
+## Readiness Scores
+
+| Lens | Score | Evidence | Main blocker |
+|---|---:|---|---|
+| Arc-ready | [0-100] | [specific files or absence] | [blocker] |
+| Pillars | [0-100] | [specific files or absence] | [blocker] |
+| Godpowers | [0-100] | [specific files or absence] | [blocker] |
+| Ready-suite | [0-100 or N/A] | [specific files or absence] | [blocker] |
+
+## Inventory
+
+- DECISION: [thing found] at `[path]`.
+- HYPOTHESIS: [thing inferred] from `[path]`.
+
+## Blockers Before Arc-Ready
+
+1. DECISION: [blocker].
+   Evidence: `[path]` or missing `[path]`.
+   Next move: [specific command or artifact].
+
+## Pillar Weaknesses
+
+1. DECISION: [weakness].
+   Evidence: `[path]` or missing `[path]`.
+   Impact: [why it matters].
+
+## Refactor Risk
+
+1. HYPOTHESIS: [risk].
+   Evidence: `[path]`.
+   Avoid until: [needed proof or test].
+
+## Recommended Sequence
+
+1. DECISION: Run [next command or task] first because [reason].
+2. DECISION: Run [next command or task] second because [reason].
+3. DECISION: Defer [task] until [condition].
+```
+
+## Routing Guidance
+
+Use the report to choose the next pass:
+
+| Finding | Suggested next |
+|---|---|
+| Missing basic project state | `/god-init` |
+| Unknown legacy structure | `/god-archaeology` |
+| Existing code lacks planning artifacts | `/god-reconstruct` |
+| Debt dominates delivery risk | `/god-tech-debt` |
+| Artifacts exist but quality is unknown | `/god-audit` |
+| Tests are absent before refactor | `/god-add-tests` |
+| Refactor path is obvious and bounded | `/god-refactor` |
+
+## Guardrails
+
+- Build nothing.
+- Do not modify application code.
+- Do not normalize formatting.
+- Do not create roadmap, PRD, architecture, or pillar artifacts.
+- Do not score by vibe. Tie every score to evidence.
+- Prefer "unknown" over confident invention.

package/skills/god-version.md

@@ -14,9 +14,9 @@ Print version and a short capability summary.
 ## Output
 
 ```
-Godpowers v1.0.0
+Godpowers v1.6.0
 Install: /Users/.../.claude/  (matches package.json)
-Surface: 105 skills, 39 agents, 13 workflows, 36 recipes
+Surface: 106 skills, 39 agents, 13 workflows, 36 recipes
 Schema: intent.v1, state.v1, events.v1, workflow.v1, routing.v1, recipe.v1
 External integrations available: impeccable, agent-browser (others lazy)
 ```