godpowers 3.0.0 → 3.0.2

package/lib/installer-args.js

@@ -11,6 +11,8 @@ const COMMANDS = new Set([
   'automation-setup',
   'dogfood',
   'extension-scaffold',
+  'surface',
+  'demo',
   'gate'
 ]);
 
@@ -21,6 +23,7 @@ function parseArgs(argv, cwd = process.cwd()) {
     project: cwd,
     json: false,
     brief: false,
+    full: false,
     stateAction: null,
     step: null,
     status: null,
@@ -30,6 +33,8 @@ function parseArgs(argv, cwd = process.cwd()) {
     extensionAgent: null,
     extensionWorkflow: null,
     tier: null,
+    apply: false,
+    dryRun: false,
     runtimes: [],
     global: false,
     local: false,
@@ -57,6 +62,21 @@ function parseArgs(argv, cwd = process.cwd()) {
       case '--brief':
         opts.brief = true;
         break;
+      case '--full':
+        opts.full = true;
+        break;
+      case '--apply':
+        opts.apply = true;
+        break;
+      case '--dry-run':
+        opts.dryRun = true;
+        break;
+      case '--runtime':
+        if (args[i + 1]) {
+          opts.runtimes.push(args[i + 1]);
+          i++;
+        }
+        break;
       case '--tier':
         if (args[i + 1]) {
           opts.tier = args[i + 1];
@@ -122,6 +142,8 @@ function parseArgs(argv, cwd = process.cwd()) {
           opts.extensionAgent = arg.slice('--agent='.length);
         } else if (arg.startsWith('--workflow=')) {
           opts.extensionWorkflow = arg.slice('--workflow='.length);
+        } else if (arg.startsWith('--runtime=')) {
+          opts.runtimes.push(arg.slice('--runtime='.length));
         } else if (arg.startsWith('--tier=')) {
           opts.tier = arg.slice('--tier='.length);
         } else if (arg.startsWith('--step=')) {

package/lib/recipe-coverage-sync.js

@@ -92,7 +92,7 @@ function detect(projectRoot) {
       matched.length > 0
         ? `Recipe coverage exists for ${required.description}.`
         : `No recipe covers ${required.description} with ${required.commands.join(', ')}.`,
-      { spawn: matched.length > 0 ? null : 'god-roadmap-reconciler' }
+      { spawn: matched.length > 0 ? null : 'god-reconciler' }
     );
   }
 

package/lib/release-surface-sync.js

@@ -12,9 +12,12 @@ const path = require('path');
 const LOG_PATH = '.godpowers/surface/RELEASE-SURFACE-SYNC.md';
 
 const REQUIRED_PACKAGE_GUARDS = [
+  'lib/artifact-map.js',
+  'lib/cli-dispatch.js',
   'lib/command-families.js',
   'lib/dogfood-runner.js',
   'lib/extension-authoring.js',
+  'lib/gate.js',
   'lib/host-capabilities.js',
   'lib/route-quality-sync.js',
   'lib/recipe-coverage-sync.js',

package/lib/repo-doc-sync.js

@@ -371,7 +371,7 @@ function adjacentOpportunities() {
       id: 'workflow-recipe-graph-sync',
       trigger: '/god-next, /god-mode, /god-doctor',
       behavior: 'compare workflow YAML, recipes, command flows, and orchestrator guidance',
-      escalation: 'spawn god-roadmap-reconciler when lifecycle intent is ambiguous'
+      escalation: 'spawn god-reconciler when lifecycle intent is ambiguous'
     },
     {
       id: 'extension-pack-sync',

package/lib/repo-surface-sync.js

@@ -270,7 +270,7 @@ function workflowRecipeChecks(projectRoot) {
       hasMetadata ? 'fresh' : 'stale',
       workflow,
       hasMetadata ? `${workflow} has metadata.` : `${workflow} is missing parseable metadata.`,
-      { spawn: hasMetadata ? null : 'god-roadmap-reconciler' }
+      { spawn: hasMetadata ? null : 'god-reconciler' }
     );
   }
 
@@ -285,7 +285,7 @@ function workflowRecipeChecks(projectRoot) {
       hasCommand ? 'fresh' : 'stale',
       recipe,
       hasCommand ? `${recipe} includes a slash-command route.` : `${recipe} has no slash-command route.`,
-      { spawn: hasCommand ? null : 'god-roadmap-reconciler' }
+      { spawn: hasCommand ? null : 'god-reconciler' }
     );
   }
 
@@ -297,7 +297,7 @@ function workflowRecipeChecks(projectRoot) {
       commandFlows.includes('/god-docs') && commandFlows.includes('/god-sync') ? 'fresh' : 'stale',
       'docs/command-flows.md',
       'docs/command-flows.md includes core docs and sync flows.',
-      { spawn: 'god-roadmap-reconciler' }
+      { spawn: 'god-reconciler' }
     );
   }
   return checks;

package/lib/route-quality-sync.js

@@ -244,7 +244,7 @@ function detect(projectRoot) {
           'stale',
           routePath,
           `${command} uses contextual next route ${next} without a typed success-path.outcome.`,
-          { spawn: 'god-roadmap-reconciler' }
+          { spawn: 'god-reconciler' }
         );
       }
     }
@@ -297,7 +297,7 @@ function detect(projectRoot) {
     checks.some((check) => check.id.startsWith('missing-route-outcome-')) ? 'stale' : 'fresh',
     'routing/',
     `${typedOutcomeCount} contextual route exits have typed outcomes and all other next routes are explicit.`,
-    { spawn: checks.some((check) => check.id.startsWith('missing-route-outcome-')) ? 'god-roadmap-reconciler' : null }
+    { spawn: checks.some((check) => check.id.startsWith('missing-route-outcome-')) ? 'god-reconciler' : null }
   );
   addCheck(
     checks,

package/lib/router.js

@@ -264,6 +264,11 @@ function getStandards(command) {
   return routing.standards;
 }
 
+function getGateCommand(command) {
+  const standards = getStandards(command);
+  return standards && standards['gate-command'] ? standards['gate-command'] : null;
+}
+
 /**
  * Get the list of agents this command spawns (primary + secondary).
  */
@@ -403,6 +408,7 @@ module.exports = {
   getRouteOutcome,
   getAlternatives,
   getStandards,
+  getGateCommand,
   getSpawnedAgents,
   getCommandFamily: commandFamilies.familyForCommand,
   resolveTrigger: commandFamilies.resolveTrigger,

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/package.json

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

@@ -182,6 +182,7 @@ When deciding what to spawn next, query the routing definition:
 - `execution.spawns` -> primary agent to spawn
 - `execution.secondary-spawns` -> downstream agents (e.g., reviewers)
 - `standards.have-nots` -> which have-nots to verify
+- `standards.gate-command` -> executable artifact gate to run after output exists
 - `success-path.next-recommended` -> what to suggest next
 
 Before spawning a command, evaluate `lib/router.js checkPrerequisites(command,
@@ -197,6 +198,12 @@ the routing config has a `standards` section). Standards check uses fresh
 context, independent of the producing agent, so it catches drift the
 producing agent's own self-check would miss.
 
+When `standards.gate-command` is present, run that exact command from the
+project root after the producing tier skill returns and before any downstream
+tier starts. A non-zero exit means the tier is not complete. Report the gate
+output, repair the artifact, and rerun the gate before updating durable state
+to done.
+
 ## Recipe-Driven Decisions (for fuzzy intent)
 
 When the user describes intent in plain English instead of running a specific
@@ -217,7 +224,7 @@ with the "why" annotations for each step.
 This is the third layer of decision support:
 1. **Routing** (`<runtimeRoot>/routing/<command>.yaml`): structural prerequisites and gates
 2. **Recipes** (`<runtimeRoot>/routing/recipes/<recipe>.yaml`): scenario-based sequences
-3. **Standards** (god-standards-check): quality gates between stages
+3. **Standards** (god-standards-check plus standards.gate-command): quality gates between stages
 
 ## Proactive Auto-Invoke Matrix
 
@@ -236,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
@@ -258,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
 
@@ -479,7 +486,7 @@ requested or final sign-off begins.
 4. Print the "Next step" card from the Step Narration Protocol
 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
+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
    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
@@ -633,18 +640,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>
@@ -652,17 +647,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>
@@ -670,22 +654,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
@@ -702,21 +670,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
@@ -840,15 +805,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
@@ -871,21 +835,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:
@@ -1256,4 +1216,6 @@ For preflight auto-routing, append:
 
 The canonical have-nots catalog lives at `references/HAVE-NOTS.md` (115 named
 failure modes). When verifying an artifact, run the relevant tier's have-nots
-against it. When in doubt, spawn god-auditor to do the check.
+against it. When the route has `standards.gate-command`, run that exact command
+after have-nots and block on any non-zero exit. When in doubt, spawn
+god-auditor to do the check.