godpowers 1.6.24 → 2.1.0

package/lib/state.js

@@ -8,6 +8,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const asyncFs = require('./fs-async');
 
 const STATE_VERSION = '1.0.0';
 const COMPLETE_STATUSES = new Set(['done', 'imported', 'skipped', 'not-required']);
@@ -34,6 +35,22 @@ const SUBSTEP_LABELS = {
   harden: 'Harden'
 };
 
+/**
+ * @typedef {Object} GodpowersState
+ * @property {string} $schema State schema URL.
+ * @property {string} version State schema version.
+ * @property {{ name: string, started?: string }} project Project identity.
+ * @property {Record<string, Record<string, Object>>} tiers Tier and sub-step state.
+ */
+
+/**
+ * @typedef {Object} ProgressStep
+ * @property {string} tierKey Tier key such as `tier-1`.
+ * @property {string} subStepKey Sub-step key such as `prd`.
+ * @property {string} status Sub-step status.
+ * @property {number} ordinal One-based step position.
+ */
+
 function statePath(projectRoot) {
   return path.join(projectRoot, '.godpowers', 'state.json');
 }
@@ -57,18 +74,46 @@ function tierComparator(a, b) {
 }
 
 /**
- * Read state.json from a project. Returns null if not initialized.
+ * Read state.json from a project.
+ *
+ * @param {string} projectRoot
+ * @returns {GodpowersState|null}
  */
 function read(projectRoot) {
   const file = statePath(projectRoot);
   if (!fs.existsSync(file)) return null;
-  return JSON.parse(fs.readFileSync(file, 'utf8'));
+  const raw = fs.readFileSync(file, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `Corrupt state file at ${file}: ${e.message}. ` +
+      `Fix the JSON or remove the file to let Godpowers reinitialize it.`
+    );
+  }
 }
 
 /**
- * Write state.json to a project. Validates basic structure.
+ * Async state.json reader for callers that should not block the event loop.
+ *
+ * @param {string} projectRoot
+ * @returns {Promise<GodpowersState|null>}
  */
-function write(projectRoot, state) {
+async function readAsync(projectRoot) {
+  const file = statePath(projectRoot);
+  if (!(await asyncFs.exists(file))) return null;
+  const raw = await asyncFs.fs.readFile(file, 'utf8');
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `Corrupt state file at ${file}: ${e.message}. ` +
+      `Fix the JSON or remove the file to let Godpowers reinitialize it.`
+    );
+  }
+}
+
+function normalizeForWrite(state) {
   if (!state || typeof state !== 'object') {
     throw new Error('state must be an object');
   }
@@ -78,6 +123,18 @@ function write(projectRoot, state) {
     throw new Error('state.project.name is required');
   }
   if (!state.tiers) state.tiers = {};
+  return state;
+}
+
+/**
+ * Write state.json to a project. Validates basic structure.
+ *
+ * @param {string} projectRoot
+ * @param {GodpowersState} state
+ * @returns {GodpowersState}
+ */
+function write(projectRoot, state) {
+  normalizeForWrite(state);
 
   const file = statePath(projectRoot);
   fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -86,10 +143,19 @@ function write(projectRoot, state) {
 }
 
 /**
- * Initialize a new state.json for a project.
+ * Async state.json writer with the same validation contract as write().
+ *
+ * @param {string} projectRoot
+ * @param {GodpowersState} state
+ * @returns {Promise<GodpowersState>}
  */
-function init(projectRoot, projectName, opts = {}) {
-  const state = {
+async function writeAsync(projectRoot, state) {
+  normalizeForWrite(state);
+  return asyncFs.writeJson(statePath(projectRoot), state);
+}
+
+function createInitialState(projectName, opts = {}) {
+  return {
     $schema: 'https://godpowers.dev/schema/state.v1.json',
     version: STATE_VERSION,
     project: {
@@ -128,7 +194,17 @@ function init(projectRoot, projectName, opts = {}) {
     'yolo-decisions': [],
     ...opts
   };
-  return write(projectRoot, state);
+}
+
+/**
+ * Initialize a new state.json for a project.
+ */
+function init(projectRoot, projectName, opts = {}) {
+  return write(projectRoot, createInitialState(projectName, opts));
+}
+
+async function initAsync(projectRoot, projectName, opts = {}) {
+  return writeAsync(projectRoot, createInitialState(projectName, opts));
 }
 
 /**
@@ -147,6 +223,19 @@ function updateSubStep(projectRoot, tierKey, subStepKey, updates) {
   return state.tiers[tierKey][subStepKey];
 }
 
+async function updateSubStepAsync(projectRoot, tierKey, subStepKey, updates) {
+  const state = await readAsync(projectRoot);
+  if (!state) throw new Error('state.json not found');
+  if (!state.tiers[tierKey]) throw new Error(`Tier not found: ${tierKey}`);
+  state.tiers[tierKey][subStepKey] = {
+    ...(state.tiers[tierKey][subStepKey] || {}),
+    ...updates,
+    updated: new Date().toISOString()
+  };
+  await writeAsync(projectRoot, state);
+  return state.tiers[tierKey][subStepKey];
+}
+
 /**
  * Hash a file. Used for artifact-hash tracking.
  */
@@ -271,9 +360,13 @@ function renderProgressLine(summary) {
 
 module.exports = {
   read,
+  readAsync,
   write,
+  writeAsync,
   init,
+  initAsync,
   updateSubStep,
+  updateSubStepAsync,
   hashFile,
   detectDrift,
   statePath,

package/lib/workflow-runner.js

@@ -19,9 +19,9 @@
  *
  * Public API:
  *   loadByName(workflowName, opts?) -> workflow object
- *   plan(workflow, ctx?) -> { steps: [...], waves: [...], summary }
+ *   plan(workflow, ctx?) -> WorkflowPlan
  *   writePlan(projectRoot, runId, plan) -> path
- *   readPlan(projectRoot, runId) -> plan | null
+ *   readPlan(projectRoot, runId) -> serialized plan | null
  *   listWorkflows(opts?) -> [{ name, version, description, file }]
  */
 
@@ -29,6 +29,26 @@ const fs = require('fs');
 const path = require('path');
 
 const parser = require('./workflow-parser');
+const asyncFs = require('./fs-async');
+const agentRefs = require('./agent-refs');
+
+/**
+ * @typedef {Object} WorkflowPlanStep
+ * @property {string} jobKey Workflow job key.
+ * @property {string} agent Validated agent name.
+ * @property {string} agentRange SemVer range declared by the workflow.
+ * @property {string} agentContractVersion Runtime agent contract version.
+ * @property {string|null} tier Tier label such as `tier-2`.
+ * @property {string[]} needs Dependency job keys.
+ */
+
+/**
+ * @typedef {Object} WorkflowPlan
+ * @property {{ name: string, version: string, description?: string }} workflow
+ * @property {WorkflowPlanStep[]} steps
+ * @property {string[][]} waves Parallel execution waves.
+ * @property {string} summary Human-readable plan summary.
+ */
 
 function workflowsDir(opts) {
   if (opts && opts.dir) return opts.dir;
@@ -102,9 +122,12 @@ function plan(workflow, ctx = {}) {
   for (const wave of waves) {
     for (const jobKey of wave) {
       const job = workflow.jobs[jobKey] || {};
+      const ref = agentRefs.assertAgentRef(job.uses);
       steps.push({
         jobKey,
-        agent: extractAgent(job.uses),
+        agent: ref.agent,
+        agentRange: ref.range,
+        agentContractVersion: ref.contractVersion,
         tier: job.tier != null ? `tier-${job.tier}` : null,
         needs: parser.normalizeNeeds(job.needs),
         uses: job.uses,
@@ -133,8 +156,7 @@ function plan(workflow, ctx = {}) {
 
 function extractAgent(uses) {
   if (!uses) return null;
-  const m = String(uses).match(/^([a-z][a-z0-9-]*)/);
-  return m ? m[1] : uses;
+  return agentRefs.parseAgentRef(uses).agent;
 }
 
 function formatSummary(workflow, waves, steps) {
@@ -169,6 +191,13 @@ function writePlan(projectRoot, runId, planObj) {
   return file;
 }
 
+async function writePlanAsync(projectRoot, runId, planObj) {
+  const file = path.join(projectRoot, '.godpowers', 'runs', runId, 'plan.yaml');
+  await asyncFs.fs.mkdir(path.dirname(file), { recursive: true });
+  await asyncFs.fs.writeFile(file, serializePlan(planObj));
+  return file;
+}
+
 function serializePlan(p) {
   // YAML-ish hand-roll, paired with our minimal parser
   const lines = [];
@@ -214,12 +243,20 @@ function readPlan(projectRoot, runId) {
   return fs.readFileSync(file, 'utf8');
 }
 
+async function readPlanAsync(projectRoot, runId) {
+  const file = path.join(projectRoot, '.godpowers', 'runs', runId, 'plan.yaml');
+  if (!(await asyncFs.exists(file))) return null;
+  return asyncFs.fs.readFile(file, 'utf8');
+}
+
 module.exports = {
   workflowsDir,
   listWorkflows,
   loadByName,
   plan,
   writePlan,
+  writePlanAsync,
   readPlan,
+  readPlanAsync,
   serializePlan
 };

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "godpowers",
-  "version": "1.6.24",
+  "version": "2.1.0",
   "description": "AI-powered development system: 110 slash commands and 40 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"
   },
   "scripts": {
-    "test": "node scripts/validate-skills.js && node scripts/test-doc-surface-counts.js && bash scripts/smoke.sh && node scripts/test-runtime.js && node scripts/test-router.js && node scripts/test-recipes.js && node scripts/test-context-writer.js && node scripts/test-pillars.js && node scripts/test-artifact-linter.js && node scripts/test-artifact-diff.js && node scripts/test-design-foundation.js && node scripts/test-linkage.js && node scripts/test-impact.js && node scripts/test-reverse-sync.js && node scripts/test-planning-systems.js && node scripts/test-feature-awareness.js && node scripts/test-repo-doc-sync.js && node scripts/test-repo-surface-sync.js && node scripts/test-automation-surface-sync.js && node scripts/test-host-capabilities.js && node scripts/test-extension-authoring.js && node scripts/test-dogfood-runner.js && node scripts/test-integration.js && node scripts/test-cross-artifact.js && node scripts/test-awesome-design.js && node scripts/test-skillui-bridge.js && node scripts/test-runtime-verification.js && node scripts/test-agent-browser.js && node scripts/test-mode-d.js && node scripts/test-runtime-heuristics.js && node scripts/test-agent-validator.js && node scripts/test-story-validator.js && node scripts/test-state.js && node scripts/test-dashboard.js && node scripts/test-automation-providers.js && node scripts/test-intent.js && node scripts/test-events.js && node scripts/test-golden-artifacts.js && node scripts/test-install-smoke.js && node scripts/test-checkpoint.js && node scripts/test-extensions.js && node scripts/test-event-reader.js && node scripts/test-state-lock.js && node scripts/test-cost-saver.js && node scripts/test-budget-onoff.js && node scripts/test-workflow-runner.js && npm run test:e2e && node scripts/test-otel-exporter.js && node scripts/test-extensions-publish.js",
+    "test": "node scripts/run-tests.js",
     "prepublishOnly": "npm run release:check",
     "validate-skills": "node scripts/validate-skills.js",
     "test:surface": "node scripts/test-doc-surface-counts.js",
+    "test:quick-proof": "node scripts/test-quick-proof.js",
+    "canary:adoption": "node scripts/run-adoption-canary.js",
+    "verify:published-install": "node scripts/verify-published-install.js",
     "smoke": "bash scripts/smoke.sh",
     "test:runtime": "node scripts/test-runtime.js",
     "test:router": "node scripts/test-router.js",
@@ -21,7 +24,8 @@
     "test:e2e": "node tests/integration/full-arc.test.js",
     "test:audit": "npm audit --omit=dev && git diff --check && npm run test:surface",
     "pack:check": "node scripts/check-package-contents.js",
-    "release:check": "npm test && npm run test:audit && npm run pack:check"
+    "release:check": "npm test && npm run test:audit && npm run pack:check",
+    "lint": "node scripts/static-check.js"
   },
   "keywords": [
     "ai",

package/references/HAVE-NOTS.md

@@ -590,11 +590,12 @@ Updates applied without reading changelog for breaking changes. Fail.
 ## Reference Tally
 
 - Universal: 12
-- Tier 0 Orchestration: 6
+- Tier 0 Orchestration: 10
 - Tier 1 PRD: 15
-- Tier 1 Architecture: 12
+- Tier 1 Architecture: 13
 - Tier 1 Roadmap: 10
 - Tier 1 Stack: 5
+- Tier 1 Domain Glossary: 5
 - Tier 2 Repo: 8
 - Tier 2 Build: 12
 - Tier 3 Deploy: 8
@@ -607,7 +608,7 @@ Updates applied without reading changelog for breaking changes. Fail.
 - Workflow Docs: 5
 - Workflow Deps: 6
 
-**Total: 146 named have-nots.**
+**Total: 156 named have-nots.**
 
 Each is grep-testable. Each is a documented failure mode. Together they form
 the mechanical quality definition for Godpowers output.

package/references/orchestration/GOD-MODE-RUNBOOK.md

@@ -0,0 +1,273 @@
+# God Mode Runbook
+
+This reference contains the detailed transcript, flag, final sync, and completion contracts for `/god-mode`. The skill file remains the dispatch contract and points here for operational templates.
+
+## User-Visible Transcript Contract
+
+The God Mode transcript is an operator console, not a prompt debugger.
+
+Show:
+- detected resume or project mode in plain language
+- a compact "Next step" card before each visible phase or tier sub-step
+- a compact "Step result" card after each visible phase or tier sub-step
+- every auto-invoked command, agent, and local runtime helper using an
+  `Auto-invoked:` or `Sync status:` card
+- plain-language workflow names. Say "project run" or "workflow" instead of
+  unexplained "arc" in visible output
+- PRD and roadmap visibility in status and closeout blocks when artifacts
+  exist or are expected
+- short progress updates for phases, commands, validations, and file edits
+- concise validation summaries instead of full command noise when possible
+- final changed paths, validation results, and completion or pause status
+- final Godpowers Dashboard from disk, including phase, tier, step, progress,
+  planning visibility, proactive checks, open items, worktree/index state, and
+  recommended next action
+
+Hide:
+- raw spawn input
+- "Hard instructions" sections
+- spawned-agent prompt text
+- detailed handoff file contents
+- system, developer, or AGENTS.md rule recitations
+- complete file loadout lists
+- internal routing metadata unless it directly affects a user decision
+
+If an internal instruction must influence a pause, translate it into the
+smallest user-facing question. For example, ask for
+`STAGING_APP_URL=<deployed staging origin>` at final sign-off instead of
+exposing the full Shipping Closure Protocol.
+
+## Step Cards
+
+Relay the orchestrator's step cards when present. If the orchestrator output is
+missing them, synthesize them from disk state before continuing.
+
+Before work starts:
+
+```text
+Next step
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
+Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
+Why this now: <one sentence>
+What will happen:
+  1. <observable action>
+  2. <observable action>
+Expected output: <artifact path or verification result>
+```
+
+After work completes or pauses:
+
+```text
+Step result
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
+Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
+Result: <done | blocked | failed | skipped | imported>
+What happened:
+  1. <observable action completed>
+  2. <artifact or verification result>
+Next: <next command or pause question>
+```
+
+## Pause Format (relay from orchestrator)
+
+```
+PAUSE: [one-sentence question]
+
+Why only you can answer: [one sentence]
+
+| Option | Tradeoff |
+|--------|----------|
+| A: ... | ... |
+| B: ... | ... |
+
+Default: If you say "go", I'll pick [X] because [Y].
+```
+
+## Flags
+
+### --yolo
+Pass through to orchestrator. Orchestrator picks defaults at every pause point
+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.
+
+`--yolo` does not skip release-truth gates. If safe sync is unresolved, route
+to `/god-reconcile Release Truth And Safe Sync`. If harden has unresolved
+Critical findings, pause even under `--yolo`.
+
+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.
+
+### --from=<tier>
+Pass through. Orchestrator re-derives state from disk and starts from named tier.
+
+### --audit
+Pass through. Orchestrator skips building, runs god-auditor on existing artifacts.
+
+### --dry-run
+Pass through. Orchestrator plans but writes nothing.
+
+### --with-hygiene
+After Launch, run a post-launch hygiene pass: god-auditor + god-deps-auditor +
+god-docs-writer verification. Catches pre-existing CVEs, doc drift, artifact
+quality drift before declaring complete.
+
+### --skip-hygiene
+Default. Skip the hygiene pass. Use when iterating quickly.
+
+## Mandatory final sync
+
+Regardless of flags, `/god-mode` always runs `/god-sync` before declaring
+complete. This ensures all 14 core artifact categories and local sync surfaces
+are in a consistent state:
+
+- 10 Tier 0-3 artifacts validated (have-nots passing)
+- 4 capture artifacts noted as `not-yet-created` (graceful handling)
+- repo-doc, repo-surface, feature awareness, source sync-back, host capability,
+  checkpoint, Pillars, and context refresh statuses reported
+- SYNC-LOG.md updated with project-run completion entry
+- state.json reflects final tier statuses
+
+Under `--yolo`, the sync step auto-applies (no pause). Under
+`--conservative`, it pauses for confirmation. Under `--with-hygiene`,
+it runs alongside the hygiene pass.
+
+Display this before the final completion block:
+
+```
+Sync status:
+  Trigger: /god-mode final sync
+  Agent: god-updater spawned
+  Local syncs:
+    + feature-awareness: <recorded runtime features, refreshed context, or no-op>
+    + reverse-sync: <counts and result>
+    + repo-doc-sync: <refreshed repo docs, recommended god-docs-writer, or no-op>
+    + repo-surface-sync: <checked structural surfaces, recommended scoped agents, or no-op>
+    + pillars-sync: <counts and result>
+    + checkpoint-sync: <created, updated, no-op, or skipped>
+    + context-refresh: <spawned, no-op, or skipped>
+  Artifacts: <changed files or no-op>
+  Log: .godpowers/SYNC-LOG.md
+```
+
+The sync step also reconciles native Pillars context. When `.godpowers`
+artifacts create or change durable project truth, Godpowers maps those changes
+to relevant pillar files through `lib/pillars.planArtifactSync`. Default mode
+proposes pillar updates for review. `--yolo` applies them immediately and logs
+the action to `.godpowers/YOLO-DECISIONS.md`.
+
+When `/god-mode` resumes an existing `.godpowers` project, it auto-invokes
+`lib/feature-awareness.run(projectRoot)` before the final sync report. This
+keeps upgraded projects aware of new runtime features, current context fences,
+and migration routes without rewriting user artifacts.
+
+The mandatory final sync also receives repo documentation sync through
+`/god-sync`. This keeps README badges, release surfaces, contribution guidance,
+security policy checks, and Pillars context planning arc-ready before the
+project run is declared complete.
+
+The mandatory final sync also receives repo surface sync through `/god-sync`.
+This keeps routes, packages, agent handoffs, workflow metadata, recipe routes,
+extension packs, and release policy checks aligned before the project run is
+declared complete.
+
+If `/god-mode` resumes an existing `.godpowers` project that lacks Pillars,
+it Pillar-izes the project before continuing. Existing `.godpowers` artifacts
+become managed source references in the relevant `agents/*.md` files.
+
+The sync step is what closes the loop between greenfield project-run creation and
+the comprehensive 14-artifact reconciliation system. See
+`docs/greenfield-coverage.md` for what's created when.
+
+## Completion
+
+When orchestrator returns "complete", display:
+
+```
+Godpowers project run complete.
+
+Sync status:
+  Trigger: /god-mode final sync
+  Agent: god-updater spawned
+  Local syncs:
+    + feature-awareness: <recorded runtime features, refreshed context, or no-op>
+    + reverse-sync: <counts and result>
+    + repo-doc-sync: <refreshed repo docs, recommended god-docs-writer, or no-op>
+    + repo-surface-sync: <checked structural surfaces, recommended scoped agents, or no-op>
+    + pillars-sync: <counts and result>
+    + checkpoint-sync: <created, updated, no-op, or skipped>
+    + context-refresh: <spawned, no-op, or skipped>
+  Artifacts: <changed files or no-op>
+  Log: .godpowers/SYNC-LOG.md
+
+Current status:
+  State: complete
+  Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
+  Worktree: <clean | modified files unstaged | staged changes | mixed>
+  Index: <untouched | staged files listed>
+
+Planning visibility:
+  PRD: <done | pending | missing | deferred> <artifact path when present>
+  Roadmap: <done | pending | missing | deferred> <artifact path when present>
+  Current milestone: <roadmap milestone, tier, or next planning gate when known>
+  Completion: <pct>% <brief basis, for example done steps over total tracked steps>
+
+Artifacts on disk:
+  + PRD           .godpowers/prd/PRD.md
+  + Architecture  .godpowers/arch/ARCH.md
+  + Roadmap       .godpowers/roadmap/ROADMAP.md
+  + Stack         .godpowers/stack/DECISION.md
+  + Repo          .godpowers/repo/AUDIT.md
+  + Build         .godpowers/build/STATE.md
+  + Deploy        .godpowers/deploy/STATE.md
+  + Observe       .godpowers/observe/STATE.md
+  + Launch        .godpowers/launch/STATE.md
+  + Harden        .godpowers/harden/FINDINGS.md
+
+Built. Tested. Shipped. Hardened.
+
+Project is now in STEADY STATE. From here, use these workflows:
+
+  Adding features:        /god-feature
+  Production bugs:        /god-hotfix
+  Code cleanup:           /god-refactor
+  Research questions:     /god-spike
+  Post-incident:          /god-postmortem
+  Framework upgrades:     /god-upgrade
+  Documentation:          /god-docs
+  Dependency updates:     /god-update-deps
+
+Periodic hygiene:
+  Quality audit:          /god-audit
+  Health check:           /god-hygiene
+
+Open items:
+  1. <none, or deployed staging deferred, pending review, unstaged files, etc.>
+
+Next:
+  Recommended: <single safest command or decision>
+  Why: <one sentence tied to disk state>
+
+Proposition:
+  1. Review status: /god-status
+  2. Continue work: /god-next or describe the next intent
+  3. Commit release-ready changes: stage only the intended files, then commit
+  4. Run deployed staging: provide STAGING_APP_URL=<deployed staging origin> when needed
+```
+
+If the run edited code but did not stage or commit, the completion block must
+say so. If unrelated or pre-existing worktree changes are present, do not imply
+the worktree is clean. Recommend a scoped review or explicit staging path.
+
+If the run is a focused brownfield/refactor workflow rather than a full greenfield
+project run, adapt the same closeout shape and replace "Project is now in STEADY
+STATE" with the actual disk-derived lifecycle and next route.

package/routing/god-arch.yaml

@@ -31,7 +31,7 @@ execution:
 standards:
   substitution-test: true
   three-label-test: true
-  have-nots: [A-01, A-02, A-03, A-04, A-05, A-06, A-07, A-08, A-09, A-10, A-11, A-12]
+  have-nots: [A-01, A-02, A-03, A-04, A-05, A-06, A-07, A-08, A-09, A-10, A-11, A-12, A-13]
   gate-on-failure: pause-for-user
 
 success-path:

package/routing/god-build.yaml

@@ -11,7 +11,7 @@ prerequisites:
       auto-complete: /god-roadmap
       human-required: true
     - check: state:tier-2.repo.status == done
-      auto-complete: /god-roadmap
+      auto-complete: /god-repo
       human-required: true
 
 execution:

package/skills/god-add-backlog.md

@@ -2,7 +2,7 @@
 name: god-add-backlog
 description: |
   Add an idea to the backlog. Less urgent than a todo. Reviewed periodically
-  via /god-review-backlog. Captured in .godpowers/backlog/BACKLOG.md.
+  via /god-add-backlog list. Captured in .godpowers/backlog/BACKLOG.md.
 
   Triggers on: "god add backlog", "/god-add-backlog", "backlog this", "for later"
 ---

package/skills/god-agent-audit.md

@@ -1,7 +1,7 @@
 ---
 name: god-agent-audit
 description: |
-  Validates every `agents/*.md` against the agent contract:
+  Validates every `agents/god-*.md` against the agent contract:
   required frontmatter, recommended sections (Have-Nots, Inputs,
   Outputs, Handoff), hand-off targets exist, no dual-ownership of
   output paths. Lenient by design: most issues are warnings; only
@@ -50,7 +50,7 @@ opportunities, not failures.
 ```
 Agent audit
 
-37 agents audited
+40 agents audited
 0 errors, 2 warnings, 90 infos
 
 Errors:

package/skills/god-build.md

@@ -39,12 +39,14 @@ For each slice in the wave (parallel):
    - The slice plan only (not the whole PLAN.md)
    - Relevant ARCH context for this slice
    - Stack DECISION
-2. Wait for executor to complete (TDD enforced)
+2. Wait for executor to complete (TDD and request-trace discipline enforced)
 3. Spawn **god-spec-reviewer** in fresh context (independent of executor)
-   - If FAIL: return slice to god-executor with findings
+   - If FAIL: return slice to god-executor with findings, including any
+     scope creep or request-trace failures
    - If PASS: proceed to stage 2
 4. Spawn **god-quality-reviewer** in fresh context (independent)
-   - If FAIL: return slice to god-executor with findings
+   - If FAIL: return slice to god-executor with findings, including any
+     overcomplication, speculative abstraction, or unrelated cleanup
    - If PASS: commit the slice atomically
 5. Update `.godpowers/build/STATE.md`
 

package/skills/god-context-scan.md

@@ -60,9 +60,8 @@ called drifts.
      last 3 events)
    - **info**: claim mentions facts not in CHECKPOINT held-facts
      (might be new, worth recording)
-6. Suggested actions: `/god-locate` to re-orient, `/god-repair`
-   for state drift, or accept the new facts via `/god-checkpoint
-   --record-facts`.
+6. Suggested actions: `/god-locate` to re-orient, or `/god-repair`
+   to reconcile state drift and record the new facts.
 
 ### Output