godpowers 2.6.0 → 3.0.0

package/lib/state-lock.js

@@ -46,6 +46,10 @@ const state = require('./state');
 
 const DEFAULT_TTL_MS = 5 * 60 * 1000; // 5 minutes
 
+function writeLockState(projectRoot, nextState) {
+  return state.write(projectRoot, nextState, { refreshViews: false });
+}
+
 function nowIso(offsetMs) {
   const d = offsetMs ? new Date(Date.now() + offsetMs) : new Date();
   return d.toISOString();
@@ -102,7 +106,7 @@ function acquire(projectRoot, opts = {}) {
         (existing.scope === scope || existing.scope === 'all' || scope === 'all')) {
       existing.expires = nowIso(ttlMs);
       s.lock = existing;
-      state.write(projectRoot, s);
+      writeLockState(projectRoot, s);
       return { acquired: true, lock: existing, reentrant: true };
     }
     if (scopesConflict(existing.scope || 'all', scope)) {
@@ -134,7 +138,7 @@ function acquire(projectRoot, opts = {}) {
   };
   const reclaimedFrom = existing && isStale(existing) ? existing.holder : null;
   s.lock = lock;
-  state.write(projectRoot, s);
+  writeLockState(projectRoot, s);
   return {
     acquired: true,
     lock,
@@ -158,7 +162,7 @@ function release(projectRoot, holder) {
     return { released: false, reason: 'wrong-holder', heldBy: lock.holder };
   }
   s.lock = null;
-  state.write(projectRoot, s);
+  writeLockState(projectRoot, s);
   return { released: true, releasedAt: nowIso() };
 }
 
@@ -176,7 +180,7 @@ function reclaim(projectRoot, holder) {
   }
   const prev = lock.holder;
   s.lock = null;
-  state.write(projectRoot, s);
+  writeLockState(projectRoot, s);
   return { reclaimed: true, previousHolder: prev };
 }
 

package/lib/state-views.js

@@ -0,0 +1,460 @@
+/**
+ * Generated state views.
+ *
+ * Writes human-readable markdown views from .godpowers/state.json while
+ * preserving user content outside managed fences.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const atomic = require('./atomic-write');
+
+const FENCE_BEGIN = '<!-- godpowers:state-view:begin -->';
+const FENCE_END = '<!-- godpowers:state-view:end -->';
+const CHECKSUM_PREFIX = '<!-- godpowers:checksum ';
+const CHECKSUM_SUFFIX = ' -->';
+const PROGRESS_VIEW_PATH = '.godpowers/PROGRESS.md';
+const STATE_VIEW_SPECS = [
+  { tierKey: 'tier-1', subStepKey: 'design', relPath: '.godpowers/design/STATE.md' },
+  { tierKey: 'tier-2', subStepKey: 'build', relPath: '.godpowers/build/STATE.md' },
+  { tierKey: 'tier-3', subStepKey: 'deploy', relPath: '.godpowers/deploy/STATE.md' },
+  { tierKey: 'tier-3', subStepKey: 'observe', relPath: '.godpowers/observe/STATE.md' },
+  { tierKey: 'tier-3', subStepKey: 'launch', relPath: '.godpowers/launch/STATE.md' }
+];
+const STATE_VIEW_PATHS = Object.freeze(STATE_VIEW_SPECS.reduce((acc, spec) => {
+  acc[spec.subStepKey] = spec.relPath;
+  return acc;
+}, {}));
+const KNOWN_SUBSTEP_FIELDS = new Set([
+  'status',
+  'artifact',
+  'artifact-hash',
+  'agent-version',
+  'have-nots-passed',
+  'updated',
+  'notes',
+  'verification'
+]);
+
+const COMPLETE_STATUSES = new Set(['done', 'imported', 'skipped', 'not-required']);
+const ACTIVE_STATUSES = new Set(['in-flight', 'failed', 're-invoked']);
+const TIER_LABELS = {
+  'tier-0': 'Orchestration',
+  'tier-1': 'Planning',
+  'tier-2': 'Building',
+  'tier-3': 'Shipping'
+};
+const SUBSTEP_LABELS = {
+  orchestration: 'Orchestration',
+  prd: 'PRD',
+  arch: 'Architecture',
+  roadmap: 'Roadmap',
+  stack: 'Stack',
+  design: 'Design',
+  product: 'Product',
+  repo: 'Repo',
+  build: 'Build',
+  deploy: 'Deploy',
+  observe: 'Observe',
+  launch: 'Launch',
+  harden: 'Harden'
+};
+
+function sha(content) {
+  return `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`;
+}
+
+function tierNumber(tierKey) {
+  const match = String(tierKey).match(/^tier-(\d+)$/);
+  return match ? Number(match[1]) : Number.MAX_SAFE_INTEGER;
+}
+
+function labelFromKey(key) {
+  return String(key)
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+function tierComparator(a, b) {
+  const byNumber = tierNumber(a) - tierNumber(b);
+  return byNumber === 0 ? String(a).localeCompare(String(b)) : byNumber;
+}
+
+function isCompleteStatus(status) {
+  return COMPLETE_STATUSES.has(status);
+}
+
+function isActiveStatus(status) {
+  return ACTIVE_STATUSES.has(status);
+}
+
+function escapeTable(value) {
+  const text = value == null || value === '' ? '-' : String(value);
+  return text.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+function formatValue(value) {
+  if (value == null || value === '') return '-';
+  if (typeof value === 'object') return JSON.stringify(value);
+  return String(value);
+}
+
+function subStepForSpec(currentState, spec) {
+  return currentState &&
+    currentState.tiers &&
+    currentState.tiers[spec.tierKey] &&
+    currentState.tiers[spec.tierKey][spec.subStepKey]
+    ? currentState.tiers[spec.tierKey][spec.subStepKey]
+    : null;
+}
+
+function existingStateViewSpecs(currentState) {
+  return STATE_VIEW_SPECS.filter(spec => subStepForSpec(currentState, spec));
+}
+
+function orderedSubSteps(currentState) {
+  if (!currentState || !currentState.tiers) return [];
+  const steps = [];
+  for (const tierKey of Object.keys(currentState.tiers).sort(tierComparator)) {
+    const tier = currentState.tiers[tierKey] || {};
+    for (const [subStepKey, subStep] of Object.entries(tier)) {
+      const status = subStep && subStep.status ? subStep.status : 'pending';
+      steps.push({
+        tierKey,
+        tierNumber: tierNumber(tierKey),
+        tierLabel: TIER_LABELS[tierKey] || labelFromKey(tierKey),
+        subStepKey,
+        subStepLabel: SUBSTEP_LABELS[subStepKey] || labelFromKey(subStepKey),
+        status,
+        artifact: subStep && subStep.artifact,
+        updated: subStep && subStep.updated
+      });
+    }
+  }
+  return steps.map((step, index) => ({ ...step, ordinal: index + 1 }));
+}
+
+function progressSummary(currentState) {
+  const steps = orderedSubSteps(currentState);
+  const total = steps.length;
+  const completed = steps.filter(step => isCompleteStatus(step.status)).length;
+
+  let currentIndex = steps.findIndex(step => isActiveStatus(step.status));
+  if (currentIndex < 0) {
+    currentIndex = steps.findIndex(step => !isCompleteStatus(step.status));
+  }
+  if (currentIndex < 0 && total > 0) currentIndex = total - 1;
+
+  return {
+    percent: total === 0 ? 0 : Math.round((completed / total) * 100),
+    completed,
+    total,
+    current: currentIndex >= 0 ? steps[currentIndex] : null
+  };
+}
+
+function buildProgressBody(currentState) {
+  const project = currentState && currentState.project ? currentState.project : {};
+  const summary = progressSummary(currentState);
+  const lines = [];
+
+  lines.push('# Godpowers Progress');
+  lines.push('');
+  lines.push('- [DECISION] This file is a generated human-readable view of `.godpowers/state.json`.');
+  lines.push('- [DECISION] The managed section may be replaced by Godpowers whenever project state changes.');
+  lines.push('- [DECISION] Edit project state through Godpowers commands rather than editing this managed section.');
+  lines.push(`- [DECISION] Project: ${project.name || 'unnamed'}.`);
+  lines.push(`- [DECISION] Lifecycle phase: ${(currentState && currentState['lifecycle-phase']) || 'unknown'}.`);
+  if (summary.total > 0) {
+    lines.push(`- [HYPOTHESIS] Workflow progress is ${summary.percent} percent with ${summary.completed} of ${summary.total} tracked steps complete.`);
+    if (summary.current) {
+      lines.push(`- [HYPOTHESIS] Current step is ${summary.current.tierLabel}: ${summary.current.subStepLabel} with status \`${summary.current.status}\`.`);
+    }
+  } else {
+    lines.push('- [HYPOTHESIS] Workflow progress cannot be computed because no tracked steps exist.');
+  }
+  lines.push('');
+  lines.push('## Workflow Steps');
+  lines.push('');
+  lines.push('| Step | Tier | Sub-step | Status | Artifact | Updated |');
+  lines.push('|---|---|---|---|---|---|');
+  for (const step of orderedSubSteps(currentState)) {
+    lines.push([
+      step.ordinal,
+      escapeTable(step.tierLabel),
+      escapeTable(step.subStepLabel),
+      escapeTable(step.status),
+      escapeTable(step.artifact),
+      escapeTable(step.updated)
+    ].join(' | ').replace(/^/, '| ').replace(/$/, ' |'));
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function buildVerificationLines(subStep) {
+  const commands = subStep &&
+    subStep.verification &&
+    Array.isArray(subStep.verification.commands)
+    ? subStep.verification.commands
+    : [];
+  const lines = [];
+
+  lines.push('## Verification Commands');
+  lines.push('');
+  if (commands.length === 0) {
+    lines.push('- [HYPOTHESIS] No verification command evidence is recorded in `state.json` for this step.');
+    lines.push('');
+    return lines;
+  }
+
+  lines.push('| Command | Status | Exit code | Ran at | Duration ms | Diagnostics |');
+  lines.push('|---|---|---|---|---|---|');
+  for (const command of commands) {
+    lines.push([
+      command.command,
+      command.status,
+      command.exitCode,
+      command.ranAt,
+      command.durationMs,
+      command.diagnostics
+    ].map(escapeTable).join(' | ').replace(/^/, '| ').replace(/$/, ' |'));
+  }
+  lines.push('');
+  return lines;
+}
+
+function buildEvidenceLines(subStep) {
+  const entries = Object.entries(subStep || {})
+    .filter(([key]) => !KNOWN_SUBSTEP_FIELDS.has(key))
+    .sort(([a], [b]) => a.localeCompare(b));
+  const lines = [];
+
+  lines.push('## Evidence Fields');
+  lines.push('');
+  if (entries.length === 0) {
+    lines.push('- [HYPOTHESIS] No additional evidence fields are recorded in `state.json` for this step.');
+    lines.push('');
+    return lines;
+  }
+
+  lines.push('| Field | Value |');
+  lines.push('|---|---|');
+  for (const [key, value] of entries) {
+    lines.push(`| ${escapeTable(key)} | ${escapeTable(formatValue(value))} |`);
+  }
+  lines.push('');
+  return lines;
+}
+
+function buildStateViewBody(currentState, spec) {
+  const project = currentState && currentState.project ? currentState.project : {};
+  const subStep = subStepForSpec(currentState, spec) || {};
+  const status = subStep.status || 'pending';
+  const tierLabel = TIER_LABELS[spec.tierKey] || labelFromKey(spec.tierKey);
+  const subStepLabel = SUBSTEP_LABELS[spec.subStepKey] || labelFromKey(spec.subStepKey);
+  const lines = [];
+
+  lines.push(`# Godpowers ${subStepLabel} State`);
+  lines.push('');
+  lines.push(`- [DECISION] This file is a generated human-readable view of \`.godpowers/state.json\` for \`${spec.tierKey}.${spec.subStepKey}\`.`);
+  lines.push('- [DECISION] The managed section may be replaced by Godpowers whenever project state changes.');
+  lines.push('- [DECISION] Edit project state through Godpowers commands or owning command wrappers rather than editing this managed section.');
+  lines.push(`- [DECISION] Project: ${project.name || 'unnamed'}.`);
+  lines.push(`- [DECISION] Step: ${tierLabel}: ${subStepLabel}.`);
+  lines.push(`- [DECISION] Status: \`${status}\`.`);
+  if (subStep.artifact) {
+    lines.push(`- [DECISION] Artifact: \`.godpowers/${subStep.artifact}\`.`);
+  } else {
+    lines.push('- [HYPOTHESIS] No artifact path is recorded in `state.json` for this step.');
+  }
+  if (subStep.updated) {
+    lines.push(`- [DECISION] Updated: ${subStep.updated}.`);
+  } else {
+    lines.push('- [HYPOTHESIS] No updated timestamp is recorded in `state.json` for this step.');
+  }
+  if (subStep.notes) {
+    lines.push(`- [DECISION] Notes: ${String(subStep.notes).replace(/\r?\n/g, ' ')}.`);
+  }
+  lines.push('');
+  lines.push(...buildVerificationLines(subStep));
+  lines.push(...buildEvidenceLines(subStep));
+  return lines.join('\n');
+}
+
+function parseManaged(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {
+      exists: false,
+      hasFence: false,
+      before: '',
+      body: '',
+      checksum: null,
+      after: '',
+      validChecksum: null
+    };
+  }
+  const content = fs.readFileSync(filePath, 'utf8');
+  const beginIdx = content.indexOf(FENCE_BEGIN);
+  const endIdx = content.indexOf(FENCE_END);
+  if (beginIdx === -1 || endIdx === -1 || endIdx < beginIdx) {
+    return {
+      exists: true,
+      hasFence: false,
+      before: content,
+      body: '',
+      checksum: null,
+      after: '',
+      validChecksum: null
+    };
+  }
+
+  const fenced = content.slice(beginIdx + FENCE_BEGIN.length, endIdx);
+  const after = content.slice(endIdx + FENCE_END.length);
+  const lines = fenced.replace(/^\r?\n/, '').replace(/\r?\n$/, '').split(/\r?\n/);
+  const checksumLine = lines[0] || '';
+  const checksum = checksumLine.startsWith(CHECKSUM_PREFIX) && checksumLine.endsWith(CHECKSUM_SUFFIX)
+    ? checksumLine.slice(CHECKSUM_PREFIX.length, -CHECKSUM_SUFFIX.length)
+    : null;
+  const body = checksum ? lines.slice(1).join('\n') : lines.join('\n');
+  return {
+    exists: true,
+    hasFence: true,
+    before: content.slice(0, beginIdx),
+    body,
+    checksum,
+    after,
+    validChecksum: checksum ? checksum === sha(body) : false
+  };
+}
+
+function fencedBlock(body) {
+  return `${FENCE_BEGIN}\n${CHECKSUM_PREFIX}${sha(body)}${CHECKSUM_SUFFIX}\n${body}\n${FENCE_END}`;
+}
+
+function maybeWarn(parsed, filePath, opts) {
+  if (!parsed.hasFence || parsed.validChecksum !== false) return;
+  const relPath = opts.relPath || filePath;
+  const warning = `Managed state view checksum mismatch in ${relPath}; replacing generated section from state.json.`;
+  if (typeof opts.onWarning === 'function') opts.onWarning(warning);
+}
+
+function nextManagedContent(filePath, body, opts = {}) {
+  const parsed = parseManaged(filePath);
+  maybeWarn(parsed, filePath, opts);
+  const block = fencedBlock(body);
+  if (!parsed.exists) return `${block}\n`;
+  if (!parsed.hasFence) {
+    const sep = parsed.before.endsWith('\n\n') ? '' : (parsed.before.endsWith('\n') ? '\n' : '\n\n');
+    return `${parsed.before}${sep}${block}\n`;
+  }
+  return `${parsed.before}${block}${parsed.after}`;
+}
+
+function writeManaged(filePath, body, opts = {}) {
+  const next = nextManagedContent(filePath, body, opts);
+  if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === next) {
+    return { path: filePath, written: false };
+  }
+  atomic.writeFileAtomic(filePath, next);
+  return { path: filePath, written: true };
+}
+
+async function writeManagedAsync(filePath, body, opts = {}) {
+  const next = nextManagedContent(filePath, body, opts);
+  if (fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === next) {
+    return { path: filePath, written: false };
+  }
+  await atomic.writeFileAtomicAsync(filePath, next);
+  return { path: filePath, written: true };
+}
+
+function progressPath(projectRoot) {
+  return path.join(projectRoot, PROGRESS_VIEW_PATH);
+}
+
+function stateViewPath(projectRoot, specOrStep) {
+  const spec = typeof specOrStep === 'string'
+    ? STATE_VIEW_SPECS.find(item => item.subStepKey === specOrStep || item.relPath === specOrStep)
+    : specOrStep;
+  if (!spec || !spec.relPath) return null;
+  return path.join(projectRoot, spec.relPath);
+}
+
+function viewPathsForState(currentState) {
+  return [
+    PROGRESS_VIEW_PATH,
+    ...existingStateViewSpecs(currentState).map(spec => spec.relPath)
+  ];
+}
+
+function writeProgress(projectRoot, currentState, opts = {}) {
+  return writeManaged(progressPath(projectRoot), buildProgressBody(currentState), {
+    ...opts,
+    relPath: PROGRESS_VIEW_PATH
+  });
+}
+
+async function writeProgressAsync(projectRoot, currentState, opts = {}) {
+  return writeManagedAsync(progressPath(projectRoot), buildProgressBody(currentState), {
+    ...opts,
+    relPath: PROGRESS_VIEW_PATH
+  });
+}
+
+function writeStateView(projectRoot, currentState, spec, opts = {}) {
+  return writeManaged(stateViewPath(projectRoot, spec), buildStateViewBody(currentState, spec), {
+    ...opts,
+    relPath: spec.relPath
+  });
+}
+
+async function writeStateViewAsync(projectRoot, currentState, spec, opts = {}) {
+  return writeManagedAsync(stateViewPath(projectRoot, spec), buildStateViewBody(currentState, spec), {
+    ...opts,
+    relPath: spec.relPath
+  });
+}
+
+function writeAll(projectRoot, currentState, opts = {}) {
+  return [
+    writeProgress(projectRoot, currentState, opts),
+    ...existingStateViewSpecs(currentState).map(spec => writeStateView(projectRoot, currentState, spec, opts))
+  ];
+}
+
+async function writeAllAsync(projectRoot, currentState, opts = {}) {
+  const results = [await writeProgressAsync(projectRoot, currentState, opts)];
+  for (const spec of existingStateViewSpecs(currentState)) {
+    results.push(await writeStateViewAsync(projectRoot, currentState, spec, opts));
+  }
+  return results;
+}
+
+module.exports = {
+  FENCE_BEGIN,
+  FENCE_END,
+  CHECKSUM_PREFIX,
+  PROGRESS_VIEW_PATH,
+  STATE_VIEW_PATHS,
+  STATE_VIEW_SPECS,
+  buildProgressBody,
+  buildStateViewBody,
+  parseManaged,
+  writeManaged,
+  writeManagedAsync,
+  writeProgress,
+  writeProgressAsync,
+  writeStateView,
+  writeStateViewAsync,
+  writeAll,
+  writeAllAsync,
+  progressPath,
+  stateViewPath,
+  viewPathsForState,
+  sha
+};

package/lib/state.js

@@ -10,6 +10,7 @@ const path = require('path');
 const crypto = require('crypto');
 const asyncFs = require('./fs-async');
 const atomic = require('./atomic-write');
+const stateViews = require('./state-views');
 
 const STATE_VERSION = '1.0.0';
 const COMPLETE_STATUSES = new Set(['done', 'imported', 'skipped', 'not-required']);
@@ -94,6 +95,42 @@ function read(projectRoot) {
   }
 }
 
+function isUnsafePathSegment(segment) {
+  return segment === '__proto__' || segment === 'constructor' || segment === 'prototype';
+}
+
+function valueFromPath(source, dottedPath) {
+  if (!source || !dottedPath) return undefined;
+  return dottedPath.split('.').reduce((acc, segment) => {
+    if (!acc || isUnsafePathSegment(segment)) return undefined;
+    return acc[segment];
+  }, source);
+}
+
+function isInitializedState(currentState) {
+  return Boolean(
+    currentState &&
+    typeof currentState === 'object' &&
+    currentState.project &&
+    typeof currentState.project.name === 'string' &&
+    currentState.project.name.trim() &&
+    currentState.tiers &&
+    typeof currentState.tiers === 'object'
+  );
+}
+
+function isInitialized(projectRoot) {
+  return isInitializedState(read(projectRoot));
+}
+
+function valueAtPath(currentState, dottedPath) {
+  if (dottedPath === 'initialized') return isInitializedState(currentState);
+  const rootValue = valueFromPath(currentState, dottedPath);
+  if (rootValue !== undefined) return rootValue;
+  if (!currentState || !currentState.tiers || dottedPath.startsWith('tiers.')) return undefined;
+  return valueFromPath(currentState.tiers, dottedPath);
+}
+
 /**
  * Async state.json reader for callers that should not block the event loop.
  *
@@ -132,14 +169,18 @@ function normalizeForWrite(state) {
  *
  * @param {string} projectRoot
  * @param {GodpowersState} state
+ * @param {{ refreshViews?: boolean, onStateViewWarning?: Function }} [opts]
  * @returns {GodpowersState}
  */
-function write(projectRoot, state) {
+function write(projectRoot, state, opts = {}) {
   normalizeForWrite(state);
 
   const file = statePath(projectRoot);
   fs.mkdirSync(path.dirname(file), { recursive: true });
   atomic.writeJsonAtomic(file, state);
+  if (opts.refreshViews !== false) {
+    stateViews.writeAll(projectRoot, state, { onWarning: opts.onStateViewWarning });
+  }
   return state;
 }
 
@@ -148,11 +189,16 @@ function write(projectRoot, state) {
  *
  * @param {string} projectRoot
  * @param {GodpowersState} state
+ * @param {{ refreshViews?: boolean, onStateViewWarning?: Function }} [opts]
  * @returns {Promise<GodpowersState>}
  */
-async function writeAsync(projectRoot, state) {
+async function writeAsync(projectRoot, state, opts = {}) {
   normalizeForWrite(state);
-  return asyncFs.writeJson(statePath(projectRoot), state);
+  await asyncFs.writeJson(statePath(projectRoot), state);
+  if (opts.refreshViews !== false) {
+    await stateViews.writeAllAsync(projectRoot, state, { onWarning: opts.onStateViewWarning });
+  }
+  return state;
 }
 
 function createInitialState(projectName, opts = {}) {
@@ -376,6 +422,9 @@ module.exports = {
   hashFile,
   detectDrift,
   statePath,
+  isInitialized,
+  isInitializedState,
+  valueAtPath,
   orderedSubSteps,
   progressSummary,
   renderProgressLine,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "godpowers",
-  "version": "2.6.0",
-  "description": "AI-powered development system: 112 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.",
+  "version": "3.0.0",
+  "description": "AI-powered development system: 117 slash commands and 40 specialist agents that take a project from raw idea to hardened production. Runs inside Claude Code, Codex, Cursor, Windsurf, Gemini, and 10+ other AI coding tools.",
   "bin": {
     "godpowers": "./bin/install.js"
   },

package/routing/god-audit.yaml

@@ -8,7 +8,7 @@ metadata:
 
 prerequisites:
   required:
-    - check: file:.godpowers/PROGRESS.md
+    - check: state:initialized == true
       auto-complete: /god-init
       human-required: true
 

package/routing/god-build.yaml

@@ -21,7 +21,7 @@ execution:
   secondary-spawns: [god-executor, god-spec-reviewer, god-quality-reviewer]
   writes:
     - .godpowers/build/PLAN.md
-    - .godpowers/build/STATE.md
+    - .godpowers/state.json
     - source code
 
 standards:

package/routing/god-capture.yaml

@@ -0,0 +1,41 @@
+apiVersion: godpowers/v1
+kind: CommandRouting
+metadata:
+  command: /god-capture
+  description: Capture verb dispatcher
+  tier: 0
+  family: capture
+
+prerequisites:
+  required: []
+
+execution:
+  spawns: [built-in]
+  context: fresh
+  reads:
+    - routing/god-note.yaml
+    - routing/god-add-todo.yaml
+    - routing/god-add-backlog.yaml
+    - routing/god-plant-seed.yaml
+  writes: []
+
+dispatch:
+  note: /god-note
+  todo: /god-add-todo
+  backlog: /god-add-backlog
+  seed: /god-plant-seed
+
+success-path:
+  next-recommended: varies
+  outcome:
+    type: contextual
+    label: Capture dispatch route
+    reason: The next route depends on whether the item is a note, todo, backlog item, or seed.
+    allowed-next: [/god-note, /god-add-todo, /god-add-backlog, /god-plant-seed]
+
+failure-path:
+  on-error: /god-doctor
+
+endoff:
+  state-update: no direct state update; selected leaf command owns state
+  events: [agent.start, decision.route, agent.end]

package/routing/god-context.yaml

@@ -8,7 +8,7 @@ metadata:
 
 prerequisites:
   required:
-    - check: file:.godpowers/PROGRESS.md
+    - check: state:initialized == true
       reason: "/god-context needs an initialized project"
       auto-complete: /god-init
 

package/routing/god-deploy.yaml

@@ -19,7 +19,9 @@ execution:
   spawns: [god-deploy-engineer]
   context: fresh
   writes:
-    - .godpowers/deploy/STATE.md
+    - .godpowers/state.json
+    - deploy config
+    - .godpowers/deploy/WAITING-FOR-EXTERNAL-ACCESS.md when needed
 
 standards:
   substitution-test: true