godpowers 0.15.18 → 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/lib/pillars.js

@@ -375,9 +375,10 @@ function dedupeMissing(missing) {
 
 function buildProtocolContent(exclusions = []) {
   const lines = [];
-  lines.push('# Pillars: Agent Protocol');
+  lines.push('# Godpowers Project Context');
   lines.push('');
-  lines.push('This project follows the Pillars standard. Coding agents read project context from `./agents/*.md` before changing code.');
+  lines.push('This is a Godpowers project. Godpowers uses the Pillars standard as its native project context layer.');
+  lines.push('Coding agents read project context from `./agents/*.md` before changing code, while `.godpowers/` remains the Godpowers workflow state and artifact layer.');
   lines.push('');
   lines.push('## At the start of any task');
   lines.push('');
@@ -516,6 +517,9 @@ function pillarStub(name, meta, opts = {}) {
   lines.push('## Context');
   lines.push('');
   lines.push('(stub) Fill with facts an agent cannot reliably infer from code alone.');
+  for (const line of opts.context || []) {
+    lines.push(`- ${sanitizeSignal(line)}`);
+  }
   lines.push('');
   lines.push('## Decisions');
   lines.push('');
@@ -559,7 +563,9 @@ function init(projectRoot, opts = {}) {
   writeFenced(agentsFile, PILLARS_FENCE_BEGIN, PILLARS_FENCE_END, buildProtocolContent(exclusions));
 
   const results = [];
-  results.push(ensurePillar(projectRoot, 'context', ALWAYS_PILLARS.context, { always: true }));
+  const context = [];
+  if (opts.projectName) context.push(`[HYPOTHESIS] Project name: ${opts.projectName}`);
+  results.push(ensurePillar(projectRoot, 'context', ALWAYS_PILLARS.context, { always: true, context }));
   results.push(ensurePillar(projectRoot, 'repo', ALWAYS_PILLARS.repo, { always: true }));
 
   const coreNames = opts.corePillars || Object.keys(CORE_PILLARS);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "godpowers",
-  "version": "0.15.18",
-  "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"
   },
@@ -72,6 +72,7 @@
     "lib/",
     "extensions/",
     "INSPIRATION.md",
+    "RELEASE.md",
     "SKILL.md",
     "AGENTS.md",
     "CHANGELOG.md",

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 (0.15.18)
+  [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-extension-info.md

@@ -31,7 +31,7 @@ Description:
   specific checks.
 
 Engines:
-  godpowers: >=0.14.0 <2.0.0  (compatible with running v0.15.18? YES)
+  godpowers: >=0.14.0 <2.0.0  (compatible with running v1.0.0? YES)
 
 Provides:
   Agents (3):

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
 
 ```