godpowers 1.6.14 → 1.6.16

package/CHANGELOG.md

@@ -5,6 +5,70 @@ 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.
+
+### Added
+- Added `lib/planning-systems.js` to detect GSD, BMAD, and Superpowers
+  planning context and convert useful signals into Godpowers prep and seed
+  artifacts.
+- Added `lib/source-sync.js` to write current Godpowers progress back into
+  managed companion files for imported planning systems.
+- Added `/god-migrate` as the explicit command for planning-system detection,
+  import, sync-back, and specialist escalation when migration evidence is
+  ambiguous.
+- Added `docs/planning-system-migration.md` with detection signals, import
+  mapping, sync-back destinations, conflict rules, and return-path guidance.
+- Added behavioral tests for GSD, BMAD, Superpowers, imported seed artifacts,
+  state recording, and idempotent sync-back.
+
+### Changed
+- `/god-init` now auto-invokes planning-system import when GSD, BMAD, or
+  Superpowers evidence is detected.
+- `/god-sync` now auto-invokes source-system sync-back when `state.json`
+  records enabled source systems.
+- `reverse-sync` now includes source-system sync-back in its runtime result.
+- `state.v1.json` now records imported source systems, import hashes,
+  sync-back hashes, conflict counts, and sync-back policy.
+
+### Guardrails
+- Imported planning context remains `[HYPOTHESIS]` until confirmed by the user
+  or a Godpowers artifact.
+- Existing Godpowers artifacts are preserved unless the user explicitly forces
+  overwrite.
+- Source-system files are not rewritten outside Godpowers-owned fences or
+  companion files.
+- Low-confidence or conflicting imports route to `god-greenfieldifier` for a
+  controlled migration plan.
+
 ## [1.6.14] - 2026-05-16
 
 Approved automation setup execution.

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.14-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,16 +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.14 builds on the executable dashboard engine and CLI status surface:
-`godpowers status --project .` and `godpowers next --project .` now compute the
-same disk-derived progress, planning visibility, proactive checks, and next
-action used by `/god-status`, `/god-next`, and God Mode closeouts.
-It adds an opt-in automation-provider layer so Godpowers can detect host
-automation surfaces such as Codex App automations, Claude Routines, Cline
-schedules, Qwen loops, Cursor Background Agents, Copilot cloud agent, and
-scriptable CLI providers without silently creating background work.
-Approved setup can now use host tool calling for simple read-only automation
-or spawn `god-automation-engineer` for complex automation setup.
+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:
 
@@ -147,6 +143,7 @@ npx godpowers status --project=. --json
 | `/god-status` | Re-derive state from disk | (built-in) |
 | `/god-automation-status` | Show host automation provider support | (built-in) |
 | `/god-automation-setup` | Prepare opt-in automation setup | (built-in) |
+| `/god-migrate` | Detect GSD, BMAD, and Superpowers context; import and sync back | god-greenfieldifier when needed |
 | `/god-preflight` | Read-only intake audit before project-run readiness and pillars | god-auditor |
 | `/god-audit` | Score artifacts against have-nots | god-auditor |
 | `/god-debug` | 4-phase systematic debug | god-debugger |
@@ -217,6 +214,29 @@ background agents, API triggers, or CI workflows. Safe starting templates are
 read-only status, checkpoint, review queue, hygiene, and release readiness
 reports.
 
+Godpowers can migrate from adjacent planning systems:
+
+```bash
+/god-migrate
+```
+
+This detects GSD `.planning/` or `.gsd/`, BMAD `_bmad-output/` or `.bmad/`,
+and Superpowers specs or plans. It writes
+`.godpowers/prep/IMPORTED-CONTEXT.md`, optional imported seed artifacts, and
+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
@@ -339,9 +359,10 @@ Pi. T3 Code inherits from the underlying agent (Codex / Claude / OpenCode).
 
 - [Getting Started](docs/getting-started.md)
 - [Concepts](docs/concepts.md)
-- [Command reference (all 108 skills + 40 agents)](docs/reference.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,21 +1,19 @@
-# Godpowers 1.6.14 Release
+# Godpowers 1.6.16 Release
 
 Date: 2026-05-16
 
-Godpowers 1.6.14 turns automation setup from a plan-only contract into an
-approved execution contract for hosts that expose tool calling. The CLI remains
-deterministic and read-only, while `/god-automation-setup` can use host-native
-tool calling for simple read-only setup or spawn `god-automation-engineer` for
-complex setup.
+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
 
-- 108 slash commands
+- 109 slash commands
 - 40 specialist agents
 - 13 executable workflows
 - 36 intent recipes
 - 15-runtime installer
-- 459 package files in the npm tarball
 - Codex installs with generated `god-*.toml` agent metadata files
 - Markdown specialist agent contracts at `<runtime>/agents/god-*.md`
 - Shared runtime bundle at `<runtime>/godpowers-runtime`
@@ -23,63 +21,54 @@ complex setup.
 - `.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 `god-automation-engineer`.
-- Added automation execution-plan metadata to `lib/automation-providers.js`.
-- Added gated automation state recording helpers.
-- `/god-automation-setup` now shows direct host tool calling availability,
-  complex setup delegation, and the state recording path.
-- Tests now cover host tool execution plans, complex setup delegation, and
-  post-success automation recording.
-
-## Platform behavior
-
-Claude Code, Codex, Cursor, Windsurf, Gemini, OpenCode, Copilot, Augment,
-Trae, Cline, Kilo, Antigravity, Qwen, CodeBuddy, and Pi all receive the same
-portable Markdown agent contracts. Codex also receives `god-*.toml` files as
-its registry adapter.
-
-The dashboard and automation provider engines ship in the installed runtime
-bundle so host tools can use shared implementation code instead of parallel
-command-specific Markdown contracts. If a host platform cannot provide a true
-fresh-context agent spawn, durable scheduler, or callable automation tool,
-Godpowers must say so visibly and report the work as local runtime only,
-manual workflow only, or simulated in current context.
-
-## Safety policy
-
-Godpowers may proactively suggest next steps and may run directly evidenced
-local helpers. It may spawn bounded agents only when the current workflow owns
-that surface.
-
-Godpowers still must not auto-run these without explicit user intent:
-
-- deployed staging verification against a guessed URL
-- production launch
-- provider dashboard, admin console, DNS, credential, or secret checks
-- schedule, routine, background agent, API trigger, or CI workflow creation
-- broad dependency upgrades
-- destructive repair, rollback, reset, delete, or cleanup
-- clearing `.godpowers/REVIEW-REQUIRED.md`
-- accepting Critical security findings
-- git stage, commit, push, package, release, or publish
-- `.godpowers/automations.json` writes before host setup success
+- 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.
+
+## Awareness behavior
+
+For an initialized `.godpowers` project, the helper:
+
+- 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
+
+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
+
+Feature awareness is local runtime work and must be reported as:
+
+```
+Agent: none, local runtime only
+```
+
+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-dashboard.js`
-- `node scripts/test-automation-providers.js`
-- `npm test`
-- `npm run test:audit`
-- `node scripts/check-package-contents.js`
+- `node scripts/test-feature-awareness.js`
+- `node scripts/test-context-writer.js`
+- `node scripts/test-planning-systems.js`
+- `node scripts/test-doc-surface-counts.js`
+- `node scripts/validate-skills.js`
 - `git diff --check`
 
-The `v1.6.14` git tag points to the release commit that matches the npm
-`godpowers@1.6.14` 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:
-    + <reverse-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>
 ```
@@ -238,6 +238,10 @@ Automatic steps that especially need visible reporting:
 - checkpoint refresh after state mutations
 - automation provider detection in `/god-status`, `/god-next`,
   `/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
@@ -265,6 +269,15 @@ Run these local runtime helpers automatically when their trigger is present:
   `PROGRESS.md` mutation.
 - Lightweight reverse-sync or linkage scan after code or artifact edits.
 - Pillars sync planning after durable artifact truth changes.
+- `lib/planning-systems.importPlanningContext` when GSD, BMAD, or
+  Superpowers planning context is detected during `/god-init` or
+  `/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.
@@ -289,6 +302,11 @@ Spawn these agents only when the trigger is direct and scope is bounded:
 - `god-automation-engineer` after the user approves provider, template,
   cadence, and scope for multi-template, write-capable, background-agent,
   scriptable-scheduler, or provider-uncertain automation setup.
+- `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
+};