godpowers 2.3.1 → 2.4.0

package/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-06-08
+
+### Added
+- Added command-family UX metadata for start, continue, build, verify,
+  operate, maintain, capture, recover, extend, collaborate, and configure
+  while keeping every shipped leaf command available.
+- Added capture, work-size, verification, status-view, and trigger-precedence
+  helpers in `lib/command-families.js`.
+- Added typed route outcome metadata for contextual, verdict-based,
+  steady-state, session-end, and selection-based route exits.
+- Added workflow helper groups with serialized plan expansion so closeout
+  helpers can be consolidated without hiding local runtime work.
+
+### Changed
+- Updated `/god`, `/god-help`, `/god-next`, `/god-status`, README,
+  reference docs, recipes, architecture docs, command-flow docs, and
+  auto-invoke visibility docs to present the consolidated UX paths.
+- Updated all shipped command routes with command family metadata.
+- Updated repeated workflow closeout helper lists to named helper groups while
+  preserving explicit expanded helpers in generated plans.
+- Updated extension recipe copy to describe current extension-pack-required
+  flows instead of old release annotations.
+
+### Fixed
+- Route-quality sync now requires typed outcomes for flexible route exits
+  instead of accepting unexplained placeholder next routes.
+- The full-arc e2e smoke test now verifies both helper groups and expanded
+  local helper visibility.
+
 ## [2.3.1] - 2026-06-08
 
 ### Added

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-2.3.1-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.4.0-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.**
@@ -21,12 +21,10 @@ Godpowers makes AI coding accountable: every serious run should leave disk
 state, artifacts, validation gates, host guarantees, and a next action. Code is
 only one output. The project memory and proof trail matter too.
 
-Version 2.3.1 keeps the proof loop executable and adds release-surface
-hardening. Extension authors get `/god-extension-scaffold`, public starter
-paths are regression-tested against the actual router, host capability reports
-include optional code-intelligence tooling, clean user dashboards avoid
-maintainer-repo drift, and symlink handling is hardened across extension,
-planning-system, and cache paths.
+Version 2.4.0 keeps every leaf command available while making the command
+surface easier to navigate. `/god`, `/god-help`, `/god-next`, and route
+metadata now share command families, decision ladders, typed route outcomes,
+and workflow helper groups so users see clearer paths without losing power.
 
 Maintainer hardening continues on the 2.x line with small, audited public
 surface updates when they close real workflow gaps. The 2.1.0 patch closes a command-injection vector in the
@@ -109,6 +107,16 @@ preserves the complete command surface, while the smaller profiles install the
 commands most relevant to the role. `--minimal` is an alias for
 `--profile=core`.
 
+Use profiles as journeys:
+
+| Journey | Profile |
+|---|---|
+| I want the basics | `core` |
+| I build products | `builder` |
+| I maintain Godpowers or mature repos | `maintainer` |
+| I coordinate suites | `suite` |
+| I want everything | `full` |
+
 Agent spawning is host-native. Claude uses its native agent/task interface,
 Codex uses installed `agents/*.toml` metadata backed by the same Markdown agent
 contracts, and the other runtimes use their supported agent or subagent
@@ -185,6 +193,10 @@ hook does the same thing when you open a new session in a Godpowers project.
 If the full command surface feels large, begin with one of these paths and only
 learn the next command when Godpowers recommends it.
 
+`/god-help` presents command families first: start, continue, build, verify,
+operate, maintain, capture, recover, extend, collaborate, and configure. Leaf
+commands remain direct shortcuts.
+
 | Goal | Starter path |
 |---|---|
 | Start a product | `/god-init`, `/god-prd`, `/god-design`, `/god-arch`, `/god-roadmap`, `/god-stack`, `/god-repo`, `/god-build` |

package/RELEASE.md

@@ -1,12 +1,12 @@
-# Godpowers 2.3.1 Release
+# Godpowers 2.4.0 Release
 
 > Status: Ready for package verification
 > Date: 2026-06-08
 
-Godpowers 2.3.1 is an accountability and release-surface hardening release for
-the 2.x line. It strengthens planning grounding, package legitimacy, install
-profiles, atomic persistence, executor recovery, extension authoring,
-front-door route coverage, host capability reporting, and dashboard behavior.
+Godpowers 2.4.0 is a UX flow consolidation release for the 2.x line. It keeps
+the complete 112-command surface intact while making the primary paths easier
+to understand through command families, decision ladders, typed route outcomes,
+and auditable workflow helper groups.
 
 ## What's in this release
 
@@ -17,52 +17,43 @@ front-door route coverage, host capability reporting, and dashboard behavior.
 
 ## Highlights
 
-- `/god-extension-scaffold` gives extension authors a first-class
-  slash-command path before `/god-test-extension` and `/god-extension-add`.
-- Public `/god` intent matching now covers the starter phrases users are most
-  likely to type: start a product, add a feature, fix production, audit an
-  existing repo, ship a release, maintain health, and extend Godpowers.
-- Quick Proof and README starter paths are now regression-tested against the
-  actual router and recipe engine.
-- User project dashboards no longer show maintainer-repository documentation
-  drift when a clean non-Godpowers project is inspected.
-- Host capability reporting now includes optional code-intelligence tooling
-  without treating missing optional tools as a host degradation.
-- Extension install, planning-system detection, and agent-cache cleanup are
-  hardened around symlinked paths that point outside trusted source trees.
-- Source-grounded planning records existing files, existing symbols, planned new
-  artifacts, and unchecked references before build execution.
-- Package legitimacy checks give stack and dependency decisions a concrete npm
-  evidence gate before recommending package-backed choices.
-- Installer profiles let users install a smaller role-based command surface
-  with `--profile=<name>` or `--minimal`.
-- Atomic write helpers now protect core state and ledger writes from partial
-  file updates.
-- Executor repair classification names whether a failed attempt should retry,
-  decompose, prune, or escalate.
-- Public migration language now uses neutral legacy-planning terminology so
-  Godpowers is not confused with external workflow products.
-- Architecture docs now include an executable audit map for disconnected
-  commands, actions, workflows, recipes, and package surfaces.
+- `/god-help` now presents command families first, then ladders and the full
+  catalog.
+- `/god` and `/god-next` now share command-family helpers for capture, work
+  sizing, verification, and overlapping trigger phrases.
+- `/god-status` is documented as the continue-family hub, with `/god-progress`,
+  `/god-lifecycle`, `/god-locate`, and `/god-next` as direct views.
+- Every shipped route now carries command family metadata.
+- Flexible route exits now carry typed `success-path.outcome` metadata so
+  contextual, verdict-based, steady-state, session-end, and selection outcomes
+  can be explained to users.
+- Workflow YAML can now use named helper groups, while generated plans still
+  expand the exact local helper list for visibility.
+- Recipes now split simple existing-repo onboarding from deeper inheritance
+  flows, and clarify workstream versus suite collaboration paths.
+- Extension journey docs now describe current extension-pack-required flows
+  instead of old release annotations.
+- Release guardrails now require the command-family runtime files, helper group
+  runtime files, and command-family regression test.
 
 ## Validation
 
 - `npm test` green across the full suite
-- `npm run lint` clean
-- `npm run release:check` green (tests, audit, package contents)
-- `npm pack` creates a local `godpowers-2.3.1.tgz` tarball for package
+- `npm run test:audit` green
+- `npm run pack:check` green
+- `npm pack` creates a local `godpowers-2.4.0.tgz` tarball for package
   inspection
 
 ## Upgrade
 
-- `npm install -g godpowers@2.3.1` or `npx godpowers@2.3.1`
+- `npm install -g godpowers@2.4.0` or `npx godpowers@2.4.0`
 - Re-run `/god-context` in each project to refresh installed runtime metadata
 - No breaking changes; existing `.godpowers/` state is compatible. Users who
   want a compact install can run `npx godpowers --profile=core`.
 
 ## Notes
 
-- GitHub release creation for `v2.3.1`
+- GitHub release creation for `v2.4.0`
 - The tag should match the npm package version
-- The `v2.3.1` tag should point to the release commit that matches the npm
-  `godpowers@2.3.1` package.
+- The `v2.4.0` tag should point to the release commit that matches the npm
+  `godpowers@2.4.0` package.

package/SKILL.md

@@ -198,7 +198,30 @@ When the command only recommends work, keep the same dashboard but set
 command pauses, set `State: blocked` or `State: paused` and make `Next` the
 one exact user decision needed to continue.
 
-### 11. User-Facing Vocabulary
+### 11. Command Family UX
+Godpowers has many leaf commands, but user-facing routing should start from
+families. Keep the full command surface available while presenting these
+families first:
+
+- Start: start or import a project.
+- Continue: understand state and choose the next move.
+- Build: plan, implement, test, and ship product work.
+- Verify: check artifacts, code, runtime behavior, and release readiness.
+- Operate: deploy, observe, harden, launch, and respond in production.
+- Maintain: keep artifacts, docs, dependencies, context, and repo surfaces current.
+- Capture: save thoughts, tasks, backlog items, seeds, and learnings.
+- Recover: undo, repair, restore, skip, or diagnose broken state.
+- Extend: install, inspect, test, remove, or author extension packs.
+- Collaborate: coordinate people, workstreams, suites, sprints, and pull requests.
+- Configure: tune settings, budgets, cache, profiles, help, and version info.
+
+When choosing between similar commands, use the ladders from
+`lib/command-families.js`: capture ladder, work size ladder, verification
+ladder, status views, and trigger precedence. `/god-help` should render
+families before leaf commands, and `/god` should use the family helpers before
+asking the user to choose from a long list.
+
+### 12. User-Facing Vocabulary
 Godpowers may use internal words such as "arc" in routing, recipes, and agent
 implementation notes. Do not require the user to decode that word in visible
 output.
@@ -218,7 +241,7 @@ and roadmap visibility when those files exist or are expected. Show whether
 the PRD is done, whether the roadmap exists, which milestone or tier is active,
 how close the tracked workflow is to completion, and the next concrete move.
 
-### 12. Auto-Invoke Visibility
+### 13. Auto-Invoke Visibility
 When Godpowers automatically runs another command, agent, or local runtime
 helper, show the user what happened. Do not describe these as "background"
 unless they are truly detached from the current run. Most Godpowers sync work
@@ -271,7 +294,7 @@ Automatic steps that especially need visible reporting:
 - dogfood runner execution during `/god-dogfood`, release checks, or explicit
   dogfood requests
 
-### 13. Proactive Auto-Invoke Policy
+### 14. Proactive Auto-Invoke Policy
 Godpowers should be proactive from disk evidence, not from guesswork. Before
 auto-invoking anything, classify the action by risk and apply the safest
 allowed behavior.

package/bin/install.js

@@ -18,6 +18,7 @@ const {
   countInstalledSurface
 } = require('../lib/installer-core');
 const { describeProfiles } = require('../lib/install-profiles');
+const commandFamilies = require('../lib/command-families');
 const identity = require('../lib/package-identity');
 
 const VERSION = identity.PACKAGE_VERSION;
@@ -55,6 +56,11 @@ function showHelp() {
   log('  dogfood              Run built-in messy-repo dogfood scenarios');
   log('  extension-scaffold   Create a publishable extension pack skeleton');
   log('');
+  log('Command families:');
+  for (const family of commandFamilies.COMMAND_FAMILIES) {
+    log(`  ${family.id.padEnd(12)} ${family.purpose}`);
+  }
+  log('');
   log('Options:');
   log('  --project=<path>     Project root for status, next, proof, or automation commands');
   log('  --json               Emit JSON for status, next, proof, or automation commands');

package/lib/README.md

@@ -17,7 +17,7 @@ package-level integrations.
 | `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. |
+| `route-quality-sync.js` | Detect symbolic route spawns, unresolved agent targets, and untyped contextual route exits. |
 | `recipe-coverage-sync.js` | Detect missing high-frequency intent recipe coverage. |
 | `release-surface-sync.js` | Detect release-facing drift across badges, release notes, changelog, package checks, and release checklist policy. |
 | `dogfood-runner.js` | Run deterministic messy-repo scenarios against migration, host, extension, and suite release behavior. |
@@ -41,9 +41,11 @@ package-level integrations.
 | Module | Purpose |
 |--------|---------|
 | `router.js` | Resolve user intent to skills, agents, recipes, and workflows. |
+| `command-families.js` | Define UX command families, status views, decision ladders, and trigger precedence helpers. |
 | `recipes.js` | Load and validate routing recipes. |
 | `workflow-parser.js` | Parse workflow YAML into executable steps. |
 | `workflow-runner.js` | Execute workflow steps with validation hooks. |
+| `workflow-helper-groups.js` | Expand named workflow helper groups into explicit local helper names for plan visibility. |
 | `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. |

package/lib/command-families.js

@@ -0,0 +1,375 @@
+/**
+ * Command family metadata.
+ *
+ * Keeps the user-facing command catalog small without removing leaf commands.
+ * These groupings are used by help, routing, docs, and UX audits.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COMMAND_FAMILIES = [
+  {
+    id: 'start',
+    label: 'Start',
+    purpose: 'Start or import a project.',
+    commands: [
+      '/god',
+      '/god-init',
+      '/god-mode',
+      '/god-explore',
+      '/god-discuss',
+      '/god-list-assumptions',
+      '/god-prd',
+      '/god-design',
+      '/god-design-impact',
+      '/god-arch',
+      '/god-roadmap',
+      '/god-stack',
+      '/god-repo',
+      '/god-preflight',
+      '/god-map-codebase',
+      '/god-archaeology',
+      '/god-org-context',
+      '/god-migrate'
+    ]
+  },
+  {
+    id: 'continue',
+    label: 'Continue',
+    purpose: 'Understand state and choose the next move.',
+    commands: [
+      '/god-status',
+      '/god-next',
+      '/god-progress',
+      '/god-lifecycle',
+      '/god-locate',
+      '/god-resume-work',
+      '/god-pause-work'
+    ]
+  },
+  {
+    id: 'build',
+    label: 'Build',
+    purpose: 'Plan, implement, test, and ship product work.',
+    commands: [
+      '/god-build',
+      '/god-feature',
+      '/god-story',
+      '/god-stories',
+      '/god-story-build',
+      '/god-story-verify',
+      '/god-story-close',
+      '/god-fast',
+      '/god-quick',
+      '/god-debug',
+      '/god-add-tests',
+      '/god-refactor',
+      '/god-spike'
+    ]
+  },
+  {
+    id: 'verify',
+    label: 'Verify',
+    purpose: 'Check artifacts, code, runtime behavior, and release readiness.',
+    commands: [
+      '/god-lint',
+      '/god-standards',
+      '/god-review',
+      '/god-review-changes',
+      '/god-test-runtime',
+      '/god-audit',
+      '/god-agent-audit',
+      '/god-hygiene',
+      '/god-dogfood',
+      '/god-preflight'
+    ]
+  },
+  {
+    id: 'operate',
+    label: 'Operate',
+    purpose: 'Deploy, observe, harden, launch, and respond in production.',
+    commands: [
+      '/god-deploy',
+      '/god-observe',
+      '/god-harden',
+      '/god-launch',
+      '/god-hotfix',
+      '/god-postmortem',
+      '/god-logs',
+      '/god-metrics',
+      '/god-trace',
+      '/god-export-otel'
+    ]
+  },
+  {
+    id: 'maintain',
+    label: 'Maintain',
+    purpose: 'Keep artifacts, docs, dependencies, context, and repo surfaces current.',
+    commands: [
+      '/god-docs',
+      '/god-sync',
+      '/god-scan',
+      '/god-link',
+      '/god-reconcile',
+      '/god-reconstruct',
+      '/god-intel',
+      '/god-tech-debt',
+      '/god-update-deps',
+      '/god-upgrade',
+      '/god-context',
+      '/god-context-scan',
+      '/god-roadmap-check',
+      '/god-roadmap-update'
+    ]
+  },
+  {
+    id: 'capture',
+    label: 'Capture',
+    purpose: 'Save thoughts, tasks, backlog items, seeds, and learnings.',
+    commands: [
+      '/god-note',
+      '/god-add-todo',
+      '/god-check-todos',
+      '/god-add-backlog',
+      '/god-plant-seed',
+      '/god-extract-learnings',
+      '/god-thread',
+      '/god-graph'
+    ]
+  },
+  {
+    id: 'recover',
+    label: 'Recover',
+    purpose: 'Undo, repair, restore, skip, or diagnose broken state.',
+    commands: [
+      '/god-undo',
+      '/god-redo',
+      '/god-rollback',
+      '/god-restore',
+      '/god-repair',
+      '/god-skip',
+      '/god-smite',
+      '/god-doctor'
+    ]
+  },
+  {
+    id: 'extend',
+    label: 'Extend',
+    purpose: 'Install, inspect, test, remove, or author extension packs.',
+    commands: [
+      '/god-extension-scaffold',
+      '/god-extension-add',
+      '/god-extension-list',
+      '/god-extension-info',
+      '/god-extension-remove',
+      '/god-test-extension',
+      '/god-build-agent'
+    ]
+  },
+  {
+    id: 'collaborate',
+    label: 'Collaborate',
+    purpose: 'Coordinate people, workstreams, suites, sprints, and pull requests.',
+    commands: [
+      '/god-workstream',
+      '/god-suite-init',
+      '/god-suite-status',
+      '/god-suite-sync',
+      '/god-suite-patch',
+      '/god-suite-release',
+      '/god-party',
+      '/god-sprint',
+      '/god-pr-branch'
+    ]
+  },
+  {
+    id: 'configure',
+    label: 'Configure',
+    purpose: 'Tune settings, budgets, cache, profiles, help, and version info.',
+    commands: [
+      '/god-settings',
+      '/god-set-profile',
+      '/god-budget',
+      '/god-cost',
+      '/god-cache-clear',
+      '/god-automation-status',
+      '/god-automation-setup',
+      '/god-help',
+      '/god-version'
+    ]
+  }
+];
+
+const STATUS_VIEWS = [
+  { id: 'overview', command: '/god-status', label: 'Overview', purpose: 'Operational state, proactive checks, and blockers.' },
+  { id: 'progress', command: '/god-progress', label: 'Progress', purpose: 'Requirement and roadmap increment completion.' },
+  { id: 'lifecycle', command: '/god-lifecycle', label: 'Lifecycle', purpose: 'Project phase and fitting workflows.' },
+  { id: 'locate', command: '/god-locate', label: 'Locate', purpose: 'Resume orientation from checkpoint and disk state.' },
+  { id: 'next', command: '/god-next', label: 'Next', purpose: 'Single recommended command with reason.' }
+];
+
+const CAPTURE_LADDER = [
+  { id: 'note', command: '/god-note', signal: 'save only', purpose: 'Save a thought without priority or workflow impact.' },
+  { id: 'todo', command: '/god-add-todo', signal: 'actionable soon', purpose: 'Create a prioritized action item.' },
+  { id: 'backlog', command: '/god-add-backlog', signal: 'optional later', purpose: 'Park an idea for future roadmap review.' },
+  { id: 'seed', command: '/god-plant-seed', signal: 'conditional future trigger', purpose: 'Store an idea until a metric, date, or event happens.' }
+];
+
+const WORK_SIZE_LADDER = [
+  { id: 'fast', command: '/god-fast', signal: 'trivial direct edit', purpose: 'One tiny edit with existing verification.' },
+  { id: 'quick', command: '/god-quick', signal: 'small TDD task', purpose: 'Small task with TDD and review but no full planning tier.' },
+  { id: 'story', command: '/god-story', signal: 'fine-grained planned slice', purpose: 'Create a STORY.md before implementation.' },
+  { id: 'feature', command: '/god-feature', signal: 'existing-product feature', purpose: 'Feature workflow with mini-PRD, build, harden, and sync.' },
+  { id: 'build', command: '/god-build', signal: 'current milestone work', purpose: 'Build the planned roadmap increment.' },
+  { id: 'debug', command: '/god-debug', signal: 'non-urgent bug', purpose: 'Run the systematic debug loop.' },
+  { id: 'hotfix', command: '/god-hotfix', signal: 'production outage', purpose: 'Expedited production fix and postmortem trigger.' }
+];
+
+const VERIFY_LADDER = [
+  { id: 'lint', command: '/god-lint', signal: 'mechanical artifact check', purpose: 'Fast file-level artifact validation.' },
+  { id: 'standards', command: '/god-standards', signal: 'artifact quality gate', purpose: 'Substitution, labels, and have-nots for one artifact.' },
+  { id: 'review', command: '/god-review', signal: 'code diff review', purpose: 'Two-stage spec and quality review.' },
+  { id: 'runtime', command: '/god-test-runtime', signal: 'live behavior check', purpose: 'Browser-backed design and acceptance verification.' },
+  { id: 'audit', command: '/god-audit', signal: 'artifact set score', purpose: 'Score existing Godpowers artifacts.' },
+  { id: 'hygiene', command: '/god-hygiene', signal: 'ongoing project health', purpose: 'Composite audit, dependency, and docs check.' },
+  { id: 'preflight', command: '/god-preflight', signal: 'existing repo intake', purpose: 'Read-only readiness check before stronger workflows.' },
+  { id: 'dogfood', command: '/god-dogfood', signal: 'release fixture readiness', purpose: 'Messy-repo scenarios for release confidence.' }
+];
+
+const TRIGGER_PRECEDENCE = {
+  continue: {
+    default: '/god-next',
+    conditional: [
+      { command: '/god-resume-work', when: 'handoff-exists', reason: 'A handoff exists on disk.' }
+    ],
+    reason: 'Continue means resume a handoff when present, otherwise compute the next route.'
+  },
+  'think through': {
+    default: '/god-discuss',
+    conditional: [
+      { command: '/god-explore', when: 'broad-idea', reason: 'The request is broad ideation rather than a concrete decision.' }
+    ],
+    reason: 'Discussion handles concrete decisions while exploration handles broad ideation.'
+  },
+  'what happened': {
+    default: '/god-logs',
+    conditional: [
+      { command: '/god-postmortem', when: 'post-incident-pending', reason: 'The project is waiting on incident follow-up.' }
+    ],
+    reason: 'Logs answer run history unless an incident loop is open.'
+  },
+  "what's done": {
+    default: '/god-progress',
+    conditional: [
+      { command: '/god-status', when: 'operational-status-request', reason: 'The wording asks for operational state, not deliverables.' }
+    ],
+    reason: 'Progress answers deliverables while status answers operational state.'
+  },
+  'where am i': {
+    default: '/god-lifecycle',
+    conditional: [
+      { command: '/god-locate', when: 'checkpoint-or-handoff-exists', reason: 'Resume artifacts exist on disk.' }
+    ],
+    reason: 'Lifecycle explains the phase while locate orients a resumed session.'
+  }
+};
+
+function familyForCommand(command) {
+  return COMMAND_FAMILIES.find((family) => family.commands.includes(command)) || null;
+}
+
+function renderFamilyCards(families = COMMAND_FAMILIES) {
+  return families.map((family) => (
+    `${family.label}: ${family.purpose} (${family.commands.join(', ')})`
+  ));
+}
+
+function renderLadder(ladder) {
+  return ladder.map((step) => `${step.command}: ${step.signal} - ${step.purpose}`);
+}
+
+function detectCondition(condition, projectRoot, text = '') {
+  if (!condition) return false;
+  const root = projectRoot || process.cwd();
+  if (condition === 'handoff-exists') {
+    return fs.existsSync(path.join(root, '.godpowers', 'HANDOFF.md'));
+  }
+  if (condition === 'checkpoint-or-handoff-exists') {
+    return fs.existsSync(path.join(root, '.godpowers', 'CHECKPOINT.md'))
+      || fs.existsSync(path.join(root, '.godpowers', 'HANDOFF.md'));
+  }
+  if (condition === 'post-incident-pending') {
+    try {
+      const statePath = path.join(root, '.godpowers', 'state.json');
+      if (!fs.existsSync(statePath)) return false;
+      const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+      return parsed['lifecycle-phase'] === 'post-incident-pending';
+    } catch (e) {
+      return false;
+    }
+  }
+  if (condition === 'broad-idea') {
+    return /\b(idea|brainstorm|explore|what if|possibilities|options)\b/i.test(text || '');
+  }
+  if (condition === 'operational-status-request') {
+    return /\b(status|state|blocked|sync|health|where)\b/i.test(text || '');
+  }
+  return false;
+}
+
+function resolveTrigger(trigger, opts = {}) {
+  const key = String(trigger || '').trim().toLowerCase();
+  const rule = TRIGGER_PRECEDENCE[key];
+  if (!rule) return null;
+  for (const branch of rule.conditional || []) {
+    if (detectCondition(branch.when, opts.projectRoot, opts.text)) {
+      return { trigger: key, command: branch.command, reason: branch.reason, rule };
+    }
+  }
+  return { trigger: key, command: rule.default, reason: rule.reason, rule };
+}
+
+function classifyCapture(text = '') {
+  if (/\b(when|if|after|in \d+|once)\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'seed');
+  if (/\b(todo|task|remind|priority|p[0-3])\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'todo');
+  if (/\b(backlog|later|someday|future)\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'backlog');
+  return CAPTURE_LADDER.find((item) => item.id === 'note');
+}
+
+function classifyWorkSize(text = '') {
+  if (/\b(production|outage|down|urgent|hotfix)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'hotfix');
+  if (/\b(bug|debug|failing|error|regression)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'debug');
+  if (/\b(story|acceptance criteria)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'story');
+  if (/\b(feature|new capability|enhancement)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'feature');
+  if (/\b(milestone|roadmap|increment)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'build');
+  if (/\b(tiny|typo|one-line|config tweak|trivial)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'fast');
+  return WORK_SIZE_LADDER.find((item) => item.id === 'quick');
+}
+
+function classifyVerification(text = '') {
+  if (/\b(dogfood|release readiness|fixture)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'dogfood');
+  if (/\b(preflight|intake|existing repo)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'preflight');
+  if (/\b(hygiene|health|weekly|monthly)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'hygiene');
+  if (/\b(audit|score artifacts)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'audit');
+  if (/\b(runtime|browser|e2e|flow|render|design audit)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'runtime');
+  if (/\b(review|diff|code review)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'review');
+  if (/\b(standard|substitution|have-nots)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'standards');
+  return VERIFY_LADDER.find((item) => item.id === 'lint');
+}
+
+module.exports = {
+  COMMAND_FAMILIES,
+  STATUS_VIEWS,
+  CAPTURE_LADDER,
+  WORK_SIZE_LADDER,
+  VERIFY_LADDER,
+  TRIGGER_PRECEDENCE,
+  familyForCommand,
+  renderFamilyCards,
+  renderLadder,
+  resolveTrigger,
+  classifyCapture,
+  classifyWorkSize,
+  classifyVerification
+};