godpowers 2.6.0 → 3.0.0

package/lib/gate.js

@@ -11,6 +11,7 @@ const path = require('path');
 const artifactMap = require('./artifact-map');
 const linter = require('./artifact-linter');
 const router = require('./router');
+const stateStore = require('./state');
 
 function relToAbs(projectRoot, relPath) {
   return path.join(projectRoot, relPath);
@@ -168,12 +169,108 @@ function extractCommandStatuses(text) {
   return entries;
 }
 
-function checkBuildEvidence(projectRoot, result) {
-  const relPath = '.godpowers/build/STATE.md';
-  const file = relToAbs(projectRoot, relPath);
-  if (!fs.existsSync(file)) return;
-  const text = fs.readFileSync(file, 'utf8');
-  const failedCommands = extractFailedCommands(text);
+function commandName(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const value = entry.command || entry.cmd || entry.name;
+  return value ? String(value).trim() : null;
+}
+
+function normalizeVerificationStatus(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const raw = entry.status || entry.result || entry.verdict;
+  if (raw) {
+    const text = String(raw).trim().toLowerCase();
+    if (/^(pass|passed|green|success|succeeded|ok)$/.test(text)) return 'pass';
+    if (/^(fail|failed|red|error)$/.test(text)) return 'fail';
+  }
+  if (Number.isInteger(entry.exitCode)) return entry.exitCode === 0 ? 'pass' : 'fail';
+  return null;
+}
+
+function stateVerificationCommands(subStep) {
+  if (!subStep || typeof subStep !== 'object') return [];
+  const verification = subStep.verification && typeof subStep.verification === 'object'
+    ? subStep.verification
+    : {};
+  const commands = verification.commands ||
+    subStep.verificationCommands ||
+    subStep['verification-commands'] ||
+    [];
+  return Array.isArray(commands) ? commands : [];
+}
+
+function commandsWithStatus(subStep, wantedStatus) {
+  const commands = [];
+  for (const entry of stateVerificationCommands(subStep)) {
+    const name = commandName(entry);
+    if (!name) continue;
+    if (normalizeVerificationStatus(entry) !== wantedStatus) continue;
+    if (!commands.includes(name)) commands.push(name);
+  }
+  return commands;
+}
+
+function checkStateStepEvidence(projectRoot, tier, result) {
+  const stepRef = artifactMap.stateStepForTier(tier);
+  if (!stepRef) return null;
+
+  const relPath = '.godpowers/state.json';
+  const currentState = stateStore.read(projectRoot);
+  if (!currentState) {
+    const finding = makeFinding(
+      `state:${tier}:missing`,
+      'error',
+      relPath,
+      `${tier} gate requires structured state evidence in state.json.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+    result.checks.push(makeCheck(`state:${tier}:status`, 'fail', relPath, finding.reason));
+    return null;
+  }
+
+  const tierState = currentState.tiers && currentState.tiers[stepRef.tierKey];
+  const subStep = tierState && tierState[stepRef.subStepKey];
+  if (!subStep) {
+    const finding = makeFinding(
+      `state:${tier}:step-missing`,
+      'error',
+      relPath,
+      `state.json does not record ${stepRef.tierKey}.${stepRef.subStepKey}.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+    result.checks.push(makeCheck(`state:${tier}:status`, 'fail', relPath, finding.reason));
+    return null;
+  }
+
+  const status = subStep.status || 'pending';
+  const complete = stateStore.isCompleteStatus(status);
+  if (!complete) {
+    const finding = makeFinding(
+      `state:${tier}:incomplete`,
+      'error',
+      relPath,
+      `${stepRef.tierKey}.${stepRef.subStepKey} status is ${status}, expected a complete status.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+  }
+  result.checks.push(makeCheck(
+    `state:${tier}:status`,
+    complete ? 'pass' : 'fail',
+    relPath,
+    complete
+      ? `${stepRef.tierKey}.${stepRef.subStepKey} records complete status ${status}.`
+      : `${stepRef.tierKey}.${stepRef.subStepKey} must be complete before this gate passes.`
+  ));
+  return subStep;
+}
+
+function checkBuildEvidence(result, buildStep) {
+  const relPath = '.godpowers/state.json';
+  if (!buildStep) return;
+  const failedCommands = commandsWithStatus(buildStep, 'fail');
   if (failedCommands.length > 0) {
     const finding = makeFinding(
       'build-verification-failed-command',
@@ -192,7 +289,7 @@ function checkBuildEvidence(projectRoot, result) {
     result.summary.buildVerificationFailedCommands = failedCommands;
     return;
   }
-  const passedCommands = extractPassedCommands(text);
+  const passedCommands = commandsWithStatus(buildStep, 'pass');
   if (passedCommands.length === 0) {
     const finding = makeFinding(
       'build-verification-evidence',
@@ -214,7 +311,7 @@ function checkBuildEvidence(projectRoot, result) {
     'build-verification-evidence',
     'pass',
     relPath,
-    `Build state records ${passedCommands.length} passed verification command(s).`
+    `state.json records ${passedCommands.length} passed build verification command(s).`
   ));
   result.summary.buildVerificationCommands = passedCommands;
 }
@@ -280,7 +377,8 @@ function check(opts = {}) {
   }
 
   checkArtifacts(projectRoot, tier, artifacts, opts, result);
-  if (tier === 'build') checkBuildEvidence(projectRoot, result);
+  const stateStep = checkStateStepEvidence(projectRoot, tier, result);
+  if (tier === 'build') checkBuildEvidence(result, stateStep);
   if (tier === 'harden') checkHardenCriticals(projectRoot, result);
   return finalize(result);
 }

package/lib/install-profiles.js

@@ -2,27 +2,33 @@ const COMMON = [
   'god',
   'god-help',
   'god-version',
-  'god-next',
-  'god-status',
-  'god-progress',
-  'god-doctor',
-  'god-settings'
+  'god-status'
 ];
 
 const PROFILE_SKILLS = {
   core: [
     ...COMMON,
     'god-init',
+    'god-plan',
     'god-mode',
     'god-build',
+    'god-fix',
     'god-review',
+    'god-ship',
+    'god-audit',
+    'god-capture',
     'god-sync',
-    'god-quick',
-    'god-fast'
+    'god-undo',
+    'god-extend'
   ],
   builder: [
     ...COMMON,
+    'god-next',
+    'god-progress',
+    'god-doctor',
+    'god-settings',
     'god-init',
+    'god-plan',
     'god-mode',
     'god-discuss',
     'god-explore',
@@ -35,6 +41,7 @@ const PROFILE_SKILLS = {
     'god-stack',
     'god-repo',
     'god-build',
+    'god-fix',
     'god-add-tests',
     'god-feature',
     'god-story',
@@ -43,13 +50,28 @@ const PROFILE_SKILLS = {
     'god-story-verify',
     'god-story-close',
     'god-review',
+    'god-ship',
+    'god-audit',
+    'god-capture',
     'god-test-runtime',
     'god-sync',
+    'god-undo',
+    'god-extend',
     'god-quick',
     'god-fast'
   ],
   maintainer: [
     ...COMMON,
+    'god-next',
+    'god-progress',
+    'god-doctor',
+    'god-settings',
+    'god-audit',
+    'god-fix',
+    'god-ship',
+    'god-capture',
+    'god-undo',
+    'god-extend',
     'god-hygiene',
     'god-update-deps',
     'god-docs',
@@ -61,7 +83,6 @@ const PROFILE_SKILLS = {
     'god-agent-audit',
     'god-context',
     'god-context-scan',
-    'god-locate',
     'god-scan',
     'god-link',
     'god-review-changes',
@@ -89,6 +110,12 @@ const PROFILE_SKILLS = {
   ],
   suite: [
     ...COMMON,
+    'god-next',
+    'god-progress',
+    'god-doctor',
+    'god-settings',
+    'god-sync',
+    'god-undo',
     'god-suite-init',
     'god-suite-status',
     'god-suite-sync',
@@ -96,7 +123,6 @@ const PROFILE_SKILLS = {
     'god-suite-release',
     'god-workstream',
     'god-pr-branch',
-    'god-sync',
     'god-reconcile',
     'god-review',
     'god-quick',
@@ -105,20 +131,20 @@ const PROFILE_SKILLS = {
 };
 
 const PROFILE_DESCRIPTIONS = {
-  core: 'front door, status, init, build, review, sync, quick edits',
-  builder: 'core plus planning, design, stories, and runtime verification',
+  core: 'front door, status, verbs, and autonomous compatibility',
+  builder: 'core plus planning leaves, stories, and runtime verification',
   maintainer: 'core plus hygiene, deps, docs, repair, automation, and extensions',
   suite: 'core plus multi-repo suite and workstream coordination',
   full: 'all shipped slash commands'
 };
 
 function normalizeProfiles(value) {
-  if (!value) return ['full'];
+  if (!value) return ['core'];
   const raw = String(value)
     .split(',')
     .map(part => part.trim().toLowerCase())
     .filter(Boolean);
-  const profiles = raw.length > 0 ? raw : ['full'];
+  const profiles = raw.length > 0 ? raw : ['core'];
   for (const profile of profiles) {
     if (profile !== 'full' && !PROFILE_SKILLS[profile]) {
       throw new Error(`Unknown install profile: ${profile}`);

package/lib/installer-args.js

@@ -4,6 +4,7 @@ const { RUNTIMES } = require('./installer-runtimes');
 const COMMANDS = new Set([
   'status',
   'next',
+  'state',
   'quick-proof',
   'mcp-info',
   'automation-status',
@@ -20,6 +21,9 @@ function parseArgs(argv, cwd = process.cwd()) {
     project: cwd,
     json: false,
     brief: false,
+    stateAction: null,
+    step: null,
+    status: null,
     extensionName: null,
     extensionOutput: cwd,
     extensionSkill: null,
@@ -32,7 +36,7 @@ function parseArgs(argv, cwd = process.cwd()) {
     all: false,
     help: false,
     uninstall: false,
-    profile: 'full',
+    profile: 'core',
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -41,6 +45,10 @@ function parseArgs(argv, cwd = process.cwd()) {
       opts.command = arg;
       continue;
     }
+    if (opts.command === 'state' && !opts.stateAction && !arg.startsWith('-')) {
+      opts.stateAction = arg;
+      continue;
+    }
 
     switch (arg) {
       case '--json':
@@ -55,6 +63,18 @@ function parseArgs(argv, cwd = process.cwd()) {
           i++;
         }
         break;
+      case '--step':
+        if (args[i + 1]) {
+          opts.step = args[i + 1];
+          i++;
+        }
+        break;
+      case '--status':
+        if (args[i + 1]) {
+          opts.status = args[i + 1];
+          i++;
+        }
+        break;
       case '--project':
         if (args[i + 1]) {
           opts.project = path.resolve(args[i + 1]);
@@ -104,6 +124,10 @@ function parseArgs(argv, cwd = process.cwd()) {
           opts.extensionWorkflow = arg.slice('--workflow='.length);
         } else if (arg.startsWith('--tier=')) {
           opts.tier = arg.slice('--tier='.length);
+        } else if (arg.startsWith('--step=')) {
+          opts.step = arg.slice('--step='.length);
+        } else if (arg.startsWith('--status=')) {
+          opts.status = arg.slice('--status='.length);
         } else if (arg.startsWith('--profile=')) {
           opts.profile = arg.slice('--profile='.length);
         } else if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {

package/lib/pillars.js

@@ -96,8 +96,7 @@ const ARTIFACT_PILLAR_MAP = [
   { pattern: /(^|\/)stack\/DECISION\.md$/i, pillars: ['stack'] },
   { pattern: /(^|\/)roadmap\/ROADMAP\.md$/i, pillars: ['context', 'quality'] },
   { pattern: /(^|\/)build\/PLAN\.md$/i, pillars: ['quality', 'repo'] },
-  { pattern: /(^|\/)deploy\/STATE\.md$/i, pillars: ['deploy'] },
-  { pattern: /(^|\/)observe\/STATE\.md$/i, pillars: ['observe'] },
+  { pattern: /^\.godpowers\/state\.json$/i, pillars: ['context', 'deploy', 'observe'] },
   { pattern: /(^|\/)harden\/FINDINGS\.md$/i, pillars: ['security', 'auth'] },
   { pattern: /(^|\/)design\/DESIGN\.md$/i, pillars: ['ui'] },
   { pattern: /(^|\/)design\/PRODUCT\.md$/i, pillars: ['context', 'ui'] }
@@ -109,8 +108,7 @@ const GODPOWERS_ARTIFACTS = [
   '.godpowers/stack/DECISION.md',
   '.godpowers/roadmap/ROADMAP.md',
   '.godpowers/build/PLAN.md',
-  '.godpowers/deploy/STATE.md',
-  '.godpowers/observe/STATE.md',
+  '.godpowers/state.json',
   '.godpowers/harden/FINDINGS.md',
   '.godpowers/design/DESIGN.md',
   '.godpowers/design/PRODUCT.md'

package/lib/recipes.js

@@ -112,6 +112,14 @@ function evaluateStateCondition(condition, projectRoot) {
   if (cond.startsWith('file:')) {
     return fs.existsSync(path.join(projectRoot, cond.slice(5).trim()));
   }
+  if (cond.startsWith('state:')) {
+    const m = cond.slice(6).trim().match(/^([\w.-]+)\s*==\s*(.+)$/);
+    if (!m) return true;
+    const [, dottedPath, expected] = m;
+    const s = state.read(projectRoot);
+    const actual = state.valueAtPath(s, dottedPath);
+    return actual === expected.trim() || actual === parseValue(expected.trim());
+  }
   if (cond.startsWith('lifecycle-phase ==')) {
     const expected = cond.split('==')[1].trim();
     const s = state.read(projectRoot);
@@ -131,6 +139,14 @@ function evaluateStateCondition(condition, projectRoot) {
   return true;
 }
 
+function parseValue(value) {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  if (/^\d+$/.test(value)) return parseInt(value, 10);
+  return value;
+}
+
 /**
  * Suggest top recipes based on current project state alone (no intent text).
  */

package/lib/router.js

@@ -119,11 +119,7 @@ function evaluateCheck(check, projectRoot) {
     if (!match) return false;
     const [, dottedPath, expected] = match;
     const s = state.read(projectRoot);
-    if (!s) return false;
-    const actual = dottedPath.split('.').reduce((acc, k) => {
-      if (!acc || k === '__proto__' || k === 'constructor' || k === 'prototype') return undefined;
-      return acc[k];
-    }, s.tiers || s);
+    const actual = state.valueAtPath(s, dottedPath);
     return actual === expected || actual === parseValue(expected);
   }
 

package/lib/source-sync.js

@@ -131,7 +131,7 @@ function progressLines(projectRoot) {
   lines.push(summarizeArtifact(projectRoot, '.godpowers/arch/ARCH.md', 'Architecture'));
   lines.push(summarizeArtifact(projectRoot, '.godpowers/roadmap/ROADMAP.md', 'Roadmap'));
   lines.push(summarizeArtifact(projectRoot, '.godpowers/stack/DECISION.md', 'Stack'));
-  lines.push(summarizeArtifact(projectRoot, '.godpowers/build/STATE.md', 'Build state'));
+  lines.push(summarizeArtifact(projectRoot, '.godpowers/state.json', 'Godpowers state'));
   lines.push('');
   lines.push('## Return Path');
   lines.push('');

package/lib/state-advance.js

@@ -0,0 +1,244 @@
+/**
+ * State advance CLI mutation.
+ *
+ * Moves one tracked Godpowers step to a new status through state.json,
+ * cooperative locking, and generated markdown view refresh.
+ */
+
+const stateStore = require('./state');
+const stateLock = require('./state-lock');
+const stateViews = require('./state-views');
+
+const VALID_STATUSES = new Set([
+  'pending',
+  'in-flight',
+  'done',
+  'skipped',
+  'imported',
+  'failed',
+  're-invoked',
+  'not-required'
+]);
+
+function statusList() {
+  return Array.from(VALID_STATUSES).join(', ');
+}
+
+function check(status, reason, detail = {}) {
+  return {
+    id: detail.id || reason,
+    status,
+    reason: detail.message || reason,
+    artifact: detail.artifact || '.godpowers/state.json'
+  };
+}
+
+function resultFailure(projectRoot, id, reason, opts = {}) {
+  return {
+    command: 'state advance',
+    verdict: 'fail',
+    project: projectRoot,
+    step: opts.step || null,
+    status: opts.status || null,
+    previousStatus: null,
+    updated: null,
+    warnings: opts.warnings || [],
+    checks: [check('fail', reason, { id })],
+    findings: [{ id, severity: 'error', artifact: '.godpowers/state.json', reason }],
+    summary: { updated: false, state: '.godpowers/state.json', views: [stateViews.PROGRESS_VIEW_PATH] }
+  };
+}
+
+function resultPass(projectRoot, target, previousStatus, status, updated, warnings, views) {
+  return {
+    command: 'state advance',
+    verdict: 'pass',
+    project: projectRoot,
+    step: {
+      tierKey: target.tierKey,
+      subStepKey: target.subStepKey,
+      tierLabel: target.tierLabel,
+      subStepLabel: target.subStepLabel,
+      ordinal: target.ordinal
+    },
+    status,
+    previousStatus,
+    updated,
+    warnings,
+    checks: [check('pass', `advanced ${target.tierKey}.${target.subStepKey} to ${status}`, { id: 'state-advanced' })],
+    findings: [],
+    summary: { updated: true, state: '.godpowers/state.json', views: views || [stateViews.PROGRESS_VIEW_PATH] }
+  };
+}
+
+function normalizeStep(rawStep) {
+  return String(rawStep || '').trim();
+}
+
+function splitStep(rawStep) {
+  const step = normalizeStep(rawStep);
+  const compound = step.match(/^(tier-\d+)[.:/](.+)$/);
+  if (compound) {
+    return { tierKey: compound[1], subStepKey: compound[2] };
+  }
+  if (/^\d+$/.test(step)) {
+    return { ordinal: Number(step) };
+  }
+  return { subStepKey: step };
+}
+
+function resolveStep(currentState, rawStep) {
+  const token = splitStep(rawStep);
+  const steps = stateStore.orderedSubSteps(currentState);
+
+  if (token.ordinal != null) {
+    return steps.find(step => step.ordinal === token.ordinal) || null;
+  }
+
+  if (token.tierKey) {
+    return steps.find(step =>
+      step.tierKey === token.tierKey && step.subStepKey === token.subStepKey
+    ) || null;
+  }
+
+  const matches = steps.filter(step => step.subStepKey === token.subStepKey);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    const err = new Error(`ambiguous step: ${rawStep}`);
+    err.code = 'AMBIGUOUS_STEP';
+    err.matches = matches.map(step => `${step.tierKey}.${step.subStepKey}`);
+    throw err;
+  }
+  return null;
+}
+
+function validateRequest(projectRoot, opts) {
+  if (!projectRoot) {
+    return resultFailure(projectRoot, 'project-required', 'state advance requires --project=<path>', opts);
+  }
+  if (!opts.step) {
+    return resultFailure(projectRoot, 'step-required', 'state advance requires --step=<step>', opts);
+  }
+  if (!opts.status) {
+    return resultFailure(projectRoot, 'status-required', 'state advance requires --status=<status>', opts);
+  }
+  if (!VALID_STATUSES.has(opts.status)) {
+    return resultFailure(projectRoot, 'status-invalid', `invalid status "${opts.status}"; expected one of ${statusList()}`, opts);
+  }
+  return null;
+}
+
+function advance(projectRoot, opts = {}) {
+  const request = {
+    step: normalizeStep(opts.step),
+    status: String(opts.status || '').trim(),
+    holder: opts.holder || `godpowers-state-advance:${process.pid}`,
+    ttlMs: opts.ttlMs
+  };
+  const invalid = validateRequest(projectRoot, request);
+  if (invalid) return invalid;
+
+  const initialState = stateStore.read(projectRoot);
+  if (!initialState) {
+    return resultFailure(projectRoot, 'state-missing', 'state.json not found', request);
+  }
+
+  let target;
+  try {
+    target = resolveStep(initialState, request.step);
+  } catch (e) {
+    if (e.code === 'AMBIGUOUS_STEP') {
+      return resultFailure(
+        projectRoot,
+        'step-ambiguous',
+        `ambiguous step "${request.step}"; use one of ${e.matches.join(', ')}`,
+        request
+      );
+    }
+    throw e;
+  }
+  if (!target) {
+    return resultFailure(projectRoot, 'step-not-found', `tracked step not found: ${request.step}`, request);
+  }
+
+  const lockResult = stateLock.acquire(projectRoot, {
+    holder: request.holder,
+    scope: `${target.tierKey}.${target.subStepKey}`,
+    ttlMs: request.ttlMs
+  });
+  if (!lockResult.acquired) {
+    return resultFailure(
+      projectRoot,
+      'lock-unavailable',
+      `state lock unavailable: held by ${lockResult.holder} on ${lockResult.scope}`,
+      request
+    );
+  }
+
+  const warnings = [];
+  try {
+    const currentState = stateStore.read(projectRoot);
+    const freshTarget = resolveStep(currentState, request.step);
+    if (!freshTarget) {
+      return resultFailure(projectRoot, 'step-not-found', `tracked step not found after lock: ${request.step}`, request);
+    }
+
+    const tier = currentState.tiers[freshTarget.tierKey] || {};
+    const current = tier[freshTarget.subStepKey] || {};
+    const previousStatus = current.status || 'pending';
+    const updated = opts.now || new Date().toISOString();
+    currentState.tiers[freshTarget.tierKey][freshTarget.subStepKey] = {
+      ...current,
+      status: request.status,
+      updated
+    };
+    stateStore.write(projectRoot, currentState, {
+      onStateViewWarning: warning => warnings.push(warning)
+    });
+    return resultPass(
+      projectRoot,
+      freshTarget,
+      previousStatus,
+      request.status,
+      updated,
+      warnings,
+      stateViews.viewPathsForState(currentState)
+    );
+  } finally {
+    stateLock.release(projectRoot, request.holder);
+  }
+}
+
+function render(result) {
+  const lines = [];
+  lines.push('Godpowers State Advance');
+  lines.push('');
+  lines.push(`Verdict: ${result.verdict}`);
+  if (result.verdict === 'pass') {
+    const step = result.step;
+    lines.push(`Step: ${step.tierKey}.${step.subStepKey}`);
+    lines.push(`Status: ${result.previousStatus} to ${result.status}`);
+    lines.push(`Updated: ${result.updated}`);
+    for (const warning of result.warnings || []) {
+      lines.push(`Warning: ${warning}`);
+    }
+  } else {
+    for (const finding of result.findings || []) {
+      lines.push(`Error: ${finding.reason}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function exitCode(result) {
+  return result && result.verdict === 'pass' ? 0 : 1;
+}
+
+module.exports = {
+  VALID_STATUSES,
+  advance,
+  render,
+  exitCode,
+  resolveStep,
+  statusList
+};