infernoflow 0.33.1 → 0.34.0

package/dist/bin/infernoflow.mjs

@@ -1,21 +1,170 @@
 #!/usr/bin/env node
-import{readFileSync as d}from"node:fs";import{dirname as m,join as u}from"node:path";import{fileURLToPath as h}from"node:url";import{bold as t,gray as a,red as s}from"../lib/ui/output.mjs";const f=m(h(import.meta.url)),y=JSON.parse(d(u(f,"..","..","package.json"),"utf8")),r=y.version||"0.0.0",c={publish:"Bump version, update changelog, build, npm publish, git commit + push in one shot",diff:"Show what capabilities changed since the last git tag (or any ref)",changelog:"Draft a changelog entry from commits since the last tag",setup:"One command to get fully operational \u2014 detects IDE, inits, installs hooks + MCP",init:"Scaffold inferno/ in your project (or adopt existing project)","install-cursor-hooks":"Install Cursor hooks: draft agent replies to inferno/CONTEXT.draft.md","install-vscode-copilot-hooks":"Install VS Code + Copilot agent hooks (Preview): draft to inferno/CONTEXT.draft.md",check:"Validate contract, capabilities, scenarios, changelog",status:"Show contract health at a glance","pr-impact":"Summarize PR impact on capabilities and docs",sync:"Run deterministic inferno sync flow",run:"One-command detect/propose/apply/validate flow","doc-gate":"Fail if code changed but docs were not updated",suggest:"Generate AI prompt + apply capability updates",implement:"Generate code-agent implementation prompt(s)",context:"Generate AI-ready context for new sessions","generate-skills":"Generate personalised Cursor rules + skill files from your developer profile",synthesize:"Auto-detect workflow patterns and synthesize reusable skills + agents",agent:"Manage and run auto-synthesized agents (list | run | show | delete)",version:"Smart semver bump recommendation based on capability changes (--apply to write)","pr-comment":"Post capability drift analysis as a GitHub PR comment (works in CI automatically)",dashboard:"Launch local web dashboard on localhost:7337 \u2014 live contract health, capabilities, agents","team-sync":"Sync capability contract across a team via a shared git branch (push | pull | status | init)",onboard:"Interactive onboarding wizard for new developers \u2014 explains infernoflow in 5 minutes",cloud:"Sync capability contracts via infernoflow cloud (init | push | pull | status | dashboard)",share:"Generate a public read-only HTML snapshot of your capability contract",watch:"Watch source files and run suggest automatically on save",ci:"CI-native check: GitHub Actions annotations, GitLab code quality, exit codes",notify:"Post capability drift summary to Slack or Discord",report:"Generate a weekly/monthly HTML or Markdown report of capability activity",monorepo:"Manage infernoflow across monorepo packages (init | list | status | diff | sync)",link:"Link capabilities to Jira, Linear, or GitHub Issues tickets",audit:"Classify capabilities by sensitivity (auth, payment, PII, admin) and generate security surface map",scout:"Scan source files for undocumented capabilities not yet in the contract",export:"Export contract to OpenAPI, Backstage catalog-info.yaml, CSV, or Markdown",snapshot:"Save/diff/restore named snapshots of the capability contract",health:"Compute a 0\u2013100 health score across coverage, docs, freshness, completeness, drift",vibe:"Vibe coding mode \u2014 watches files, auto-syncs contract, regenerates context on every save",adopt:"Interactive wizard to adopt infernoflow in an existing project (detect \u2192 review \u2192 wire up)",doctor:"Diagnose your infernoflow setup \u2014 checks Node, git, contract, AI providers, MCP, hooks",coverage:"Map test files to capabilities \u2014 show which caps have test coverage and which don't",review:"AI-powered capability impact review for staged or recent git changes",scan:"Deep AST scan \u2014 reads actual function bodies, extracts calls, DB ops, external services",graph:"Build capability dependency graph \u2014 shows which caps call which, detects breaking changes",stability:"Show solid/liquid stability level for every capability (frozen/stable/experimental)",freeze:"Mark a capability as frozen (solid) \u2014 AI will not modify it without explicit instruction",thaw:"Reset a capability to experimental (liquid) \u2014 free to evolve",why:"Given a file or function name \u2014 show which capability it serves, scenarios, stability, and git history",impact:"Blast radius analysis \u2014 see every cap, scenario, and risk level affected before you change anything",scaffold:"Generate a new capability \u2014 source skeleton, contract registration, and placeholder scenario in one command",explain:"AI narrative about a capability \u2014 what it does, why it exists, what's risky, and what to test",test:"Run registered scenarios for a capability \u2014 auto-generates a smoke harness if no test runner is configured",ai:"Manage AI providers \u2014 setup, status, test connection (subcommands: setup | status | test | clear)",demo:"Interactive walkthrough \u2014 scaffolds a sample project and runs the full capability chain end-to-end",log:"Append to session memory (decisions, gotchas, failed attempts, theme changes) \u2014 what AI can't infer from code",theme:"Scan fonts, colors, and CSS variables \u2014 write inferno/theme.json so AI always matches the design system",switch:"Generate a handoff summary when switching AI agents \u2014 paste into the next session so nothing is lost"},l={publish:async e=>(await import("../lib/commands/publish.mjs")).publishCommand(e),diff:async e=>(await import("../lib/commands/diff.mjs")).diffCommand(e),changelog:async e=>(await import("../lib/commands/changelog.mjs")).changelogCommand(e),setup:async e=>(await import("../lib/commands/setup.mjs")).setupCommand(e),init:async e=>(await import("../lib/commands/init.mjs")).initCommand(e),"install-cursor-hooks":async e=>(await import("../lib/commands/installCursorHooks.mjs")).installCursorHooksCommand(e),"install-vscode-copilot-hooks":async e=>(await import("../lib/commands/installVsCodeCopilotHooks.mjs")).installVsCodeCopilotHooksCommand(e),check:async e=>(await import("../lib/commands/check.mjs")).checkCommand(e),status:async e=>(await import("../lib/commands/status.mjs")).statusCommand(e),"pr-impact":async e=>(await import("../lib/commands/prImpact.mjs")).prImpactCommand(e),sync:async e=>(await import("../lib/commands/syncAuto.mjs")).syncCommand(e),run:async e=>(await import("../lib/commands/run.mjs")).runCommand(e),suggest:async e=>(await import("../lib/commands/suggest.mjs")).suggestCommand(e),implement:async e=>(await import("../lib/commands/implement.mjs")).implementCommand(e),context:async e=>(await import("../lib/commands/context.mjs")).contextCommand(e),"doc-gate":async e=>(await import("../lib/commands/docGate.mjs")).docGateCommand(e),"generate-skills":async e=>(await import("../lib/commands/generateSkills.mjs")).generateSkillsCommand(e),synthesize:async e=>(await import("../lib/commands/synthesize.mjs")).synthesizeCommand(e),agent:async e=>(await import("../lib/commands/agent.mjs")).agentCommand(e),version:async e=>(await import("../lib/commands/version.mjs")).versionCommand(e),"pr-comment":async e=>(await import("../lib/commands/prComment.mjs")).prCommentCommand(e),dashboard:async e=>(await import("../lib/commands/dashboard.mjs")).dashboardCommand(e),"team-sync":async e=>(await import("../lib/commands/teamSync.mjs")).teamSyncCommand(e),onboard:async e=>(await import("../lib/commands/onboard.mjs")).onboardCommand(e),cloud:async e=>(await import("../lib/commands/cloud.mjs")).cloudCommand(e),share:async e=>(await import("../lib/commands/share.mjs")).shareCommand(e),watch:async e=>(await import("../lib/commands/watch.mjs")).watchCommand(e),ci:async e=>(await import("../lib/commands/ci.mjs")).ciCommand(e),notify:async e=>(await import("../lib/commands/notify.mjs")).notifyCommand(e),report:async e=>(await import("../lib/commands/report.mjs")).reportCommand(e),monorepo:async e=>(await import("../lib/commands/monorepo.mjs")).monorepoCommand(e),link:async e=>(await import("../lib/commands/link.mjs")).linkCommand(e),audit:async e=>(await import("../lib/commands/audit.mjs")).auditCommand(e),scout:async e=>(await import("../lib/commands/scout.mjs")).scoutCommand(e),export:async e=>(await import("../lib/commands/export.mjs")).exportCommand(e),snapshot:async e=>(await import("../lib/commands/snapshot.mjs")).snapshotCommand(e),health:async e=>(await import("../lib/commands/health.mjs")).healthCommand(e),vibe:async e=>(await import("../lib/commands/vibe.mjs")).vibeCommand(e),adopt:async e=>(await import("../lib/commands/adoptWizard.mjs")).adoptWizardCommand(e),doctor:async e=>(await import("../lib/commands/doctor.mjs")).doctorCommand(e),coverage:async e=>(await import("../lib/commands/coverage.mjs")).coverageCommand(e),review:async e=>(await import("../lib/commands/review.mjs")).reviewCommand(e),scan:async e=>(await import("../lib/commands/scan.mjs")).scanCommand(e),graph:async e=>(await import("../lib/commands/graph.mjs")).graphCommand(e),stability:async e=>(await import("../lib/commands/stability.mjs")).stabilityCommand(e),freeze:async e=>(await import("../lib/commands/stability.mjs")).freezeCommand(e),thaw:async e=>(await import("../lib/commands/stability.mjs")).thawCommand(e),why:async e=>(await import("../lib/commands/why.mjs")).whyCommand(e),impact:async e=>(await import("../lib/commands/impact.mjs")).impactCommand(e),scaffold:async e=>(await import("../lib/commands/scaffold.mjs")).scaffoldCommand(e),explain:async e=>(await import("../lib/commands/explain.mjs")).explainCommand(e),test:async e=>(await import("../lib/commands/test.mjs")).testCommand(e),ai:async e=>(await import("../lib/commands/ai.mjs")).aiCommand(e),demo:async e=>(await import("../lib/commands/demo.mjs")).demoCommand(e),log:async e=>(await import("../lib/commands/log.mjs")).logCommand(e),theme:async e=>(await import("../lib/commands/theme.mjs")).themeCommand(e),switch:async e=>(await import("../lib/commands/switch.mjs")).switchCommand(e)};function w(){const e=Object.keys(c),n=Math.max(...e.map(i=>i.length),8)+1;return Object.entries(c).map(([i,p])=>`    ${i.padEnd(n," ")}${p}`).join(`
-`)}const g=`
-  ${t("\u{1F525} infernoflow")} ${a("v"+r)}
-  ${a("The forge for liquid code \u2014 keep every AI session in sync")}
-
-  ${t("Usage:")}
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bold, gray, cyan, red } from "../lib/ui/output.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// When installed globally: __dirname = .../infernoflow/dist/bin
+// Root package.json lives two levels up at .../infernoflow/package.json
+// npm always includes the root package.json, so this path is always reliable.
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf8"));
+const VERSION = pkg.version || "0.0.0";
+const COMMAND_DESCRIPTIONS = {
+  publish: "Bump version, update changelog, build, npm publish, git commit + push in one shot",
+  diff: "Show what capabilities changed since the last git tag (or any ref)",
+  changelog: "Draft a changelog entry from commits since the last tag",
+  setup: "One command to get fully operational — detects IDE, inits, installs hooks + MCP",
+  init: "Scaffold inferno/ in your project (or adopt existing project)",
+  "install-cursor-hooks": "Install Cursor hooks: draft agent replies to inferno/CONTEXT.draft.md",
+  "install-vscode-copilot-hooks":
+    "Install VS Code + Copilot agent hooks (Preview): draft to inferno/CONTEXT.draft.md",
+  check: "Validate contract, capabilities, scenarios, changelog",
+  status: "Show contract health at a glance",
+  "pr-impact": "Summarize PR impact on capabilities and docs",
+  sync: "Run deterministic inferno sync flow",
+  run: "One-command detect/propose/apply/validate flow",
+  "doc-gate": "Fail if code changed but docs were not updated",
+  suggest: "Generate AI prompt + apply capability updates",
+  implement: "Generate code-agent implementation prompt(s)",
+  context: "Generate AI-ready context for new sessions",
+  "generate-skills": "Generate personalised Cursor rules + skill files from your developer profile",
+  synthesize: "Auto-detect workflow patterns and synthesize reusable skills + agents",
+  agent: "Manage and run auto-synthesized agents (list | run | show | delete)",
+  version: "Smart semver bump recommendation based on capability changes (--apply to write)",
+  "pr-comment": "Post capability drift analysis as a GitHub PR comment (works in CI automatically)",
+  dashboard: "Launch local web dashboard on localhost:7337 — live contract health, capabilities, agents",
+  "team-sync": "Sync capability contract across a team via a shared git branch (push | pull | status | init)",
+  onboard: "Interactive onboarding wizard for new developers — explains infernoflow in 5 minutes",
+  cloud:   "Sync capability contracts via infernoflow cloud (init | push | pull | status | dashboard)",
+  share:   "Generate a public read-only HTML snapshot of your capability contract",
+  watch:   "Watch source files and run suggest automatically on save",
+  ci:      "CI-native check: GitHub Actions annotations, GitLab code quality, exit codes",
+  notify:  "Post capability drift summary to Slack or Discord",
+  report:  "Generate a weekly/monthly HTML or Markdown report of capability activity",
+  monorepo: "Manage infernoflow across monorepo packages (init | list | status | diff | sync)",
+  link:    "Link capabilities to Jira, Linear, or GitHub Issues tickets",
+  audit:   "Classify capabilities by sensitivity (auth, payment, PII, admin) and generate security surface map",
+  scout:   "Scan source files for undocumented capabilities not yet in the contract",
+  export:  "Export contract to OpenAPI, Backstage catalog-info.yaml, CSV, or Markdown",
+  snapshot: "Save/diff/restore named snapshots of the capability contract",
+  health:  "Compute a 0–100 health score across coverage, docs, freshness, completeness, drift",
+  vibe:    "Vibe coding mode — watches files, auto-syncs contract, regenerates context on every save",
+  adopt:   "Interactive wizard to adopt infernoflow in an existing project (detect → review → wire up)",
+  doctor:  "Diagnose your infernoflow setup — checks Node, git, contract, AI providers, MCP, hooks",
+  coverage: "Map test files to capabilities — show which caps have test coverage and which don't",
+  review:  "AI-powered capability impact review for staged or recent git changes",
+  scan:       "Deep AST scan — route discovery, entry point detection, HTTP URL extraction, capability suggestions",
+  graph:      "Build capability dependency graph — shows which caps call which, detects breaking changes",
+  stability:  "Show solid/liquid stability level for every capability (frozen/stable/experimental)",
+  freeze:     "Mark a capability as frozen (solid) — AI will not modify it without explicit instruction",
+  thaw:       "Reset a capability to experimental (liquid) — free to evolve",
+  why:        "Given a file or function name — show which capability it serves, scenarios, stability, and git history",
+  impact:     "Blast radius analysis — see every cap, scenario, and risk level affected before you change anything",
+  scaffold:   "Generate a new capability — source skeleton, contract registration, and placeholder scenario in one command",
+  explain:    "AI narrative about a capability — what it does, why it exists, what's risky, and what to test",
+  test:       "Run registered scenarios for a capability — auto-generates a smoke harness if no test runner is configured",
+  ai:         "Manage AI providers — setup, status, test connection (subcommands: setup | status | test | clear)",
+  demo:       "Interactive walkthrough — scaffolds a sample project and runs the full capability chain end-to-end",
+  log:        "Append to session memory (decisions, gotchas, failed attempts, theme changes) — what AI can't infer from code",
+  theme:      "Scan fonts, colors, and CSS variables — write inferno/theme.json so AI always matches the design system",
+  switch:     "Generate a handoff summary when switching AI agents — paste into the next session so nothing is lost",
+  upgrade:    "Upgrade a lite infernoflow setup to the full structure (scenarios, changelog, scripts)",
+  stats:      "Value dashboard — session memory, tokens injected per session, coverage %, estimated savings",
+  ask:        "Query session memory — search gotchas, decisions, and failed attempts by keyword or type",
+  recap:      "End-of-session summary — what was captured, what git changes weren't logged, session health score",
+};
+
+const COMMAND_HANDLERS = {
+  publish: async (args) => (await import("../lib/commands/publish.mjs")).publishCommand(args),
+  diff: async (args) => (await import("../lib/commands/diff.mjs")).diffCommand(args),
+  changelog: async (args) => (await import("../lib/commands/changelog.mjs")).changelogCommand(args),
+  setup: async (args) => (await import("../lib/commands/setup.mjs")).setupCommand(args),
+  init: async (args) => (await import("../lib/commands/init.mjs")).initCommand(args),
+  "install-cursor-hooks": async (args) =>
+    (await import("../lib/commands/installCursorHooks.mjs")).installCursorHooksCommand(args),
+  "install-vscode-copilot-hooks": async (args) =>
+    (await import("../lib/commands/installVsCodeCopilotHooks.mjs")).installVsCodeCopilotHooksCommand(args),
+  check: async (args) => (await import("../lib/commands/check.mjs")).checkCommand(args),
+  status: async (args) => (await import("../lib/commands/status.mjs")).statusCommand(args),
+  "pr-impact": async (args) => (await import("../lib/commands/prImpact.mjs")).prImpactCommand(args),
+  sync: async (args) => (await import("../lib/commands/syncAuto.mjs")).syncCommand(args),
+  run: async (args) => (await import("../lib/commands/run.mjs")).runCommand(args),
+  suggest: async (args) => (await import("../lib/commands/suggest.mjs")).suggestCommand(args),
+  implement: async (args) => (await import("../lib/commands/implement.mjs")).implementCommand(args),
+  context: async (args) => (await import("../lib/commands/context.mjs")).contextCommand(args),
+  "doc-gate": async (args) => (await import("../lib/commands/docGate.mjs")).docGateCommand(args),
+  "generate-skills": async (args) => (await import("../lib/commands/generateSkills.mjs")).generateSkillsCommand(args),
+  synthesize: async (args) => (await import("../lib/commands/synthesize.mjs")).synthesizeCommand(args),
+  agent: async (args) => (await import("../lib/commands/agent.mjs")).agentCommand(args),
+  version: async (args) => (await import("../lib/commands/version.mjs")).versionCommand(args),
+  "pr-comment": async (args) => (await import("../lib/commands/prComment.mjs")).prCommentCommand(args),
+  dashboard: async (args) => (await import("../lib/commands/dashboard.mjs")).dashboardCommand(args),
+  "team-sync": async (args) => (await import("../lib/commands/teamSync.mjs")).teamSyncCommand(args),
+  onboard: async (args) => (await import("../lib/commands/onboard.mjs")).onboardCommand(args),
+  cloud:   async (args) => (await import("../lib/commands/cloud.mjs")).cloudCommand(args),
+  share:   async (args) => (await import("../lib/commands/share.mjs")).shareCommand(args),
+  watch:   async (args) => (await import("../lib/commands/watch.mjs")).watchCommand(args),
+  ci:      async (args) => (await import("../lib/commands/ci.mjs")).ciCommand(args),
+  notify:  async (args) => (await import("../lib/commands/notify.mjs")).notifyCommand(args),
+  report:  async (args) => (await import("../lib/commands/report.mjs")).reportCommand(args),
+  monorepo: async (args) => (await import("../lib/commands/monorepo.mjs")).monorepoCommand(args),
+  link:    async (args) => (await import("../lib/commands/link.mjs")).linkCommand(args),
+  audit:    async (args) => (await import("../lib/commands/audit.mjs")).auditCommand(args),
+  scout:    async (args) => (await import("../lib/commands/scout.mjs")).scoutCommand(args),
+  export:   async (args) => (await import("../lib/commands/export.mjs")).exportCommand(args),
+  snapshot: async (args) => (await import("../lib/commands/snapshot.mjs")).snapshotCommand(args),
+  health:   async (args) => (await import("../lib/commands/health.mjs")).healthCommand(args),
+  vibe:     async (args) => (await import("../lib/commands/vibe.mjs")).vibeCommand(args),
+  adopt:    async (args) => (await import("../lib/commands/adoptWizard.mjs")).adoptWizardCommand(args),
+  doctor:   async (args) => (await import("../lib/commands/doctor.mjs")).doctorCommand(args),
+  coverage: async (args) => (await import("../lib/commands/coverage.mjs")).coverageCommand(args),
+  review:   async (args) => (await import("../lib/commands/review.mjs")).reviewCommand(args),
+  scan:      async (args) => (await import("../lib/commands/scan.mjs")).scanCommand(args),
+  graph:     async (args) => (await import("../lib/commands/graph.mjs")).graphCommand(args),
+  stability: async (args) => (await import("../lib/commands/stability.mjs")).stabilityCommand(args),
+  freeze:    async (args) => (await import("../lib/commands/stability.mjs")).freezeCommand(args),
+  thaw:      async (args) => (await import("../lib/commands/stability.mjs")).thawCommand(args),
+  why:       async (args) => (await import("../lib/commands/why.mjs")).whyCommand(args),
+  impact:    async (args) => (await import("../lib/commands/impact.mjs")).impactCommand(args),
+  scaffold:  async (args) => (await import("../lib/commands/scaffold.mjs")).scaffoldCommand(args),
+  explain:   async (args) => (await import("../lib/commands/explain.mjs")).explainCommand(args),
+  test:      async (args) => (await import("../lib/commands/test.mjs")).testCommand(args),
+  ai:        async (args) => (await import("../lib/commands/ai.mjs")).aiCommand(args),
+  demo:      async (args) => (await import("../lib/commands/demo.mjs")).demoCommand(args),
+  log:       async (args) => (await import("../lib/commands/log.mjs")).logCommand(args),
+  theme:     async (args) => (await import("../lib/commands/theme.mjs")).themeCommand(args),
+  switch:    async (args) => (await import("../lib/commands/switch.mjs")).switchCommand(args),
+  upgrade:   async (args) => (await import("../lib/commands/upgrade.mjs")).upgradeCommand(args),
+  stats:     async (args) => (await import("../lib/commands/stats.mjs")).statsCommand(args),
+  ask:       async (args) => (await import("../lib/commands/ask.mjs")).askCommand(args),
+  recap:     async (args) => (await import("../lib/commands/recap.mjs")).recapCommand(args),
+};
+
+function formatCommandsHelp() {
+  const names = Object.keys(COMMAND_DESCRIPTIONS);
+  const w = Math.max(...names.map((n) => n.length), 8) + 1;
+  return Object.entries(COMMAND_DESCRIPTIONS)
+    .map(([name, desc]) => `    ${name.padEnd(w, " ")}${desc}`)
+    .join("\n");
+}
+
+const HELP = `
+  ${bold("🔥 infernoflow")} ${gray("v" + VERSION)}
+  ${gray("The forge for liquid code — keep every AI session in sync")}
+
+  ${bold("Usage:")}
     infernoflow <command> [options]
 
-  ${t("Commands:")}
-${w()}
+  ${bold("Commands:")}
+${formatCommandsHelp()}
 
-  ${t("diff options:")}
+  ${bold("diff options:")}
     --ref <tag|commit>        Compare against a specific ref (default: last git tag)
     --summary                 One-liner count only
     --json                    Machine-readable output
 
-  ${t("changelog options:")}
+  ${bold("changelog options:")}
     update                    Draft ## Unreleased from commits (default sub-command)
     show                      Print the current ## Unreleased block
     list                      List commits since last tag
@@ -26,7 +175,7 @@ ${w()}
     --append                  Append to existing ## Unreleased instead of replacing
     --json                    Machine-readable output
 
-  ${t("publish options:")}
+  ${bold("publish options:")}
     --bump patch|minor|major  Version bump type (default: patch)
     --skip-build              Skip the build step
     --skip-tests              Skip smoke tests
@@ -35,13 +184,13 @@ ${w()}
     --dry-run                 Print all steps without executing
     --yes, -y                 Non-interactive (skip confirmation prompt)
 
-  ${t("setup options:")}
+  ${bold("setup options:")}
     --yes, -y           Skip prompts (non-interactive)
     --force, -f         Overwrite existing hook files
 
-  ${t("init options:")}
-    --cursor-hooks           Also install Cursor hooks (draft \u2192 inferno/CONTEXT.draft.md)
-    --vscode-copilot-hooks   Also install VS Code + Copilot hooks (.github/hooks \u2014 Preview)
+  ${bold("init options:")}
+    --cursor-hooks           Also install Cursor hooks (draft → inferno/CONTEXT.draft.md)
+    --vscode-copilot-hooks   Also install VS Code + Copilot hooks (.github/hooks — Preview)
     --adopt             Infer capabilities from an existing codebase
     --lang <name>       Override detected language (e.g. ts, js, py)
     --framework <name>  Override detected framework (e.g. react, angular, express)
@@ -52,13 +201,13 @@ ${w()}
     --yes, -y           Skip prompts and accept inferred/default values
     --force, -f         Overwrite existing inferno/ files
 
-  ${t("install-cursor-hooks options:")}
+  ${bold("install-cursor-hooks options:")}
     --force, -f         Overwrite .cursor/hooks.json and hook scripts if they exist
 
-  ${t("install-vscode-copilot-hooks options:")}
+  ${bold("install-vscode-copilot-hooks options:")}
     --force, -f         Overwrite .github/hooks/infernoflow-drafts.json and scripts if they exist
 
-  ${t("context options:")}
+  ${bold("context options:")}
     --intent  "..."     What you plan to build next
     --working "..."     What you are building right now
     --decision "..."    Record a decision or note
@@ -70,39 +219,39 @@ ${w()}
     --auto-commit       Watch mode: commit CONTEXT.md to git on every change
     --auto-push         Watch mode: commit + push CONTEXT.md on every change
 
-  ${t("generate-skills options:")}
+  ${bold("generate-skills options:")}
     --cursor            Also install rules to .cursor/rules/infernoflow.md
     --force, -f         Overwrite existing generated skill files
 
-  ${t("implement options:")}
+  ${bold("implement options:")}
     --mode <type>       cursor | generic | both (default: both)
     --copy, -c          Copy generated prompt(s) to clipboard
 
-  ${t("run options:")}
+  ${bold("run options:")}
     --dry-run           Execute full flow without writing files
     --json              Emit machine-readable events and result payload
     --no-rollback       Keep changes even if validation fails
     --provider <type>   auto | agent | local | prompt (default: auto)
     --ide <name>        auto | cursor | vscode | windsurf (default: auto)
 
-  ${t("Typical workflow:")}
-    ${a('1. infernoflow context --intent "what I want to build"')}
-    ${a("2. [paste inferno/CONTEXT.md into Claude / Cursor / Copilot]")}
-    ${a("3. [build the feature]")}
-    ${a('4. infernoflow suggest "what I built"')}
-    ${a("5. infernoflow check")}
+  ${bold("Typical workflow:")}
+    ${gray('1. infernoflow context --intent "what I want to build"')}
+    ${gray("2. [paste inferno/CONTEXT.md into Claude / Cursor / Copilot]")}
+    ${gray("3. [build the feature]")}
+    ${gray('4. infernoflow suggest "what I built"')}
+    ${gray("5. infernoflow check")}
 
-  ${t("suggest options:")}
+  ${bold("suggest options:")}
     --json                    Non-interactive: emit prompt as JSON, no readline prompts
     --response <json|@file>   Provide AI response directly (use with --json)
     --apply                   Apply the response changes when using --json --response
 
-  ${t("version options:")}
+  ${bold("version options:")}
     --ref <tag|commit>    Compare against a specific ref (default: last git tag)
     --apply               Write recommended version bump to package.json
     --json                Machine-readable output
 
-  ${t("pr-comment options:")}
+  ${bold("pr-comment options:")}
     --pr <number>         PR number to comment on (auto-detected in GitHub Actions)
     --repo <owner/repo>   GitHub repository (auto-detected in GitHub Actions)
     --token <ghp_...>     GitHub token (auto-detected from GITHUB_TOKEN env var)
@@ -110,83 +259,83 @@ ${w()}
     --dry-run             Print the comment without posting it
     --json                Machine-readable output
 
-  ${t("cloud sub-commands:")}
+  ${bold("cloud sub-commands:")}
     init                      Generate a project token and configure cloud sync
     push                      Upload local capability contract to cloud
     pull                      Download latest contract from cloud (conflict detection)
     status                    Compare local vs cloud (hashes, capability counts)
     dashboard                 Print hosted dashboard URL and open in browser
 
-  ${t("cloud options:")}
+  ${bold("cloud options:")}
     --token <tok>             Override token (or set INFERNOFLOW_TOKEN env var)
     --endpoint <url>          Override default endpoint (https://cloud.infernoflow.dev)
     --force, -f               Overwrite on init; overwrite local on conflicted pull
     --dry-run                 Print what would happen without sending
     --json                    Machine-readable output
 
-  ${t("share options:")}
+  ${bold("share options:")}
     --upload                  Upload to dpaste.com and print a public URL
     --open                    Open the snapshot in your browser immediately
     --copy                    Copy HTML to clipboard
     --out <path>              Custom output path (default: inferno/share.html)
     --json                    Machine-readable: { ok, file, url }
 
-  ${t("watch options:")}
+  ${bold("watch options:")}
     [dirs...]                 Directories to watch (default: src/, lib/, app/)
     --interval <secs>         Debounce interval in seconds (default: 3)
     --dry-run                 Print what would run without executing
     --silent                  No output (for git hook use)
 
-  ${t("notify options:")}
+  ${bold("notify options:")}
     --slack <url>             Slack incoming webhook URL
     --discord <url>           Discord webhook URL
     --on-change               Only notify if capabilities actually changed
     --dry-run                 Print message without sending
     --json                    Machine-readable result
 
-  ${t("report options:")}
+  ${bold("report options:")}
     --format html|md          Output format (default: html)
     --since <period>          7d, 30d, 90d, or YYYY-MM-DD (default: 30d)
     --out <path>              Output file path (default: inferno/report.html)
     --open                    Open HTML report in browser after generating
     --json                    Machine-readable summary
 
-  ${t("ci options:")}
+  ${bold("ci options:")}
     --platform <name>         github | gitlab | bitbucket | generic (auto-detected)
     --fail-on <level>         error | warning (default: error)
     --json                    Machine-readable result + exit code
 
-  ${t("monorepo sub-commands:")}
+  ${bold("monorepo sub-commands:")}
     init                      Run infernoflow init --adopt in every package
     list                      List detected packages with their capability counts
     status                    Show contract health across all packages
     diff                      Show capability changes across packages (--package to filter)
     sync                      Aggregate all contracts into inferno-monorepo.json
 
-  ${t("monorepo options:")}
+  ${bold("monorepo options:")}
     --package <name>          Filter to a specific package
     --json                    Machine-readable output
 
-  ${t("link sub-commands:")}
+  ${bold("link sub-commands:")}
     (default)                 Link a capability to a ticket
-    list                      Show all capability\u2192ticket links
+    list                      Show all capability→ticket links
     status                    Show linked and unlinked capabilities
     remove                    Remove a link by capability ID
 
-  ${t("link options:")}
+  ${bold("link options:")}
     --capability <id>         Capability to link
     --jira <TICKET>           Jira ticket ID (e.g. PROJ-123)
     --linear <ID>             Linear issue ID
     --github <NUM>            GitHub issue number
     --json                    Machine-readable output
 
-  ${t("audit options:")}
+  ${bold("audit options:")}
     --format text|json|html   Output format (default: text)
     --out <path>              Save to file (default: prints to stdout)
     --fail-on high|medium     Exit 1 if unreviewed caps at given severity exist
     --json                    Machine-readable output
 
-  ${t("vibe options:")}
+  ${bold("vibe options:")}
     --dir <dirs>              Comma-separated directories to watch (default: auto-detected)
     --no-suggest              Disable automatic contract sync on file save
     --no-context              Disable CONTEXT.md regeneration
@@ -194,30 +343,30 @@ ${w()}
     --port <n>                Also run a mini status dashboard on localhost:<n>
     --silent                  Suppress all terminal output (pure background mode)
 
-  ${t("adopt options:")}
+  ${bold("adopt options:")}
     --dir <dirs>              Source directories to scan (default: src,lib,app,api,routes,controllers)
     --yes, -y                 Auto-approve all candidates (non-interactive)
     --json                    Machine-readable output, implies --yes
 
-  ${t("init --template options:")}
+  ${bold("init --template options:")}
     --template rest-api       REST API (Express/Fastify/Hono) starter
     --template nextjs         Next.js fullstack app starter
     --template cli            CLI tool (Node.js/Python) starter
     --template graphql        GraphQL API (Apollo/Pothos) starter
     --template monorepo       Monorepo workspace starter
 
-  ${t("scout options:")}
+  ${bold("scout options:")}
     --dir <dirs>              Comma-separated directories to scan (default: src,lib,app,api,routes)
     --apply                   Write discovered capabilities to the contract file
     --min-confidence <0-1>    Minimum confidence threshold (default: 0.6)
     --json                    Machine-readable output
 
-  ${t("export options:")}
+  ${bold("export options:")}
     --format openapi|backstage|csv|markdown|json   Output format (required)
     --out <path>              Output file path (default: project root, auto-named)
     --json                    Machine-readable summary
 
-  ${t("snapshot sub-commands:")}
+  ${bold("snapshot sub-commands:")}
     save <name>               Save current contract as a named snapshot
     list                      List all snapshots
     show <name>               Print a snapshot's capabilities
@@ -225,62 +374,63 @@ ${w()}
     restore <name>            Overwrite contract with snapshot contents
     delete <name>             Delete a snapshot
 
-  ${t("snapshot options:")}
+  ${bold("snapshot options:")}
     --json                    Machine-readable output
 
-  ${t("health options:")}
+  ${bold("health options:")}
     --fail-below <score>      Exit 1 if health score is below this threshold (CI gate)
     --watch                   Re-run every 30s (live terminal view)
     --interval <secs>         Watch interval in seconds (default: 30)
     --json                    Machine-readable score + breakdown
 
-  ${t("doctor options:")}
+  ${bold("doctor options:")}
     --fix                     Auto-fix common issues (installs hooks, runs init, etc.)
     --json                    Machine-readable list of pass/warn/fail results
 
-  ${t("coverage options:")}
+  ${bold("coverage options:")}
     --dir <path>              Extra directory to scan for test files (repeatable)
     --threshold <0-1>         Minimum fuzzy-match score to count a test (default: 0.25)
     --fail-below <pct>        Exit 1 if coverage percentage is below this value (CI gate)
     --json                    Machine-readable coverage breakdown
 
-  ${t("scan options:")}
+  ${bold("scan options:")}
     --dir <path>              Extra directory to scan (repeatable)
     --capability <id>         Scan and enrich a single capability only
+    --suggest, -s             Show untracked entry points as new capability candidates
     --dry-run                 Print results without writing files
-    --json                    Machine-readable scan output
+    --json                    Machine-readable scan output (includes discovered routes)
 
-  ${t("graph options:")}
+  ${bold("graph options:")}
     --cap <id>                Show dependency view for a single capability
     --check                   Exit 1 if breaking dependency changes detected (CI gate)
     --json                    Machine-readable graph output
 
-  ${t("stability / freeze / thaw options:")}
+  ${bold("stability / freeze / thaw options:")}
     infernoflow stability     List all capabilities with their stability level
     infernoflow freeze <id>   Mark capability as frozen (AI won't touch it)
     infernoflow freeze <id> --stable   Mark as stable (careful, not forbidden)
-    infernoflow thaw <id>     Reset to experimental (liquid \u2014 free to change)
+    infernoflow thaw <id>     Reset to experimental (liquid — free to change)
     --json                    Machine-readable stability list
 
-  ${t("review options:")}
+  ${bold("review options:")}
     --unstaged                Review all working-tree changes (not just staged)
     --last                    Review last commit (git diff HEAD~1)
-    --dry-run                 Print the AI prompt only \u2014 no API call made
+    --dry-run                 Print the AI prompt only — no API call made
     --json                    Machine-readable output (affectedCaps, summary, provider)
 
-  ${t("why options:")}
+  ${bold("why options:")}
     infernoflow why <file>               Show capability for a source file
     infernoflow why <functionName>       Show capability for a function name
     --function <name>                    Filter to a specific function when multiple caps match
     --json                               Machine-readable output
 
-  ${t("impact options:")}
+  ${bold("impact options:")}
     infernoflow impact <cap-id>          Show blast radius for a capability
     --depth <n>                          Max transitive depth to traverse (default: 10)
     --check                              Exit 1 if risk level is HIGH or CRITICAL (CI gate)
     --json                               Machine-readable output
 
-  ${t("scaffold options:")}
+  ${bold("scaffold options:")}
     infernoflow scaffold <cap-id>        Generate a new capability skeleton
     --dir <path>                         Output directory for the source file (default: auto-detected)
     --lang ts|js|py|go                   Language override (default: auto-detected from project)
@@ -288,12 +438,12 @@ ${w()}
     --dry-run                            Preview what would be generated without writing files
     --json                               Machine-readable output including generated code
 
-  ${t("explain options:")}
+  ${bold("explain options:")}
     infernoflow explain <cap-id>         AI narrative: what it does, risk, what to test
-    --dry-run                            Print the AI prompt only \u2014 no API call made
+    --dry-run                            Print the AI prompt only — no API call made
     --json                               Machine-readable output (narrative, stability, scenarios)
 
-  ${t("test options:")}
+  ${bold("test options:")}
     infernoflow test                     Run all caps that have registered scenarios
     infernoflow test <cap-id>            Run scenarios for a specific capability
     infernoflow test --all               Run every capability (including those without scenarios)
@@ -302,30 +452,66 @@ ${w()}
     --verbose, -v                        Show runner output for each scenario
     --json                               Machine-readable output (passed/failed/skipped counts)
 
-  ${t("ai options:")}
-    infernoflow ai setup                 Interactive wizard \u2014 pick provider, enter API key, verify
+  ${bold("ai options:")}
+    infernoflow ai setup                 Interactive wizard — pick provider, enter API key, verify
     infernoflow ai status                Show all providers and which are configured
     infernoflow ai test [provider]       Send a test prompt and verify the connection
     infernoflow ai clear <provider>      Remove a provider's config from integrations.json
     Supported providers: anthropic  openai  gemini  openrouter  ollama
 
-  ${t("demo options:")}
+  ${bold("demo options:")}
     infernoflow demo                     Full interactive walkthrough (sample e-commerce project)
-    infernoflow demo --fast              Skip pauses \u2014 good for CI or screen recording
+    infernoflow demo --fast              Skip pauses — good for CI or screen recording
     infernoflow demo --no-cleanup        Keep the temp demo project after the run
 
-  ${t("Machine output:")}
-    ${a("status --json")}
-    ${a("check --json")}
-    ${a("doc-gate --json")}
-    ${a("pr-impact --json")}
-    ${a("sync --auto --json")}
-    ${a('run "task" --json')}
-    ${a('suggest "what changed" --json')}
-    ${a(`suggest "what changed" --json --response '{"newCapabilities":[...]}' --apply`)}
-    ${a("version --json")}
-    ${a("version --apply")}
-`;import*as b from"node:fs";import*as v from"node:path";try{const e=v.join(process.cwd(),"inferno");if(b.existsSync(e)){const{observeCommandStart:n}=await import("../lib/learning/observe.mjs"),i=process.argv[2];i&&!i.startsWith("-")&&n(e,i)}}catch{}const[,,o,...k]=process.argv;(!o||o==="--help"||o==="-h")&&(console.log(g),process.exit(0)),(o==="--version"||o==="-v")&&(console.log(r),process.exit(0));const C=Object.keys(l);C.includes(o)||(console.error(s(`
-Unknown command: ${o}`)),console.error(a(`Run: infernoflow --help
-`)),process.exit(1));const j=[o,...k];l[o](j).catch(e=>{console.error(s(`
-Error: `)+e.message),process.exit(1)});
+  ${bold("Machine output:")}
+    ${gray("status --json")}
+    ${gray("check --json")}
+    ${gray("doc-gate --json")}
+    ${gray("pr-impact --json")}
+    ${gray("sync --auto --json")}
+    ${gray('run "task" --json')}
+    ${gray('suggest "what changed" --json')}
+    ${gray('suggest "what changed" --json --response \'{"newCapabilities":[...]}\' --apply')}
+    ${gray("version --json")}
+    ${gray("version --apply")}
+`;
+
+// ── Silent behavior observation ───────────────────────────────────────────
+import * as fs from "node:fs";
+import * as path from "node:path";
+try {
+  const infernoDir = path.join(process.cwd(), "inferno");
+  if (fs.existsSync(infernoDir)) {
+    const { observeCommandStart } = await import("../lib/learning/observe.mjs");
+    const cmdForObserve = process.argv[2];
+    if (cmdForObserve && !cmdForObserve.startsWith("-")) {
+      observeCommandStart(infernoDir, cmdForObserve);
+    }
+  }
+} catch {}
+
+const [, , cmd, ...rest] = process.argv;
+
+if (!cmd || cmd === "--help" || cmd === "-h") {
+  console.log(HELP);
+  process.exit(0);
+}
+if (cmd === "--version" || cmd === "-v") {
+  console.log(VERSION);
+  process.exit(0);
+}
+
+const commands = Object.keys(COMMAND_HANDLERS);
+
+if (!commands.includes(cmd)) {
+  console.error(red(`\nUnknown command: ${cmd}`));
+  console.error(gray("Run: infernoflow --help\n"));
+  process.exit(1);
+}
+
+const args = [cmd, ...rest];
+COMMAND_HANDLERS[cmd](args).catch((err) => {
+  console.error(red("\nError: ") + err.message);
+  process.exit(1);
+});