godpowers 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -5,6 +5,58 @@ 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.2] - 2026-05-11
+
+Runtime hardening release. Fixes packaging and workflow edge cases found by
+a deep audit, then locks them behind regression tests and pack publish gates.
+
+### Fixed
+- Installed `/god`, `/god-next`, `/god-help`, `/god-standards`, and
+  `/god-version` now point agents at the installed `godpowers-runtime`
+  bundle when the user is not inside the repository checkout.
+- Installer now copies `package.json` into `godpowers-runtime`, so installed
+  OTel exports report the real Godpowers version instead of `0.0.0`.
+- Linkage scans now replace stale scanner-owned links instead of only adding
+  new links. Manual links are preserved, and legacy maps without source
+  metadata are migrated safely.
+- `checkpoint.recordFact()` now preserves existing actions instead of wiping
+  the checkpoint action history.
+- Context writer now reads root-level `mode` and `scale`, matching the
+  canonical `state.json` shape produced by `lib/state.js`.
+- Event hash chains now stay valid when an event line is larger than 4KB.
+- Extension reinstall now clears the old installed pack directory first, so
+  deleted files do not remain active after reinstall.
+- Installer uninstall now removes all installed data/runtime directories,
+  including workflows, schema, routing, and `godpowers-runtime`.
+
+### Tests
+- Added regression coverage for stale linkage cleanup, checkpoint action
+  preservation, root-level mode/scale context rendering, large event hash
+  chains, installed OTel version metadata, runtime bundle guidance in installed
+  skills, extension reinstall cleanup, and uninstall cleanup.
+- Extension pack publish gate now verifies package peer dependency ranges
+  match the manifest and include the current Godpowers version.
+
+## [0.15.1] - 2026-05-11
+
+Metadata + documentation polish. No code changes.
+
+### Changed
+- `package.json` description rewritten from tagline to searchable
+  one-liner: explains what godpowers is and lists the AI tools it
+  runs in. Improves npm registry discoverability.
+- `package.json` keywords expanded 10 -> 25. Adds variants like
+  `ai-agent`, `ai-orchestration`, specific tool names
+  (`claude-code`, `windsurf`, `gemini`, `copilot`), and artifact
+  taxonomy (`prd`, `architecture`, `roadmap`, `specialist-agents`).
+- `docs/reference.md`: catalogue gap closed. The 23 skills shipped
+  in v0.13 - v0.15 are now indexed (recovery, observability, the
+  OTel exporter, extension management). Index now matches the 104
+  skill files on disk.
+- `README.md`: clean Install section without scaffold disclaimers.
+- `docs/ROADMAP.md`: v0.16 and v1.0 sections rewritten in a tighter,
+  goal-focused tone.
+
 ## [0.15.0] - 2026-05-11
 
 Distribution release. Godpowers and its three first-party packs are

package/README.md

@@ -2,7 +2,8 @@
 
 [![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.14.0-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-0.15.2-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.**
 

package/bin/install.js

@@ -157,6 +157,20 @@ function copyRecursive(src, dest) {
   }
 }
 
+function copyRuntimeBundle(srcDir, destDir) {
+  ensureDir(destDir);
+  for (const dir of ['lib', 'routing', 'workflows', 'schema', 'templates', 'references']) {
+    const src = path.join(srcDir, dir);
+    if (fs.existsSync(src)) {
+      copyRecursive(src, path.join(destDir, dir));
+    }
+  }
+  const packageJson = path.join(srcDir, 'package.json');
+  if (fs.existsSync(packageJson)) {
+    fs.copyFileSync(packageJson, path.join(destDir, 'package.json'));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Parse args
 // ---------------------------------------------------------------------------
@@ -299,6 +313,11 @@ function installForRuntime(runtimeKey, srcDir) {
     success('Installed routing/');
   }
 
+  // 4f. Install the executable runtime bundle with lib/ next to its data dirs.
+  const runtimeBundleDest = path.join(runtime.configDir, 'godpowers-runtime');
+  copyRuntimeBundle(srcDir, runtimeBundleDest);
+  success('Installed runtime bundle/');
+
   // 5. Install hooks (Claude Code only for now)
   if (runtimeKey === 'claude') {
     const hooksSrc = path.join(srcDir, 'hooks');
@@ -339,6 +358,10 @@ function uninstallForRuntime(runtimeKey) {
   const agentsDir = path.join(runtime.configDir, 'agents');
   const templatesDir = path.join(runtime.configDir, 'godpowers-templates');
   const referencesDir = path.join(runtime.configDir, 'godpowers-references');
+  const workflowsDir = path.join(runtime.configDir, 'godpowers-workflows');
+  const schemaDir = path.join(runtime.configDir, 'godpowers-schema');
+  const routingDir = path.join(runtime.configDir, 'godpowers-routing');
+  const runtimeBundleDir = path.join(runtime.configDir, 'godpowers-runtime');
   const versionFile = path.join(runtime.configDir, 'GODPOWERS_VERSION');
 
   let removed = 0;
@@ -366,14 +389,19 @@ function uninstallForRuntime(runtimeKey) {
     success(`Removed ${agentsRemoved} god-* agent(s)`);
   }
 
-  // Remove templates and references directories
-  if (fs.existsSync(templatesDir)) {
-    fs.rmSync(templatesDir, { recursive: true, force: true });
-    success('Removed godpowers-templates/');
-  }
-  if (fs.existsSync(referencesDir)) {
-    fs.rmSync(referencesDir, { recursive: true, force: true });
-    success('Removed godpowers-references/');
+  // Remove installed data and runtime directories
+  for (const dir of [
+    templatesDir,
+    referencesDir,
+    workflowsDir,
+    schemaDir,
+    routingDir,
+    runtimeBundleDir
+  ]) {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+      success(`Removed ${path.basename(dir)}/`);
+    }
   }
 
   // Remove hooks (Claude Code only)

package/lib/checkpoint.js

@@ -228,6 +228,7 @@ function recordFact(projectRoot, fact) {
   facts.unshift(f);
 
   const state = existing ? frontmatterToState(existing.frontmatter, facts) : { facts };
+  state.actions = existing ? existing.actions.slice() : [];
   state.facts = facts;
   return write(projectRoot, state);
 }

package/lib/code-scanner.js

@@ -230,12 +230,9 @@ function scan(projectRoot, opts = {}) {
  */
 function applyScan(projectRoot, scanResult, opts = {}) {
   const { links } = scanResult;
-  let added = 0;
-  for (const l of links) {
-    const r = linkage.addLink(projectRoot, l.artifactId, l.file, { source: l.source });
-    if (r.added) added++;
-  }
-  return { totalLinks: links.length, added };
+  const source = opts.source || 'code-scanner';
+  const result = linkage.bulkReplaceFromSource(projectRoot, source, links);
+  return { totalLinks: links.length, added: result.added, removed: result.removed };
 }
 
 // ============================================================================

package/lib/context-writer.js

@@ -79,8 +79,8 @@ function buildCanonicalContent(state, opts = {}) {
   lines.push('');
 
   const projectName = (state && state.project && state.project.name) || opts.projectName || '(unnamed)';
-  const mode = (state && state.project && state.project.mode) || opts.mode || 'unknown';
-  const scale = (state && state.project && state.project.scale) || opts.scale || 'unknown';
+  const mode = (state && (state.mode || (state.project && state.project.mode))) || opts.mode || 'unknown';
+  const scale = (state && (state.scale || (state.project && state.project.scale))) || opts.scale || 'unknown';
   lines.push(`- Project: ${projectName}`);
   lines.push(`- Mode: ${mode}    Scale: ${scale}`);
   lines.push('- State: `.godpowers/state.json` (machine) and `.godpowers/PROGRESS.md` (human)');

package/lib/events.js

@@ -38,6 +38,13 @@ function eventsPath(projectRoot, runId) {
   return path.join(projectRoot, '.godpowers', 'runs', runId, 'events.jsonl');
 }
 
+function readLastNonEmptyLine(file) {
+  const raw = fs.readFileSync(file, 'utf8').trimEnd();
+  if (!raw) return null;
+  const i = raw.lastIndexOf('\n');
+  return i >= 0 ? raw.slice(i + 1) : raw;
+}
+
 /**
  * Start a new run. Returns a run handle with trace_id and write functions.
  */
@@ -105,17 +112,10 @@ function emit(file, event) {
   if (fs.existsSync(file)) {
     const stat = fs.statSync(file);
     if (stat.size > 0) {
-      // Read just the last 4KB to find the last full line.
-      const fd = fs.openSync(file, 'r');
-      const chunkSize = Math.min(4096, stat.size);
-      const buf = Buffer.alloc(chunkSize);
-      fs.readSync(fd, buf, 0, chunkSize, stat.size - chunkSize);
-      fs.closeSync(fd);
-      const tail = buf.toString('utf8');
-      const lines = tail.split('\n').filter(l => l.trim());
-      if (lines.length > 0) {
+      const line = readLastNonEmptyLine(file);
+      if (line) {
         prev = 'sha256:' + crypto.createHash('sha256')
-          .update(lines[lines.length - 1])
+          .update(line)
           .digest('hex');
       }
     }

package/lib/extensions.js

@@ -212,6 +212,7 @@ function install(runtimeConfigDir, sourceDir, godpowersVersion) {
   }
 
   const destDir = path.join(extensionsDir(runtimeConfigDir), manifest.metadata.name);
+  fs.rmSync(destDir, { recursive: true, force: true });
   fs.mkdirSync(destDir, { recursive: true });
 
   // Copy manifest + standard pack subdirs if they exist

package/lib/intent.js

@@ -38,7 +38,8 @@ function parseSimpleYaml(content) {
   const result = {};
   const stack = [{ obj: result, indent: -1, key: null, isArray: false, parent: null }];
 
-  for (let line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
     if (!line.trim() || line.trim().startsWith('#')) continue;
     // Strip inline comments (but not # inside quotes)
     const hashIdx = line.indexOf(' #');
@@ -60,8 +61,6 @@ function parseSimpleYaml(content) {
       stack.pop();
     }
     const parent = stack[stack.length - 1].obj;
-    const parentMeta = stack[stack.length - 1];
-
     // List item: "- key: value" or "- value"
     if (trimmed.startsWith('- ')) {
       const rest = trimmed.slice(2);
@@ -108,7 +107,9 @@ function parseSimpleYaml(content) {
       parent[key] = child;
       stack.push({ obj: child, indent, key, parent });
     } else if (valueStr === '|' || valueStr === '>') {
-      parent[key] = '';
+      const block = readBlockScalar(lines, i + 1, indent, valueStr === '>');
+      parent[key] = block.value;
+      i = block.nextIndex - 1;
     } else {
       parent[key] = parseValue(valueStr);
     }
@@ -117,6 +118,37 @@ function parseSimpleYaml(content) {
   return cleanArrays(result);
 }
 
+function readBlockScalar(lines, startIndex, parentIndent, folded) {
+  const blockLines = [];
+  let i = startIndex;
+
+  for (; i < lines.length; i++) {
+    const raw = lines[i];
+    if (!raw.trim()) {
+      blockLines.push('');
+      continue;
+    }
+    const indent = raw.length - raw.trimStart().length;
+    if (indent <= parentIndent) break;
+    blockLines.push(raw);
+  }
+
+  const nonBlankIndents = blockLines
+    .filter(line => line.trim())
+    .map(line => line.length - line.trimStart().length);
+  const trimIndent = nonBlankIndents.length
+    ? Math.min(...nonBlankIndents)
+    : parentIndent + 2;
+  const normalized = blockLines.map(line => (
+    line.trim() ? line.slice(Math.min(trimIndent, line.length)) : ''
+  ));
+
+  return {
+    value: folded ? normalized.join(' ').replace(/\s+/g, ' ').trim() : normalized.join('\n').trimEnd(),
+    nextIndex: i
+  };
+}
+
 function parseValue(str) {
   if (str === 'true') return true;
   if (str === 'false') return false;

package/lib/linkage.js

@@ -8,6 +8,7 @@
  * Storage:
  *   .godpowers/links/artifact-to-code.json   - forward map
  *   .godpowers/links/code-to-artifact.json   - reverse map
+ *   .godpowers/links/link-sources.json       - source ownership map
  *   .godpowers/links/LINKAGE-LOG.md          - append-only history
  *
  * Stable ID format:
@@ -53,6 +54,10 @@ function reversePath(projectRoot) {
   return path.join(linksDir(projectRoot), 'code-to-artifact.json');
 }
 
+function sourcePath(projectRoot) {
+  return path.join(linksDir(projectRoot), 'link-sources.json');
+}
+
 function logPath(projectRoot) {
   return path.join(linksDir(projectRoot), 'LINKAGE-LOG.md');
 }
@@ -75,6 +80,19 @@ function writeMap(filePath, data) {
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
 }
 
+function linkKey(artifactId, filePath) {
+  return `${artifactId}\u0000${filePath}`;
+}
+
+function parseLinkKey(key) {
+  const i = key.indexOf('\u0000');
+  return { artifactId: key.slice(0, i), file: key.slice(i + 1) };
+}
+
+function readSources(projectRoot) {
+  return readMap(sourcePath(projectRoot));
+}
+
 /**
  * Read forward map: artifact ID -> array of file paths.
  */
@@ -111,8 +129,16 @@ function addLink(projectRoot, artifactId, filePath, opts = {}) {
   fwd[artifactId].sort();
   rev[normFile].sort();
 
+  const sources = readSources(projectRoot);
+  const source = opts.source || 'manual';
+  const key = linkKey(artifactId, normFile);
+  if (!sources[key]) sources[key] = [];
+  if (!sources[key].includes(source)) sources[key].push(source);
+  sources[key].sort();
+
   writeMap(forwardPath(projectRoot), fwd);
   writeMap(reversePath(projectRoot), rev);
+  writeMap(sourcePath(projectRoot), sources);
 
   if (!fwdHad || !revHad) {
     appendLog(projectRoot, `+ link: ${artifactId} <-> ${normFile}` + (opts.source ? ` (via ${opts.source})` : ''));
@@ -143,8 +169,12 @@ function removeLink(projectRoot, artifactId, filePath) {
     if (before !== (rev[normFile] ? rev[normFile].length : 0)) removed = true;
   }
 
+  const sources = readSources(projectRoot);
+  delete sources[linkKey(artifactId, normFile)];
+
   writeMap(forwardPath(projectRoot), fwd);
   writeMap(reversePath(projectRoot), rev);
+  writeMap(sourcePath(projectRoot), sources);
 
   if (removed) {
     appendLog(projectRoot, `- link: ${artifactId} <-> ${normFile}`);
@@ -204,12 +234,84 @@ function appendLog(projectRoot, message) {
  */
 function bulkReplaceFromSource(projectRoot, source, links) {
   ensureDir(projectRoot);
-  const log = [];
+  const fwd = readForward(projectRoot);
+  const rev = readReverse(projectRoot);
+  const sources = readSources(projectRoot);
+  const desired = new Set();
+  let removed = 0;
+  let added = 0;
+
   for (const { artifactId, file } of links) {
-    const r = addLink(projectRoot, artifactId, file, { source });
-    if (r.added) log.push(`from ${source}: ${artifactId} -> ${file}`);
+    const normFile = path.relative(projectRoot, path.resolve(projectRoot, file));
+    desired.add(linkKey(artifactId, normFile));
+  }
+
+  const knownSourceKeys = Object.keys(sources)
+    .filter(key => Array.isArray(sources[key]) && sources[key].includes(source));
+  const hasSourceMetadata = Object.keys(sources).length > 0;
+  const replaceKeys = knownSourceKeys.length > 0
+    ? knownSourceKeys
+    : hasSourceMetadata
+      ? []
+    : Object.entries(fwd).flatMap(([artifactId, files]) =>
+      files.map(file => linkKey(artifactId, file)));
+
+  for (const key of replaceKeys) {
+    if (desired.has(key)) continue;
+    const { artifactId, file } = parseLinkKey(key);
+    sources[key] = (sources[key] || []).filter(s => s !== source);
+    if (sources[key] && sources[key].length > 0) continue;
+
+    delete sources[key];
+    if (fwd[artifactId]) {
+      fwd[artifactId] = fwd[artifactId].filter(f => f !== file);
+      if (fwd[artifactId].length === 0) delete fwd[artifactId];
+    }
+    if (rev[file]) {
+      rev[file] = rev[file].filter(id => id !== artifactId);
+      if (rev[file].length === 0) delete rev[file];
+    }
+    appendLog(projectRoot, `- link: ${artifactId} <-> ${file} (via ${source})`);
+    removed++;
+  }
+
+  for (const { artifactId, file } of links) {
+    const normFile = path.relative(projectRoot, path.resolve(projectRoot, file));
+    const key = linkKey(artifactId, normFile);
+    if (!fwd[artifactId]) fwd[artifactId] = [];
+    if (!rev[normFile]) rev[normFile] = [];
+    const hadLink = fwd[artifactId].includes(normFile) && rev[normFile].includes(artifactId);
+    if (!fwd[artifactId].includes(normFile)) fwd[artifactId].push(normFile);
+    if (!rev[normFile].includes(artifactId)) rev[normFile].push(artifactId);
+    if (!sources[key]) sources[key] = [];
+    if (!sources[key].includes(source)) sources[key].push(source);
+    sources[key].sort();
+    if (!hadLink) {
+      appendLog(projectRoot, `+ link: ${artifactId} <-> ${normFile} (via ${source})`);
+      added++;
+    }
+  }
+
+  for (const files of Object.values(fwd)) files.sort();
+  for (const ids of Object.values(rev)) ids.sort();
+
+  writeMap(forwardPath(projectRoot), fwd);
+  writeMap(reversePath(projectRoot), rev);
+  writeMap(sourcePath(projectRoot), sources);
+
+  return {
+    count: links.length,
+    added,
+    removed
+  };
+}
+
+function clearSourceMetadata(projectRoot) {
+  ensureDir(projectRoot);
+  const file = sourcePath(projectRoot);
+  if (fs.existsSync(file)) {
+    fs.rmSync(file, { force: true });
   }
-  return { count: links.length, added: log.length };
 }
 
 module.exports = {
@@ -225,8 +327,10 @@ module.exports = {
   coverage,
   appendLog,
   bulkReplaceFromSource,
+  clearSourceMetadata,
   forwardPath,
   reversePath,
+  sourcePath,
   logPath,
   linksDir
 };

package/lib/router.js

@@ -83,6 +83,12 @@ function checkPrerequisites(command, projectRoot) {
  * Predicates: file:path, state:dotted.path == value, env:VAR
  */
 function evaluateCheck(check, projectRoot) {
+  // OR conditions must be handled before prefix-specific checks so both
+  // branches can be evaluated as independent predicates.
+  if (check.includes(' OR ')) {
+    return check.split(' OR ').some(part => evaluateCheck(part.trim(), projectRoot));
+  }
+
   // file:path
   if (check.startsWith('file:')) {
     const filePath = check.slice(5).trim();
@@ -101,11 +107,6 @@ function evaluateCheck(check, projectRoot) {
     return actual === expected || actual === parseValue(expected);
   }
 
-  // OR conditions
-  if (check.includes(' OR ')) {
-    return check.split(' OR ').some(part => evaluateCheck(part.trim(), projectRoot));
-  }
-
   // mode-A-greenfield: pass-through hint, treat as satisfiable
   if (check.includes('greenfield') || check.includes('mode-A')) {
     return !fs.existsSync(path.join(projectRoot, '.godpowers'));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "godpowers",
-  "version": "0.15.0",
-  "description": "Ship fast. Ship right. Ship everything. Ship accountably.",
+  "version": "0.15.2",
+  "description": "AI-powered development system: 104 slash commands and 38 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"
   },
@@ -19,15 +19,30 @@
   },
   "keywords": [
     "ai",
-    "coding",
+    "ai-agent",
+    "ai-agents",
+    "ai-development",
+    "ai-coding",
+    "ai-orchestration",
     "agent",
+    "agents",
     "claude",
+    "claude-code",
     "codex",
     "cursor",
+    "windsurf",
+    "gemini",
+    "copilot",
     "tdd",
     "orchestration",
     "godmode",
-    "slash-commands"
+    "slash-commands",
+    "skills",
+    "prd",
+    "architecture",
+    "roadmap",
+    "specialist-agents",
+    "developer-tools"
   ],
   "author": "Godpowers",
   "license": "MIT",

package/skills/god-help.md

@@ -51,7 +51,9 @@ Show only one category (lifecycle, planning, building, shipping, etc.).
 Built-in, no spawned agent. Reads:
 - `<runtime>/skills/*.md` frontmatter
 - `.godpowers/state.json` (for current state line)
-- `lib/recipes.js` (for suggested next)
+- `<runtimeRoot>/lib/recipes.js` (for suggested next)
+
+Resolve `<runtimeRoot>` as `<projectRoot>` when `<projectRoot>/lib/recipes.js` exists. Otherwise use the installed bundle at `<tool-config-dir>/godpowers-runtime`, where `<tool-config-dir>` is the directory that contains this installed skill.
 
 ## When to use
 

package/skills/god-next.md

@@ -3,7 +3,7 @@ name: god-next
 description: |
   Decision engine. For any command intent, checks prerequisites, proposes
   auto-completion of missing prerequisites, runs standards checks at gates,
-  and suggests next commands after success. Backed by routing/<command>.yaml
+  and suggests next commands after success. Backed by runtime routing YAML
   configurations.
 
   Triggers on: "god next", "/god-next", "what's next", "what should I do next",
@@ -15,16 +15,24 @@ description: |
 The unified decision engine. Routes between commands based on disk state,
 routing definitions, and user intent.
 
+## Runtime module resolution
+
+Before reading routing data or calling runtime modules, resolve the Godpowers runtime root:
+
+1. If `<projectRoot>/lib/router.js` exists, use the repository checkout runtime at `<projectRoot>`.
+2. Otherwise use the installed bundle at `<tool-config-dir>/godpowers-runtime`, where `<tool-config-dir>` is the directory that contains this installed skill, such as `~/.claude`, `~/.codex`, `~/.cursor`, `~/.windsurf`, or `~/.gemini`.
+3. Read routing definitions from `<runtimeRoot>/routing/*.yaml` and recipes from `<runtimeRoot>/routing/recipes/*.yaml`.
+
 ## Three modes of invocation
 
 ### Mode 1: After a command (post-completion routing)
 The completing skill calls /god-next to determine what's next.
-Reads `routing/<just-completed>.yaml`, gets `success-path.next-recommended`,
+Reads `<runtimeRoot>/routing/<just-completed>.yaml`, gets `success-path.next-recommended`,
 suggests it.
 
 ### Mode 2: Before a command (pre-flight)
 User wants to run /god-X. /god-next checks prerequisites first.
-Reads `routing/<X>.yaml`, evaluates prerequisites, proposes auto-completion
+Reads `<runtimeRoot>/routing/<X>.yaml`, evaluates prerequisites, proposes auto-completion
 if any are missing.
 
 ### Mode 3: Standalone (state-driven)
@@ -40,7 +48,7 @@ A skill completes (e.g., /god-prd just finished)
 Skill calls: /god-next --after=/god-prd
    |
    v
-Read routing/god-prd.yaml
+Read <runtimeRoot>/routing/god-prd.yaml
    |
    v
 Get success-path.next-recommended (e.g., "/god-arch")
@@ -76,7 +84,7 @@ User types: /god-arch
 The /god-arch skill calls: /god-next --before=/god-arch
    |
    v
-Read routing/god-arch.yaml
+Read <runtimeRoot>/routing/god-arch.yaml
    |
    v
 For each prerequisite in prerequisites.required:
@@ -109,7 +117,7 @@ User types: /god-next
 Read .godpowers/state.json (or PROGRESS.md as fallback)
    |
    v
-Use lib/router.suggestNext(projectRoot)  <- structural next
+Use <runtimeRoot>/lib/router.js suggestNext(projectRoot)  <- structural next
    |
    v
 For each tier in order:
@@ -118,7 +126,7 @@ For each tier in order:
    |
    v
 If all tiers done:
-   - Use lib/recipes.suggestForState(projectRoot)  <- scenario-aware
+   - Use <runtimeRoot>/lib/recipes.js suggestForState(projectRoot)  <- scenario-aware
    - Returns recipes matching current lifecycle phase
    |
    v
@@ -132,7 +140,7 @@ Display: "Suggested next: /god-arch
 User says: "I need to add a new feature mid-development"
    |
    v
-/god-next consults lib/recipes.matchIntent(text, projectRoot)
+/god-next consults <runtimeRoot>/lib/recipes.js matchIntent(text, projectRoot)
    |
    v
 Returns ranked recipes matching:
@@ -150,20 +158,20 @@ Display top match with the recipe's sequence:
     Run this sequence? Or see other matches?"
 ```
 
-This is the recipe-driven decision support: agents consult `routing/recipes/`
+This is the recipe-driven decision support: agents consult `<runtimeRoot>/routing/recipes/`
 when user intent is fuzzy or doesn't map to a single command.
 
 ## Routing data
 
-Routing definitions live in `routing/*.yaml`. Each command has a file:
-- `routing/god-prd.yaml`
-- `routing/god-arch.yaml`
+Routing definitions live in `<runtimeRoot>/routing/*.yaml`. Each command has a file:
+- `<runtimeRoot>/routing/god-prd.yaml`
+- `<runtimeRoot>/routing/god-arch.yaml`
 - ...
 
 These define prerequisites, execution, success-path, failure-path, and
 endoff for each command.
 
-The `lib/router.js` JS module provides programmatic queries:
+The `<runtimeRoot>/lib/router.js` JS module provides programmatic queries:
 - `getRouting(command)` - load a command's routing
 - `checkPrerequisites(command, projectRoot)` - prereq check
 - `getNextCommand(command)` - get success-path next

package/skills/god-standards.md

@@ -23,8 +23,9 @@ Run quality gate check on an artifact.
 ## Process
 
 1. Identify the artifact to check (user provides, or auto-detect from PROGRESS.md)
-2. Look up the routing for the relevant tier (lib/router.js getStandards)
-3. Spawn god-standards-check in fresh context with:
+2. Resolve the Godpowers runtime root: use `<projectRoot>` when `<projectRoot>/lib/router.js` exists, otherwise use the installed bundle at `<tool-config-dir>/godpowers-runtime`
+3. Look up the routing for the relevant tier (`<runtimeRoot>/lib/router.js` getStandards)
+4. Spawn god-standards-check in fresh context with:
    - artifact-path
    - tier
    - have-nots-list (from routing)

package/skills/god-version.md

@@ -34,4 +34,4 @@ soft if offline).
 
 Built-in, no spawned agent. Reads:
 - `<runtime>/GODPOWERS_VERSION`
-- File counts in `<runtime>/skills/`, `<runtime>/agents/`, `workflows/`, `routing/recipes/`
+- File counts in `<runtime>/skills/`, `<runtime>/agents/`, `<runtime>/godpowers-runtime/workflows/`, and `<runtime>/godpowers-runtime/routing/recipes/`

package/skills/god.md

@@ -2,7 +2,7 @@
 name: god
 description: |
   Front door. Take free-text intent from the user, match it to a recipe via
-  lib/recipes.matchIntent, and propose the matching command sequence. If no
+  the Godpowers runtime recipes module, and propose the matching command sequence. If no
   text given, fall back to state-driven suggestion (same as /god-next Mode 3).
 
   Triggers on: "/god", "god", "/god help", "I want to ...", "how do I ..."
@@ -13,7 +13,16 @@ description: |
 
 The natural-language entry point. Users describe what they want; this skill
 matches the intent to a recipe and suggests the right command sequence. No
-agent is spawned here. This is a thin router on top of `lib/recipes.js`.
+agent is spawned here. This is a thin router on top of the Godpowers runtime
+recipes module.
+
+## Runtime module resolution
+
+Before calling runtime modules, resolve the Godpowers runtime root:
+
+1. If `<projectRoot>/lib/recipes.js` exists, use the repository checkout runtime at `<projectRoot>`.
+2. Otherwise use the installed bundle at `<tool-config-dir>/godpowers-runtime`, where `<tool-config-dir>` is the directory that contains this installed skill, such as `~/.claude`, `~/.codex`, `~/.cursor`, `~/.windsurf`, or `~/.gemini`.
+3. Load recipes from `<runtimeRoot>/lib/recipes.js`, routing from `<runtimeRoot>/lib/router.js`, and recipe YAML from `<runtimeRoot>/routing/recipes/`.
 
 ## Why this exists
 
@@ -50,11 +59,11 @@ Treat everything after `/god` as free text. If empty, treat as state-driven.
 
 ```
 text empty?
-  yes -> state-driven: call lib/recipes.suggestForState(projectRoot)
+  yes -> state-driven: call <runtimeRoot>/lib/recipes.js suggestForState(projectRoot)
          display top 3 recipes ranked by current lifecycle phase
-         also call lib/router.suggestNext(projectRoot) for structural next
+         also call <runtimeRoot>/lib/router.js suggestNext(projectRoot) for structural next
 
-  no  -> intent-driven: call lib/recipes.matchIntent(text, projectRoot)
+  no  -> intent-driven: call <runtimeRoot>/lib/recipes.js matchIntent(text, projectRoot)
          take top 1-3 matches by score
          if highest score >= 10 (exact phrase match): propose directly
          if highest score 5-9 (all-words match): propose with confirmation
@@ -116,8 +125,8 @@ If user picks the structural next:
 ## Interaction model
 
 This skill is a router, not an orchestrator. It:
-- Reads recipes (via `lib/recipes.js`)
-- Reads state (via `lib/state.js`)
+- Reads recipes (via `<runtimeRoot>/lib/recipes.js`)
+- Reads state (via `<runtimeRoot>/lib/state.js`)
 - Proposes commands
 
 It does NOT:
@@ -194,7 +203,7 @@ Suggested: /god-next   show all valid next-step options
 ## Why a skill, not an agent
 
 The matching and dispatch logic is mechanical (lookups against
-`routing/recipes/*.yaml`) and has no need for fresh-context isolation. Running
+`<runtimeRoot>/routing/recipes/*.yaml`) and has no need for fresh-context isolation. Running
 it as a skill keeps it fast, lets the user see the proposed commands, and
 avoids stacking another orchestrator layer above `god-orchestrator`. See
 `docs/concepts.md` (the Quarterback section) for why we don't add a second