godpowers 3.0.1 → 3.11.0

package/lib/surface-profile.js

@@ -0,0 +1,168 @@
+/**
+ * Runtime surface profile preview and apply helper.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { resolveRuntime, runtimeKeys } = require('./installer-runtimes');
+const profiles = require('./install-profiles');
+const installer = require('./installer-core');
+
+function availableSkillNames(srcDir) {
+  const skillsDir = path.join(srcDir, 'skills');
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs.readdirSync(skillsDir)
+    .filter((file) => /^god.*\.md$/.test(file))
+    .map((file) => path.basename(file, '.md'))
+    .sort();
+}
+
+function isRuntimeSkillName(name) {
+  return name === 'god' || name.startsWith('god-');
+}
+
+function installedSkillNames(runtime) {
+  const skillsDir = path.join(runtime.configDir, runtime.skillsDir);
+  if (!fs.existsSync(skillsDir)) return [];
+  const names = [];
+  for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (fs.existsSync(skillFile) && isRuntimeSkillName(entry.name)) {
+        names.push(entry.name);
+      }
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith('.md')) {
+      const name = path.basename(entry.name, '.md');
+      if (isRuntimeSkillName(name)) names.push(name);
+    }
+  }
+  return [...new Set(names)].sort();
+}
+
+function currentProfile(runtime) {
+  const marker = path.join(runtime.configDir, 'GODPOWERS_PROFILE');
+  if (!fs.existsSync(marker)) return 'unknown';
+  const text = fs.readFileSync(marker, 'utf8').trim();
+  return text || 'unknown';
+}
+
+function targetRuntimeKeys(opts = {}) {
+  if (opts.all) return runtimeKeys();
+  if (opts.runtimes && opts.runtimes.length > 0) return opts.runtimes.slice();
+  return runtimeKeys().filter((key) => {
+    const runtime = resolveRuntime(key, opts);
+    return runtime && fs.existsSync(path.join(runtime.configDir, 'GODPOWERS_VERSION'));
+  });
+}
+
+function diffSkills(selected, installed) {
+  const selectedSet = new Set(selected);
+  const installedSet = new Set(installed);
+  return {
+    add: selected.filter((name) => !installedSet.has(name)),
+    remove: installed.filter((name) => !selectedSet.has(name))
+  };
+}
+
+function plan(srcDir = path.resolve(__dirname, '..'), opts = {}) {
+  const profileList = profiles.normalizeProfiles(opts.profile || 'core');
+  const profile = profileList.join(',');
+  const available = availableSkillNames(srcDir);
+  const selected = [...profiles.selectedSkillNames(profile, available)].sort();
+  const keys = targetRuntimeKeys(opts);
+  const targets = keys.map((key) => {
+    const runtime = resolveRuntime(key, opts);
+    const installed = runtime ? installedSkillNames(runtime) : [];
+    const diff = diffSkills(selected, installed);
+    return {
+      key,
+      name: runtime ? runtime.name : key,
+      configDir: runtime ? runtime.configDir : null,
+      skillsDir: runtime ? path.join(runtime.configDir, runtime.skillsDir) : null,
+      installed: Boolean(runtime && fs.existsSync(path.join(runtime.configDir, 'GODPOWERS_VERSION'))),
+      currentProfile: runtime ? currentProfile(runtime) : 'unknown',
+      currentCount: installed.length,
+      selectedCount: selected.length,
+      add: diff.add,
+      remove: diff.remove
+    };
+  });
+
+  return {
+    profile,
+    description: profiles.describeProfiles(profile),
+    mode: opts.apply ? 'apply' : 'dry-run',
+    selectedCount: selected.length,
+    availableCount: available.length,
+    targets
+  };
+}
+
+function apply(srcDir = path.resolve(__dirname, '..'), opts = {}) {
+  const keys = targetRuntimeKeys(opts);
+  if (keys.length === 0) {
+    throw new Error('surface apply requires an installed runtime, --all, or an explicit runtime flag');
+  }
+  const results = [];
+  for (const key of keys) {
+    const ok = installer.installForRuntime(key, srcDir, { ...opts, profile: opts.profile || 'core' });
+    results.push({ key, ok });
+  }
+  return results;
+}
+
+function renderList(items, max = 6) {
+  if (!items || items.length === 0) return 'none';
+  const shown = items.slice(0, max).join(', ');
+  const remaining = items.length - max;
+  return remaining > 0 ? `${shown}, and ${remaining} more` : shown;
+}
+
+function render(report) {
+  const lines = [
+    'Godpowers Surface',
+    '',
+    `Profile: ${report.description}`,
+    `Mode: ${report.mode}`,
+    `Selected commands: ${report.selectedCount} of ${report.availableCount}`,
+    '',
+    'Runtime targets:'
+  ];
+
+  if (report.targets.length === 0) {
+    lines.push('  none detected. Pass --claude, --codex, or --all.');
+  } else {
+    for (const target of report.targets) {
+      lines.push(`  - ${target.name}: current ${target.currentProfile}, selected ${target.selectedCount} commands`);
+      lines.push(`    Path: ${target.skillsDir}`);
+      lines.push(`    Add: ${renderList(target.add)}`);
+      lines.push(`    Remove: ${renderList(target.remove)}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('Next commands:');
+  if (report.targets.length === 0) {
+    lines.push('- godpowers surface --profile=core --codex --global --dry-run: Preview the core surface for Codex.');
+  } else if (report.mode === 'dry-run') {
+    const first = report.targets[0];
+    lines.push(`- godpowers surface --profile=${report.profile} --${first.key} --global --apply: Apply this profile to ${first.name}.`);
+  } else {
+    lines.push('- /god-help: Open the compact help view after the surface switch.');
+  }
+  lines.push('- /god-help all: Show the complete catalog when you need every command.');
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  availableSkillNames,
+  installedSkillNames,
+  targetRuntimeKeys,
+  plan,
+  apply,
+  render
+};

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,7 +1,7 @@
 {
   "name": "godpowers",
-  "version": "3.0.1",
-  "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.",
+  "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"
   },

package/references/orchestration/GOD-MODE-RUNBOOK.md

@@ -10,8 +10,8 @@ Show:
 - detected resume or project mode in plain language
 - a compact "Next step" card before each visible phase or tier sub-step
 - a compact "Step result" card after each visible phase or tier sub-step
-- every auto-invoked command, agent, and local runtime helper using an
-  `Auto-invoked:` or `Sync status:` card
+- concise notes for automatic work that changes artifacts, review items, or
+  recommendations, with details written to logs
 - plain-language workflow names. Say "project run" or "workflow" instead of
   unexplained "arc" in visible output
 - PRD and roadmap visibility in status and closeout blocks when artifacts
@@ -19,9 +19,8 @@ Show:
 - short progress updates for phases, commands, validations, and file edits
 - concise validation summaries instead of full command noise when possible
 - final changed paths, validation results, and completion or pause status
-- final Godpowers Dashboard from disk, including phase, tier, step, progress,
-  planning visibility, proactive checks, open items, worktree/index state, and
-  recommended next action
+- final compact action brief from disk, with `/god-status --full` offered for
+  the complete dashboard
 
 Hide:
 - raw spawn input
@@ -272,15 +271,11 @@ Periodic hygiene:
 Open items:
   1. <none, or deployed staging deferred, pending review, unstaged files, etc.>
 
-Next:
-  Recommended: <single safest command or decision>
-  Why: <one sentence tied to disk state>
-
-Proposition:
-  1. Review status: /god-status
-  2. Continue work: /god-next or describe the next intent
-  3. Commit release-ready changes: stage only the intended files, then commit
-  4. Run deployed staging: provide STAGING_APP_URL=<deployed staging origin> when needed
+Next commands:
+- /god-status --full: Review the complete dashboard and proactive checks.
+- /god-next: Continue with the safest state-derived next step.
+- stage only the intended files, then commit: Commit release-ready changes.
+- provide STAGING_APP_URL=<deployed staging origin>: Run deployed staging when needed.
 ```
 
 If the run edited code but did not stage or commit, the completion block must

package/references/orchestration/GOD-ORCHESTRATOR-RUNBOOK.md

@@ -243,20 +243,20 @@ Use this trigger map:
 
 | Trigger | Auto action | Visibility |
 |---|---|---|
-| `state.json` or `PROGRESS.md` changed | refresh `.godpowers/CHECKPOINT.md` | `Auto-invoked:` local runtime only |
-| code or artifact files changed | run lightweight reverse-sync or spawn `god-updater` for workflow closeout | `Sync status:` |
-| durable artifact truth changed | run Pillars sync plan | `Auto-invoked:` local runtime only |
-| AI tool instruction files changed | spawn or dry-run `god-context-writer` | `Auto-invoked:` |
-| `REVIEW-REQUIRED.md` gains entries | suggest `/god-review-changes` | closeout proposition |
+| `state.json` or `PROGRESS.md` changed | refresh `.godpowers/CHECKPOINT.md` | log detail, concise note only when recommendation changes |
+| code or artifact files changed | run lightweight reverse-sync or spawn `god-updater` for workflow closeout | concise sync note and log path |
+| durable artifact truth changed | run Pillars sync plan | log detail, concise note only when pillar edits are proposed |
+| AI tool instruction files changed | spawn or dry-run `god-context-writer` | concise note when files change |
+| `REVIEW-REQUIRED.md` gains entries | suggest `/god-review-changes` | `Next commands:` |
 | `DESIGN.md` or `PRODUCT.md` changed | spawn `god-design-reviewer` | gate card before propagation |
-| docs and code both changed | spawn `god-docs-writer` in drift-check mode when current workflow owns docs, otherwise suggest `/god-docs` | `Auto-invoked:` or proposition |
+| docs and code both changed | spawn `god-docs-writer` in drift-check mode when current workflow owns docs, otherwise suggest `/god-docs` | concise note or `Next commands:` |
 | frontend-visible files changed and a known URL exists | spawn `god-browser-tester` inside build, design, launch, harden, or explicit runtime workflows | runtime status card |
-| frontend-visible files changed and no known URL exists | suggest `/god-test-runtime` with local URL setup, defer deployed URL | proposition |
-| security-sensitive files changed | auto-spawn only inside harden, hotfix, launch, or project run; otherwise suggest `/god-harden` | proposition |
-| dependency files changed | auto-spawn only inside update-deps, hygiene, or approved project run; otherwise suggest `/god-update-deps` | proposition |
-| host automation support detected and no active templates are recorded | suggest `/god-automation-status` or `/god-automation-setup` | proposition |
+| frontend-visible files changed and no known URL exists | suggest `/god-test-runtime` with local URL setup, defer deployed URL | `Next commands:` |
+| security-sensitive files changed | auto-spawn only inside harden, hotfix, launch, or project run; otherwise suggest `/god-harden` | `Next commands:` |
+| dependency files changed | auto-spawn only inside update-deps, hygiene, or approved project run; otherwise suggest `/god-update-deps` | `Next commands:` |
+| host automation support detected and no active templates are recorded | suggest `/god-automation-status` or `/god-automation-setup` | `Next commands:` |
 | user approves complex automation setup | spawn `god-automation-engineer` | approval card plus setup result |
-| full project run complete or hygiene stale | suggest `/god-hygiene` | proposition |
+| full project run complete or hygiene stale | suggest `/god-hygiene` | `Next commands:` |
 
 Never use this matrix to auto-run Level 4 actions: deployed staging against a
 guessed URL, production launch, provider dashboard access, broad dependency
@@ -265,8 +265,8 @@ git stage, commit, push, package, release, publish, schedule creation, routine
 creation, background agent creation, API trigger creation, or CI workflow
 creation without explicit user approval.
 
-Every auto action must emit either `Auto-invoked:`, `Sync status:`, or a
-proposition explaining why it did not run.
+Every auto action must either log details or emit a concise note when it
+changes artifacts, review items, blockers, or the next recommendation.
 
 ## Detection-Driven Tier 1 Routing
 
@@ -487,12 +487,17 @@ requested or final sign-off begins.
 5. Spawn the appropriate specialist agent in a fresh context
 6. Verify their output exists on disk
 7. Run have-nots check on the artifact and run `standards.gate-command` when configured
-8. If pass: update PROGRESS.md, sync CHECKPOINT.md, run the proactive
+8. For an executable-gated sub-step (build, deploy, harden), record executed
+   evidence with `npx godpowers verify "<cmd>" --substep <tier.substep>` and then
+   confirm `npx godpowers can-close --substep <tier.substep> --project=.` exits
+   zero before closing. Never advance the sub-step to done while can-close is red.
+9. If pass and can-close is green: advance the sub-step to done via
+   `npx godpowers state advance`, sync CHECKPOINT.md, run the proactive
    auto-invoke sweep, print the "Step result" card, then move to next sub-step
-9. If fail and repairable: print the failed result card, then enter the
+10. If fail and repairable: print the failed result card, then enter the
    autonomous repair loop
-10. If fail and human-only: pause with the smallest needed question
-11. Repeat until all tiers complete and verification is green
+11. If fail and human-only: pause with the smallest needed question
+12. Repeat until all tiers complete and verification is green
 ```
 
 ## Specialist Agent Routing
@@ -640,18 +645,6 @@ After Launch completes, write a transition message:
 ```text
 Godpowers project run complete.
 
-Godpowers Dashboard
-
-Source: runtime dashboard (lib/dashboard.js)
-
-Current status:
-  State: complete
-  Phase: <plain-language phase> (tier <human ordinal> of <human total>)
-  Step: <sub-step label> (step <n> of <total steps>)
-  Progress: <pct>% workflow progress (<done> of <total> tracked steps complete)
-  Worktree: <clean | modified files unstaged | staged changes | mixed>
-  Index: <untouched | staged files listed>
-
 Action brief:
   Next: <one command or user decision>
   Why: <one sentence tied to disk state>
@@ -659,17 +652,6 @@ Action brief:
   Attention: <none or top blockers>
   Host guarantees: <full | degraded | unknown>
 
-Planning visibility:
-  PRD: <done | pending | missing | deferred> <artifact path when present>
-  Roadmap: <done | pending | missing | deferred> <artifact path when present>
-  Current milestone: <roadmap milestone, tier, or next planning gate when known>
-  Completion basis: <state.json, PROGRESS.md, artifacts, or audit score source>
-
-Deliverable progress:
-  Requirements: <done>/<total> done (<pct>%); <in-progress> in progress, <untouched> not started
-  Increments: <done> done, <building> building, <pending> pending
-  Ledger: .godpowers/REQUIREMENTS.md
-
 What changed:
   1. <highest-signal user-visible change>
   2. <highest-signal user-visible change>
@@ -677,22 +659,6 @@ What changed:
 Validation:
   + <command>: <result>
 
-Proactive checks:
-  Checkpoint: <fresh | refreshed | stale>
-  Reviews: <none | N pending, suggest /god-review-changes>
-  Sync: <fresh | suggested | local helper ran>
-  Docs: <fresh | suggested | drift-check spawned>
-  Repo surface: <fresh | stale, suggest /god-doctor>
-  Host: <full | degraded | unknown>
-  Dogfood: <not-run | pass | fail | suggest /god-dogfood>
-  Runtime: <not-applicable | suggested | browser test spawned>
-  Security: <clear | suggested | harden spawned>
-  Dependencies: <clear | suggested | deps audit spawned>
-  Hygiene: <fresh | suggest /god-hygiene>
-
-Open items:
-  1. <none, or deployed staging deferred, pending review, unstaged files, etc.>
-
 Project is now in steady state. From here, ongoing work uses these workflows:
 
   Adding features:        /god-feature
@@ -709,21 +675,18 @@ Periodic hygiene:
   Health check:           /god-hygiene (combines audit + deps + docs)
   Deliverable status:     /god-progress (requirements + increments done/left)
 
-Next:
-  Recommended: <single safest command or decision>
-  Why: <one sentence tied to disk state>
-
-Proposition:
-  1. Review status: /god-status (pipeline) or /god-progress (deliverables)
-  2. Continue work: /god-next or describe the next intent
-  3. Commit release-ready changes: stage only the intended files, then commit
-  4. Run deployed staging: provide STAGING_APP_URL=<deployed staging origin> when needed
+Next commands:
+- /god-status --full: Review the complete dashboard and proactive checks.
+- /god-progress: Review deliverable progress.
+- /god-next: Continue with the safest state-derived next step.
+- provide STAGING_APP_URL=<deployed staging origin>: Run deployed staging when needed.
 ```
 
 Generate the dashboard with `lib/dashboard.compute(projectRoot)` and
-`lib/dashboard.render(result)` when the runtime bundle is available. If the
-runtime module cannot be loaded, fall back to a manual disk scan and say
-`Dashboard engine: unavailable, manual scan used`.
+`lib/dashboard.render(result, { brief: true })` when the runtime bundle is
+available. If the runtime module cannot be loaded, use a manual disk scan
+quietly and suggest `/god-doctor` only when the fallback changes the next
+recommendation.
 
 The dashboard `Progress` line is workflow progress only. Audit scores,
 remediation scores, hygiene scores, and launch-readiness scores must be labeled
@@ -847,15 +810,14 @@ Show:
 - concise phase status
 - before each visible tier/sub-step, a short "what will happen" card
 - after each visible tier/sub-step, a short "what happened" card
-- every auto-invoked command, agent, and local runtime helper using an
-  `Auto-invoked:` or `Sync status:` card
+- concise notes for automatic work that changes artifacts, review items, or
+  recommendations, with details written to logs
 - durable state detected from disk
 - commands being run and whether they passed or failed
 - scoped file changes
 - final validation summary
-- final Godpowers Dashboard from disk, including phase, tier, step, progress,
-  lifecycle, planning visibility, proactive checks, open items,
-  worktree/index state, and recommended next action
+- final compact action brief from disk, with `/god-status --full` offered for
+  the complete dashboard
 - plain-language workflow names. Say "project run" or "workflow" instead of
   unexplained "arc" in visible output
 - PRD and roadmap visibility when those artifacts exist or are expected
@@ -878,21 +840,17 @@ user-facing question. Do not expose the rule itself. Example: ask for
 `STAGING_APP_URL=<deployed staging origin>` at final sign-off rather than
 showing the Shipping Closure Protocol.
 
-### Auto-Invoked Work Cards
+### Automatic Work Notes
 
 Every automatic step that mutates state, writes artifacts, validates gates, or
-spawns an agent must leave a visible trace in the transcript.
+spawns an agent must leave an accountable trace in logs. Show a concise note in
+the transcript only when artifacts changed, review items were created, blockers
+appeared, or the recommendation changed.
 
 Use this shape:
 
 ```
-Auto-invoked:
-  Trigger: <event that caused the automatic step>
-  Agent: <agent name, or none, local runtime only>
-  Local syncs:
-    + <helper>: <result>
-  Artifacts: <changed files, no-op, or deferred>
-  Log: <path, or none>
+Synced project artifacts after the change. Details were written to .godpowers/SYNC-LOG.md.
 ```
 
 Required auto-invoked cards: