godpowers 2.2.0 → 2.3.0

package/lib/package-legitimacy.js

@@ -0,0 +1,158 @@
+const { execFileSync } = require('child_process');
+
+const STALE_MONTHS = 18;
+
+function normalizeName(name) {
+  return String(name || '')
+    .toLowerCase()
+    .replace(/^@/, '')
+    .replace(/[^a-z0-9]+/g, '');
+}
+
+function levenshtein(a, b) {
+  a = normalizeName(a);
+  b = normalizeName(b);
+  const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  for (let i = 0; i <= a.length; i++) dp[i][0] = i;
+  for (let j = 0; j <= b.length; j++) dp[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[a.length][b.length];
+}
+
+function monthsBetween(a, b) {
+  return Math.abs((b.getFullYear() - a.getFullYear()) * 12 + (b.getMonth() - a.getMonth()));
+}
+
+function latestPublishedAt(metadata) {
+  if (!metadata || !metadata.time) return null;
+  const latest = metadata['dist-tags'] && metadata['dist-tags'].latest;
+  const raw = latest && metadata.time[latest] ? metadata.time[latest] : metadata.time.modified;
+  return raw ? new Date(raw) : null;
+}
+
+function repoUrl(metadata) {
+  if (!metadata || !metadata.repository) return null;
+  if (typeof metadata.repository === 'string') return metadata.repository;
+  return metadata.repository.url || null;
+}
+
+function typoRisk(name, knownNames = []) {
+  const risks = [];
+  for (const known of knownNames) {
+    if (normalizeName(name) === normalizeName(known)) continue;
+    const distance = levenshtein(name, known);
+    if (distance > 0 && distance <= 2) {
+      risks.push({ known, distance });
+    }
+  }
+  return risks.sort((a, b) => a.distance - b.distance);
+}
+
+function assessNpmMetadata(name, metadata, opts = {}) {
+  const now = opts.now || new Date();
+  const findings = [];
+  if (!metadata || metadata.missing) {
+    findings.push({
+      severity: 'fail',
+      code: 'package-missing',
+      message: `${name} was not found in the npm registry data.`
+    });
+    return { status: 'fail', findings, signals: { exists: false } };
+  }
+
+  const risks = typoRisk(name, opts.knownNames || []);
+  for (const risk of risks) {
+    findings.push({
+      severity: 'fail',
+      code: 'typo-risk',
+      message: `${name} is within edit distance ${risk.distance} of ${risk.known}.`
+    });
+  }
+
+  const published = latestPublishedAt(metadata);
+  if (!published) {
+    findings.push({
+      severity: 'warn',
+      code: 'unknown-recency',
+      message: `${name} has no publish timestamp in registry metadata.`
+    });
+  } else if (monthsBetween(published, now) > STALE_MONTHS) {
+    findings.push({
+      severity: 'warn',
+      code: 'stale-package',
+      message: `${name} latest release is older than ${STALE_MONTHS} months.`
+    });
+  }
+
+  if (!repoUrl(metadata)) {
+    findings.push({
+      severity: 'warn',
+      code: 'missing-repository',
+      message: `${name} does not expose a repository URL.`
+    });
+  }
+
+  const status = findings.some(f => f.severity === 'fail')
+    ? 'fail'
+    : findings.some(f => f.severity === 'warn')
+      ? 'warn'
+      : 'pass';
+
+  return {
+    status,
+    findings,
+    signals: {
+      exists: true,
+      latest: metadata['dist-tags'] && metadata['dist-tags'].latest,
+      publishedAt: published ? published.toISOString() : null,
+      repository: repoUrl(metadata)
+    }
+  };
+}
+
+function npmView(name) {
+  try {
+    const raw = execFileSync('npm', ['view', name, '--json'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    return JSON.parse(raw);
+  } catch (error) {
+    return { missing: true, error: error.message };
+  }
+}
+
+function checkNpmPackage(name, opts = {}) {
+  const metadata = opts.metadata || npmView(name);
+  if (metadata && metadata.error && opts.failOnUnknown === false) {
+    return {
+      status: 'unknown',
+      findings: [{
+        severity: 'warn',
+        code: 'registry-unavailable',
+        message: `${name} could not be verified from npm metadata.`
+      }],
+      signals: { exists: null }
+    };
+  }
+  return assessNpmMetadata(name, metadata, opts);
+}
+
+module.exports = {
+  STALE_MONTHS,
+  normalizeName,
+  levenshtein,
+  typoRisk,
+  assessNpmMetadata,
+  checkNpmPackage,
+  latestPublishedAt
+};

package/lib/planning-systems.js

@@ -1,7 +1,7 @@
 /**
  * Planning System Migration
  *
- * Detects GSD, BMAD, and Superpowers project artifacts, converts their useful
+ * Detects legacy planning, BMAD, and Superpowers project artifacts, converts their useful
  * signals into Godpowers preparation artifacts, and records source-system state
  * so /god-sync can later write progress back through lib/source-sync.js.
  */
@@ -71,11 +71,11 @@ const GODPOWERS_ARTIFACTS = [
 ];
 
 const SYSTEMS = {
-  gsd: {
-    displayName: 'GSD',
-    markerPaths: ['.planning', '.gsd', 'GSD.md'],
-    fileRoots: ['.planning', '.gsd'],
-    standalonePatterns: [/^gsd.*\.md$/i]
+  'legacy-planning': {
+    displayName: 'legacy planning',
+    markerPaths: ['.planning', '.legacy-planning', 'LEGACY-PLANNING.md'],
+    fileRoots: ['.planning', '.legacy-planning'],
+    standalonePatterns: [/^legacy-planning.*\.md$/i]
   },
   bmad: {
     displayName: 'BMAD',
@@ -246,7 +246,7 @@ function detectSystem(projectRoot, id, system) {
     };
   });
 
-  const hasPrimaryRoot = markerHits.some((marker) => ['.planning', '.gsd', '_bmad-output', 'docs/superpowers'].includes(marker));
+  const hasPrimaryRoot = markerHits.some((marker) => ['.planning', '.legacy-planning', '_bmad-output', 'docs/superpowers'].includes(marker));
   const score = markerHits.length * 3 + fileRecords.length;
   const confidence = score >= 10 || (hasPrimaryRoot && fileRecords.length >= 3)
     ? 'high'
@@ -294,7 +294,7 @@ function buildImportedContext(detection) {
   lines.push('');
 
   if (detection.systems.length === 0) {
-    lines.push('- [DECISION] No GSD, BMAD, or Superpowers planning context was detected.');
+    lines.push('- [DECISION] No legacy planning, BMAD, or Superpowers planning context was detected.');
   }
 
   for (const system of detection.systems) {
@@ -331,7 +331,7 @@ function buildImportedContext(detection) {
   lines.push('## Sync-Back Policy');
   lines.push('');
   lines.push('- [DECISION] Godpowers may write managed sync-back summaries only inside Godpowers-owned fences or companion files.');
-  lines.push('- [DECISION] Godpowers must not rewrite GSD, BMAD, or Superpowers source documents outside managed sync-back sections.');
+  lines.push('- [DECISION] Godpowers must not rewrite legacy planning, BMAD, or Superpowers source documents outside managed sync-back sections.');
   lines.push('- [DECISION] Sync-back exists so a project can return to the prior planning system with current Godpowers progress visible.');
 
   lines.push('');

package/lib/repo-surface-sync.js

@@ -442,7 +442,7 @@ function dogfoodChecks(projectRoot) {
   const pkg = readJson(projectRoot, 'package.json') || {};
   const scriptsText = releaseGateText(projectRoot, pkg);
   const scenarios = [
-    'fixtures/dogfood/half-migrated-gsd/manifest.json',
+    'fixtures/dogfood/half-migrated-planning/manifest.json',
     'fixtures/dogfood/host-degraded/manifest.json',
     'fixtures/dogfood/host-full/manifest.json',
     'fixtures/dogfood/extension-authoring/manifest.json',

package/lib/requirements.js

@@ -31,6 +31,7 @@ const path = require('path');
 
 const linkage = require('./linkage');
 const state = require('./state');
+const atomic = require('./atomic-write');
 
 const PRD_PATH = '.godpowers/prd/PRD.md';
 const ROADMAP_PATH = '.godpowers/roadmap/ROADMAP.md';
@@ -363,6 +364,27 @@ function progressBar(done, total, width = 20) {
 
 const MARK = { done: '[x]', 'in-progress': '[~]', untouched: '[ ]' };
 const INC_MARK = { done: '[x]', building: '[~]', pending: '[ ]' };
+const UPDATED_LINE_RE = /^Updated: .+$/m;
+
+function finishLedger(lines) {
+  while (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  return lines.join('\n');
+}
+
+function normalizeLedgerTimestamp(content) {
+  return String(content).replace(UPDATED_LINE_RE, 'Updated: <timestamp>');
+}
+
+function withoutUpdated(value) {
+  if (!value || typeof value !== 'object') return value;
+  const copy = JSON.parse(JSON.stringify(value));
+  delete copy.updated;
+  return copy;
+}
+
+function sameIgnoringUpdated(a, b) {
+  return JSON.stringify(withoutUpdated(a)) === JSON.stringify(withoutUpdated(b));
+}
 
 /**
  * Compact lines for the dashboard "Deliverable progress" section.
@@ -411,7 +433,7 @@ function renderLedger(derived) {
     out.push('No requirements are declared yet. Once the PRD lists MUST/SHOULD/COULD');
     out.push('requirements with stable ids (P-MUST-01, ...), they appear here.');
     out.push('');
-    return out.join('\n');
+    return finishLedger(out);
   }
 
   out.push(`Progress: ${progressBar(s.done, s.total)} done (${s.percent}%) | ${s.inProgress} in progress | ${s.untouched} not started`);
@@ -469,23 +491,30 @@ function renderLedger(derived) {
     out.push('');
   }
 
-  return out.join('\n');
+  return finishLedger(out);
 }
 
 function writeLedger(projectRoot, derived) {
   const data = derived || derive(projectRoot);
   const file = path.join(projectRoot, LEDGER_PATH);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, renderLedger(data) + '\n');
+  const rendered = renderLedger(data) + '\n';
+  if (fs.existsSync(file)) {
+    const current = fs.readFileSync(file, 'utf8');
+    if (normalizeLedgerTimestamp(current) === normalizeLedgerTimestamp(rendered)) {
+      return LEDGER_PATH;
+    }
+  }
+  atomic.writeFileAtomic(file, rendered);
   return LEDGER_PATH;
 }
 
 /**
  * Small cacheable summary for state.json (state.deliverables).
  */
-function summarizeForState(derived) {
+function summarizeForState(derived, currentSummary = null) {
   const s = derived.summary;
-  return {
+  const next = {
     updated: derived.updated,
     source: 'PRD + ROADMAP + linkage + build state',
     requirements: {
@@ -505,6 +534,10 @@ function summarizeForState(derived) {
     })),
     gaps: derived.gaps.length
   };
+  if (currentSummary && currentSummary.updated && sameIgnoringUpdated(currentSummary, next)) {
+    next.updated = currentSummary.updated;
+  }
+  return next;
 }
 
 module.exports = {

package/lib/reverse-sync.js

@@ -27,6 +27,8 @@ const reviewRequired = require('./review-required');
 const impeccable = require('./impeccable-bridge');
 const sourceSync = require('./source-sync');
 const requirements = require('./requirements');
+const state = require('./state');
+const atomic = require('./atomic-write');
 
 const FENCE_BEGIN = '<!-- godpowers:linkage:begin -->';
 const FENCE_END = '<!-- godpowers:linkage:end -->';
@@ -67,7 +69,7 @@ function writeFenced(filePath, sectionContent) {
   } else {
     next = `${parsed.before}${fencedBlock}${parsed.after}`;
   }
-  fs.writeFileSync(filePath, next);
+  atomic.writeFileAtomic(filePath, next);
   return { written: true, hadFenceBefore: parsed.fenced !== '' };
 }
 
@@ -321,7 +323,15 @@ function run(projectRoot, opts = {}) {
       const derived = requirements.derive(projectRoot);
       if (derived.hasRequirements) {
         requirements.writeLedger(projectRoot, derived);
-        requirementsSummary = requirements.summarizeForState(derived);
+        const currentState = state.read(projectRoot);
+        requirementsSummary = requirements.summarizeForState(
+          derived,
+          currentState && currentState.deliverables
+        );
+        if (currentState) {
+          currentState.deliverables = requirementsSummary;
+          state.write(projectRoot, currentState);
+        }
       }
     } catch (e) {
       requirementsSummary = null;

package/lib/source-grounding.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_IGNORE_DIRS = new Set([
+  '.git',
+  '.godpowers',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.turbo'
+]);
+
+function normalizeRel(filePath) {
+  return String(filePath || '').split(path.sep).join('/');
+}
+
+function listFiles(root, opts = {}) {
+  const ignoreDirs = opts.ignoreDirs || DEFAULT_IGNORE_DIRS;
+  const out = [];
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (ignoreDirs.has(entry.name)) continue;
+        walk(path.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const rel = normalizeRel(path.relative(root, path.join(dir, entry.name)));
+        out.push(rel);
+      }
+    }
+  }
+  if (fs.existsSync(root)) walk(root);
+  return out.sort();
+}
+
+function parseSectionLists(planText) {
+  const result = {
+    existingFiles: [],
+    existingSymbols: [],
+    newArtifacts: [],
+    unchecked: []
+  };
+  let section = null;
+  const lines = String(planText || '').split(/\r?\n/);
+  for (const raw of lines) {
+    const heading = raw.match(/^#{2,4}\s+(.+)$/);
+    if (heading) {
+      const title = heading[1].toLowerCase();
+      if (/existing (files|references)/.test(title)) section = 'existingFiles';
+      else if (/existing symbols/.test(title)) section = 'existingSymbols';
+      else if (/new artifacts|files to create/.test(title)) section = 'newArtifacts';
+      else if (/unchecked references|unknown references/.test(title)) section = 'unchecked';
+      else section = null;
+      continue;
+    }
+    if (!section) continue;
+    const item = raw.match(/^\s*[-*]\s+(.*)$/);
+    if (!item) continue;
+    const value = item[1]
+      .replace(/^(file|symbol|new|unchecked)\s*:\s*/i, '')
+      .replace(/^`|`$/g, '')
+      .trim();
+    if (value) result[section].push(value);
+  }
+  return result;
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function findSymbolInFiles(root, symbol, files) {
+  const needle = String(symbol || '').trim();
+  if (!needle) return [];
+  const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`\\b${escaped}\\b`);
+  const hits = [];
+  for (const rel of files) {
+    const full = path.join(root, rel);
+    let text;
+    try {
+      text = fs.readFileSync(full, 'utf8');
+    } catch (_) {
+      continue;
+    }
+    if (re.test(text)) hits.push(rel);
+  }
+  return hits;
+}
+
+function checkPlan(projectRoot, planText, opts = {}) {
+  const parsed = parseSectionLists(planText);
+  const existingFiles = unique([...(opts.existingFiles || []), ...parsed.existingFiles]);
+  const existingSymbols = unique([...(opts.existingSymbols || []), ...parsed.existingSymbols]);
+  const newArtifacts = unique([...(opts.newArtifacts || []), ...parsed.newArtifacts]);
+  const unchecked = unique([...(opts.unchecked || []), ...parsed.unchecked]);
+  const files = listFiles(projectRoot, opts);
+  const fileSet = new Set(files);
+
+  const fileChecks = existingFiles.map(file => ({
+    type: 'file',
+    value: normalizeRel(file),
+    status: fileSet.has(normalizeRel(file)) ? 'pass' : 'fail'
+  }));
+
+  const symbolChecks = existingSymbols.map(symbol => {
+    const hits = findSymbolInFiles(projectRoot, symbol, files);
+    return {
+      type: 'symbol',
+      value: symbol,
+      status: hits.length > 0 ? 'pass' : 'fail',
+      files: hits
+    };
+  });
+
+  const checks = [...fileChecks, ...symbolChecks];
+  const failures = checks.filter(check => check.status === 'fail');
+  const warnings = unchecked.map(value => ({
+    type: 'unchecked',
+    value,
+    status: 'warn'
+  }));
+  const newArtifactSet = new Set(newArtifacts.map(normalizeRel));
+  const declaredNew = newArtifacts.map(file => ({
+    type: 'new-artifact',
+    value: normalizeRel(file),
+    status: fileSet.has(normalizeRel(file)) ? 'exists' : 'declared-new'
+  }));
+
+  return {
+    ok: failures.length === 0,
+    checks,
+    failures,
+    warnings,
+    declaredNew,
+    newArtifacts: [...newArtifactSet],
+    summary: {
+      pass: checks.filter(check => check.status === 'pass').length,
+      fail: failures.length,
+      warn: warnings.length,
+      declaredNew: declaredNew.length
+    }
+  };
+}
+
+function renderReport(result) {
+  const lines = [];
+  lines.push(`Source grounding: ${result.ok ? 'PASS' : 'FAIL'}`);
+  lines.push(`  passed: ${result.summary.pass}`);
+  lines.push(`  failed: ${result.summary.fail}`);
+  lines.push(`  unchecked: ${result.summary.warn}`);
+  if (result.failures.length > 0) {
+    lines.push('');
+    lines.push('Failures:');
+    for (const failure of result.failures) {
+      lines.push(`  - ${failure.type}: ${failure.value}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push('');
+    lines.push('Unchecked references:');
+    for (const warning of result.warnings) {
+      lines.push(`  - ${warning.value}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  DEFAULT_IGNORE_DIRS,
+  listFiles,
+  parseSectionLists,
+  checkPlan,
+  renderReport,
+  findSymbolInFiles
+};

package/lib/source-sync.js

@@ -1,7 +1,7 @@
 /**
  * Source System Sync-Back
  *
- * Writes Godpowers progress back to detected GSD, BMAD, and Superpowers
+ * Writes Godpowers progress back to detected legacy planning, BMAD, and Superpowers
  * projects through managed companion files and optional managed fences.
  */
 
@@ -10,13 +10,14 @@ const path = require('path');
 const crypto = require('crypto');
 
 const state = require('./state');
+const atomic = require('./atomic-write');
 
 const FENCE_BEGIN = '<!-- godpowers:source-sync:begin -->';
 const FENCE_END = '<!-- godpowers:source-sync:end -->';
 
 const SYSTEM_TARGETS = {
-  gsd: {
-    companionCandidates: ['.planning/GODPOWERS-SYNC.md', '.gsd/GODPOWERS-SYNC.md'],
+  'legacy-planning': {
+    companionCandidates: ['.planning/GODPOWERS-SYNC.md', '.legacy-planning/GODPOWERS-SYNC.md'],
     pointerCandidates: ['.planning/STATE.md']
   },
   bmad: {
@@ -68,7 +69,7 @@ function writeFenced(filePath, sectionContent) {
     next = `${parsed.before}${block}${parsed.after}`;
   }
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, next);
+  atomic.writeFileAtomic(filePath, next);
   return {
     written: true,
     hadFenceBefore: parsed.exists && parsed.fenced !== ''
@@ -134,7 +135,7 @@ function progressLines(projectRoot) {
   lines.push('');
   lines.push('## Return Path');
   lines.push('');
-  lines.push('- [DECISION] If the project returns to GSD, BMAD, or Superpowers, use this file as a migration note rather than treating it as a native source-system artifact.');
+  lines.push('- [DECISION] If the project returns to legacy planning, BMAD, or Superpowers, use this file as a migration note rather than treating it as a native source-system artifact.');
   lines.push('- [OPEN QUESTION] Confirm which Godpowers decisions should be copied into native source-system documents before switching systems. Owner: user. Due: before switching systems.');
   lines.push('');
   return lines.join('\n');

package/lib/state.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const asyncFs = require('./fs-async');
+const atomic = require('./atomic-write');
 
 const STATE_VERSION = '1.0.0';
 const COMPLETE_STATUSES = new Set(['done', 'imported', 'skipped', 'not-required']);
@@ -138,7 +139,7 @@ function write(projectRoot, state) {
 
   const file = statePath(projectRoot);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(state, null, 2) + '\n');
+  atomic.writeJsonAtomic(file, state);
   return state;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godpowers",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "AI-powered development system: 111 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"

package/references/HAVE-NOTS.md

@@ -87,7 +87,7 @@ A command completed without a disk-derived dashboard, action brief, or
 recommended next command. Fail.
 
 ### O-09 Sync-back ambiguity
-Imported GSD, BMAD, or Superpowers context exists but the project does not say
+Imported legacy planning, BMAD, or Superpowers context exists but the project does not say
 whether managed sync-back is enabled, disabled, or not applicable. Fail.
 
 ### O-10 Host guarantees hidden

package/references/orchestration/MODE-DETECTION.md

@@ -18,7 +18,7 @@
 - Some `.godpowers/<tier>/<artifact>` files already exist
 - OR existing codebase signals: package.json, Dockerfile, .github/workflows
 - User describes an existing project they want to add Godpowers to
-- GSD, BMAD, or Superpowers planning context is detected and should be imported
+- legacy planning, BMAD, or Superpowers planning context is detected and should be imported
   into Godpowers preparation artifacts
 
 **Behavior**:
@@ -33,7 +33,7 @@ Codebase signals (for inferring partial completion):
 - `.github/workflows/` or `.gitlab-ci.yml` exists -> CI present
 - `tests/` or `*.test.*` files exist -> Build tier in progress
 - `Dockerfile` + deploy config -> Deploy tier may be done
-- `.planning/`, `.gsd/`, `_bmad-output/`, `.bmad/`, or Superpowers specs ->
+- `.planning/`, `.legacy-planning/`, `_bmad-output/`, `.bmad/`, or Superpowers specs ->
   source-system import and managed sync-back may be needed
 
 ## Mode C: Audit

package/references/shared/ORCHESTRATORS.md

@@ -45,7 +45,7 @@ If you arrive at Godpowers carrying artifacts from another system,
 `/god-init` Mode B (gap-fill) and `/god-migrate` read what exists and map it
 forward:
 
-- GSD `.planning/` or `.gsd/` context -> `.godpowers/prep/IMPORTED-CONTEXT.md`
+- legacy planning `.planning/` or `.legacy-planning/` context -> `.godpowers/prep/IMPORTED-CONTEXT.md`
   and optional native seed artifacts
 - BMAD `_bmad-output/` or `.bmad/` context -> imported preparation context and
   open questions for PRD, architecture, roadmap, and stack
@@ -74,7 +74,7 @@ authoritative. `/god-sync` writes managed companion files such as:
 The sync-back file is a bridge, not a second source of truth. It should contain
 the current Godpowers status, imported-context mapping, open conflicts, and the
 next safe route back into either system. It must be fenced or companion-owned
-so Godpowers does not overwrite arbitrary GSD, BMAD, or Superpowers artifacts.
+so Godpowers does not overwrite arbitrary legacy planning, BMAD, or Superpowers artifacts.
 
 ## Existing Godpowers projects after upgrades
 
@@ -94,7 +94,7 @@ frontmatter. There's no proprietary binary state. To leave:
    system doesn't understand them (they're recoverable from code
    annotations).
 3. Use the most recent managed sync-back file as the return-path summary if the
-   target system is GSD, BMAD, or Superpowers.
+   target system is legacy planning, BMAD, or Superpowers.
 4. Delete `.godpowers/`.
 
 ## What Godpowers does not try to be

package/routing/god-design.yaml

@@ -17,7 +17,7 @@ prerequisites:
     - check: file:.godpowers/prep/INITIAL-FINDINGS.md
       reason: "Initial findings can show UI and product-experience signals"
     - check: file:.godpowers/prep/IMPORTED-CONTEXT.md
-      reason: "Imported GSD, Superpowers, or BMAD context can inform design hypotheses"
+      reason: "Imported legacy planning, Superpowers, or BMAD context can inform design hypotheses"
     - check: file:.godpowers/arch/ARCH.md
       reason: "ARCH names the UI surface that DESIGN applies to"
     - check: file:.godpowers/stack/DECISION.md