godpowers 1.6.15 → 1.6.16

package/CHANGELOG.md

@@ -5,6 +5,33 @@ 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).
 
+## [1.6.16] - 2026-05-16
+
+Feature awareness for existing Godpowers projects.
+
+### Added
+- Added `lib/feature-awareness.js` to detect stale project awareness after a
+  Godpowers runtime upgrade.
+- Added state recording for the current Godpowers feature set so existing
+  projects can tell whether their context has learned about new capabilities.
+- Added behavioral tests for feature-awareness detection, safe state refresh,
+  AI-tool context refresh, migration suggestions, and `god-greenfieldifier`
+  escalation.
+
+### Changed
+- `AGENTS.md` context refresh now advertises `/god-sync`, `/god-migrate`, and
+  `/god-context refresh` so AI tools opening an existing project see the new
+  migration and awareness commands.
+- `/god-doctor`, `/god-context`, `/god-sync`, and `/god-mode` now document the
+  feature-awareness auto-invoke path for existing `.godpowers` projects.
+- `state.v1.json` now accepts the `godpowers-features` awareness record.
+
+### Guardrails
+- Detection is read-only by default.
+- The apply path writes only safe state metadata and managed context fences.
+- Ambiguous planning-system evidence is reported as a scoped
+  `god-greenfieldifier` recommendation instead of being converted blindly.
+
 ## [1.6.15] - 2026-05-16
 
 Planning-system migration and sync-back.

package/README.md

@@ -2,7 +2,7 @@
 
 [![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-1.6.15-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.6.16-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.**
@@ -12,13 +12,12 @@ idea to hardened production. It runs as **slash commands inside your AI coding
 tool** (Claude Code, Codex, Cursor, etc.) that orchestrate **specialist agents**
 in fresh contexts to do the work.
 
-Version 1.6.15 adds planning-system migration for teams arriving from GSD,
-BMAD, or Superpowers. `/god-init` now auto-detects those systems, imports
-useful context into Godpowers prep and seed artifacts, and records source
-systems in `state.json`. `/god-sync` now syncs current Godpowers progress back
-to managed companion files so teams can return to the prior system with a clear
-handoff trail. Ambiguous imports can auto-spawn `god-greenfieldifier` for a
-controlled migration plan.
+Version 1.6.16 adds feature awareness for existing Godpowers projects. When a
+new runtime adds capabilities, `/god-doctor`, `/god-context`, `/god-sync`, and
+`/god-mode` can detect stale project awareness, record the current feature set
+in `state.json`, refresh AI-tool context fences, and point source-system
+migration cases to `/god-migrate` or `god-greenfieldifier` when judgment is
+needed.
 
 It fuses four disciplines into one unified workflow:
 
@@ -228,6 +227,16 @@ managed sync-back files such as `.planning/GODPOWERS-SYNC.md`,
 `_bmad-output/GODPOWERS-SYNC.md`, or
 `docs/superpowers/GODPOWERS-SYNC.md`.
 
+Existing Godpowers projects can refresh their awareness after an upgrade:
+
+```bash
+/god-context refresh
+```
+
+This records the current Godpowers feature set in `.godpowers/state.json`,
+refreshes managed AI-tool context fences, and suggests `/god-migrate` or
+`god-greenfieldifier` when source-system evidence needs migration judgment.
+
 For existing codebases and org-constrained new projects, God Mode now runs a
 greenfield simulation audit and then actions it through a greenfieldification
 plan. It pauses before risky artifact rewrites because that process can change
@@ -351,8 +360,9 @@ Pi. T3 Code inherits from the underlying agent (Codex / Claude / OpenCode).
 - [Getting Started](docs/getting-started.md)
 - [Concepts](docs/concepts.md)
 - [Command reference (all 109 skills + 40 agents)](docs/reference.md)
+- [Feature awareness](docs/feature-awareness.md)
 - [Roadmap](docs/ROADMAP.md)
-- [1.5 Release Notes](RELEASE.md)
+- [Release Notes](RELEASE.md)
 - [Changelog](CHANGELOG.md)
 - [Inspiration](INSPIRATION.md)
 

package/RELEASE.md

@@ -1,10 +1,11 @@
-# Godpowers 1.6.15 Release
+# Godpowers 1.6.16 Release
 
 Date: 2026-05-16
 
-Godpowers 1.6.15 adds automatic migration from GSD, BMAD, and Superpowers
-projects into Godpowers. The release also adds managed sync-back so a team can
-return to its prior planning system with current Godpowers progress visible.
+Godpowers 1.6.16 adds feature awareness for existing Godpowers projects. After
+the installed runtime gains new capabilities, Godpowers can detect stale project
+awareness, record the current feature set in `state.json`, refresh AI-tool
+context fences, and route migration judgment to the right command or agent.
 
 ## What is stable
 
@@ -20,74 +21,54 @@ return to its prior planning system with current Godpowers progress visible.
 - `.godpowers/` workflow state and artifact layout
 - Safe-sync routing before deploy, observe, harden, launch, or god-mode work
 - Critical harden finding gate before launch
-- GSD-style proposition closeouts for exploratory, diagnostic, audit,
-  lifecycle, status, reconciliation, and decision-support outputs
-- Plain-language project-run wording in user-facing reports
+- Planning-system migration for GSD, BMAD, and Superpowers
+- Managed sync-back companion files for imported source systems
 
 ## What is new
 
-- Added `lib/planning-systems.js` for GSD, BMAD, and Superpowers detection.
-- Added `lib/source-sync.js` for managed sync-back companion files.
-- Added `/god-migrate` as the explicit migration command.
-- `/god-init` now auto-invokes planning-system import when source systems are
-  detected.
-- `/god-sync` now auto-invokes source-system sync-back when enabled source
-  systems are recorded in `state.json`.
-- `reverse-sync` now returns source-system sync-back results.
-- `state.v1.json` now records source-system import and sync-back state.
-- Added `docs/planning-system-migration.md`.
+- Added `lib/feature-awareness.js`.
+- Added `godpowers-features` to `state.v1.json`.
+- Added `scripts/test-feature-awareness.js`.
+- `/god-doctor`, `/god-context`, `/god-sync`, and `/god-mode` now document the
+  feature-awareness auto-invoke path.
+- `AGENTS.md` refreshes now include `/god-sync`, `/god-migrate`, and
+  `/god-context refresh` in the useful command list.
 
-## Migration behavior
+## Awareness behavior
 
-Godpowers detects:
+For an initialized `.godpowers` project, the helper:
 
-- GSD: `.planning/`, `.gsd/`, `GSD.md`, and `gsd*.md`
-- BMAD: `_bmad/`, `_bmad-output/`, `.bmad-core/`, `.bmad/`, and `BMAD.md`
-- Superpowers: `docs/superpowers/`, `.superpowers/`, `SUPERPOWERS.md`, and
-  project-local skills
+- reads the installed runtime version
+- compares the project `godpowers-features` record to the current feature set
+- detects missing managed AI-tool context fences
+- detects unimported GSD, BMAD, or Superpowers planning artifacts
+- writes only safe state metadata and managed context fences when applied
 
-Imported context is written to `.godpowers/prep/IMPORTED-CONTEXT.md`.
-Missing Godpowers seed artifacts are created only when source evidence exists.
-Existing Godpowers artifacts are preserved unless the user explicitly forces an
-overwrite.
-
-## Sync-back behavior
-
-Godpowers writes managed companion files:
-
-- GSD: `.planning/GODPOWERS-SYNC.md` or `.gsd/GODPOWERS-SYNC.md`
-- BMAD: `_bmad-output/GODPOWERS-SYNC.md` or `.bmad/GODPOWERS-SYNC.md`
-- Superpowers: `docs/superpowers/GODPOWERS-SYNC.md` or
-  `.superpowers/GODPOWERS-SYNC.md`
-
-Pointer fences are written only when a safe native state file already exists.
-Godpowers never rewrites source-system prose outside managed fences.
+Detection is read-only. Applying awareness does not rewrite product, planning,
+source-system, or code files outside Godpowers-owned fences.
 
 ## Auto-invoke and auto-spawn policy
 
-The import path is local runtime work and must be reported as:
+Feature awareness is local runtime work and must be reported as:
 
 ```
 Agent: none, local runtime only
 ```
 
-The sync-back path is also local runtime work and must be reported the same
-way.
-
-Godpowers spawns `god-greenfieldifier` only when import confidence is low,
-multiple source systems conflict, or canonical seed artifacts cannot be safely
-created from available evidence.
+Godpowers recommends or spawns `god-greenfieldifier` only when imported or
+detected planning-system context has low confidence or conflicts that need
+migration judgment.
 
 ## Validation
 
 Release validation includes:
 
+- `node scripts/test-feature-awareness.js`
+- `node scripts/test-context-writer.js`
 - `node scripts/test-planning-systems.js`
-- `node scripts/test-reverse-sync.js`
-- `npm test`
-- `npm run test:audit`
-- `node scripts/check-package-contents.js`
+- `node scripts/test-doc-surface-counts.js`
+- `node scripts/validate-skills.js`
 - `git diff --check`
 
-The `v1.6.15` git tag points to the release commit that matches the npm
-`godpowers@1.6.15` package.
+The `v1.6.16` tag should point to the release commit that matches the npm
+`godpowers@1.6.16` package.

package/SKILL.md

@@ -214,7 +214,7 @@ Auto-invoked:
   Trigger: <what caused this automatic step>
   Agent: <god-updater | god-context-writer | none, local runtime only>
   Local syncs:
-    + <planning-system-import | reverse-sync | source-sync | pillars-sync | checkpoint-sync | context-refresh>: <result or skipped reason>
+    + <feature-awareness | planning-system-import | reverse-sync | source-sync | pillars-sync | checkpoint-sync | context-refresh>: <result or skipped reason>
   Artifacts: <changed files, no-op, or deferred>
   Log: <SYNC-LOG.md, CHECKPOINT.md, REVIEW-REQUIRED.md, or none>
 ```
@@ -240,6 +240,8 @@ Automatic steps that especially need visible reporting:
   `/god-automation-status`, and `/god-automation-setup`
 - planning-system import during `/god-init` or `/god-migrate`
 - source-system sync-back during `/god-sync`, `/god-scan`, or `/god-migrate`
+- feature-awareness refresh during `/god-doctor`, `/god-context`,
+  `/god-sync`, or `/god-mode`
 
 ### 13. Proactive Auto-Invoke Policy
 Godpowers should be proactive from disk evidence, not from guesswork. Before
@@ -272,6 +274,10 @@ Run these local runtime helpers automatically when their trigger is present:
   `/god-migrate`.
 - `lib/source-sync.run` when `state.json` records enabled `source-systems`
   entries and `/god-sync`, `/god-scan`, or `/god-migrate` closes a workflow.
+- `lib/feature-awareness.detect` during `/god-doctor` and
+  `lib/feature-awareness.run` during `/god-context`, `/god-sync`, or
+  `/god-mode` when an initialized `.godpowers` project lacks current runtime
+  feature metadata or managed AI-tool context fences.
 - Context refresh dry-run after `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`,
   `.cursor/rules/`, `.windsurfrules`, `.github/copilot-instructions.md`,
   `.clinerules`, `.roo/`, or `.continue/` changes.
@@ -299,6 +305,8 @@ Spawn these agents only when the trigger is direct and scope is bounded:
 - `god-greenfieldifier` when imported GSD, BMAD, or Superpowers context has
   low confidence, conflicting systems, or missing canonical Godpowers seed
   artifacts after local import.
+- `god-greenfieldifier` when feature-awareness detects unimported or imported
+  source-system context that is low confidence or conflicting.
 
 #### Level 4: Explicit approval required
 Never auto-run these from inference alone:

package/lib/README.md

@@ -12,6 +12,7 @@ package-level integrations.
 | `state-lock.js` | Coordinate state writes with a lock file. |
 | `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. |
 | `budget.js` | Read and enforce configured budget controls. |
 | `cost-tracker.js` | Track token and cost estimates from event streams. |
 
@@ -52,6 +53,8 @@ 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. |
+| `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. |
 | `awesome-design.js` | Validate design guidance against awesome-design rules. |

package/lib/context-writer.js

@@ -97,11 +97,10 @@ function buildCanonicalContent(state, opts = {}) {
   lines.push('');
   lines.push('- `/god-status` - re-derive state from disk');
   lines.push('- `/god-next` - what to run next, with reason');
-  lines.push('- `/god <free text>` - match intent to a recipe');
   lines.push('- `/god-mode` - run the full autonomous project run');
-  lines.push('- `/god-lint` - validate artifacts against have-nots');
-  lines.push('- `/god-scan` - rebuild linkage map from code');
-  lines.push('- `/god-review-changes` - walk REVIEW-REQUIRED.md');
+  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-context refresh` - refresh AI-tool awareness for this project');
   lines.push('');
 
   // Pointers to design and product files when present

package/lib/feature-awareness.js

@@ -0,0 +1,220 @@
+/**
+ * Godpowers Feature Awareness
+ *
+ * Keeps existing Godpowers projects aware of capabilities added by newer
+ * installed runtimes. This module is deliberately conservative: detect is
+ * read-only, run applies only safe state and context refreshes, and ambiguous
+ * migration cases are returned as spawn recommendations.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const state = require('./state');
+const contextWriter = require('./context-writer');
+const planningSystems = require('./planning-systems');
+
+const FEATURE_SET_VERSION = 1;
+
+const FEATURES = [
+  {
+    id: 'planning-system-migration',
+    since: '1.6.15',
+    commands: ['/god-migrate', '/god-init'],
+    description: 'Detect and import GSD, BMAD, and Superpowers planning artifacts.'
+  },
+  {
+    id: 'source-system-sync-back',
+    since: '1.6.15',
+    commands: ['/god-sync', '/god-migrate'],
+    description: 'Write managed Godpowers progress summaries back to detected source systems.'
+  },
+  {
+    id: 'feature-awareness',
+    since: '1.6.16',
+    commands: ['/god-doctor', '/god-context', '/god-sync', '/god-mode'],
+    description: 'Refresh existing Godpowers projects when the installed runtime gains new capabilities.'
+  }
+];
+
+function packageVersion(projectRoot) {
+  const candidates = [
+    path.join(__dirname, '..', 'package.json'),
+    path.join(projectRoot || process.cwd(), 'package.json')
+  ];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+      if (parsed && parsed.name === 'godpowers' && parsed.version) return parsed.version;
+    } catch (err) {
+      // Ignore malformed package metadata. Awareness can still run with unknown.
+    }
+  }
+  return 'unknown';
+}
+
+function expectedFeatureIds() {
+  return FEATURES.map((feature) => feature.id);
+}
+
+function existingFeatureIds(current) {
+  const record = current && current['godpowers-features'];
+  return Array.isArray(record && record.known) ? record.known : [];
+}
+
+function missingFeatureIds(current) {
+  const known = new Set(existingFeatureIds(current));
+  return expectedFeatureIds().filter((id) => !known.has(id));
+}
+
+function sourceSystemsNeedJudgment(current) {
+  const systems = Array.isArray(current && current['source-systems'])
+    ? current['source-systems']
+    : [];
+  return systems.filter((system) => {
+    return system.confidence === 'low' || Number(system['conflict-count'] || 0) > 0;
+  });
+}
+
+function missingContextTargets(projectRoot) {
+  const status = contextWriter.status(projectRoot);
+  const missing = [];
+  if (!status.canonical.hasFence) missing.push('AGENTS.md');
+  for (const pointer of status.pointers) {
+    if (!pointer.hasFence) {
+      missing.push(path.relative(projectRoot, pointer.path).split(path.sep).join('/'));
+    }
+  }
+  return missing;
+}
+
+function detect(projectRoot, opts = {}) {
+  const current = state.read(projectRoot);
+  const runtimeVersion = opts.runtimeVersion || packageVersion(projectRoot);
+  if (!current) {
+    return {
+      initialized: false,
+      runtimeVersion,
+      actions: [],
+      missingFeatures: expectedFeatureIds(),
+      missingContext: [],
+      migrationCandidates: [],
+      spawnRecommendation: null
+    };
+  }
+
+  const record = current['godpowers-features'] || {};
+  const missingFeatures = missingFeatureIds(current);
+  const missingContext = missingContextTargets(projectRoot);
+  const migrationCandidates = planningSystems.detect(projectRoot).systems
+    .filter((system) => {
+      const configured = Array.isArray(current['source-systems'])
+        ? current['source-systems']
+        : [];
+      return !configured.some((entry) => entry.id === system.id);
+    })
+    .map((system) => ({
+      id: system.id,
+      name: system.name,
+      confidence: system.confidence,
+      files: system.files.length
+    }));
+
+  const actions = [];
+  if (record['runtime-version'] !== runtimeVersion) actions.push('record-runtime-version');
+  if (missingFeatures.length > 0) actions.push('record-feature-set');
+  if (missingContext.length > 0) actions.push('refresh-context');
+  if (migrationCandidates.length > 0) actions.push('suggest-god-migrate');
+
+  const needsJudgment = sourceSystemsNeedJudgment(current);
+  const lowConfidenceCandidates = migrationCandidates.filter((system) => system.confidence === 'low');
+  const spawnRecommendation = needsJudgment.length > 0 || lowConfidenceCandidates.length > 0
+    ? {
+        agent: 'god-greenfieldifier',
+        reason: 'Imported or detected planning-system context needs migration judgment.',
+        systems: [...needsJudgment.map((system) => system.id), ...lowConfidenceCandidates.map((system) => system.id)]
+      }
+    : null;
+
+  return {
+    initialized: true,
+    runtimeVersion,
+    featureSetVersion: FEATURE_SET_VERSION,
+    actions,
+    currentFeatures: existingFeatureIds(current),
+    expectedFeatures: FEATURES,
+    missingFeatures,
+    missingContext,
+    migrationCandidates,
+    spawnRecommendation
+  };
+}
+
+function buildFeatureRecord(runtimeVersion, now) {
+  return {
+    'feature-set-version': FEATURE_SET_VERSION,
+    'runtime-version': runtimeVersion,
+    known: expectedFeatureIds(),
+    'last-awareness-refresh-at': now
+  };
+}
+
+function sameFeatureRecord(existing, next) {
+  if (!existing) return false;
+  return existing['feature-set-version'] === next['feature-set-version']
+    && existing['runtime-version'] === next['runtime-version']
+    && JSON.stringify(existing.known || []) === JSON.stringify(next.known || []);
+}
+
+function applyStateAwareness(projectRoot, current, runtimeVersion, now) {
+  const nextRecord = buildFeatureRecord(runtimeVersion, now);
+  if (sameFeatureRecord(current['godpowers-features'], nextRecord)) {
+    return { written: false, record: current['godpowers-features'] };
+  }
+  const nextState = {
+    ...current,
+    'godpowers-features': nextRecord
+  };
+  state.write(projectRoot, nextState);
+  return { written: true, record: nextRecord };
+}
+
+function run(projectRoot, opts = {}) {
+  const before = detect(projectRoot, opts);
+  if (!before.initialized) {
+    return {
+      ...before,
+      applied: false,
+      stateWritten: false,
+      contextResults: [],
+      reason: '.godpowers/state.json not found'
+    };
+  }
+
+  const current = state.read(projectRoot);
+  const now = opts.now || new Date().toISOString();
+  const stateResult = applyStateAwareness(projectRoot, current, before.runtimeVersion, now);
+  const refreshedState = state.read(projectRoot);
+  const shouldRefreshContext = opts.refreshContext !== false;
+  const contextResults = shouldRefreshContext
+    ? contextWriter.apply(projectRoot, refreshedState, { projectRoot })
+    : [];
+  const after = detect(projectRoot, opts);
+
+  return {
+    ...after,
+    applied: true,
+    stateWritten: stateResult.written,
+    contextResults,
+    stateRecord: stateResult.record
+  };
+}
+
+module.exports = {
+  FEATURE_SET_VERSION,
+  FEATURES,
+  packageVersion,
+  detect,
+  run
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "godpowers",
-  "version": "1.6.15",
+  "version": "1.6.16",
   "description": "AI-powered development system: 109 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-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/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-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",
     "prepublishOnly": "npm test",
     "validate-skills": "node scripts/validate-skills.js",
     "test:surface": "node scripts/test-doc-surface-counts.js",

package/schema/state.v1.json

@@ -131,6 +131,32 @@
         "additionalProperties": false
       }
     },
+    "godpowers-features": {
+      "type": "object",
+      "description": "Installed Godpowers feature awareness recorded for this project.",
+      "required": ["feature-set-version", "runtime-version", "known"],
+      "properties": {
+        "feature-set-version": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "runtime-version": {
+          "type": "string",
+          "pattern": "^(unknown|\\d+\\.\\d+\\.\\d+)$"
+        },
+        "known": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "last-awareness-refresh-at": {
+          "type": "string",
+          "format": "date-time"
+        }
+      },
+      "additionalProperties": false
+    },
     "yolo-decisions": {
       "type": "array",
       "description": "Auto-decisions made under --yolo. Mirrored to YOLO-DECISIONS.md.",

package/skills/god-context.md

@@ -33,10 +33,12 @@ the Godpowers fences off, check status, or refresh on demand.
 
 1. Verify `.godpowers/` exists. If not, suggest `/god-init` first.
 2. Read `.godpowers/state.json`.
-3. Call `lib/pillars.detect(projectRoot)`.
-4. If Pillars is absent or partial, call `lib/pillars.init(projectRoot)`.
-5. Spawn `god-context-writer` agent with the requested mode.
-6. Report results.
+3. Call `lib/feature-awareness.run(projectRoot)` to record current runtime
+   features and refresh managed AI-tool awareness safely.
+4. Call `lib/pillars.detect(projectRoot)`.
+5. If Pillars is absent or partial, call `lib/pillars.init(projectRoot)`.
+6. Spawn `god-context-writer` agent with the requested mode.
+7. Report results.
 
 ## What gets written
 
@@ -136,6 +138,14 @@ When `/god-sync` runs (after a project run, or any sync), `god-updater` calls th
 with `refresh` to keep `AGENTS.md` content aligned with the latest project
 state (mode, scale, completed tiers, active artifacts).
 
+For existing projects after a Godpowers upgrade, `/god-context refresh`
+auto-invokes `lib/feature-awareness.run(projectRoot)`. Report it as:
+
+```
+Agent: none, local runtime only
+Why: this path records current runtime features and refreshes managed context fences
+```
+
 You can disable the Godpowers fences by running `/god-context off`. Pillars
 remains because it is the native context contract for Godpowers projects.
 
@@ -146,7 +156,7 @@ The fenced content contains:
 - Mode (greenfield/brownfield/audit) and scale
 - A short list of completed-tier artifact paths
 - Quarterback rule reminder
-- Top 4 useful slash commands
+- Short useful slash command list
 
 It does NOT contain:
 - Secrets, credentials, API keys

package/skills/god-doctor.md

@@ -32,6 +32,8 @@ Run a system-state diagnostic. Build nothing. Touch nothing. Report only.
 5. Is the reflog (`.godpowers/log`) parseable?
 6. Are there entries in `.godpowers/.trash/`?
 7. Do declared linkage entries point at real code files?
+8. Does `state.json` know the current Godpowers feature set?
+9. Are managed AI-tool context fences present when tools are detected?
 
 ### External integration health
 1. Is impeccable present? `node_modules/impeccable` or `~/.claude/skills/impeccable`?
@@ -53,6 +55,7 @@ Install: claude (~/.claude/)
 
 Project: /Users/.../my-project/.godpowers/
   [OK] state.json valid
+  [WARN] feature awareness stale -> run /god-context refresh
   [WARN] PRD declared but .godpowers/prd/PRD.md missing -> run /god-prd
   [INFO] 2 entries in .trash/; run /god-restore to review
 
@@ -96,12 +99,29 @@ Skip install checks. Useful inside the project.
 ### `/god-doctor --fix`
 Attempt to repair detected issues automatically (only for safe categories: regenerate missing routing YAMLs, repair PROGRESS.md from state.json, etc.). Pauses before any destructive change.
 
+## Feature Awareness
+
+For initialized projects, `/god-doctor` calls `lib/feature-awareness.detect`
+as a read-only diagnostic. It reports:
+- runtime version recorded in `state.json`
+- missing current Godpowers feature IDs
+- missing managed AI-tool context fences
+- unimported GSD, BMAD, or Superpowers evidence that should route to
+  `/god-migrate`
+- `god-greenfieldifier` recommendation when migration evidence is low
+  confidence or conflicting
+
+`/god-doctor --fix` may call `lib/feature-awareness.run(projectRoot)` because
+that helper writes only safe state metadata and managed context fences.
+
 ## Implementation
 
 Built-in, no spawned agent. Reads:
 - `<runtime>/GODPOWERS_VERSION` (compare to package.json)
 - `<runtime>/skills/` and `<runtime>/agents/` listings
 - `.godpowers/state.json`, `intent.yaml`, `log`, `linkage.json`
+- `lib/feature-awareness.detect(projectRoot)` for existing-project upgrade
+  awareness
 - `bin/install.js` VERSION constant
 
 ## Exit codes

package/skills/god-mode.md

@@ -304,6 +304,7 @@ 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>
     + pillars-sync: <counts and result>
     + checkpoint-sync: <created, updated, no-op, or skipped>
@@ -318,6 +319,11 @@ 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.
+
 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.
@@ -337,6 +343,7 @@ 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>
     + pillars-sync: <counts and result>
     + checkpoint-sync: <created, updated, no-op, or skipped>

package/skills/god-sync.md

@@ -29,14 +29,17 @@ User runs `/god-sync` after manual changes. Useful for:
 ## Setup
 
 1. Verify `.godpowers/` exists
-2. Call `lib/pillars.pillarizeExisting(projectRoot)` if Pillars is absent or
+2. Call `lib/feature-awareness.run(projectRoot)` so existing projects learn
+   about newly installed Godpowers runtime capabilities before sync closes.
+   Report this as `Agent: none, local runtime only`.
+3. Call `lib/pillars.pillarizeExisting(projectRoot)` if Pillars is absent or
    partial, because every Godpowers project must also carry native Pillars
    context.
-3. If `state.json` contains enabled `source-systems`, auto-invoke
+4. If `state.json` contains enabled `source-systems`, auto-invoke
    `lib/source-sync.run(projectRoot)` so current Godpowers progress is written
    back to imported GSD, BMAD, or Superpowers companion files. Report this as
    `Agent: none, local runtime only`.
-4. Spawn god-updater in fresh context with:
+5. Spawn god-updater in fresh context with:
    - The reconciliation verdict (if available from a prior /god-reconcile)
    - Or: re-run reconciliation against current state to detect what changed
    - Recent commits for context
@@ -48,7 +51,7 @@ Auto-invoked:
   Trigger: <manual /god-sync, recipe closeout, /god-mode final sync, or other source>
   Agent: god-updater
   Local syncs:
-    - pending: reverse-sync, source-sync, pillars-sync, checkpoint-sync, context-refresh
+    - pending: feature-awareness, reverse-sync, source-sync, pillars-sync, checkpoint-sync, context-refresh
   Artifacts: pending
   Log: .godpowers/SYNC-LOG.md
 ```
@@ -73,6 +76,7 @@ Sync status:
   Agent: god-updater spawned
   Local syncs:
     + reverse-sync: <scanned N files, updated M footers, populated K review items>
+    + feature-awareness: <recorded runtime features, refreshed context, or no-op>
     + source-sync: <written GSD/BMAD/Superpowers companion files, no-op, or skipped>
     + pillars-sync: <updated N pillar files, no-op, or proposed>
     + checkpoint-sync: <CHECKPOINT.md updated or skipped>

package/skills/god-version.md

@@ -14,11 +14,12 @@ Print version and a short capability summary.
 ## Output
 
 ```
-Godpowers v1.6.6
+Godpowers v1.6.16
 Install: /Users/.../.claude/  (matches package.json)
 Surface: 109 skills, 40 agents, 13 workflows, 36 recipes
 Schema: intent.v1, state.v1, events.v1, workflow.v1, routing.v1, recipe.v1
 External integrations available: impeccable, agent-browser (others lazy)
+Feature awareness: planning-system migration, source-system sync-back, context refresh
 ```
 
 ## Subcommands