godpowers 3.0.2 → 3.11.0

package/lib/gate.js

@@ -12,6 +12,7 @@ const artifactMap = require('./artifact-map');
 const linter = require('./artifact-linter');
 const router = require('./router');
 const stateStore = require('./state');
+const evidence = require('./evidence');
 
 function relToAbs(projectRoot, relPath) {
   return path.join(projectRoot, relPath);
@@ -267,40 +268,47 @@ function checkStateStepEvidence(projectRoot, tier, result) {
   return subStep;
 }
 
-function checkBuildEvidence(result, buildStep) {
+// Executed-evidence requirement for executable-gated tiers. Generalized from
+// the original build-only check: a substep whose key is in
+// evidence.EXECUTED_REQUIRED_SUBSTEPS must record at least one passed
+// verification command and zero failed ones. Finding ids and summary keys are
+// tier-prefixed so the build tier keeps its existing `build-verification-*`
+// contract while harden gains `harden-verification-*`.
+function checkExecutedEvidence(result, step, tier) {
   const relPath = '.godpowers/state.json';
-  if (!buildStep) return;
-  const failedCommands = commandsWithStatus(buildStep, 'fail');
+  if (!step) return;
+  const label = tier.charAt(0).toUpperCase() + tier.slice(1);
+  const failedCommands = commandsWithStatus(step, 'fail');
   if (failedCommands.length > 0) {
     const finding = makeFinding(
-      'build-verification-failed-command',
+      `${tier}-verification-failed-command`,
       'error',
       relPath,
-      `Build state records failed verification command(s): ${failedCommands.join(', ')}.`
+      `${label} state records failed verification command(s): ${failedCommands.join(', ')}.`
     );
     result.findings.push(finding);
     addFindingSummary(result.summary, finding.severity);
     result.checks.push(makeCheck(
-      'build-verification-failed-command',
+      `${tier}-verification-failed-command`,
       'fail',
       relPath,
       finding.reason
     ));
-    result.summary.buildVerificationFailedCommands = failedCommands;
+    result.summary[`${tier}VerificationFailedCommands`] = failedCommands;
     return;
   }
-  const passedCommands = commandsWithStatus(buildStep, 'pass');
+  const passedCommands = commandsWithStatus(step, 'pass');
   if (passedCommands.length === 0) {
     const finding = makeFinding(
-      'build-verification-evidence',
+      `${tier}-verification-evidence`,
       'error',
       relPath,
-      'Build state does not record exact project verification commands that passed.'
+      `${label} state does not record exact project verification commands that passed.`
     );
     result.findings.push(finding);
     addFindingSummary(result.summary, finding.severity);
     result.checks.push(makeCheck(
-      'build-verification-evidence',
+      `${tier}-verification-evidence`,
       'fail',
       relPath,
       finding.reason
@@ -308,12 +316,12 @@ function checkBuildEvidence(result, buildStep) {
     return;
   }
   result.checks.push(makeCheck(
-    'build-verification-evidence',
+    `${tier}-verification-evidence`,
     'pass',
     relPath,
-    `state.json records ${passedCommands.length} passed build verification command(s).`
+    `state.json records ${passedCommands.length} passed ${tier} verification command(s).`
   ));
-  result.summary.buildVerificationCommands = passedCommands;
+  result.summary[`${tier}VerificationCommands`] = passedCommands;
 }
 
 function checkHardenCriticals(projectRoot, result) {
@@ -378,7 +386,10 @@ function check(opts = {}) {
 
   checkArtifacts(projectRoot, tier, artifacts, opts, result);
   const stateStep = checkStateStepEvidence(projectRoot, tier, result);
-  if (tier === 'build') checkBuildEvidence(result, stateStep);
+  const stepRef = artifactMap.stateStepForTier(tier);
+  if (stepRef && evidence.EXECUTED_REQUIRED_SUBSTEPS.has(stepRef.subStepKey)) {
+    checkExecutedEvidence(result, stateStep, tier);
+  }
   if (tier === 'harden') checkHardenCriticals(projectRoot, result);
   return finalize(result);
 }

package/lib/installer-args.js

@@ -13,7 +13,16 @@ const COMMANDS = new Set([
   'extension-scaffold',
   'surface',
   'demo',
-  'gate'
+  'gate',
+  'verify',
+  'can-close',
+  'route',
+  'report',
+  'reflect',
+  'memory',
+  'lesson',
+  'outcome',
+  'import-ledger'
 ]);
 
 function parseArgs(argv, cwd = process.cwd()) {
@@ -33,6 +42,36 @@ function parseArgs(argv, cwd = process.cwd()) {
     extensionAgent: null,
     extensionWorkflow: null,
     tier: null,
+    verifyCommand: null,
+    routePrompt: null,
+    substep: null,
+    claim: null,
+    timeout: null,
+    attest: false,
+    evidence: null,
+    since: null,
+    peek: false,
+    reflectAction: null,
+    outcome: null,
+    observation: null,
+    rootCause: null,
+    nextAction: null,
+    lesson: null,
+    memoryAction: null,
+    memoryKey: null,
+    memoryValue: null,
+    category: null,
+    lessonAction: null,
+    lessonText: null,
+    tags: null,
+    scope: null,
+    outcomeAction: null,
+    outcomeSlug: null,
+    outcomeGoal: null,
+    outcomeVerify: null,
+    budget: null,
+    reason: null,
+    importFrom: null,
     apply: false,
     dryRun: false,
     runtimes: [],
@@ -54,6 +93,27 @@ function parseArgs(argv, cwd = process.cwd()) {
       opts.stateAction = arg;
       continue;
     }
+    if (opts.command === 'verify' && opts.verifyCommand === null && !arg.startsWith('-')) {
+      opts.verifyCommand = arg;
+      continue;
+    }
+    if (opts.command === 'route' && opts.routePrompt === null && !arg.startsWith('-')) {
+      opts.routePrompt = arg;
+      continue;
+    }
+    if (opts.command === 'memory' && !arg.startsWith('-')) {
+      if (opts.memoryAction === null) { opts.memoryAction = arg; continue; }
+      if (opts.memoryKey === null) { opts.memoryKey = arg; continue; }
+      if (opts.memoryValue === null) { opts.memoryValue = arg; continue; }
+    }
+    if (opts.command === 'lesson' && !arg.startsWith('-')) {
+      if (opts.lessonAction === null) { opts.lessonAction = arg; continue; }
+      if (opts.lessonText === null) { opts.lessonText = arg; continue; }
+    }
+    if (opts.command === 'outcome' && !arg.startsWith('-')) {
+      if (opts.outcomeAction === null) { opts.outcomeAction = arg; continue; }
+      if (opts.outcomeSlug === null) { opts.outcomeSlug = arg; continue; }
+    }
 
     switch (arg) {
       case '--json':
@@ -95,6 +155,126 @@ function parseArgs(argv, cwd = process.cwd()) {
           i++;
         }
         break;
+      case '--substep':
+        if (args[i + 1]) {
+          opts.substep = args[i + 1];
+          i++;
+        }
+        break;
+      case '--claim':
+        if (args[i + 1]) {
+          opts.claim = args[i + 1];
+          i++;
+        }
+        break;
+      case '--timeout':
+        if (args[i + 1]) {
+          opts.timeout = args[i + 1];
+          i++;
+        }
+        break;
+      case '--evidence':
+        if (args[i + 1]) {
+          opts.evidence = args[i + 1];
+          i++;
+        }
+        break;
+      case '--attest':
+        opts.attest = true;
+        break;
+      case '--peek':
+        opts.peek = true;
+        break;
+      case '--since':
+        if (args[i + 1]) {
+          opts.since = args[i + 1];
+          i++;
+        }
+        break;
+      case '--action':
+        if (args[i + 1]) {
+          opts.reflectAction = args[i + 1];
+          i++;
+        }
+        break;
+      case '--outcome':
+        if (args[i + 1]) {
+          opts.outcome = args[i + 1];
+          i++;
+        }
+        break;
+      case '--observation':
+        if (args[i + 1]) {
+          opts.observation = args[i + 1];
+          i++;
+        }
+        break;
+      case '--root-cause':
+        if (args[i + 1]) {
+          opts.rootCause = args[i + 1];
+          i++;
+        }
+        break;
+      case '--next':
+        if (args[i + 1]) {
+          opts.nextAction = args[i + 1];
+          i++;
+        }
+        break;
+      case '--lesson':
+        if (args[i + 1]) {
+          opts.lesson = args[i + 1];
+          i++;
+        }
+        break;
+      case '--category':
+        if (args[i + 1]) {
+          opts.category = args[i + 1];
+          i++;
+        }
+        break;
+      case '--tags':
+        if (args[i + 1]) {
+          opts.tags = args[i + 1];
+          i++;
+        }
+        break;
+      case '--scope':
+        if (args[i + 1]) {
+          opts.scope = args[i + 1];
+          i++;
+        }
+        break;
+      case '--goal':
+        if (args[i + 1]) {
+          opts.outcomeGoal = args[i + 1];
+          i++;
+        }
+        break;
+      case '--verify':
+        if (args[i + 1]) {
+          opts.outcomeVerify = args[i + 1];
+          i++;
+        }
+        break;
+      case '--budget':
+        if (args[i + 1]) {
+          opts.budget = args[i + 1];
+          i++;
+        }
+        break;
+      case '--reason':
+        if (args[i + 1]) {
+          opts.reason = args[i + 1];
+          i++;
+        }
+        break;
+      case '--from':
+        if (args[i + 1]) {
+          opts.importFrom = args[i + 1];
+          i++;
+        }
+        break;
       case '--project':
         if (args[i + 1]) {
           opts.project = path.resolve(args[i + 1]);
@@ -150,6 +330,44 @@ function parseArgs(argv, cwd = process.cwd()) {
           opts.step = arg.slice('--step='.length);
         } else if (arg.startsWith('--status=')) {
           opts.status = arg.slice('--status='.length);
+        } else if (arg.startsWith('--substep=')) {
+          opts.substep = arg.slice('--substep='.length);
+        } else if (arg.startsWith('--claim=')) {
+          opts.claim = arg.slice('--claim='.length);
+        } else if (arg.startsWith('--timeout=')) {
+          opts.timeout = arg.slice('--timeout='.length);
+        } else if (arg.startsWith('--evidence=')) {
+          opts.evidence = arg.slice('--evidence='.length);
+        } else if (arg.startsWith('--since=')) {
+          opts.since = arg.slice('--since='.length);
+        } else if (arg.startsWith('--action=')) {
+          opts.reflectAction = arg.slice('--action='.length);
+        } else if (arg.startsWith('--outcome=')) {
+          opts.outcome = arg.slice('--outcome='.length);
+        } else if (arg.startsWith('--observation=')) {
+          opts.observation = arg.slice('--observation='.length);
+        } else if (arg.startsWith('--root-cause=')) {
+          opts.rootCause = arg.slice('--root-cause='.length);
+        } else if (arg.startsWith('--next=')) {
+          opts.nextAction = arg.slice('--next='.length);
+        } else if (arg.startsWith('--lesson=')) {
+          opts.lesson = arg.slice('--lesson='.length);
+        } else if (arg.startsWith('--category=')) {
+          opts.category = arg.slice('--category='.length);
+        } else if (arg.startsWith('--tags=')) {
+          opts.tags = arg.slice('--tags='.length);
+        } else if (arg.startsWith('--scope=')) {
+          opts.scope = arg.slice('--scope='.length);
+        } else if (arg.startsWith('--goal=')) {
+          opts.outcomeGoal = arg.slice('--goal='.length);
+        } else if (arg.startsWith('--verify=')) {
+          opts.outcomeVerify = arg.slice('--verify='.length);
+        } else if (arg.startsWith('--budget=')) {
+          opts.budget = arg.slice('--budget='.length);
+        } else if (arg.startsWith('--reason=')) {
+          opts.reason = arg.slice('--reason='.length);
+        } else if (arg.startsWith('--from=')) {
+          opts.importFrom = arg.slice('--from='.length);
         } else if (arg.startsWith('--profile=')) {
           opts.profile = arg.slice('--profile='.length);
         } else if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {

package/lib/quarterback.js

@@ -0,0 +1,183 @@
+/**
+ * Quarterback: the entry-level router.
+ *
+ * A thin decision layer that composes the existing structural router
+ * (lib/router.js) and the fuzzy-intent playbook (lib/recipes.js) rather than
+ * duplicating them. It adds exactly two genes that Godpowers lacks at entry:
+ *   - refuse-on-red: never start new work when the latest executed verdict is
+ *     red or harden findings carry an unresolved Critical (the [10] route).
+ *   - proportional ceremony: do not open an arc for a one-line fix (the [90]
+ *     route).
+ * Everything else delegates to router.suggestNext() and recipes.matchIntent().
+ *
+ * Read-only: route() never mutates state. See docs/FUSION-ARCHITECTURE.md 4.3.
+ *
+ * @typedef {Object} Play
+ * @property {string} route One of recover, resume, recovery, brownfield,
+ *   research, review, full, feature, trivial.
+ * @property {string} reason Why this route was chosen.
+ * @property {string|null} nextCommand The command (or null to answer inline).
+ * @property {string} ceremony none | light | focused | full | inherit.
+ * @property {string} verificationStrategy none | artifact+attested | executed-where-gated.
+ * @property {string} chatPolicy Always "stay in this chat as executor".
+ * @property {boolean} mutatesState Always false.
+ * @property {{ classification: string, latestVerdict: string, activeArc: string|null, openFindings: boolean }} evidence
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const router = require('./router');
+const recipes = require('./recipes');
+const evidence = require('./evidence');
+const stateStore = require('./state');
+
+const CONTINUATION_KEYWORDS = ['continue', 'resume', 'next step', 'keep going', "what's next", 'whats next', 'pick up', 'carry on'];
+const INCIDENT_KEYWORDS = ['incident', 'outage', 'hotfix', 'postmortem', 'post-mortem', 'rollback', 'regression', 'production is down', 'broke prod', 'sev1', 'sev 1'];
+const BROWNFIELD_KEYWORDS = ['inherited', 'inherit', 'existing codebase', 'legacy', 'brownfield', 'took over', 'onboard onto', 'understand this repo', 'archaeology'];
+const RESEARCH_KEYWORDS = ['spike', 'explore', 'research', 'prototype', 'proof of concept', 'proof-of-concept', 'poc', 'evaluate', 'not sure which', 'unsure', 'investigate'];
+const REVIEW_KEYWORDS = ['audit', 'review', 'critique', 'find risks', 'find bugs', 'security review', 'assess', 'what could go wrong', 'red team'];
+const FULL_KEYWORDS = ['idea to production', 'ship it all', 'end to end', 'end-to-end', 'full arc', 'god mode', 'build the whole', 'whole thing', 'from scratch to launch', 'take it to production'];
+const TRIVIAL_KEYWORDS = ['typo', 'rename', 'one-line', 'one line', 'quick question', 'what is', 'how do i', 'how do you', 'tweak', 'small fix', 'change the wording', 'bump the'];
+
+function hasAny(text, keywords) {
+  return keywords.some((kw) => text.includes(kw));
+}
+
+function classify(prompt) {
+  const text = String(prompt || '').toLowerCase().trim();
+  if (text === '') return 'continue';
+  if (hasAny(text, CONTINUATION_KEYWORDS)) return 'continue';
+  if (hasAny(text, INCIDENT_KEYWORDS)) return 'incident';
+  if (hasAny(text, FULL_KEYWORDS)) return 'full';
+  if (hasAny(text, BROWNFIELD_KEYWORDS)) return 'brownfield';
+  if (hasAny(text, RESEARCH_KEYWORDS)) return 'research';
+  if (hasAny(text, REVIEW_KEYWORDS)) return 'review';
+  if (hasAny(text, TRIVIAL_KEYWORDS)) return 'trivial';
+  return 'feature';
+}
+
+function latestVerdict(projectRoot) {
+  const records = evidence.history({ projectRoot });
+  for (let i = records.length - 1; i >= 0; i--) {
+    const record = records[i];
+    if (record && record.kind === 'executed') {
+      return record.verified ? 'green' : 'red';
+    }
+  }
+  return 'none';
+}
+
+function openFindings(projectRoot) {
+  const findings = path.join(projectRoot, '.godpowers', 'harden', 'FINDINGS.md');
+  // Only treat findings as open when the file exists and carries a Critical or a
+  // blocked launch gate. router.hasNoCriticalFindings is fail-closed (false when
+  // the file is absent), so guard on existence to avoid false "red" on projects
+  // that have not run harden yet.
+  if (!fs.existsSync(findings)) return false;
+  return !router.hasNoCriticalFindings(projectRoot);
+}
+
+function activeArc(projectRoot) {
+  const state = stateStore.read(projectRoot);
+  if (!state) return null;
+  return state['active-arc'] || state.arc || state['lifecycle-phase'] || null;
+}
+
+function recipeCommand(prompt, projectRoot) {
+  const matches = recipes.matchIntent(prompt, projectRoot);
+  if (!matches.length || matches[0].score < 10) return null;
+  const recipe = matches[0].recipe;
+  const name = recipe['default-sequence'] || 'default';
+  const steps = recipes.getSequence(recipe, name);
+  const first = steps[0] && steps[0].command;
+  return first ? String(first).split(/\s+/)[0] : null;
+}
+
+function play(route, reason, nextCommand, ceremony, verificationStrategy, ev) {
+  return {
+    route,
+    reason,
+    nextCommand,
+    ceremony,
+    verificationStrategy,
+    chatPolicy: 'stay in this chat as executor',
+    mutatesState: false,
+    evidence: ev
+  };
+}
+
+/**
+ * Decide the entry play for a prompt. First match wins down the priority ladder.
+ *
+ * @param {string} prompt Free-text user intent (may be empty).
+ * @param {{ projectRoot?: string }} [opts]
+ * @returns {Play}
+ */
+function route(prompt, opts = {}) {
+  const projectRoot = path.resolve(opts.projectRoot || process.cwd());
+  const ev = {
+    classification: classify(prompt),
+    latestVerdict: latestVerdict(projectRoot),
+    activeArc: activeArc(projectRoot),
+    openFindings: openFindings(projectRoot)
+  };
+  const next = router.suggestNext(projectRoot);
+  const initialized = stateStore.isInitialized(projectRoot);
+
+  // [10] recover: refuse-on-red. Never start new work on a red check.
+  if (ev.latestVerdict === 'red') {
+    return play('recover', 'Latest executed verification is red; debug and re-verify before new work.',
+      '/god-debug', 'focused', 'executed-where-gated', ev);
+  }
+  if (ev.openFindings) {
+    return play('recover', 'Harden findings carry an unresolved Critical or a blocked launch gate; resolve before new work.',
+      '/god-debug', 'focused', 'executed-where-gated', ev);
+  }
+
+  // [20] resume: an active arc with non-done substeps plus continuation intent.
+  const hasOpenArc = initialized && next && next.command && next.command !== '/god-init'
+    && next.tier !== 'steady-state';
+  if (hasOpenArc && ev.classification === 'continue') {
+    return play('resume', `Active arc has open work: ${next.reason}.`,
+      next.command, 'inherit', 'executed-where-gated', ev);
+  }
+
+  // [30]-[90]: classification-based new work. Delegate to recipes/router.
+  switch (ev.classification) {
+    case 'incident':
+      return play('recovery', 'Incident, hotfix, or postmortem intent.',
+        recipeCommand(prompt, projectRoot) || '/god-hotfix', 'focused', 'executed-where-gated', ev);
+    case 'brownfield':
+      return play('brownfield', 'Inheriting or understanding existing code.',
+        recipeCommand(prompt, projectRoot) || '/god-archaeology', 'full', 'artifact+attested', ev);
+    case 'research':
+      return play('research', 'Uncertain technology; time-box a spike or exploration.',
+        recipeCommand(prompt, projectRoot) || '/god-spike', 'light', 'artifact+attested', ev);
+    case 'review':
+      return play('review', 'Find risks, critique, or audit; no new feature work.',
+        recipeCommand(prompt, projectRoot) || '/god-code-review', 'light', 'artifact+attested', ev);
+    case 'full':
+      return play('full', 'Idea-to-production request; run the full arc.',
+        '/god-mode', 'full', 'executed-where-gated', ev);
+    case 'trivial':
+      return play('trivial', 'Single reversible edit or question; do not open an arc.',
+        '/god-fast', 'none', 'none', ev);
+    case 'continue':
+      // Continuation intent but no open arc: point at the structural next step.
+      return play('resume', next && next.reason ? next.reason : 'Continue from current state.',
+        next ? next.command : '/god-init', initialized ? 'inherit' : 'full', 'executed-where-gated', ev);
+    default:
+      return play('feature', 'Ordinary multi-step feature.',
+        recipeCommand(prompt, projectRoot) || '/god-feature', 'full', 'executed-where-gated', ev);
+  }
+}
+
+module.exports = {
+  route,
+  classify,
+  // Internals exposed for tests.
+  _latestVerdict: latestVerdict,
+  _openFindings: openFindings,
+  _activeArc: activeArc
+};

package/lib/work-report.js

@@ -0,0 +1,137 @@
+/**
+ * Work report: the chat play-by-play (Phase 3 visibility gene).
+ *
+ * Rebound from Mythify's build_work_report: cursor-based, reads the evidence
+ * ledger, surfaces an "Attention" section for reds, and advances a cursor
+ * unless --peek. The cursor lives at .godpowers/ledger/reports/cursor.json so a
+ * fresh session can emit only what is new since the last report.
+ *
+ * Read-mostly: report() reads the ledger and, unless peek is set, advances the
+ * report cursor. It never mutates state.json.
+ *
+ * @typedef {Object} WorkReport
+ * @property {string} since "last" or "all".
+ * @property {boolean} peek Whether the cursor was left unadvanced.
+ * @property {Object[]} records The ledger records in the window, oldest first.
+ * @property {Object[]} attention Executed records that did not verify (reds).
+ * @property {{ total: number, passed: number, failed: number, attested: number }} summary
+ * @property {{ previous: string|null, next: string|null }} cursor
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const atomic = require('./atomic-write');
+const evidence = require('./evidence');
+
+function reportsDir(projectRoot) {
+  return path.join(projectRoot, '.godpowers', 'ledger', 'reports');
+}
+
+function cursorPath(projectRoot) {
+  return path.join(reportsDir(projectRoot), 'cursor.json');
+}
+
+function readCursor(projectRoot) {
+  try {
+    return JSON.parse(fs.readFileSync(cursorPath(projectRoot), 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeCursor(projectRoot, cursor) {
+  fs.mkdirSync(reportsDir(projectRoot), { recursive: true });
+  atomic.writeJsonAtomic(cursorPath(projectRoot), cursor);
+}
+
+function summarize(window) {
+  const executed = window.filter((r) => r && r.kind === 'executed');
+  return {
+    total: window.length,
+    passed: executed.filter((r) => r.verified).length,
+    failed: executed.filter((r) => !r.verified).length,
+    attested: window.filter((r) => r && r.kind === 'attested').length
+  };
+}
+
+/**
+ * Build the work report for records since the last cursor (or all records).
+ *
+ * @param {{ since?: string, peek?: boolean, projectRoot?: string }} [opts]
+ * @returns {WorkReport}
+ */
+function report(opts = {}) {
+  const projectRoot = path.resolve(opts.projectRoot || process.cwd());
+  const since = opts.since === 'all' ? 'all' : 'last';
+  const peek = Boolean(opts.peek);
+
+  const records = evidence.read(projectRoot); // oldest first (append order)
+  const cursor = readCursor(projectRoot);
+  const lastTs = cursor.lastTs || null;
+
+  const window = since === 'all'
+    ? records.slice()
+    : records.filter((r) => r && r.timestamp && (!lastTs || r.timestamp > lastTs));
+
+  const attention = window.filter((r) => r && r.kind === 'executed' && !r.verified);
+  const newest = window.length ? window[window.length - 1].timestamp : lastTs;
+
+  if (!peek && newest && newest !== lastTs) {
+    writeCursor(projectRoot, { lastTs: newest });
+  }
+
+  return {
+    since,
+    peek,
+    records: window,
+    attention,
+    summary: summarize(window),
+    cursor: { previous: lastTs, next: newest || null }
+  };
+}
+
+function describeRecord(record) {
+  const label = record.claim || record.command || '(unlabeled)';
+  if (record.kind === 'attested') {
+    return `  ATTESTED  ${record.substep || '-'}  ${label}`;
+  }
+  const verdict = record.verified ? 'PASS' : 'FAIL';
+  return `  ${verdict}  ${record.substep || '-'}  exit ${record.exit_code}  ${label}`;
+}
+
+function render(result) {
+  const lines = [];
+  lines.push('Godpowers Work Report');
+  lines.push('');
+  if (result.records.length === 0) {
+    lines.push(result.since === 'all'
+      ? 'No verification records yet.'
+      : 'Nothing new since the last report.');
+    return lines.join('\n');
+  }
+  lines.push(`Since: ${result.since}${result.peek ? ' (peek, cursor not advanced)' : ''}`);
+  lines.push('');
+  lines.push('Play-by-play:');
+  for (const record of result.records) {
+    lines.push(describeRecord(record));
+  }
+  if (result.attention.length > 0) {
+    lines.push('');
+    lines.push('Attention (unverified):');
+    for (const record of result.attention) {
+      lines.push(describeRecord(record));
+    }
+  }
+  const s = result.summary;
+  lines.push('');
+  lines.push(`Summary: ${s.passed} passed, ${s.failed} failed, ${s.attested} attested (${s.total} record(s))`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  report,
+  render,
+  reportsDir,
+  cursorPath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godpowers",
-  "version": "3.0.2",
+  "version": "3.11.0",
   "description": "AI-powered development system: 120 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"