godpowers 2.2.1 → 2.3.1

package/agents/god-quality-reviewer.md

@@ -63,6 +63,26 @@ Your job: would you ship this code in production?
 - Flag missing or inaccurate annotations: the deliverable ledger derives
   requirement status from them, so a gap here understates delivered work
 
+### 8. Comment Quality and Style Fidelity
+- Required traceability comments such as `// Implements: P-...` remain present
+  and accurate.
+- Comments explain non-obvious why, constraints, hazards, or tradeoffs. Flag
+  comments that narrate obvious code, duplicate names, go stale, or use generic
+  AI-assistant prose.
+- Avoid decorative section banners or chatty explanation unless the surrounding
+  codebase already uses that convention.
+- If `CODEDNA.md` exists, compare naming, comment voice, extraction threshold,
+  error style, test style, and common idioms against the profile.
+- Absence of `CODEDNA.md` is not a failure. When no profile exists, judge style
+  against nearby code and repository conventions.
+
+### 9. Optional Code Intelligence
+- When `ast-grep`, `sg`, or LSP tools are available, use them to support
+  maintainability review for structural matches, impacted references, or
+  diagnostics that plain grep can miss.
+- Absence of these tools is not a failure. Treat them as extra evidence when
+  present.
+
 ## Output
 
 Return verdict to orchestrator:
@@ -78,6 +98,8 @@ Return verdict to orchestrator:
 - [PASS/FAIL] Maintainability: [evidence]
 - [PASS/FAIL] Simplicity and surgicality: [evidence]
 - [PASS/FAIL] Requirement traceability: [evidence]
+- [PASS/FAIL] Comment quality and style fidelity: [evidence]
+- [PASS/FAIL] Optional code intelligence: [evidence or not applicable]
 
 ### Verdict: PASS / FAIL
 
@@ -86,7 +108,7 @@ Return verdict to orchestrator:
 
 ## Pass Criteria
 
-ALL seven dimensions must PASS. Any FAIL blocks the commit.
+ALL nine dimensions must PASS. Any FAIL blocks the commit.
 
 If FAIL: orchestrator returns the slice to god-executor.
 If PASS: orchestrator commits the slice atomically.

package/agents/god-reconciler.md

@@ -144,7 +144,7 @@ For each artifact below, check (in parallel where possible):
 - If imported planning systems have low confidence or conflicts: recommend
   `god-greenfieldifier`.
 
-#### SOURCE SYSTEM SYNC-BACK (GSD, BMAD, Superpowers)
+#### SOURCE SYSTEM SYNC-BACK (legacy planning, BMAD, Superpowers)
 - Did migrated source-system summaries need managed sync-back?
 - Verdict: not-applicable / fresh / needs-sync-back / blocked-by-conflict
 - If conflicts exist: recommend greenfieldifier review before writes.

package/agents/god-roadmapper.md

@@ -36,7 +36,7 @@ If `.godpowers/prep/INITIAL-FINDINGS.md` exists, read it first for repo risks,
 existing tests, docs, CI, deploy, and suggested sequencing implications.
 
 If `.godpowers/prep/IMPORTED-CONTEXT.md` exists, read its delivery signals
-before sequencing work. Use imported GSD, Superpowers, BMAD, or similar
+before sequencing work. Use imported legacy planning, Superpowers, BMAD, or similar
 stories and plans as hypothesis-level input only. Convert imported terminology
 into Godpowers vocabulary. Do not preserve imported methodology terminology in
 Godpowers artifacts unless the user explicitly asked for it.

package/agents/god-spec-reviewer.md

@@ -57,6 +57,20 @@ Answer each with EVIDENCE from the code:
    - A planned requirement id with no annotation is a finding, because the
      deliverable ledger derives requirement status from those annotations.
 
+7. **Did the implementation honor source grounding and package legitimacy?**
+   - Did every existing file or symbol cited by the slice plan exist before
+     execution?
+   - Did new files appear only under the plan's new artifacts or expected file
+     list?
+   - If the slice added a dependency, is there package legitimacy evidence or
+     an explicit accepted-risk note?
+
+8. **Did available code intelligence support the review?**
+   - If `ast-grep`, `sg`, or LSP tools are available, use them to verify
+     impacted references, structural matches, or diagnostics for the touched
+     language when relevant.
+   - If unavailable or irrelevant, do not fail the slice for absence alone.
+
 ## Output
 
 Return verdict to orchestrator:
@@ -83,6 +97,8 @@ Return verdict to orchestrator:
 - Every touched file has request-trace evidence
 - No speculative flexibility or unrelated cleanup entered the diff
 - Every planned requirement id carries its `// Implements: P-...` annotation
+- Source-grounding failures are resolved or explicitly accepted
+- New dependencies have legitimacy evidence or accepted-risk notes
 
 If FAIL: orchestrator returns the slice to god-executor with the failures.
 If PASS: orchestrator spawns god-quality-reviewer next.

package/agents/god-stack-selector.md

@@ -65,6 +65,9 @@ Rules:
 3. For each category:
    - List 2-3 viable candidates
    - Score on: fit-for-requirements, maturity, ecosystem health, team familiarity, total cost
+   - For package-backed choices, run or request the package legitimacy gate:
+     registry existence, package age, repository signal, maintainer signal,
+     typo-squat risk, and known vulnerability status where available
    - Document the **flip point**: condition under which you'd reverse this choice
    - Document the **lock-in cost**: how hard is it to switch (Low/Medium/High)
 4. Verify pairing compatibility (e.g., chosen ORM works with chosen DB)
@@ -103,6 +106,7 @@ Stack DECISION FAILS if:
 - High lock-in choice with likely flip point in <6 months
 - Pairing incompatibility (chosen ORM doesn't support chosen DB, etc.)
 - "Best practice" rationale without specific rationale tied to ARCH
+- Package-backed choice without legitimacy evidence or an accepted-risk note
 
 ## Pause Conditions
 

package/agents/god-updater.md

@@ -174,7 +174,7 @@ After feature work, every artifact that was impacted needs to reflect reality.
 
 ### Source-system sync-back
 - Call `lib/source-sync.run(projectRoot)` when `.godpowers/state.json`
-  declares GSD, BMAD, Superpowers, or other source-system records.
+  declares legacy planning, BMAD, Superpowers, or other source-system records.
 - Write only managed Godpowers summary sections back to source systems.
 - Preserve user-authored source-system content outside managed sections.
 - If source-system confidence is low or conflicts are present, recommend

package/bin/install.js

@@ -17,8 +17,10 @@ const {
   uninstallForRuntime,
   countInstalledSurface
 } = require('../lib/installer-core');
+const { describeProfiles } = require('../lib/install-profiles');
+const identity = require('../lib/package-identity');
 
-const VERSION = require('../package.json').version;
+const VERSION = identity.PACKAGE_VERSION;
 
 const BANNER = `
   GODPOWERS v${VERSION}
@@ -80,6 +82,8 @@ function showHelp() {
   log('  --codebuddy          Install for CodeBuddy');
   log('  --pi                 Install for Pi');
   log('  --all                Install for all 15 runtimes');
+  log('  --profile=<name>     Install profile: core, builder, maintainer, suite, or full');
+  log('  --minimal            Alias for --profile=core');
   log('  -u, --uninstall      Uninstall Godpowers');
   log('  -h, --help           Show this help message');
   log('');
@@ -92,6 +96,7 @@ function showHelp() {
   log('  npx godpowers dogfood');
   log('  npx godpowers extension-scaffold --name=@godpowers/my-pack --output=.');
   log('  npx godpowers --claude --global');
+  log('  npx godpowers --claude --global --profile=core');
   log('  npx godpowers --all');
   log('  npx godpowers --codex --cursor');
 }
@@ -243,10 +248,11 @@ function runInstall(opts, srcDir) {
     process.exit(1);
   }
 
-  const surface = countInstalledSurface(srcDir);
+  const surface = countInstalledSurface(srcDir, opts);
   log('');
   log(`\x1b[32mDone!\x1b[0m Installed Godpowers v${VERSION} for ${installed} runtime(s).`);
   log('');
+  log(`\x1b[36mProfile:\x1b[0m ${describeProfiles(opts.profile)}`);
   log(`\x1b[36mInstalled:\x1b[0m`);
   log(`  ${surface.skills} slash commands (try: /god-mode, /god-next, /god-status, /god-progress)`);
   log(`  ${surface.agents} specialist agents`);
@@ -258,7 +264,7 @@ function runInstall(opts, srcDir) {
   log(`     Or:   \x1b[36m/god-next\x1b[0m to see what to run next`);
   log(`     Or:   \x1b[36m/god-init\x1b[0m to start a new project`);
   log('');
-  log(`\x1b[36mDocs:\x1b[0m https://github.com/godpowers/godpowers`);
+  log(`\x1b[36mDocs:\x1b[0m ${identity.HOMEPAGE_URL}`);
   log('');
 }
 

package/fixtures/dogfood/{half-migrated-gsd → half-migrated-planning}/manifest.json

@@ -1,12 +1,12 @@
 {
-  "name": "Half migrated GSD project",
+  "name": "Half migrated planning project",
   "kind": "planning-migration",
   "actions": [
     "import-planning-context",
     "sync-back"
   ],
   "expectedSystems": [
-    "gsd"
+    "legacy-planning"
   ],
   "expectedFiles": [
     ".godpowers/prep/IMPORTED-CONTEXT.md",

package/lib/README.md

@@ -13,7 +13,8 @@ package-level integrations.
 | `intent.js` | Read and validate `intent.yaml` from project roots or `.godpowers/`. |
 | `checkpoint.js` | Create and inspect resumable checkpoint artifacts. |
 | `feature-awareness.js` | Detect and refresh existing-project awareness after runtime upgrades. |
-| `host-capabilities.js` | Detect host guarantees for shell, git, npm, agent spawning, extension authoring, and suite dry-runs. |
+| `code-intelligence.js` | Detect optional `ast-grep`, `sg`, and LSP tooling for structural search, rewrite, and diagnostics guidance. |
+| `host-capabilities.js` | Detect host guarantees for shell, git, npm, agent spawning, optional code intelligence, extension authoring, and suite dry-runs. |
 | `repo-doc-sync.js` | Detect and refresh mechanical repository documentation surfaces. |
 | `repo-surface-sync.js` | Detect structural drift across commands, routes, packages, agents, workflows, recipes, extensions, and release policy. |
 | `route-quality-sync.js` | Detect symbolic route spawns, unresolved agent targets, and unapproved contextual route exits. |
@@ -22,6 +23,7 @@ package-level integrations.
 | `dogfood-runner.js` | Run deterministic messy-repo scenarios against migration, host, extension, and suite release behavior. |
 | `budget.js` | Read and enforce configured budget controls. |
 | `cost-tracker.js` | Track token and cost estimates from event streams. |
+| `atomic-write.js` | Write load-bearing files through temp-file validation and atomic rename. |
 | `fs-async.js` | Promise-based file read/write helpers for non-blocking runtime paths. |
 
 ## Events and observability
@@ -45,6 +47,7 @@ package-level integrations.
 | `agent-cache.js` | Cache agent metadata for faster routing. |
 | `agent-validator.js` | Validate agent frontmatter and contracts. |
 | `agent-refs.js` | Validate workflow agent references and scan skill/agent prose for phantom references. |
+| `executor-repair.js` | Classify executor repair decisions as retry, decompose, prune, or escalate. |
 | `skill-surface.js` | Derive slash-command metadata from the individual `skills/` files. |
 
 ## Artifact quality
@@ -63,7 +66,7 @@ package-level integrations.
 |--------|---------|
 | `context-writer.js` | Produce tool-specific context files. |
 | `context-budget.js` | Keep generated context within budget. |
-| `planning-systems.js` | Detect and import GSD, BMAD, and Superpowers planning context. |
+| `planning-systems.js` | Detect and import legacy planning, BMAD, and Superpowers planning context. |
 | `source-sync.js` | Write managed Godpowers progress back to source-system companion files. |
 | `design-detector.js` | Detect design-system conventions. |
 | `design-spec.js` | Normalize design specifications. |
@@ -74,6 +77,7 @@ package-level integrations.
 | `impeccable-bridge.js` | Bridge runtime checks into impeccable quality workflows. |
 | `extensions.js` | Load and validate extension packs. |
 | `extension-authoring.js` | Scaffold publishable extension packs with manifest, package, README, skill, agent, and workflow files. |
+| `package-legitimacy.js` | Assess third-party package metadata for existence, typo risk, recency, and repository signals. |
 | `pillars.js` | Manage the Pillars project-context layer (`AGENTS.md` plus routed `agents/*.md`). |
 
 ## Repository and graph helpers
@@ -81,6 +85,7 @@ package-level integrations.
 | Module | Purpose |
 |--------|---------|
 | `code-scanner.js` | Scan source trees for routing and quality evidence. |
+| `source-grounding.js` | Check that build plans cite existing files and symbols before execution starts. |
 | `cross-artifact-impact.js` | Detect relationships between changed artifacts. |
 | `cross-repo-linkage.js` | Track suite-level repository relationships. |
 | `drift-detector.js` | Detect context drift between artifacts and implementation. |
@@ -98,7 +103,9 @@ package-level integrations.
 | `installer-core.js` | Install and uninstall the Godpowers surface for each runtime. |
 | `installer-files.js` | File-copy helpers shared by the installer and its tests. |
 | `installer-args.js` | Parse `bin/install.js` arguments and subcommands. |
+| `install-profiles.js` | Select smaller role-specific slash-command install surfaces. |
 | `installer-runtimes.js` | Map supported runtimes to their config directories. |
+| `package-identity.js` | Centralize package name, version, repository, docs, and command identity. |
 | `automation-providers.js` | Detect and configure host-native automation providers. |
 | `dashboard.js` | Compute the next-step action brief and host guarantee line. |
 | `quick-proof.js` | Render the shipped proof fixture for `godpowers quick-proof`. |

package/lib/agent-cache.js

@@ -134,9 +134,29 @@ function clear(projectRoot, opts = {}) {
   const now = Date.now();
   for (const shard of fs.readdirSync(dir)) {
     const shardPath = path.join(dir, shard);
-    if (!fs.statSync(shardPath).isDirectory()) continue;
+    const shardStat = fs.lstatSync(shardPath);
+    if (shardStat.isSymbolicLink()) {
+      if (opts.all) {
+        fs.unlinkSync(shardPath);
+        removed++;
+      } else {
+        kept++;
+      }
+      continue;
+    }
+    if (!shardStat.isDirectory()) continue;
     for (const fname of fs.readdirSync(shardPath)) {
       const fpath = path.join(shardPath, fname);
+      const fileStat = fs.lstatSync(fpath);
+      if (fileStat.isSymbolicLink()) {
+        if (opts.all) { fs.unlinkSync(fpath); removed++; }
+        else { kept++; }
+        continue;
+      }
+      if (!fileStat.isFile()) {
+        kept++;
+        continue;
+      }
       let entry;
       try { entry = JSON.parse(fs.readFileSync(fpath, 'utf8')); }
       catch (e) {
@@ -173,10 +193,12 @@ function stats(projectRoot) {
   let oldestTs = null;
   for (const shard of fs.readdirSync(dir)) {
     const shardPath = path.join(dir, shard);
-    if (!fs.statSync(shardPath).isDirectory()) continue;
+    const shardStat = fs.lstatSync(shardPath);
+    if (shardStat.isSymbolicLink() || !shardStat.isDirectory()) continue;
     for (const fname of fs.readdirSync(shardPath)) {
       const fpath = path.join(shardPath, fname);
-      const stat = fs.statSync(fpath);
+      const stat = fs.lstatSync(fpath);
+      if (stat.isSymbolicLink() || !stat.isFile()) continue;
       totalBytes += stat.size;
       count += 1;
       try {

package/lib/atomic-write.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+function tempPathFor(filePath) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  return path.join(dir, `.${base}.${process.pid}.${Date.now()}.tmp`);
+}
+
+function validateContent(content, validate) {
+  if (typeof validate === 'function') validate(content);
+}
+
+function writeFileAtomic(filePath, content, opts = {}) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = tempPathFor(filePath);
+  try {
+    fs.writeFileSync(tmp, content);
+    validateContent(content, opts.validateContent);
+    if (typeof opts.validateFile === 'function') opts.validateFile(tmp);
+    fs.renameSync(tmp, filePath);
+    return filePath;
+  } catch (error) {
+    try {
+      fs.rmSync(tmp, { force: true });
+    } catch (_) {
+      // Best-effort cleanup. The original file is still untouched.
+    }
+    throw error;
+  }
+}
+
+async function writeFileAtomicAsync(filePath, content, opts = {}) {
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
+  const tmp = tempPathFor(filePath);
+  try {
+    await fsp.writeFile(tmp, content);
+    validateContent(content, opts.validateContent);
+    if (typeof opts.validateFile === 'function') await opts.validateFile(tmp);
+    await fsp.rename(tmp, filePath);
+    return filePath;
+  } catch (error) {
+    try {
+      await fsp.rm(tmp, { force: true });
+    } catch (_) {
+      // Best-effort cleanup. The original file is still untouched.
+    }
+    throw error;
+  }
+}
+
+function jsonContent(value) {
+  return JSON.stringify(value, null, 2) + '\n';
+}
+
+function writeJsonAtomic(filePath, value, opts = {}) {
+  const content = jsonContent(value);
+  return writeFileAtomic(filePath, content, {
+    ...opts,
+    validateContent: text => {
+      JSON.parse(text);
+      validateContent(text, opts.validateContent);
+    }
+  });
+}
+
+async function writeJsonAtomicAsync(filePath, value, opts = {}) {
+  const content = jsonContent(value);
+  return writeFileAtomicAsync(filePath, content, {
+    ...opts,
+    validateContent: text => {
+      JSON.parse(text);
+      validateContent(text, opts.validateContent);
+    }
+  });
+}
+
+module.exports = {
+  tempPathFor,
+  writeFileAtomic,
+  writeFileAtomicAsync,
+  writeJsonAtomic,
+  writeJsonAtomicAsync
+};

package/lib/checkpoint.js

@@ -49,6 +49,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const atomic = require('./atomic-write');
 
 const MAX_ACTIONS = 20;
 const MAX_FACTS = 10;
@@ -224,7 +225,7 @@ function write(projectRoot, state) {
     ''
   ].filter(line => line !== null).join('\n');
 
-  fs.writeFileSync(file, fm + body);
+  atomic.writeFileAtomic(file, fm + body);
   return file;
 }
 

package/lib/code-intelligence.js

@@ -0,0 +1,161 @@
+/**
+ * Optional code intelligence capability detection.
+ *
+ * These tools sharpen refactors and reviews when present, but Godpowers must
+ * keep working through grep-backed workflows when they are absent.
+ */
+
+const cp = require('child_process');
+
+const AST_GREP_CANDIDATES = [
+  { id: 'ast-grep', command: 'ast-grep', args: ['--version'], match: /ast-grep/i },
+  { id: 'sg', command: 'sg', args: ['--version'], match: /\b(ast-grep|sg\s+\d)/i }
+];
+
+const LSP_CANDIDATES = [
+  { id: 'omo-lsp', command: 'omo-lsp', args: ['--version'], languages: ['multi'] },
+  { id: 'typescript-language-server', command: 'typescript-language-server', args: ['--version'], languages: ['javascript', 'typescript'] },
+  { id: 'vscode-json-language-server', command: 'vscode-json-language-server', args: ['--version'], languages: ['json'] },
+  { id: 'yaml-language-server', command: 'yaml-language-server', args: ['--version'], languages: ['yaml'] },
+  { id: 'pyright-langserver', command: 'pyright-langserver', args: ['--version'], languages: ['python'] },
+  { id: 'pylsp', command: 'pylsp', args: ['--version'], languages: ['python'] },
+  { id: 'gopls', command: 'gopls', args: ['version'], languages: ['go'] },
+  { id: 'rust-analyzer', command: 'rust-analyzer', args: ['--version'], languages: ['rust'] },
+  { id: 'clangd', command: 'clangd', args: ['--version'], languages: ['c', 'cpp'] },
+  { id: 'jdtls', command: 'jdtls', args: ['--version'], languages: ['java'] },
+  { id: 'ruby-lsp', command: 'ruby-lsp', args: ['--version'], languages: ['ruby'] },
+  { id: 'solargraph', command: 'solargraph', args: ['--version'], languages: ['ruby'] },
+  { id: 'terraform-ls', command: 'terraform-ls', args: ['version'], languages: ['terraform'] }
+];
+
+function firstLine(value) {
+  if (!value) return null;
+  const text = String(value).trim();
+  if (!text) return null;
+  return text.split(/\r?\n/)[0] || 'installed';
+}
+
+function commandVersion(command, args, opts = {}) {
+  try {
+    const out = cp.execFileSync(command, args, {
+      cwd: opts.cwd || process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: opts.timeout || 800
+    });
+    return firstLine(out) || 'installed';
+  } catch (err) {
+    return null;
+  }
+}
+
+function checkCandidate(candidate, opts) {
+  const version = firstLine(opts.commandVersion(candidate.command, candidate.args, {
+    cwd: opts.cwd,
+    timeout: opts.timeout
+  }));
+  if (!version) return null;
+  if (candidate.match && !candidate.match.test(version)) return null;
+  return {
+    id: candidate.id,
+    command: candidate.command,
+    version,
+    languages: candidate.languages || []
+  };
+}
+
+function detectFirst(candidates, opts) {
+  for (const candidate of candidates) {
+    const found = checkCandidate(candidate, opts);
+    if (found) return found;
+  }
+  return null;
+}
+
+function detectAll(candidates, opts) {
+  const found = [];
+  const limit = opts.maxTools || 5;
+  for (const candidate of candidates) {
+    const result = checkCandidate(candidate, opts);
+    if (result) found.push(result);
+    if (found.length >= limit) break;
+  }
+  return found;
+}
+
+function detect(projectRoot, opts = {}) {
+  const root = projectRoot || process.cwd();
+  const probe = opts.commandVersion || commandVersion;
+  const probeOpts = {
+    cwd: root,
+    commandVersion: probe,
+    timeout: opts.timeout || 800,
+    maxTools: opts.maxTools || 5
+  };
+
+  const astGrep = detectFirst(opts.astGrepCandidates || AST_GREP_CANDIDATES, probeOpts);
+  const lspTools = detectAll(opts.lspCandidates || LSP_CANDIDATES, probeOpts);
+  const gaps = [];
+  if (!astGrep) gaps.push('ast-grep not detected');
+  if (lspTools.length === 0) gaps.push('LSP tools not detected');
+
+  return {
+    level: astGrep || lspTools.length > 0 ? 'available' : 'not-detected',
+    astGrep: astGrep
+      ? { available: true, command: astGrep.command, version: astGrep.version }
+      : { available: false, command: null, version: null },
+    lsp: {
+      available: lspTools.length > 0,
+      primary: lspTools[0] || null,
+      tools: lspTools
+    },
+    gaps
+  };
+}
+
+function lspSummary(lsp) {
+  if (!lsp || !lsp.available) return 'not detected';
+  return lsp.tools.map(tool => tool.command).join(', ');
+}
+
+function summary(report) {
+  if (!report) return 'not detected';
+  const parts = [];
+  if (report.astGrep && report.astGrep.available) {
+    parts.push(`ast-grep via ${report.astGrep.command}`);
+  }
+  if (report.lsp && report.lsp.available) {
+    parts.push(`LSP via ${lspSummary(report.lsp)}`);
+  }
+  return parts.length > 0 ? parts.join('; ') : 'not detected';
+}
+
+function render(report) {
+  const ast = report && report.astGrep && report.astGrep.available
+    ? `${report.astGrep.command} (${report.astGrep.version})`
+    : 'not detected';
+  const lsp = report && report.lsp && report.lsp.available
+    ? lspSummary(report.lsp)
+    : 'not detected';
+  const gaps = report && report.gaps && report.gaps.length > 0
+    ? report.gaps.join('; ')
+    : 'none';
+  return [
+    'Code intelligence:',
+    `  Structural search: ${ast}`,
+    `  LSP tools: ${lsp}`,
+    `  Gaps: ${gaps}`
+  ].join('\n');
+}
+
+module.exports = {
+  detect,
+  summary,
+  render,
+  _private: {
+    AST_GREP_CANDIDATES,
+    LSP_CANDIDATES,
+    commandVersion,
+    firstLine
+  }
+};

package/lib/context-writer.js

@@ -99,7 +99,7 @@ function buildCanonicalContent(state, opts = {}) {
   lines.push('- `/god-next` - what to run next, with reason');
   lines.push('- `/god-mode` - run the full autonomous project run');
   lines.push('- `/god-sync` - refresh artifacts, context, and source-system sync-back');
-  lines.push('- `/god-migrate` - import or sync GSD, BMAD, or Superpowers context');
+  lines.push('- `/god-migrate` - import or sync legacy planning, BMAD, or Superpowers context');
   lines.push('- `/god-context refresh` - refresh AI-tool awareness for this project');
   lines.push('');