avorelo 0.1.0

package/scripts/lib/public-cli.js

@@ -0,0 +1,3891 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const {
+  PRODUCT_NAME,
+  CLI_NAME,
+  PUBLIC_INIT_COMMAND,
+  formatCliCommand,
+} = require("./brand");
+const {
+  findWorkspaceRoot,
+  resolveWorkspace,
+  registerWorkspace,
+  clearLastWorkspace,
+  validateWorkspacePath,
+  workspaceDoctor,
+  formatWorkspaceShowText,
+  formatWorkspaceDoctorText,
+} = require("./workspace-resolver");
+const {
+  renderRouteCommand,
+  renderRunCommand,
+  renderModelsCommand,
+  renderStatusCommand: renderOrchestrationStatusCommand,
+  renderProofCommand,
+  renderVerifyCommand: renderOrchestrationVerifyCommand,
+  renderSettingsCommand: renderOrchestrationSettingsCommand,
+  renderHandoffCommand,
+  renderOrchestrationSurfaceCommand,
+} = require("./orchestration/cli");
+const REPO_ROOT = path.resolve(__dirname, "..", "..");
+
+function getCanonicalSessionId(cwd = process.cwd()) {
+  const carryForwardPath = path.join(cwd, ".claude", "cco", "state", "reentry-carry-forward.json");
+  if (fs.existsSync(carryForwardPath)) {
+    try {
+      const state = JSON.parse(fs.readFileSync(carryForwardPath, "utf8"));
+      if (state.sessionId) return state.sessionId;
+    } catch {}
+  }
+  return `${CLI_NAME}-${Date.now()}`;
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      `${PRODUCT_NAME} CLI`,
+      "",
+      `Usage: ${CLI_NAME} <command> [args]`,
+      "",
+      "Commands:",
+      `  activate   Run the public activation flow`,
+      `  init       Print or run the public init path (${PUBLIC_INIT_COMMAND})`,
+      "  status     Show the current Avorelo status",
+      "  dashboard  Show the current Avorelo dashboard",
+      "  audit      Run the current Avorelo audit",
+      "  settings   Open or print the current settings surface",
+      "  panel      Start the local panel",
+      "  doctor     Run the setup checks",
+      "  summary    Show the post-run summary",
+      "  prompt     Improve a rough AI coding instruction",
+      "  route      Route a task to the cheapest capable safe path",
+      "  run        Safe execution controller: routes, compiles packet, prepares handoff, runs whitelisted local proof steps (alias: execute)",
+      "  models     Show detected workers, providers, and model/profile signals",
+      "  orchestration  Show orchestration status and settings helpers (subcommands: status, handoff, surface, settings)",
+      "  handoff    Generate a compact handoff prompt for the next worker/session",
+      "  workspace  Show or manage workspace resolution for global usage",
+      "  workspace-map  Generate a compact workspace navigation map",
+      "  workspace-registry  Build and inspect the local AI workspace asset registry (alias: assets, registry)",
+      "  skills     Review sources, parse skills, route tasks, and sync thin adapters",
+      "  proof      Show the latest orchestration proof (--history: retained proof trail, --export: local proof export, --debug: include blocked/unavailable worker details)",
+      "  context    Build a stage-specific context pack for a task (alias: context-pack)",
+      "  intake     Scan local install and intake surfaces and write a compact receipt",
+      "  visual-qa  Run local screenshot-backed Visual QA when configured",
+      "  capabilities  Show recommended capability packs and next action",
+      "  guard      Evaluate a proposed agent action without executing it",
+      "  work-control  Show unified work-control receipt (what happened, what was risky, what is next)",
+      "  brain-pack  Generate a compact Brain Pack with project/repo/user context for session continuity",
+      "  session-context  Generate compact session-start context for the next AI session (alias: session-start)",
+      "  verify     Verify a file with the local verifier or run orchestration verification",
+      "  operating-value  Show what Avorelo did for you: time saved, tokens/context reduced, risks avoided (alias: value, savings)",
+      "  readiness  Check launch readiness: package audit, install, external repo gate (alias: install-check)",
+      "  outcome    Show end-of-run value summary: completed/saved/protected/verified/next (alias: reality-gate)",
+      "  workspace-hygiene  Scan AI workspace assets and show hygiene report (aliases: hygiene, ai-workspace). Use --debug for full asset detail.",
+      "  orchestrate  Build a work-aware stage plan for a task (aliases: work-plan, plan-work). Use --debug for stage/worker/context detail.",
+      "  ledger     Build and show the unified work ledger linking all receipts (alias: work-ledger). Use --debug for full entry detail.",
+      "  company-loop  Run the AI-native company operating loop: personas, friction clusters, next PR recommendation (aliases: loop, learn). Use --debug for persona findings.",
+      "  project-profile  Detect and show the project profile: framework, package manager, scripts, deploy, risk boundaries (alias: profile).",
+      "  execution-packet  Compile a scoped execution packet for a task: allowed/blocked scope, risk, proof, agent prompt (alias: packet). Use --debug for agent prompt.",
+      "  work-panel  Generate a local work panel preview for the current or a new task (alias: panel-preview). Use --debug for full detail.",
+      "  smart-route  Route work to the cheapest safe capable path: decide, prepare handoff, write receipts (alias: work-route). Use --debug for reason codes.",
+      "  worker-handoff  Show the latest worker handoff receipt prepared by smart-route.",
+      "  hooks      Show hook baseline and lifecycle readiness (alias: hook-baseline, hook-readiness). Use --debug for event detail.",
+      "  hooks preview  Generate hook config preview (what would be added — no config modified). Use --json for machine output.",
+      "  hooks apply [--dry-run] [--yes]  Apply Avorelo hooks to repo-local config. Default: dry-run. Requires --yes for real apply.",
+      "  hooks rollback  Restore the latest config backup from before hook apply.",
+      "  hooks uninstall --yes  Remove only Avorelo-managed hooks from config. Preserves all other hooks.",
+      "  hooks doctor  Validate installed hooks, command paths, recursion guard, and lifecycle smoke.",
+      "  adapter-readiness  Detect which AI coding host adapters are available (claude_code, openhands, generic_cli).",
+      "  lifecycle-hook <event>  Handle a lifecycle event (session-start, user-prompt-submit, pre-tool-use, post-tool-use, stop, session-end). Use --json.",
+      "  token-efficiency  Show token efficiency evidence and context quality status (alias: token-evidence). Use --json.",
+      "  repo-map   Build and show the repo/symbol map for context-efficient task planning. Use --json.",
+      "  context-plan <task>  Build a context acquisition plan for a task. Use --json.",
+      "  cache-readiness  Check prompt layout stability for cache readiness. Use --json.",
+      "  artifacts  Scan and manage .claude/cco artifact health (subcommands: health, cleanup --dry-run, cleanup --yes).",
+      "  launch-hardening  Run the launch hardening gate: checks all critical alpha-readiness surfaces. Use --json.",
+      "  mcp        MCP tool governance: inventory, risk, policy, preview, doctor (subcommands). Use --json.",
+      "  mcp inventory  Discover MCP config files and build local tool inventory (no server execution). Use --json.",
+      "  mcp risk   Classify MCP server/tool risk using static metadata analysis. Use --json.",
+      "  mcp policy  Build least-privilege policy decisions (preview only — config not modified). Use --json.",
+      "  mcp preview  Show policy preview without writing policy. Use --json.",
+      "  mcp doctor  Full MCP governance status: inventory + risk + policy summary. Use --json.",
+      "  install-ai  Generate the one-prompt AI install experience (aliases: ai-install, install-prompt). Use --prompt for text, --json for receipt, --dry-run to skip artifact write.",
+      "  prelaunch-readiness  Run the pre-launch activation readiness gate (all surfaces). Use --json.",
+      "  first-value-check  Run the first-value journey check (readiness + safe path + summary). Use --json.",
+      "  public-distribution  Run public activation distribution truth gate (aliases: distribution-truth). Use --json or --debug.",
+      "  package-audit  Audit npm pack contents for forbidden/suspicious files. Use --json.",
+      "  package-smoke  Run local tarball smoke test (install + CLI help from packed tarball). Use --json.",
+      "  install-claims  Scan docs and README for false public install claims. Use --json.",
+      "  publish-readiness  Check publish/provenance readiness without publishing. Use --json.",
+      "  host-matrix  Build host capability matrix: detect hosts, map hook/MCP/install-ai capabilities. Use --json.",
+      "  cross-host-install  Check cross-host install-ai readiness for all supported hosts. Use --json.",
+      "  cross-host-value  Check cross-host value flow: proof, ledger, token cost, events, support bundle. Use --json.",
+      "  adapter-safety  Check adapter safety boundaries: no state leak, hook timeout, MCP isolation. Use --json.",
+      "  host-support  Check host support context: support bundle, proof, ledger, host state. Use --json.",
+      "  browser-preflight  Run browser proof preflight (PREFLIGHT ONLY — no browser launched). Use --json.",
+      "  adapter-readiness-technical  Run full adapter technical readiness gate (all 6 sub-modules). Use --json.",
+      "  run-improvements  Show or generate next-run preparation (alias: next-run-prep). Use --generate to refresh, --consume to record consumption, --apply to set applied state with receipt. Use --json.",
+      "  learning  Show or generate the local evidence-backed learning memory (decisions, risks, capabilities). Use --generate to build, --summary to show, --json for machine output.",
+      "  --help     Show this help",
+      "",
+      `Examples: ${formatCliCommand("activate")}, ${formatCliCommand("status")}, ${formatCliCommand('prompt "fix landing page"')}`,
+    ].join("\n") + "\n"
+  );
+}
+
+function runNodeScript(scriptRelPath, forwardedArgs = [], options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const result = spawnSync(process.execPath || "node", [path.join(REPO_ROOT, scriptRelPath), ...forwardedArgs], {
+    cwd,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      ...(options.env || {}),
+      PROJECT_CWD: cwd,
+    },
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+function renderActivation(forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const wantHelp = forwardedArgs.includes("--help");
+  const useLegacy = forwardedArgs.some((a) =>
+    ["--dry-run", "--repair", "--force-refresh", "--open", "--agent-repair", "--local-only", "--text"].includes(a)
+  );
+
+  if (wantHelp) {
+    process.stdout.write([
+      "Usage: avorelo activate [options]",
+      "",
+      "Options:",
+      "  --json           Alpha activation contract as JSON (avorelo.alphaActivation.v1)",
+      "  --debug          Show full internal detail",
+      "  --dry-run        (legacy) Show planned repairs without applying",
+      "  --repair         (legacy) Force repair loop",
+      "  --target <t>     (legacy) Prepare target handoff",
+      "  --open           (legacy) Print dashboard preview path",
+      "  --agent-repair   (legacy) Output machine-readable repair plan",
+      "  --help           Show this help",
+      "",
+    ].join("\n"));
+    return;
+  }
+
+  const rawCwd = process.env.PROJECT_CWD || process.cwd();
+
+  // Legacy flow: preserve old behavior for legacy flags
+  if (useLegacy) {
+    const {
+      runActivationV1,
+      parseActivationArgs,
+      formatActivationText: legacyFormatText,
+      formatActivationJson,
+    } = require("./activation/activation-runner");
+    const { detectProject } = require("./activation/detect-environment");
+    const args = parseActivationArgs(forwardedArgs);
+    const currentWorkspace = findWorkspaceRoot(rawCwd)?.workspace;
+    const project = detectProject(rawCwd, { env: process.env });
+    const cwd = currentWorkspace || project.repoRoot || rawCwd;
+    const result = runActivationV1(cwd, {
+      dryRun: args.dryRun,
+      repair: args.repair,
+      target: args.target,
+      forceRefresh: args.forceRefresh,
+      env: process.env,
+    });
+    try { registerWorkspace(cwd, { env: process.env }); } catch {}
+    if (args.open) {
+      const dashPath = result.dashboardPath || ".claude/cco/orchestration/operating-value/dashboard-preview.md";
+      process.stdout.write(`Dashboard preview:\n  ${dashPath}\n\nRun: cat "${dashPath}"\n`);
+      return;
+    }
+    if (args.agentRepair) {
+      process.stdout.write(`${JSON.stringify(result.agentRepairInstructions || result, null, 2)}\n`);
+      return;
+    }
+    if (args.json) {
+      process.stdout.write(`${formatActivationJson(result)}\n`);
+      return;
+    }
+    process.stdout.write(`${legacyFormatText(result)}\n`);
+    return;
+  }
+
+  // Alpha activation flow (default for plain activate / activate --json / activate --debug)
+  const {
+    buildActivationSurface,
+    formatActivationText,
+  } = require("./alpha-activation");
+
+  const currentWorkspace = findWorkspaceRoot(rawCwd)?.workspace;
+  const cwd = currentWorkspace || rawCwd;
+
+  const receipt = buildActivationSurface(cwd, { debug: wantDebug });
+
+  try { registerWorkspace(cwd, { env: process.env }); } catch {}
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+    return;
+  }
+
+  // Default: compact human-readable
+  process.stdout.write(`${formatActivationText(receipt, { debug: wantDebug })}\n`);
+}
+
+function renderFirstValue(cwd, forwardedArgs = []) {
+  // Alias for activate with alpha activation surface
+  renderActivation(forwardedArgs);
+}
+
+function renderAlphaReadinessGate(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const { runAlphaReadinessGate, formatAlphaReadinessGateText } = require("./alpha-readiness-gate");
+  const report = runAlphaReadinessGate(cwd);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatAlphaReadinessGateText(report)}\n`);
+}
+
+function renderFeedbackCommand(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const { addFeedback, listFeedback, formatFeedbackListText } = require("./alpha-feedback");
+  const { importFeedbackEvidence, validateFeedbackEvidence, generateFeedbackIntakePack } = require("./prelaunch-evidence-store");
+
+  const subcommand = forwardedArgs.find((a) => !a.startsWith("-")) || "list";
+
+  if (subcommand === "add") {
+    const source = readFlagValue(forwardedArgs, "--source") || "dogfood";
+    const persona = readFlagValue(forwardedArgs, "--persona") || "unknown";
+    const frictionType = readFlagValue(forwardedArgs, "--friction-type") || readFlagValue(forwardedArgs, "--friction") || "other";
+    const severity = readFlagValue(forwardedArgs, "--severity") || "medium";
+    const summary = readFlagValue(forwardedArgs, "--summary") || "";
+    const desiredBehavior = readFlagValue(forwardedArgs, "--desired") || "";
+    const segment = readFlagValue(forwardedArgs, "--segment") || "unknown";
+    const theme = readFlagValue(forwardedArgs, "--theme") || null;
+    const issueCategory = readFlagValue(forwardedArgs, "--issue-category") || null;
+    const activationStage = readFlagValue(forwardedArgs, "--activation-stage") || "unknown";
+    const evidencePath = readFlagValue(forwardedArgs, "--evidence-path") || null;
+    const trustConcern = forwardedArgs.includes("--trust-concern");
+    const pricingConcern = forwardedArgs.includes("--pricing-concern");
+    const simulated = forwardedArgs.includes("--simulated");
+    const result = addFeedback(cwd, {
+      source, persona, frictionType, severity, summary, desiredBehavior,
+      segment, theme, issueCategory, activationStage, evidencePath,
+      trustConcern, pricingConcern, simulated,
+    });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+    if (result.ok) {
+      process.stdout.write(`Feedback captured: ${result.path}\n`);
+    } else {
+      process.stderr.write(`Feedback error: ${result.errors.join(", ")}\n`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (subcommand === "intake-pack" || subcommand === "pack") {
+    const receipt = generateFeedbackIntakePack(cwd);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Feedback intake pack: ${receipt.outputDir}\n`);
+    return;
+  }
+
+  if (subcommand === "validate") {
+    const file = readFlagValue(forwardedArgs, "--file");
+    if (!file) {
+      const message = { ok: false, error: "--file is required", redacted: true };
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(message, null, 2)}\n`);
+        return;
+      }
+      process.stderr.write("Feedback validate error: --file is required\n");
+      process.exit(1);
+    }
+    const receipt = validateFeedbackEvidence(cwd, file);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Feedback validation: ${receipt.acceptedCount} accepted, ${receipt.rejectedCount} rejected.\n`);
+    return;
+  }
+
+  if (subcommand === "import") {
+    const file = readFlagValue(forwardedArgs, "--file");
+    if (!file) {
+      const message = { ok: false, error: "--file is required", redacted: true };
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(message, null, 2)}\n`);
+        return;
+      }
+      process.stderr.write("Feedback import error: --file is required\n");
+      process.exit(1);
+    }
+    const receipt = importFeedbackEvidence(cwd, file);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Feedback import: ${receipt.acceptedCount} accepted, ${receipt.rejectedCount} rejected.\n`);
+    return;
+  }
+
+  if (subcommand === "session") {
+    const { buildDesignPartnerFeedbackSession, writeDesignPartnerFeedbackSession } = require("./design-partner-feedback");
+    const partnerAlias = readFlagValue(forwardedArgs, "--partner") || readFlagValue(forwardedArgs, "--partner-alias") || "";
+    const activationStage = readFlagValue(forwardedArgs, "--stage") || "unknown";
+    const frictionType = readFlagValue(forwardedArgs, "--friction-type") || readFlagValue(forwardedArgs, "--friction") || "unknown";
+    const severity = readFlagValue(forwardedArgs, "--severity") || "medium";
+    const consent = readFlagValue(forwardedArgs, "--consent") || "not_recorded";
+    const summary = readFlagValue(forwardedArgs, "--summary") || "";
+    const desiredBehavior = readFlagValue(forwardedArgs, "--desired") || "";
+    const sessionNotes = readFlagValue(forwardedArgs, "--notes") || "";
+    const theme = readFlagValue(forwardedArgs, "--theme") || "";
+    const simulated = forwardedArgs.includes("--simulated");
+    const result = buildDesignPartnerFeedbackSession(cwd, {
+      partnerAlias, activationStage, frictionType, severity, consent,
+      summary, desiredBehavior, sessionNotes, theme, simulated,
+    });
+    if (!result.ok) {
+      if (wantJson) { process.stdout.write(`${JSON.stringify(result, null, 2)}\n`); return; }
+      process.stderr.write(`Feedback session error: ${result.errors.join(", ")}\n`);
+      process.exit(1);
+    }
+    const writeResult = writeDesignPartnerFeedbackSession(cwd, result.session);
+    if (wantJson) { process.stdout.write(`${JSON.stringify({ ok: true, sessionId: result.session.sessionId, path: writeResult.path, redacted: true }, null, 2)}\n`); return; }
+    process.stdout.write(`Design partner session captured: ${writeResult.path}\n`);
+    return;
+  }
+
+  if (subcommand === "summary") {
+    const { buildDesignPartnerFeedbackSummary, writeDesignPartnerFeedbackSummary, formatDesignPartnerFeedbackText } = require("./design-partner-feedback");
+    const summary = buildDesignPartnerFeedbackSummary(cwd);
+    writeDesignPartnerFeedbackSummary(cwd, summary);
+    if (wantJson) { process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`); return; }
+    process.stdout.write(`${formatDesignPartnerFeedbackText(summary)}\n`);
+    return;
+  }
+
+  if (subcommand === "design-partner-pack") {
+    const { buildDesignPartnerFeedbackSummary, writeDesignPartnerFeedbackSummary, formatDesignPartnerFeedbackText } = require("./design-partner-feedback");
+    const summary = buildDesignPartnerFeedbackSummary(cwd);
+    writeDesignPartnerFeedbackSummary(cwd, summary);
+    const wantMarkdown = forwardedArgs.includes("--markdown");
+    if (wantJson) { process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`); return; }
+    if (wantMarkdown) {
+      const lines = ["# Design Partner Feedback Pack", "", `Status: ${summary.status}`, `Sessions: ${summary.qualifiedSessionCount} qualified / ${summary.totalSessionCount} total`, `Partners: ${summary.partnerAliasCount}`, `Blockers: ${summary.blockerCount}`, ""];
+      if (summary.topFrictions && summary.topFrictions.length > 0) {
+        lines.push("## Top Frictions");
+        summary.topFrictions.forEach((f) => lines.push(`- ${f.frictionType}: ${f.count}`));
+        lines.push("");
+      }
+      lines.push("_No public launch claim. Redacted._");
+      process.stdout.write(lines.join("\n") + "\n");
+      return;
+    }
+    process.stdout.write(`${formatDesignPartnerFeedbackText(summary)}\n`);
+    return;
+  }
+
+  // list (default)
+  const sourceFilter = readFlagValue(forwardedArgs, "--source") || null;
+  const list = listFeedback(cwd, { source: sourceFilter });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(list, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatFeedbackListText(list)}\n`);
+}
+
+function renderSupportBundle(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const { generateSupportBundle, formatSupportBundleText } = require("./support-bundle");
+  const bundle = generateSupportBundle(cwd);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(bundle, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatSupportBundleText(bundle)}\n`);
+}
+
+function renderTokenEfficiency(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const {
+    buildTokenEfficiencyEvidence,
+    writeTokenEfficiencyEvidence,
+    buildTokenEfficiencySurface,
+    formatTokenEfficiencyText,
+  } = require("./token-efficiency-evidence");
+  const {
+    runTokenContextQualityGate,
+    writeTokenContextQualityGate,
+    formatTokenContextQualityText,
+  } = require("./token-context-quality-gate");
+  const evidence = buildTokenEfficiencyEvidence(cwd, {}, {});
+  writeTokenEfficiencyEvidence(cwd, evidence);
+  const gate = runTokenContextQualityGate(cwd, {}, {});
+  writeTokenContextQualityGate(cwd, gate);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify({ evidence, gate }, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatTokenEfficiencyText(evidence)}\n${formatTokenContextQualityText(gate)}\n`);
+}
+
+function renderRepoMap(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const { buildRepoMap, writeRepoMap, formatRepoMapText } = require("./repo-map");
+  const map = buildRepoMap(cwd, {});
+  writeRepoMap(cwd, map);
+  if (wantJson) {
+    const { files: _files, symbols: _symbols, tokenCountTree: _tree, ...compact } = map;
+    process.stdout.write(`${JSON.stringify(compact, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatRepoMapText(map)}\n`);
+}
+
+function renderContextPlan(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const taskText = forwardedArgs.filter((a) => !a.startsWith("--")).join(" ") || "unknown task";
+  const { buildContextAcquisitionPlan, writeContextAcquisitionPlan, formatContextPlanText } = require("./context-acquisition-plan");
+  const plan = buildContextAcquisitionPlan(cwd, taskText, {});
+  writeContextAcquisitionPlan(cwd, plan);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatContextPlanText(plan)}\n`);
+}
+
+function renderCacheReadiness(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const { buildCacheReadiness, writeCacheReadiness, formatCacheReadinessText } = require("./cache-readiness");
+  const readiness = buildCacheReadiness(cwd, {}, {});
+  writeCacheReadiness(cwd, readiness);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(readiness, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatCacheReadinessText(readiness)}\n`);
+}
+
+function renderDoctor(cwd, forwardedArgs = []) {
+  const { parseArgs, runDoctor, formatDoctorText } = require("../wuz-doctor");
+  const args = parseArgs(forwardedArgs);
+  const report = runDoctor(cwd, args);
+  process.stdout.write(args.json ? `${JSON.stringify(report, null, 2)}\n` : `${formatDoctorText(report)}\n`);
+}
+
+function renderStatus(cwd, forwardedArgs = []) {
+  const { buildStatusJson, formatBoundedStatus } = require("../cco-status");
+  const wantJson = forwardedArgs.includes("--json");
+  const payload = buildStatusJson(cwd);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatBoundedStatus(payload)}\n`);
+}
+
+function printStatusHelp() {
+  process.stdout.write(
+    [
+      `Usage: ${CLI_NAME} status [--text|--json]`,
+      "",
+      "Show the current Avorelo status for the resolved workspace.",
+      "",
+      "Options:",
+      "  --text    Print human-readable status output",
+      "  --json    Print machine-readable status output",
+      "  --help    Show this help",
+      "",
+      `Note: Run inside your repo, use "${CLI_NAME} workspace set <path>", or set AVORELO_WORKSPACE when using this globally.`,
+    ].join("\n") + "\n"
+  );
+}
+
+function renderDashboard(cwd, forwardedArgs = []) {
+  const { buildStatusDashboard } = require("./dashboard");
+  const { buildDashboardJson, formatBoundedDashboard } = require("../cco-dashboard");
+  const wantJson = forwardedArgs.includes("--json");
+  const wantValue = forwardedArgs.includes("--value");
+  const wantOpen = forwardedArgs.includes("--open");
+  const platformArg = forwardedArgs.find((arg) => arg.startsWith("--platform="));
+  const platform = platformArg ? platformArg.split("=")[1] : "claude";
+
+  // --open: write and print path to local dashboard preview
+  if (wantOpen) {
+    const { buildOperatingValue, writeOperatingValue, OPERATING_VALUE_DASHBOARD_PREVIEW_REL } = require("./operating-value");
+    const value = buildOperatingValue(cwd);
+    writeOperatingValue(cwd, value);
+    const previewPath = value.dashboardReady && value.dashboardReady.localDashboardPath;
+    if (previewPath) {
+      process.stdout.write(`Avorelo local dashboard preview written to:\n  ${previewPath}\n\nOpen it in your editor or run: cat "${previewPath}"\n`);
+    } else {
+      process.stdout.write(`Dashboard preview not generated. Run \`avorelo operating-value --summary\` instead.\n`);
+    }
+    return;
+  }
+
+  const dashboard = buildStatusDashboard(cwd, { limit: 7 });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(buildDashboardJson(dashboard, platform, cwd), null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatBoundedDashboard({
+    cwd,
+    platform,
+    tier: dashboard.tier,
+    what: "Quick view of optimization opportunities.",
+    why: "See Time, Risk, Cost impact and clear next steps.",
+    nextBestAction: dashboard.nextBestAction,
+    topFixesNow: (dashboard.topRecommendedFixes || []).slice(0, 3),
+    benefitSummary: dashboard.benefitSummary,
+      agentSecurity: dashboard.agentSecurity || null,
+      agentAccessGovernance: dashboard.agentAccessGovernance || null,
+      safePath: dashboard.safePath || null,
+      browserCapability: dashboard.browserCapability || null,
+      skillsOperatingLayer: dashboard.skillsOperatingLayer || null,
+      settingsControls: dashboard.settingsControls || null,
+  })}\n`);
+  // --value: append operating value section after existing dashboard surfaces
+  if (wantValue) {
+    try {
+      const { buildOperatingValue, writeOperatingValue, formatOperatingValueText } = require("./operating-value");
+      const value = buildOperatingValue(cwd);
+      writeOperatingValue(cwd, value);
+      process.stdout.write("\n" + formatOperatingValueText(value) + "\n");
+    } catch { /* operating-value surface unavailable; existing dashboard output is unaffected */ }
+  }
+}
+
+function printDashboardHelp() {
+  process.stdout.write(
+    [
+      `Usage: ${CLI_NAME} dashboard [--json] [--value] [--open] [--platform=<host>]`,
+      "",
+      "Show the current Avorelo dashboard for the resolved workspace.",
+      "",
+      "Options:",
+      "  --json              Print machine-readable dashboard output",
+      "  --value             Append operating-value detail after the dashboard",
+      "  --open              Write and print the local dashboard preview path",
+      "  --platform=<host>   Set the dashboard platform context (default: claude)",
+      "  --help              Show this help",
+      "",
+      `Note: Run inside your repo, use "${CLI_NAME} workspace set <path>", or set AVORELO_WORKSPACE when using this globally.`,
+    ].join("\n") + "\n"
+  );
+}
+
+function readFlagValue(args, name) {
+  const match = args.find((arg) => arg.startsWith(`${name}=`));
+  if (match) return match.split("=").slice(1).join("=");
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] || null : null;
+}
+
+function renderPrompt(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const taskType = readFlagValue(forwardedArgs, "--task-type");
+  const plan = readFlagValue(forwardedArgs, "--plan");
+  const instruction = forwardedArgs.filter((arg) => !arg.startsWith("--")).join(" ").trim();
+  const { compilePrompt } = require("./prompt-compiler");
+  const result = compilePrompt({
+    instruction,
+    taskType,
+    plan,
+    cwd,
+  });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${result.compiledPrompt}\n`);
+}
+
+function renderCapabilities(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const packArg = (() => {
+    const idx = forwardedArgs.indexOf("--pack");
+    return idx >= 0 ? (forwardedArgs[idx + 1] || null) : null;
+  })();
+
+  const { buildCapabilityLayerSurface } = require("./capability-recommender");
+  const { listPacks, getPack } = require("./capability-packs");
+
+  // Single pack detail mode
+  if (packArg) {
+    const pack = getPack(packArg);
+    if (!pack) {
+      process.stderr.write(`[avorelo] Unknown pack: ${packArg}\n`);
+      process.stderr.write(`Available packs: ${listPacks().map((p) => p.id).join(", ")}\n`);
+      process.exit(1);
+    }
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(pack, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      `Pack: ${pack.name}`,
+      `  ${pack.description}`,
+      "",
+      "Outcomes:",
+      ...(pack.outcomes || []).map((o) => `  - ${o}`),
+      "",
+      `Entitlement: ${pack.defaultEntitlement}`,
+      "",
+      pack.userFacingCopy,
+      "",
+    ].join("\n") + "\n");
+    return;
+  }
+
+  // Default: compact recommendation summary (not a catalog dump)
+  const surface = buildCapabilityLayerSurface(cwd, {}, null);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(surface, null, 2)}\n`);
+    return;
+  }
+
+  const lines = [
+    `${PRODUCT_NAME} Capability Layer`,
+    "",
+    "Avorelo prepares the right capability for the job — locally, safely, and with evidence.",
+    "",
+  ];
+
+  if (surface && surface.recommendedPack) {
+    lines.push(`Recommended:  ${surface.recommendedPack.name} (${surface.entitlement || "free"})`);
+    lines.push(`Why:          ${surface.reason}`);
+    lines.push(`Next:         ${surface.nextAction}`);
+    if (surface.evidencePath) {
+      lines.push(`Evidence:     ${surface.evidencePath}`);
+    }
+    lines.push("");
+  }
+
+  if (surface && surface.activePacks && surface.activePacks.length > 0) {
+    lines.push(`Active packs: ${surface.activePacks.map((p) => p.name).join(", ")}`);
+    lines.push("");
+  }
+
+  if (surface && surface.additionalPacks && surface.additionalPacks.length > 0) {
+    lines.push("Also relevant:");
+    for (const p of surface.additionalPacks) {
+      lines.push(`  ${p.name}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(`Run: ${CLI_NAME} capabilities --pack <id>  to see details for a specific pack.`);
+  lines.push(`Available packs: ${listPacks().map((p) => p.id).join(", ")}`);
+  lines.push("");
+
+  process.stdout.write(lines.join("\n") + "\n");
+}
+
+function renderWorkspaceRegistry(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantSummary = forwardedArgs.includes("--summary");
+  const wantDiff = forwardedArgs.includes("--diff");
+  const typeFilter = readFlagValue(forwardedArgs, "--type");
+  const refreshIntake = forwardedArgs.includes("--refresh-intake");
+
+  const {
+    buildWorkspaceRegistry,
+    writeWorkspaceRegistry,
+    readLatestRegistry,
+    formatRegistryText,
+    formatRegistrySummaryMarkdown,
+  } = require("./workspace-registry");
+
+  if (refreshIntake) {
+    try {
+      const { scanInstallIntakeRisk } = require("./install-intake-risk");
+      scanInstallIntakeRisk(cwd, { writeReceipt: true, plan: process.env.AVORELO_PLAN || "free", generatedBy: "workspace_registry_refresh_intake" });
+    } catch {}
+  }
+
+  const registry = buildWorkspaceRegistry(cwd);
+  writeWorkspaceRegistry(cwd, registry);
+
+  if (wantDiff) {
+    const drift = registry.drift;
+    process.stdout.write(JSON.stringify({
+      registryId: registry.registryId,
+      previousRegistryId: drift.previousRegistryId,
+      addedAssets: drift.addedAssets,
+      removedAssets: drift.removedAssets,
+      changedAssets: drift.changedAssets,
+      unchangedAssets: drift.unchangedAssets,
+    }, null, 2) + "\n");
+    return;
+  }
+
+  if (typeFilter) {
+    const filtered = (registry.assets || []).filter((a) => a.type === typeFilter);
+    process.stdout.write(JSON.stringify({ type: typeFilter, count: filtered.length, assets: filtered }, null, 2) + "\n");
+    return;
+  }
+
+  if (wantJson) {
+    const { assets, ...meta } = registry;
+    process.stdout.write(JSON.stringify({
+      ...meta,
+      assetCount: (assets || []).length,
+      assetPaths: (assets || []).map((a) => a.path).filter(Boolean).slice(0, 30),
+    }, null, 2) + "\n");
+    return;
+  }
+
+  if (wantSummary) {
+    process.stdout.write(formatRegistrySummaryMarkdown(registry) + "\n");
+    return;
+  }
+
+  process.stdout.write(formatRegistryText(registry) + "\n");
+}
+
+function renderWorkspaceHygiene(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const {
+    buildHygieneReport,
+    renderHygieneText,
+    renderHygieneDebugText,
+  } = require("./ai-workspace-hygiene");
+
+  const { report, assets, findings } = buildHygieneReport(cwd, { debug: wantDebug });
+
+  if (wantJson) {
+    if (wantDebug) {
+      const {
+        LATEST_DEBUG_REPORT_REL,
+        CAPABILITY_REGISTRY_METADATA,
+      } = require("./ai-workspace-hygiene");
+      const debugOutput = {
+        ...report,
+        assets: assets.map((a) => ({
+          id: a.id, type: a.type, name: a.name, path: a.path,
+          status: a.status, riskLevel: a.riskLevel, contextCost: a.contextCost,
+          reviewStatus: a.reviewStatus, trustLevel: a.trustLevel,
+          reasonCodes: a.reasonCodes, recommendedAction: a.recommendedAction,
+          lifecycleStage: a.lifecycleStage, stageHints: a.stageHints,
+          workerHints: a.workerHints, orchestrationReady: a.orchestrationReady,
+        })),
+        findings,
+        capabilityRegistryMetadata: CAPABILITY_REGISTRY_METADATA,
+      };
+      process.stdout.write(JSON.stringify(debugOutput, null, 2) + "\n");
+    } else {
+      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    }
+    return;
+  }
+
+  if (wantDebug) {
+    process.stdout.write(renderHygieneDebugText(report, assets, findings));
+    return;
+  }
+
+  process.stdout.write(renderHygieneText(report));
+}
+
+function renderWorkspaceMap(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const task = readFlagValue(forwardedArgs, "--task");
+  const { writeWorkspaceMap, formatWorkspaceMapText } = require("./workspace-map");
+  const map = writeWorkspaceMap(cwd, { task });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(map, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatWorkspaceMapText(map)}\n`);
+}
+
+function renderVisualQa(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const dryRun = forwardedArgs.includes("--dry-run");
+  const target = readFlagValue(forwardedArgs, "--target");
+  const plan = readFlagValue(forwardedArgs, "--plan");
+  const { runVisualQa } = require("./visual-qa");
+  const result = runVisualQa(cwd, {
+    target,
+    plan,
+    dryRun,
+  });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  if (!result.ok) {
+    process.stdout.write(`${result.what}\n`);
+    if (result.nextAction) process.stdout.write(`${result.nextAction}\n`);
+    return;
+  }
+  process.stdout.write(
+    [
+      `Visual QA: ${result.checkedSurface}`,
+      `Plan: ${result.plan}`,
+      result.guardDecision ? `Guard: ${result.guardDecision.decision} (${result.guardDecision.riskLevel})` : null,
+      `Screenshots captured: ${result.screenshotsCaptured ? "yes" : "no"}`,
+      `Evidence: ${result.evidenceStoredAt || "not available"}`,
+      `Next: ${result.nextAction}`,
+    ].filter(Boolean).join("\n") + "\n"
+  );
+}
+
+function renderGuard(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const dryRun = forwardedArgs.includes("--dry-run");
+  const action = readFlagValue(forwardedArgs, "--action");
+  const target = readFlagValue(forwardedArgs, "--target");
+  const task = readFlagValue(forwardedArgs, "--task");
+  const plan = readFlagValue(forwardedArgs, "--plan");
+
+  if (!action) {
+    throw new Error("`avorelo guard` requires --action.");
+  }
+
+  const input = {
+    actionType: action,
+    requestedBy: "cli",
+    userIntent: task || "",
+    taskType: task || "",
+    target,
+    plan,
+  };
+
+  if (action === "file_read" || action === "file_write" || action === "config_change") {
+    input.targetPaths = target ? [target] : [];
+  }
+  if (action === "command_run" || action === "git_operation" || action === "deploy_operation") {
+    input.command = target || "";
+  }
+  if (action === "browser_action" || action === "visual_qa_run") {
+    input.url = target || "";
+    try {
+      input.domain = target ? new URL(/^https?:\/\//i.test(target) ? target : `http://${target}`).hostname : null;
+    } catch {
+      input.domain = null;
+    }
+  }
+  if (action === "tool_call") {
+    input.toolName = target || "";
+  }
+  if (action === "mcp_tool_call") {
+    if (target && target.includes(":")) {
+      const [mcpServer, toolName] = target.split(":");
+      input.mcpServer = mcpServer;
+      input.toolName = toolName || "";
+    } else {
+      input.toolName = target || "";
+    }
+  }
+
+  const { evaluateAgentAction } = require("./agent-enforcement");
+  const decision = evaluateAgentAction(input, {
+    cwd,
+    writeEvidence: true,
+    source: "cli",
+  });
+
+  const {
+    getDecisionVisibility,
+    buildGuardBlockOutcome,
+    writeSeamlessRunReceipt,
+    emitTaskContinuationEvents,
+    formatCompactGuardLine,
+  } = require("./seamless-enforcement");
+
+  // Determine whether this action should be visible in detail or compact
+  const visibility = getDecisionVisibility({
+    actionType: action,
+    riskLevel: decision.riskLevel,
+    isDestructive: decision.reasonCodes?.includes("DESTRUCTIVE") || false,
+    isIrreversible: decision.reasonCodes?.includes("IRREVERSIBLE") || false,
+    hasSecretsRisk: decision.reasonCodes?.includes("SECRETS_RISK") || decision.reasonCodes?.includes("SENSITIVE_ENV_FILE") || false,
+    requiresExplicitApproval: decision.decision === "block",
+  });
+
+  // Build task-specific continuation for all non-allow decisions
+  const outcomeCheck = buildGuardBlockOutcome(decision.decision, {
+    actionType: action,
+    riskLevel: decision.riskLevel,
+    target,
+    userIntent: task,
+    taskType: task,
+    saferAlternative: decision.saferAlternative,
+    reasonCodes: decision.reasonCodes,
+  });
+
+  const payload = {
+    dryRun,
+    decisionId: decision.decisionId,
+    decision: decision.decision,
+    riskLevel: decision.riskLevel,
+    reasonCodes: decision.reasonCodes,
+    matchedRules: decision.matchedRules,
+    explanation: decision.explanation,
+    saferAlternative: decision.saferAlternative,
+    // Task-specific continuation fields (top-level for automation consumers)
+    taskStillExecutable: outcomeCheck?.taskStillExecutable ?? null,
+    fallbackAvailable: outcomeCheck?.fallbackAvailable ?? null,
+    escalationRecommended: outcomeCheck?.escalationRecommended ?? null,
+    safeNextAction: outcomeCheck?.safeNextAction ?? decision.saferAlternative ?? null,
+    continuationType: outcomeCheck?.continuationType ?? null,
+    suggestedScope: outcomeCheck?.suggestedScope ?? null,
+    suggestedCommand: outcomeCheck?.suggestedCommand ?? null,
+    verificationNextStep: outcomeCheck?.verificationNextStep ?? null,
+    evidencePath: decision.evidencePath,
+    governanceReceiptPath: decision.governanceReceiptPath || null,
+    safePathReceiptPath: decision.safePathReceiptPath || null,
+    installIntakeReceiptPath: decision.installIntakeReceiptPath || null,
+    plan: decision.plan,
+    mode: decision.mode,
+    governance: decision.governance || null,
+    safePath: decision.safePath || null,
+    installIntake: decision.installIntake || null,
+    outcomePreservation: outcomeCheck || null,
+    seamlessMode: visibility.mode,
+    interruptRequired: visibility.interruptRequired,
+  };
+
+  // Auto-write value summary after guard evaluation (best-effort)
+  writeSeamlessRunReceipt(cwd, {
+    command: "guard",
+    manualDecisionsAvoided: visibility.interruptRequired ? 0 : 1,
+    unsafeActionsBlocked: decision.decision === "block" ? 1 : 0,
+    qualityPreserved: true,
+    userInterruptAvoided: !visibility.interruptRequired,
+    interruptionRequired: visibility.interruptRequired,
+    interruptReason: visibility.interruptReason,
+  });
+
+  // Emit task continuation events (best-effort)
+  if (outcomeCheck) {
+    emitTaskContinuationEvents(cwd, {
+      continuationType: outcomeCheck.continuationType,
+      safeNextAction: outcomeCheck.safeNextAction,
+      decision: decision.decision,
+      riskLevel: decision.riskLevel,
+      actionType: action,
+      taskStillExecutable: outcomeCheck.taskStillExecutable,
+      fallbackAvailable: outcomeCheck.fallbackAvailable,
+      escalationRecommended: outcomeCheck.escalationRecommended,
+    });
+  }
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  // Compact output for safe routine actions in automatic mode
+  if (!visibility.showDetail) {
+    process.stdout.write(formatCompactGuardLine(decision.decision, decision.riskLevel) + "\n");
+    return;
+  }
+
+  // Full detail output — required when interruption is needed or mode is manual_debug
+  process.stdout.write(
+    [
+      `Guard decision: ${payload.decision}`,
+      visibility.interruptRequired ? `ACTION REQUIRED: ${visibility.interruptReason || "approval needed"}` : null,
+      `Risk: ${payload.riskLevel}`,
+      `Why: ${payload.explanation}`,
+      `Reason codes: ${payload.reasonCodes.length ? payload.reasonCodes.join(", ") : "none"}`,
+      `Matched rules: ${payload.matchedRules.length ? payload.matchedRules.join(", ") : "none"}`,
+      payload.governance ? `Subject: ${payload.governance.subjectSummary.type} / ${payload.governance.subjectSummary.name} / ${payload.governance.subjectSummary.trustStatus}` : null,
+      payload.governance ? `Approval boundary: ${payload.governance.approvalBoundary.summary}` : null,
+      payload.safePath ? `Safe path: ${payload.safePath.safePathDecision}` : null,
+      payload.installIntake ? `Install intake: ${payload.installIntake.summary.totalItems} items / ${payload.installIntake.summary.unknownItems} unknown / ${payload.installIntake.summary.highRiskItems} high` : null,
+      payload.installIntake?.matchedItems?.length ? `Matched intake: ${payload.installIntake.matchedItems.map((item) => `${item.name} (${item.reviewStatus}/${item.riskLevel})`).join(", ")}` : null,
+      payload.safePath?.recommendedBoundary ? `Boundary: ${payload.safePath.recommendedBoundary.accessMode} / ${payload.safePath.recommendedBoundary.pathScope?.join(",") || payload.safePath.recommendedBoundary.domainScope?.join(",") || "narrow local scope"} / ${payload.safePath.recommendedBoundary.allowSecrets === false ? "no-secrets" : "secrets-possible"}` : null,
+      payload.safePath?.nextAction ? `Safe path next: ${payload.safePath.nextAction}` : null,
+      payload.installIntake?.nextAction ? `Intake next: ${payload.installIntake.nextAction}` : null,
+      `Safe next action: ${payload.safeNextAction || payload.saferAlternative}`,
+      payload.continuationType ? `Continuation: ${payload.continuationType}` : null,
+      payload.suggestedCommand ? `Suggested command: ${payload.suggestedCommand}` : null,
+      payload.verificationNextStep ? `Verify next: ${payload.verificationNextStep}` : null,
+      outcomeCheck ? `Task still executable: ${outcomeCheck.taskStillExecutable}` : null,
+      outcomeCheck?.escalationRecommended ? `Escalation recommended: yes` : null,
+      payload.evidencePath ? `Evidence: ${payload.evidencePath}` : null,
+      payload.governanceReceiptPath ? `Governance receipt: ${payload.governanceReceiptPath}` : null,
+      payload.safePathReceiptPath ? `Safe path receipt: ${payload.safePathReceiptPath}` : null,
+      payload.installIntakeReceiptPath ? `Install intake receipt: ${payload.installIntakeReceiptPath}` : null,
+    ].filter(Boolean).join("\n") + "\n"
+  );
+}
+
+function renderBrainPack(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantSummary = forwardedArgs.includes("--summary");
+  const wantInit = forwardedArgs.includes("--init");
+  const recipeArg = (() => {
+    const idx = forwardedArgs.indexOf("--recipe");
+    return idx >= 0 ? (forwardedArgs[idx + 1] || null) : null;
+  })();
+
+  const {
+    buildBrainPack,
+    writeBrainPack,
+    readLatestBrainPack,
+    buildBrainPackSurface,
+    buildBrainPackMarkdown,
+    formatBrainPackText,
+    detectRecipe,
+    BRAIN_PACK_CONTRACT,
+    BRAIN_PACK_LATEST_JSON,
+    BRAIN_PACK_LATEST_MD,
+  } = require("./brain-pack");
+
+  // Recipe detection only
+  if (recipeArg) {
+    const result = detectRecipe(recipeArg, { cwd });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      `Recipe: ${result.detectedRecipe || "none"}`,
+      `Confidence: ${result.confidence}`,
+      `Reason: ${result.reason}`,
+      result.recommendedCapabilityPack ? `Capability: ${result.recommendedCapabilityPack}` : null,
+      result.firstCommand ? `First command: ${result.firstCommand}` : null,
+      ...(result.doNotRepeat || []).map((d) => `- ${d}`),
+      ...(result.deferredCapabilities || []).map((d) => `Deferred: ${d}`),
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  // --init: create default brain pack if missing
+  if (wantInit) {
+    const existing = readLatestBrainPack(cwd);
+    if (existing) {
+      process.stdout.write(`Brain Pack already exists: ${BRAIN_PACK_LATEST_JSON}\n`);
+      return;
+    }
+    const bp = buildBrainPack(cwd, {});
+    const paths = writeBrainPack(cwd, bp);
+    process.stdout.write(`Brain Pack initialized: ${paths.jsonPath}\n`);
+    return;
+  }
+
+  // Default: build, write, and output
+  const bp = buildBrainPack(cwd, {});
+  writeBrainPack(cwd, bp);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify({
+      contract: bp.contract,
+      brainPackId: bp.brainPackId,
+      createdAt: bp.createdAt,
+      project: bp.project,
+      repoConventions: bp.repoConventions,
+      contextRules: bp.contextRules,
+      recipes: bp.recipes,
+      signals: {
+        lastWorkControlFinalState: bp.signals?.lastWorkControlFinalState,
+        nextSafestAction: bp.signals?.nextSafestAction,
+        nextRoadmapCandidates: bp.signals?.nextRoadmapCandidates,
+      },
+      capabilityRecommendation: bp.capabilityRecommendation,
+      jsonPath: BRAIN_PACK_LATEST_JSON,
+      mdPath: BRAIN_PACK_LATEST_MD,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  if (wantSummary) {
+    const { buildBrainPackMarkdown: mkMd } = require("./brain-pack");
+    process.stdout.write(mkMd(bp) + "\n");
+    return;
+  }
+
+  process.stdout.write(formatBrainPackText(bp));
+}
+
+function renderSessionContext(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantHandoff = forwardedArgs.includes("--handoff");
+  const targetArg = readFlagValue(forwardedArgs, "--target");
+  const maxCharsArg = readFlagValue(forwardedArgs, "--max-chars");
+
+  // Exclude flag names and their values from bare task args
+  const flagsWithValues = new Set(["--target", "--max-chars", "--task"]);
+  const taskArgTokens = [];
+  for (let i = 0; i < forwardedArgs.length; i++) {
+    const a = forwardedArgs[i];
+    if (a.startsWith("--")) {
+      if (flagsWithValues.has(a)) i += 1;
+      continue;
+    }
+    taskArgTokens.push(a);
+  }
+  const taskArg = taskArgTokens.join(" ").trim() || null;
+
+  const targetSurface = targetArg === "codex"
+    ? "codex"
+    : targetArg === "local-model"
+      ? "local_model"
+      : targetArg === "claude"
+        ? "claude"
+        : "generic";
+
+  const maxChars = maxCharsArg ? parseInt(maxCharsArg, 10) || 6000 : 6000;
+
+  const {
+    buildSessionContext,
+    writeSessionContext,
+    buildSessionContextSurface,
+    formatSessionContextText,
+    LATEST_CONTEXT_REL_PATH,
+    LATEST_CONTEXT_MD_REL_PATH,
+  } = require("./session-context-optimizer");
+
+  const context = buildSessionContext(cwd, {
+    task: taskArg || undefined,
+    targetSurface,
+    maxChars,
+  });
+
+  writeSessionContext(cwd, context, {
+    plan: process.env.AVORELO_PLAN || "free",
+  });
+
+  if (wantJson) {
+    const { markdownHandoff, compactPrompt, ...sessionStartSafe } = context.sessionStart;
+    process.stdout.write(`${JSON.stringify({
+      contract: context.contract,
+      contextId: context.contextId,
+      createdAt: context.createdAt,
+      targetSurface: context.targetSurface,
+      finalState: context.sessionStart.currentState?.finalState || "missing",
+      nextSafestAction: context.sessionStart.nextSafestAction,
+      compactPrompt,
+      tokenDiscipline: context.tokenDiscipline,
+      sourceReceipts: context.sourceReceipts,
+      receiptPath: LATEST_CONTEXT_REL_PATH,
+      markdownHandoffPath: LATEST_CONTEXT_MD_REL_PATH,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  if (wantHandoff) {
+    process.stdout.write(formatSessionContextText(context, { handoff: true, targetSurface }));
+    return;
+  }
+
+  process.stdout.write(formatSessionContextText(context, { targetSurface }));
+}
+
+function renderWorkControl(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantHandoff = forwardedArgs.includes("--handoff");
+  const doWrite = forwardedArgs.includes("--write") || true;
+
+  const {
+    buildWorkControlReceipt,
+    writeWorkControlReceipt,
+    buildWorkControlSurface,
+    formatWorkControlText,
+  } = require("./work-control-receipts");
+
+  const receipt = buildWorkControlReceipt(cwd, {
+    surface: "avorelo_cli",
+  });
+
+  if (doWrite) {
+    writeWorkControlReceipt(cwd, receipt, {
+      plan: process.env.AVORELO_PLAN || "free",
+    });
+  }
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+    return;
+  }
+
+  if (wantHandoff) {
+    process.stdout.write(formatWorkControlText(receipt, { handoff: true }));
+    return;
+  }
+
+  process.stdout.write(formatWorkControlText(receipt));
+}
+
+function renderIntake(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const typeFilter = readFlagValue(forwardedArgs, "--type");
+  const { scanInstallIntakeRisk } = require("./install-intake-risk");
+  const result = scanInstallIntakeRisk(cwd, {
+    writeReceipt: true,
+    plan: process.env.AVORELO_PLAN || "free",
+    generatedBy: "public_cli_intake",
+  });
+  const filteredItems = typeFilter
+    ? (result.receipt.items || []).filter((item) => item.type === typeFilter)
+    : (result.receipt.items || []);
+  const payload = {
+    contract: result.receipt.contract,
+    summary: {
+      ...result.receipt.summary,
+      filteredItems: filteredItems.length,
+    },
+    topRiskyItems: filteredItems
+      .filter((item) => ["high", "critical"].includes(item.riskLevel) || ["unknown", "deferred", "blocked"].includes(item.reviewStatus))
+      .slice(0, 8)
+      .map((item) => ({
+        id: item.id,
+        type: item.type,
+        name: item.name,
+        reviewStatus: item.reviewStatus,
+        riskLevel: item.riskLevel,
+        reasonCodes: item.reasonCodes.slice(0, 5),
+        safeNextAction: item.safeNextAction,
+      })),
+    topReasonCodes: result.receipt.topReasonCodes.slice(0, 8),
+    safeNextActions: filteredItems
+      .map((item) => item.safeNextAction)
+      .filter(Boolean)
+      .filter((value, index, array) => array.indexOf(value) === index)
+      .slice(0, 5),
+    receiptPath: result.receiptPath,
+    redacted: true,
+  };
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(
+    [
+      "Install Intake",
+      `Items: ${payload.summary.totalItems} total · ${payload.summary.unknownItems} unknown · ${payload.summary.deferredItems} deferred · ${payload.summary.blockedItems} blocked · ${payload.summary.highRiskItems} high · ${payload.summary.criticalRiskItems} critical`,
+      `Top reason codes: ${payload.topReasonCodes.join(", ") || "none"}`,
+      `Next: ${result.receipt.nextAction}`,
+      `Receipt: ${result.receiptPath}`,
+    ].join("\n") + "\n"
+  );
+}
+
+function renderOperatingValue(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantSummary = forwardedArgs.includes("--summary");
+  const wantMoments = forwardedArgs.includes("--moments");
+  const wantValidate = forwardedArgs.includes("--validate");
+
+  const {
+    buildOperatingValue,
+    writeOperatingValue,
+    formatOperatingValueText,
+    buildOperatingValueSummaryMarkdown,
+    OPERATING_VALUE_LATEST_REL,
+    OPERATING_VALUE_SUMMARY_REL,
+    OPERATING_VALUE_DASHBOARD_PREVIEW_REL,
+  } = require("./operating-value");
+
+  const value = buildOperatingValue(cwd);
+  writeOperatingValue(cwd, value);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    return;
+  }
+
+  if (wantSummary) {
+    process.stdout.write(buildOperatingValueSummaryMarkdown(value) + "\n");
+    return;
+  }
+
+  if (wantMoments) {
+    process.stdout.write(formatOperatingValueText(value, { momentsOnly: true }) + "\n");
+    return;
+  }
+
+  if (wantValidate) {
+    process.stdout.write(formatOperatingValueText(value, { validateOnly: true }) + "\n");
+    return;
+  }
+
+  process.stdout.write(formatOperatingValueText(value) + "\n");
+}
+
+// ── Measurement Evidence CLI ───────────────────────────────────────────────────
+
+function renderPricing(cwd, forwardedArgs = []) {
+  const {
+    initLocalPricing,
+    validateLocalPricing,
+    readLocalPricing,
+    getLocalPricingSource,
+    formatPricingText,
+  } = require("./local-pricing");
+
+  const wantJson = forwardedArgs.includes("--json");
+  const wantInit = forwardedArgs.includes("--init");
+  const wantValidate = forwardedArgs.includes("--validate");
+
+  if (wantInit) {
+    const result = initLocalPricing(cwd);
+    process.stdout.write(wantJson
+      ? `${JSON.stringify(result, null, 2)}\n`
+      : `${result.message}\n  Path: ${result.path}\n`);
+    return;
+  }
+
+  if (wantValidate) {
+    const config = readLocalPricing(cwd);
+    if (!config) {
+      process.stderr.write("No local pricing config found. Run `avorelo pricing --init` first.\n");
+      process.exit(1);
+    }
+    const result = validateLocalPricing(config);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+    if (result.valid) {
+      process.stdout.write(`Local pricing config is valid. (${config.entries.length} entries)\n`);
+    } else {
+      process.stderr.write(`Local pricing config has errors:\n${result.errors.map((e) => `  - ${e}`).join("\n")}\n`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (wantJson) {
+    const source = getLocalPricingSource(cwd);
+    const config = readLocalPricing(cwd);
+    process.stdout.write(`${JSON.stringify({ source, config }, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatPricingText(cwd));
+}
+
+function renderTokenEvidence(cwd, forwardedArgs = []) {
+  const {
+    buildTokenEvidence,
+    writeTokenEvidence,
+    formatTokenEvidenceText,
+    formatTokenEvidenceDebugSources,
+  } = require("./token-evidence");
+
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebugSources = forwardedArgs.includes("--debug-sources");
+
+  const evidence = buildTokenEvidence(cwd);
+  writeTokenEvidence(cwd, evidence);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(evidence, null, 2)}\n`);
+    return;
+  }
+
+  if (wantDebugSources) {
+    process.stdout.write(formatTokenEvidenceDebugSources(evidence));
+    return;
+  }
+
+  process.stdout.write(formatTokenEvidenceText(evidence));
+}
+
+function renderSessionTiming(cwd, forwardedArgs = []) {
+  const {
+    buildSessionTimingSummary,
+    writeSessionTiming,
+    recordTimingEvent,
+    formatSessionTimingText,
+  } = require("./session-timing");
+
+  const wantJson = forwardedArgs.includes("--json");
+  const wantSummary = forwardedArgs.includes("--summary");
+  const markIdx = forwardedArgs.indexOf("--mark");
+  const markEvent = markIdx >= 0 ? (forwardedArgs[markIdx + 1] || "first-useful-action") : null;
+
+  if (markEvent) {
+    const eventName = markEvent.replace(/-/g, "_");
+    const entry = recordTimingEvent(cwd, eventName);
+    process.stdout.write(wantJson
+      ? `${JSON.stringify(entry, null, 2)}\n`
+      : `Timing event recorded: ${eventName} at ${entry.timestamp}\n`);
+    return;
+  }
+
+  const timing = buildSessionTimingSummary(cwd);
+  writeSessionTiming(cwd, timing);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(timing, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatSessionTimingText(timing));
+}
+
+function renderContextPack(cwd, forwardedArgs = []) {
+  const {
+    buildAndWriteContextPack,
+    buildContextOptimizerSurface,
+    STAGE_BUDGETS,
+  } = require("./context-optimizer");
+
+  const wantJson = forwardedArgs.includes("--json");
+  const taskText = forwardedArgs.filter((a) => !a.startsWith("--")).join(" ").trim();
+  const stageArg = forwardedArgs.find((a) => a.startsWith("--stage="));
+  const stageId = stageArg ? stageArg.split("=")[1] : "implement";
+  const workerArg = forwardedArgs.find((a) => a.startsWith("--worker="));
+  const worker = workerArg ? workerArg.split("=")[1] : null;
+
+  if (!taskText) {
+    if (wantJson) {
+      const surface = buildContextOptimizerSurface(cwd);
+      process.stdout.write(`${JSON.stringify(surface, null, 2)}\n`);
+      return;
+    }
+    const surface = buildContextOptimizerSurface(cwd);
+    process.stdout.write([
+      "Context Optimization",
+      `Status: ${surface.status || "not_run"}`,
+      surface.stageId ? `Stage: ${surface.stageId} · Budget: ${surface.budgetClass} · ~${surface.lastEstimatedTokens || 0} tokens` : "",
+      surface.budgetWarning ? `Budget warning: ${surface.budgetWarning}` : "",
+      surface.latestContextPackPath ? `Pack: ${surface.latestContextPackPath}` : "",
+      `Next: ${surface.nextAction}`,
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  const result = buildAndWriteContextPack(cwd, {
+    taskSummary: taskText,
+    stageId,
+    stageRole: stageId,
+    selectedWorker: worker,
+  });
+
+  const payload = {
+    contract: result.pack.contract,
+    contextPackId: result.pack.contextPackId,
+    taskSummary: result.pack.taskSummary,
+    stageId: result.pack.stageId,
+    budgetClass: result.pack.targetBudget.budgetClass,
+    tokenEstimate: result.pack.tokenEstimate.estimatedTokens,
+    maxInputTokens: result.pack.tokenEstimate.maxInputTokens,
+    budgetWarning: result.pack.tokenEstimate.warning,
+    includedCount: result.pack.includedContext.length,
+    excludedCount: result.pack.excludedContext.length,
+    compactionUsed: result.pack.reductionSummary.compactionUsed,
+    localWorkerCapped: result.pack.localWorkerCapped,
+    contextPackPath: result.latestPackPath,
+    receiptPath: result.latestReceiptPath,
+    nextAction: result.pack.nextAction,
+  };
+
+  // Auto-write value summary after context pack build (best-effort)
+  const { writeSeamlessRunReceipt: writeCtxReceipt, formatCompactContextLine } = require("./seamless-enforcement");
+  const { getDecisionVisibility: getCtxVisibility } = require("./seamless-enforcement");
+  const ctxVisibility = getCtxVisibility({ actionType: "context_optimization", riskLevel: "low" });
+  writeCtxReceipt(cwd, {
+    command: "context",
+    manualDecisionsAvoided: 1,
+    userInterruptAvoided: !ctxVisibility.interruptRequired,
+  });
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return;
+  }
+
+  // Compact outcome line for automatic mode
+  if (!ctxVisibility.showDetail) {
+    process.stdout.write(formatCompactContextLine(result.pack) + "\n");
+    return;
+  }
+
+  process.stdout.write([
+    "Context Pack",
+    `ID: ${payload.contextPackId}`,
+    `Stage: ${payload.stageId} · Budget: ${payload.budgetClass} · ~${payload.tokenEstimate} / ${payload.maxInputTokens} tokens`,
+    `Warning: ${payload.budgetWarning}`,
+    `Included: ${payload.includedCount} · Excluded: ${payload.excludedCount} · Compacted: ${payload.compactionUsed}`,
+    `Local worker capped: ${payload.localWorkerCapped}`,
+    `Pack: ${payload.contextPackPath}`,
+    `Receipt: ${payload.receiptPath}`,
+    payload.nextAction ? `Next: ${payload.nextAction}` : "",
+  ].filter(Boolean).join("\n") + "\n");
+}
+
+function renderCostEvidence(cwd, forwardedArgs = []) {
+  const { getLocalPricingSource, getLocalPricingEntry } = require("./local-pricing");
+  const { buildTokenEvidence, writeTokenEvidence } = require("./token-evidence");
+  const { buildCostEvidenceV1 } = require("./cost-evidence");
+
+  const wantJson = forwardedArgs.includes("--json");
+
+  const pricingSource = getLocalPricingSource(cwd);
+  const pricingEntry = pricingSource.available
+    ? getLocalPricingEntry(cwd, "anthropic", "claude-sonnet-4-6")
+    : null;
+  const tokenEvidence = buildTokenEvidence(cwd);
+  writeTokenEvidence(cwd, tokenEvidence);
+  const costEvidence = buildCostEvidenceV1({ pricingSource, pricingEntry, tokenEvidence });
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(costEvidence, null, 2)}\n`);
+    return;
+  }
+
+  const lines = [
+    "Avorelo Cost Evidence",
+    "",
+    `  Contract:    ${costEvidence.contract}`,
+    `  Confidence:  ${costEvidence.confidence}`,
+    `  Value class: ${costEvidence.valueClass}`,
+    "",
+    costEvidence.costAvoidedEstimate !== null
+      ? `  Estimated cost impact: ~$${costEvidence.costAvoidedEstimate.toFixed(4)}`
+      : "  Cost estimate: unavailable",
+    costEvidence.formula ? `  Formula:       ${costEvidence.formula}` : null,
+    costEvidence.pricingSource ? `  Pricing source: ${costEvidence.pricingSource}` : null,
+    "",
+    "  Caveats:",
+    ...(costEvidence.caveats || []).map((c) => `    - ${c}`),
+    "",
+    `  pricingAllowed: ${costEvidence.pricingAllowed}`,
+    `  dashboardAllowed: ${costEvidence.dashboardAllowed}`,
+    `  websiteAllowed: ${costEvidence.websiteAllowed}`,
+    "",
+  ].filter((l) => l !== null);
+  process.stdout.write(lines.join("\n"));
+}
+
+function renderLaunchReadiness(cwd, forwardedArgs = []) {
+  const {
+    buildLaunchReadiness,
+    formatLaunchReadinessText,
+  } = require("./launch-readiness");
+
+  const wantJson = forwardedArgs.includes("--json");
+  const externalCwdArg = forwardedArgs.find((a) => a.startsWith("--external-cwd="));
+  const externalCwd = externalCwdArg ? externalCwdArg.split("=")[1] : null;
+
+  const result = buildLaunchReadiness(REPO_ROOT, {
+    runExternalDogfood: !!externalCwd,
+    externalCwd,
+  });
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`${formatLaunchReadinessText(result)}\n`);
+}
+
+function renderOutcome(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantGate = forwardedArgs.includes("--gate") || forwardedArgs.includes("--reality-gate");
+  const wantSummary = forwardedArgs.includes("--summary");
+  const doWrite = !forwardedArgs.includes("--no-write");
+
+  const { buildValueSummaryFromReceipts, buildSeamlessOutcomeSurface, readLatestValueSummary } = require("./seamless-outcome");
+  const { runSeamlessRealityGate, writeGateReport, buildRealityGateSurface } = require("./seamless-reality-gate");
+
+  if (wantGate) {
+    const report = runSeamlessRealityGate(cwd);
+    if (doWrite) writeGateReport(cwd, report);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      `Seamless Reality Gate: ${report.status.toUpperCase()} (score: ${report.score}/100)`,
+      `Checks: ${report.summary.pass} pass · ${report.summary.warn} warn · ${report.summary.fail} fail · ${report.summary.skip} skip`,
+      ...(report.gaps || []).map((g) => `  [${g.status}] ${g.id}: ${g.nextAction || ""}`),
+      report.gaps?.length === 0 ? "  All checks pass." : "",
+      `Report: ${report.contract}`,
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  // Build value summary from receipts
+  const { summary, path: summaryPath } = buildValueSummaryFromReceipts(cwd);
+
+  // Also run the reality gate and write report
+  const gateReport = runSeamlessRealityGate(cwd);
+  if (doWrite) writeGateReport(cwd, gateReport);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify({
+      ...summary,
+      realityGate: {
+        status: gateReport.status,
+        score: gateReport.score,
+        warnings: gateReport.summary?.warn || 0,
+        failures: gateReport.summary?.fail || 0,
+      },
+      summaryPath,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  if (wantSummary) {
+    const s = summary;
+    process.stdout.write([
+      `Seamless Outcome Summary`,
+      `Mode: ${s.mode}`,
+      `Status: ${s.completed?.status}`,
+      `Completed: ${s.completed?.completedItems} stages`,
+      `Saved (estimated): ${s.saved?.estimatedPremiumCallsAvoided} premium calls avoided · ${s.saved?.estimatedContextTokensAvoided} context tokens avoided`,
+      `Protected: ${s.protected?.unsafeActionsBlocked} blocked · ${s.protected?.unknownToolsIsolated} isolated`,
+      `Quality preserved: ${s.quality?.qualityPreserved}`,
+      `Reality gate: ${gateReport.status} (score: ${gateReport.score})`,
+      `Next: ${s.completed?.nextAction || "Run avorelo route to continue."}`,
+      `Caveats: ${s.caveats?.join("; ")}`,
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  // Default: compact human-readable
+  const s = summary;
+  process.stdout.write([
+    `Seamless Outcome  [${s.mode}]`,
+    `  Completed: ${s.completed?.completedItems} stages · ${s.completed?.status}`,
+    `  Saved (est.): ${s.saved?.estimatedPremiumCallsAvoided} premium calls avoided, ~${s.saved?.estimatedContextTokensAvoided} context tokens`,
+    `  Protected: ${s.protected?.unsafeActionsBlocked} blocked, ${s.protected?.unknownToolsIsolated} isolated`,
+    `  Quality preserved: ${s.quality?.qualityPreserved} · risk introduced: ${s.quality?.qualityRiskIntroduced}`,
+    `  Reality gate: ${gateReport.status} (${gateReport.score}/100)`,
+    `  Next: ${s.completed?.nextAction || "Run avorelo route to continue."}`,
+    `  Note: ${s.caveats?.[0]}`,
+  ].join("\n") + "\n");
+}
+
+function renderOrchestrate(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const taskText = forwardedArgs.filter((a) => !a.startsWith("--")).join(" ").trim();
+
+  const {
+    runWorkOrchestration,
+    buildWorkOrchestrationSurface,
+    formatWorkOrchestrationText,
+  } = require("./work-aware-orchestration");
+
+  if (!taskText) {
+    const surface = buildWorkOrchestrationSurface(cwd);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(surface, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      "Work-Aware Orchestration",
+      `Status: ${surface.status}`,
+      surface.stageCount ? `Stages: ${surface.stageCount} (${surface.localOrCheapStages} local/cheap, ${surface.strongWorkerStages} strong)` : "",
+      surface.nextAction ? `Next: ${surface.nextAction}` : "",
+      "",
+      `Run: avorelo orchestrate "your task description" to build a work plan.`,
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  const plan = runWorkOrchestration(cwd, taskText, { debug: wantDebug });
+
+  if (wantJson) {
+    const safe = {
+      contract: plan.contract,
+      schemaVersion: plan.schemaVersion,
+      createdAt: plan.createdAt,
+      mode: plan.mode,
+      task: plan.task,
+      stages: plan.stages.map((s) => ({
+        stageId: s.stageId,
+        objective: s.objective,
+        lifecycleStage: s.lifecycleStage,
+        riskLevel: s.riskLevel,
+        contextNeed: s.contextNeed,
+        qualityRequirement: s.qualityRequirement,
+        recommendedWorker: s.recommendedWorker,
+        fallbackWorker: s.fallbackWorker,
+        workerSelection: s.workerSelection,
+        contextSelection: s.contextSelection,
+        continuation: s.continuation,
+        proofExpected: s.proofExpected,
+        customerVisible: s.customerVisible,
+        debugVisible: s.debugVisible,
+        redacted: true,
+      })),
+      summary: plan.summary,
+      valueEvidence: plan.valueEvidence,
+      nextAction: plan.nextAction,
+      receipts: plan.receipts,
+      redacted: true,
+    };
+    process.stdout.write(`${JSON.stringify(safe, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatWorkOrchestrationText(plan, { debug: wantDebug }) + "\n");
+}
+
+function renderLedger(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildWorkLedger,
+    writeWorkLedger,
+    formatWorkLedgerText,
+    LATEST_LEDGER_REL,
+  } = require("./work-ledger");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const ledger = buildWorkLedger(cwd);
+  writeWorkLedger(cwd, ledger);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "work_ledger_built",
+      category: "work_ledger",
+      surface: "local",
+      status: "observed",
+      payload: {
+        status: ledger.status,
+        entryCount: (ledger.entries || []).length,
+        frictionCount: (ledger.rollup?.friction || []).length,
+        receiptPathCount: (ledger.evidence?.receiptPaths || []).length,
+      },
+    });
+  } catch {
+    // non-blocking
+  }
+
+  if (wantJson) {
+    const safe = wantDebug
+      ? ledger
+      : {
+          contract: ledger.contract,
+          schemaVersion: ledger.schemaVersion,
+          runId: ledger.runId,
+          status: ledger.status,
+          createdAt: ledger.createdAt,
+          rollup: ledger.rollup,
+          evidence: {
+            receiptPaths: ledger.evidence.receiptPaths,
+            feedbackPaths: ledger.evidence.feedbackPaths,
+          },
+          caveats: ledger.caveats,
+          redacted: true,
+        };
+    process.stdout.write(`${JSON.stringify(safe, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatWorkLedgerText(ledger, { debug: wantDebug }) + "\n");
+}
+
+function renderCompanyLoop(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildCompanyLoop,
+    writeCompanyLoopReport,
+    formatCompanyLoopText,
+  } = require("./company-loop");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const report = buildCompanyLoop(cwd);
+  writeCompanyLoopReport(cwd, report);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "company_loop_report_generated",
+      category: "company_loop",
+      surface: "local",
+      status: "observed",
+      payload: {
+        status: report.status,
+        personaWarnCount: report.surface?.personaWarnCount || 0,
+        frictionClusterCount: (report.frictionClusters || []).length,
+        topFriction: report.surface?.topFriction || null,
+        confidence: report.nextPrRecommendation?.confidence || "low",
+      },
+    });
+  } catch {
+    // non-blocking
+  }
+
+  if (wantJson) {
+    const safe = wantDebug
+      ? report
+      : {
+          contract: report.contract,
+          schemaVersion: report.schemaVersion,
+          createdAt: report.createdAt,
+          status: report.status,
+          surface: report.surface,
+          frictionClusters: (report.frictionClusters || []).map((c) => ({
+            clusterId: c.clusterId,
+            type: c.type,
+            severity: c.severity,
+            count: c.count,
+            recommendedFix: c.recommendedFix,
+            candidateRoadmapItem: c.candidateRoadmapItem,
+          })),
+          cogsRollup: report.cogsRollup,
+          nextPrRecommendation: report.nextPrRecommendation,
+          redacted: true,
+        };
+    process.stdout.write(`${JSON.stringify(safe, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatCompanyLoopText(report, { debug: wantDebug }) + "\n");
+}
+
+function renderProjectProfile(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildProjectProfile,
+    writeProjectProfile,
+    formatProjectProfileText,
+  } = require("./project-profile");
+
+  const profile = buildProjectProfile(cwd);
+  writeProjectProfile(cwd, profile);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(profile, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatProjectProfileText(profile, { debug: wantDebug }));
+}
+
+function renderExecutionPacket(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const taskArgs = forwardedArgs.filter((a) => !a.startsWith("--"));
+  const task = taskArgs.join(" ").trim();
+
+  const {
+    compileExecutionPacket,
+    compileAgentPrompt,
+    writeExecutionPacket,
+    formatExecutionPacketText,
+  } = require("./execution-packet");
+
+  const packet = compileExecutionPacket(cwd, { userIntent: task });
+  writeExecutionPacket(cwd, packet);
+
+  if (wantJson) {
+    if (wantDebug) {
+      const prompt = compileAgentPrompt(packet, { target: "claude_code" });
+      process.stdout.write(`${JSON.stringify({ ...packet, compiledAgentPrompt: prompt.promptText }, null, 2)}\n`);
+    } else {
+      process.stdout.write(`${JSON.stringify(packet, null, 2)}\n`);
+    }
+    return;
+  }
+
+  if (wantDebug) {
+    const prompt = compileAgentPrompt(packet, { target: "claude_code" });
+    process.stdout.write(formatExecutionPacketText(packet, { debug: true }));
+    process.stdout.write("\n--- Compiled Agent Prompt ---\n");
+    process.stdout.write(prompt.promptText + "\n");
+    return;
+  }
+
+  process.stdout.write(formatExecutionPacketText(packet));
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "agent_prompt_compiled",
+      category: "execution_packet",
+      surface: "local",
+      status: "observed",
+      payload: {
+        packetId: packet.packetId,
+        mode: packet.mode,
+        riskLevel: packet.risk?.level || "unknown",
+        debugRequested: wantDebug,
+      },
+    });
+  } catch {}
+}
+
+function renderWorkPanel(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const taskArgs = forwardedArgs.filter((a) => !a.startsWith("--"));
+  const task = taskArgs.join(" ").trim();
+
+  // If a task is provided, compile a packet first
+  if (task) {
+    const {
+      compileExecutionPacket,
+      writeExecutionPacket,
+    } = require("./execution-packet");
+    const packet = compileExecutionPacket(cwd, { userIntent: task });
+    writeExecutionPacket(cwd, packet);
+  }
+
+  const {
+    buildWorkPanelPreview,
+    writeWorkPanelPreview,
+    formatWorkPanelText,
+  } = require("./work-panel-preview");
+
+  const preview = buildWorkPanelPreview(cwd);
+  writeWorkPanelPreview(cwd, preview);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(preview, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatWorkPanelText(preview, { debug: wantDebug }));
+}
+
+function renderSmartRoute(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const taskArgs = forwardedArgs.filter((a) => !a.startsWith("--"));
+  const taskText = taskArgs.join(" ").trim();
+
+  const {
+    buildSmartWorkRoute,
+    writeSmartWorkRouteReceipt,
+    writeWorkerHandoffReceipt,
+    buildSmartRouteSurface,
+    formatSmartRouteText,
+  } = require("./smart-work-routing");
+
+  if (!taskText) {
+    const surface = buildSmartRouteSurface(cwd);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(surface, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      "Smart Work Routing",
+      `Status: ${surface.status}`,
+      surface.nextAction ? `Next: ${surface.nextAction}` : "",
+      "",
+      `Run: avorelo smart-route "your task" to route work to the cheapest safe capable path.`,
+    ].filter(Boolean).join("\n") + "\n");
+    return;
+  }
+
+  const route = buildSmartWorkRoute(cwd, taskText, { debug: wantDebug });
+  writeSmartWorkRouteReceipt(cwd, route);
+
+  if (route.workerHandoff) {
+    writeWorkerHandoffReceipt(cwd, route.workerHandoff);
+  }
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "smart_work_route_built",
+      category: "smart_work_routing",
+      surface: "local",
+      status: "observed",
+      payload: {
+        routingId: route.routingId,
+        decision: route.decision,
+        pathType: route.executionPath && route.executionPath.pathType,
+        taskType: route.task && route.task.taskType,
+        riskLevel: route.task && route.task.riskLevel,
+        sameSurfacePreferred: route.executionPath && route.executionPath.sameSurfacePreferred,
+        crossVendorAllowed: route.executionPath && route.executionPath.crossVendorAllowed,
+        proofRequired: route.executionPath && route.executionPath.proofRequired,
+        acpNeeded: route.protocolReadiness && route.protocolReadiness.acp && route.protocolReadiness.acp.neededNow,
+        a2aNeeded: route.protocolReadiness && route.protocolReadiness.a2a && route.protocolReadiness.a2a.neededNow,
+      },
+    });
+    appendProductLearningEvent(cwd, {
+      eventName: "smart_route_execution_path_selected",
+      category: "smart_work_routing",
+      surface: "local",
+      status: "observed",
+      payload: {
+        pathType: route.executionPath && route.executionPath.pathType,
+        selectedWorker: route.executionPath && route.executionPath.selectedWorker,
+        reasonCodes: route.executionPath && route.executionPath.reasonCodes,
+      },
+    });
+    if (route.workerHandoff) {
+      appendProductLearningEvent(cwd, {
+        eventName: "worker_handoff_prepared",
+        category: "smart_work_routing",
+        surface: "local",
+        status: "observed",
+        payload: {
+          handoffId: route.workerHandoff.handoffId,
+          targetWorker: route.workerHandoff.targetWorker,
+          sameSurfacePreferred: route.workerHandoff.sameSurfacePreferred,
+          proofRequired: route.workerHandoff.proofRequired,
+        },
+      });
+    }
+    appendProductLearningEvent(cwd, {
+      eventName: "protocol_readiness_evaluated",
+      category: "smart_work_routing",
+      surface: "local",
+      status: "observed",
+      payload: {
+        acpNeeded: route.protocolReadiness && route.protocolReadiness.acp && route.protocolReadiness.acp.neededNow,
+        a2aNeeded: route.protocolReadiness && route.protocolReadiness.a2a && route.protocolReadiness.a2a.neededNow,
+        acpAdapterReady: false,
+        a2aAdapterReady: false,
+      },
+    });
+    if (route.executionPath && route.executionPath.sameSurfacePreferred) {
+      appendProductLearningEvent(cwd, {
+        eventName: "same_surface_preferred",
+        category: "smart_work_routing",
+        surface: "local",
+        status: "observed",
+        payload: { pathType: route.executionPath.pathType },
+      });
+    }
+    if (route.executionPath && !route.executionPath.crossVendorAllowed) {
+      appendProductLearningEvent(cwd, {
+        eventName: "cross_vendor_blocked_by_default",
+        category: "smart_work_routing",
+        surface: "local",
+        status: "observed",
+        payload: { decision: route.decision },
+      });
+    }
+    if (route.decision === "blocked" || route.decision === "approval_required") {
+      appendProductLearningEvent(cwd, {
+        eventName: "remote_agent_delegation_blocked",
+        category: "smart_work_routing",
+        surface: "local",
+        status: "observed",
+        payload: { decision: route.decision, interruptReason: route.executionPath && route.executionPath.interruptReason },
+      });
+    }
+    appendProductLearningEvent(cwd, {
+      eventName: "smart_route_receipt_written",
+      category: "smart_work_routing",
+      surface: "local",
+      status: "observed",
+      payload: { routingId: route.routingId },
+    });
+  } catch {
+    // non-blocking
+  }
+
+  if (wantJson) {
+    const safe = {
+      contract: route.contract,
+      schemaVersion: route.schemaVersion,
+      routingId: route.routingId,
+      task: route.task,
+      mode: route.mode,
+      decision: route.decision,
+      executionPath: route.executionPath,
+      stages: route.stages,
+      context: route.context,
+      safety: route.safety,
+      protocolReadiness: route.protocolReadiness,
+      workerHandoff: route.workerHandoff
+        ? {
+            contract: route.workerHandoff.contract,
+            handoffId: route.workerHandoff.handoffId,
+            targetWorker: route.workerHandoff.targetWorker,
+            targetSurface: route.workerHandoff.targetSurface,
+            sameSurfacePreferred: route.workerHandoff.sameSurfacePreferred,
+            taskGoal: route.workerHandoff.taskGoal,
+            executionPacketRef: route.workerHandoff.executionPacketRef,
+            allowedScopeSummary: route.workerHandoff.allowedScopeSummary,
+            blockedScopeSummary: route.workerHandoff.blockedScopeSummary,
+            proofRequired: route.workerHandoff.proofRequired,
+            safeNextAction: route.workerHandoff.safeNextAction,
+            continuation: route.workerHandoff.continuation,
+            outputExpectations: route.workerHandoff.outputExpectations,
+            redacted: true,
+          }
+        : null,
+      proof: route.proof,
+      valueEvidence: route.valueEvidence,
+      receipts: route.receipts,
+      redacted: true,
+    };
+    process.stdout.write(`${JSON.stringify(safe, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(formatSmartRouteText(route, { debug: wantDebug }) + "\n");
+}
+
+function resolveWorkspaceOrExit(commandLabel) {
+  const resolution = resolveWorkspace({
+    cwd: process.cwd(),
+    env: process.env,
+    cliName: CLI_NAME,
+  });
+  if (!resolution.ok) {
+    process.stderr.write(`[${CLI_NAME}] ${resolution.message}\n`);
+    process.exit(1);
+  }
+  return resolution.workspace;
+}
+
+function renderWorkspace(forwardedArgs = []) {
+  const [subcommand = "show", ...subrest] = forwardedArgs;
+  const wantJson = forwardedArgs.includes("--json");
+
+  if (subcommand === "show") {
+    const result = resolveWorkspace({
+      cwd: process.cwd(),
+      env: process.env,
+      cliName: CLI_NAME,
+    });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatWorkspaceShowText(result)}\n`);
+    return;
+  }
+
+  if (subcommand === "set") {
+    const targetPath = subrest.filter((arg) => arg !== "--json").join(" ").trim();
+    if (!targetPath) {
+      process.stderr.write(`[${CLI_NAME}] Usage: ${CLI_NAME} workspace set <path>\n`);
+      process.exit(1);
+    }
+    const result = registerWorkspace(targetPath, { env: process.env });
+    if (!result.ok) {
+      process.stderr.write(`[${CLI_NAME}] ${result.message}\n`);
+      process.exit(1);
+    }
+    const payload = {
+      ok: true,
+      workspace: result.workspace,
+      configPath: result.configPath,
+      knownWorkspaces: result.config.knownWorkspaces,
+      lastWorkspace: result.config.lastWorkspace,
+    };
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(
+      [
+        "Avorelo Workspace",
+        `Workspace set: ${payload.workspace}`,
+        `User config: ${payload.configPath}`,
+        `Known workspaces: ${payload.knownWorkspaces.length}`,
+      ].join("\n") + "\n"
+    );
+    return;
+  }
+
+  if (subcommand === "clear") {
+    const result = clearLastWorkspace({ env: process.env });
+    const payload = {
+      ok: true,
+      configPath: result.configPath,
+      lastWorkspace: result.config.lastWorkspace,
+      knownWorkspaces: result.config.knownWorkspaces,
+    };
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(
+      [
+        "Avorelo Workspace",
+        "Cleared lastWorkspace.",
+        `Known workspaces retained: ${payload.knownWorkspaces.length}`,
+        `User config: ${payload.configPath}`,
+      ].join("\n") + "\n"
+    );
+    return;
+  }
+
+  if (subcommand === "doctor") {
+    const result = workspaceDoctor({
+      cwd: process.cwd(),
+      env: process.env,
+      cliName: CLI_NAME,
+      repoRoot: REPO_ROOT,
+    });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatWorkspaceDoctorText(result)}\n`);
+    return;
+  }
+
+  process.stderr.write(`[${CLI_NAME}] Unknown workspace command: ${subcommand}\n`);
+  process.exit(1);
+}
+
+// ── Hook Baseline / Lifecycle Automation Preview commands ─────────────────────
+
+function renderHooksCommand(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const wantDryRun = forwardedArgs.includes("--dry-run");
+  const wantYes = forwardedArgs.includes("--yes") || forwardedArgs.includes("--confirm");
+  const subcommand = forwardedArgs.find((a) => !a.startsWith("-"));
+
+  if (subcommand === "preview") {
+    const { buildHookConfigPreviewSurface, formatHookConfigPreviewText } = require("./hook-config-preview");
+    const { preview } = buildHookConfigPreviewSurface(cwd, { debug: wantDebug });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(preview, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatHookConfigPreviewText(preview, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  if (subcommand === "apply") {
+    const {
+      buildHookApplyPlan,
+      applyHookConfig,
+      formatHookApplyText,
+    } = require("./hook-apply");
+    const options = { dryRun: wantDryRun || !wantYes, yes: wantYes, confirm: wantYes, debug: wantDebug };
+    const plan = buildHookApplyPlan(cwd, options);
+    if (wantDryRun || (!wantYes && !wantDebug)) {
+      // Dry-run or no explicit approval: show plan only
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+        return;
+      }
+      process.stdout.write(`${formatHookApplyText(plan, { debug: wantDebug })}\n`);
+      return;
+    }
+    // Explicit apply
+    const receipt = applyHookConfig(cwd, plan, options);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatHookApplyText(receipt, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  if (subcommand === "rollback") {
+    const { rollbackHookApply, formatHookApplyText } = require("./hook-apply");
+    const receipt = rollbackHookApply(cwd, { debug: wantDebug });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatHookApplyText(receipt, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  if (subcommand === "uninstall") {
+    const { uninstallAvoreloHooks, formatHookApplyText } = require("./hook-apply");
+    const options = { yes: wantYes, confirm: wantYes, debug: wantDebug };
+    const receipt = uninstallAvoreloHooks(cwd, options);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatHookApplyText(receipt, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  if (subcommand === "doctor") {
+    const { runHookDoctor, formatHookDoctorText } = require("./hook-apply");
+    const receipt = runHookDoctor(cwd, { debug: wantDebug });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatHookDoctorText(receipt, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  const { buildHookBaselineSurface, formatHookBaselineText } = require("./hook-baseline");
+  const { baseline } = buildHookBaselineSurface(cwd, { debug: wantDebug });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(baseline, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatHookBaselineText(baseline, { debug: wantDebug })}\n`);
+}
+
+function renderAdapterReadinessCommand(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const { buildAdapterReadinessSurface, formatAdapterReadinessText } = require("./adapter-readiness");
+  const { readiness } = buildAdapterReadinessSurface(cwd, { debug: wantDebug });
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(readiness, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatAdapterReadinessText(readiness, { debug: wantDebug })}\n`);
+}
+
+function renderLifecycleHookCommand(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const { handleLifecycleHook, formatLifecycleHookText } = require("./lifecycle-hooks");
+
+  // First non-flag arg is the event
+  const event = forwardedArgs.find((a) => !a.startsWith("-"));
+  if (!event) {
+    const events = ["session-start", "user-prompt-submit", "pre-tool-use", "post-tool-use", "stop", "session-end"];
+    process.stderr.write(`[avorelo] lifecycle-hook requires an event. Valid events: ${events.join(", ")}\n`);
+    process.exit(1);
+  }
+
+  // Try to read JSON input from remaining args
+  let input = {};
+  const inputFlagIdx = forwardedArgs.indexOf("--input");
+  if (inputFlagIdx >= 0 && forwardedArgs[inputFlagIdx + 1]) {
+    try {
+      input = JSON.parse(forwardedArgs[inputFlagIdx + 1]);
+    } catch { /* ignore */ }
+  }
+
+  const result = handleLifecycleHook(cwd, event, input, { debug: wantDebug });
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    // Exit 1 if blocking hook blocked
+    if (result.blocking && result.decision === "block") {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  process.stdout.write(`${formatLifecycleHookText(result, { debug: wantDebug })}\n`);
+  if (result.blocking && result.decision === "block") {
+    process.exitCode = 1;
+  }
+}
+
+async function runVerify(inputFile) {
+  if (!inputFile) {
+    console.error(`[${CLI_NAME}] No input file provided`);
+    console.error(`Usage: ${CLI_NAME} verify <file>`);
+    process.exit(1);
+  }
+  if (!fs.existsSync(inputFile)) {
+    console.error(`[${CLI_NAME}] File not found: ${inputFile}`);
+    process.exit(1);
+  }
+  const input = fs.readFileSync(inputFile, "utf8");
+  const Verifier = require("../../src/verify/verifier.js").Verifier;
+  const verifier = new Verifier();
+  const result = await verifier.verify({
+    environment: "local",
+    executionMode: "safe_interaction",
+    depth: "standard",
+    input,
+    policyConfig: {},
+  });
+  console.log(JSON.stringify({
+    product: PRODUCT_NAME,
+    sessionId: getCanonicalSessionId(process.cwd()),
+    verdict: result.verdict,
+    policyOutcome: result.policyOutcome,
+    riskScore: result.riskScore,
+    executionTimeMs: result.executionTimeMs,
+    findings: result.findings,
+    evidencePath: result.evidencePath,
+  }, null, 2));
+  process.exit(result.verdict === "fail" || result.verdict === "error" ? 1 : 0);
+}
+
+function renderArtifactsCommand(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const wantYes = forwardedArgs.includes("--yes");
+  const subcommand = forwardedArgs.find((a) => !a.startsWith("-")) || "health";
+
+  const {
+    scanArtifactHealth,
+    writeArtifactHealthReceipt,
+    buildArtifactCleanupPlan,
+    applyArtifactCleanup,
+    writeArtifactCleanupReceipt,
+    formatArtifactHealthText,
+    formatArtifactCleanupText,
+  } = require("./artifact-health");
+
+  if (subcommand === "cleanup") {
+    const health = scanArtifactHealth(cwd, { debug: wantDebug });
+    const plan = buildArtifactCleanupPlan(cwd, health, { dryRun: !wantYes });
+    if (wantYes) {
+      const receipt = applyArtifactCleanup(cwd, plan, { yes: true, dryRun: false });
+      writeArtifactCleanupReceipt(cwd, receipt);
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+        return;
+      }
+      process.stdout.write(`${formatArtifactCleanupText(receipt, { debug: wantDebug })}\n`);
+      return;
+    }
+    // Default: dry-run plan
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`${formatArtifactCleanupText(plan, { debug: wantDebug })}\n`);
+    return;
+  }
+
+  // Default: health
+  const health = scanArtifactHealth(cwd, { debug: wantDebug });
+  writeArtifactHealthReceipt(cwd, health);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(health, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatArtifactHealthText(health, { debug: wantDebug })}\n`);
+}
+
+function renderLaunchHardening(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const {
+    runLaunchHardeningGate,
+    writeLaunchHardeningGate,
+    formatLaunchHardeningText,
+  } = require("./launch-hardening-gate");
+  const gate = runLaunchHardeningGate(cwd, {});
+  writeLaunchHardeningGate(cwd, gate);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(gate, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatLaunchHardeningText(gate)}\n`);
+}
+
+function renderInstallAi(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantPrompt = forwardedArgs.includes("--prompt");
+  const wantDryRun = forwardedArgs.includes("--dry-run");
+  const {
+    buildAiInstallPrompt,
+    writeAiInstallPromptReceipt,
+    formatAiInstallPromptText,
+  } = require("./ai-install-prompt");
+  const receipt = buildAiInstallPrompt(cwd, {});
+  if (!wantDryRun) {
+    writeAiInstallPromptReceipt(cwd, receipt);
+  }
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+    return;
+  }
+  if (wantPrompt) {
+    process.stdout.write(`${receipt.promptText}\n`);
+    return;
+  }
+  process.stdout.write(`${formatAiInstallPromptText(receipt)}\n`);
+}
+
+function renderPrelaunchReadiness(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const {
+    runPrelaunchActivationReadiness,
+    writePrelaunchActivationReadiness,
+    formatPrelaunchActivationText,
+  } = require("./prelaunch-activation-readiness");
+  const gate = runPrelaunchActivationReadiness(cwd, { debug: wantDebug });
+  writePrelaunchActivationReadiness(cwd, gate);
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(gate, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(`${formatPrelaunchActivationText(gate, { debug: wantDebug })}\n`);
+}
+
+function renderFirstValueCheck(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const {
+    runPrelaunchActivationReadiness,
+    buildFirstValueJourney,
+  } = require("./prelaunch-activation-readiness");
+  const gate = runPrelaunchActivationReadiness(cwd, {});
+  const journey = buildFirstValueJourney(cwd, {});
+  const result = {
+    contract: "avorelo.firstValueCheck.v1",
+    status: gate.status,
+    score: gate.score,
+    firstValueJourney: journey,
+    nextAction: gate.nextAction,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+  const lines = [
+    `First-Value Check: ${result.status}`,
+    ``,
+    `Journey steps:`,
+    ...journey.steps.map((s) => `  ${s.step}. ${s.label}`),
+    `    Command: ${s => s.command}`,
+    ``,
+    `Next: ${result.nextAction}`,
+    ``,
+    `Note: Pre-launch activation readiness only. Not a public launch claim.`,
+  ];
+  // rebuild cleanly
+  const textLines = [
+    `First-Value Check: ${result.status}`,
+    ``,
+    `Journey steps:`,
+    ...journey.steps.map((s) => `  ${s.step}. ${s.label}`),
+    ``,
+    `Next: ${result.nextAction}`,
+    ``,
+    `Note: Pre-launch activation readiness only. Not a public launch claim.`,
+  ];
+  process.stdout.write(`${textLines.join("\n")}\n`);
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+
+  if (!command || command === "--help" || command === "help") {
+    printHelp();
+    return;
+  }
+
+  if (command === "status") {
+    if (rest.includes("--help")) {
+      printStatusHelp();
+      return;
+    }
+    renderStatus(resolveWorkspaceOrExit("status"), rest.length ? rest : ["--text"]);
+    return;
+  }
+
+  if (command === "route") {
+    process.stdout.write(`${renderRouteCommand(resolveWorkspaceOrExit("route"), rest)}\n`);
+    return;
+  }
+
+  if (command === "run" || command === "execute") {
+    process.stdout.write(`${renderRunCommand(resolveWorkspaceOrExit("run"), rest)}\n`);
+    return;
+  }
+
+  if (command === "models") {
+    process.stdout.write(`${renderModelsCommand(resolveWorkspaceOrExit("models"), rest)}\n`);
+    return;
+  }
+
+  if (command === "dashboard") {
+    if (rest.includes("--help")) {
+      printDashboardHelp();
+      return;
+    }
+    renderDashboard(resolveWorkspaceOrExit("dashboard"), rest);
+    return;
+  }
+
+  if (command === "audit") {
+    runNodeScript("scripts/cco-audit.js", rest, { cwd: resolveWorkspaceOrExit("audit") });
+    return;
+  }
+
+  if (command === "settings") {
+    runNodeScript("scripts/cco-settings.js", rest, { cwd: resolveWorkspaceOrExit("settings") });
+    return;
+  }
+
+  if (command === "orchestration") {
+    const cwd = resolveWorkspaceOrExit("orchestration");
+    const [subcommand, ...subrest] = rest;
+    if (!subcommand || subcommand === "status") {
+      process.stdout.write(`${renderOrchestrationStatusCommand(cwd, subrest)}\n`);
+      return;
+    }
+    if (subcommand === "settings") {
+      process.stdout.write(`${renderOrchestrationSettingsCommand(cwd, subrest)}\n`);
+      return;
+    }
+    if (subcommand === "handoff") {
+      process.stdout.write(`${renderHandoffCommand(cwd, subrest)}\n`);
+      return;
+    }
+    if (subcommand === "surface") {
+      process.stdout.write(`${renderOrchestrationSurfaceCommand(cwd, subrest)}\n`);
+      return;
+    }
+    console.error(`[${CLI_NAME}] Unknown orchestration command: ${subcommand}`);
+    process.exit(1);
+  }
+
+  if (command === "handoff") {
+    process.stdout.write(`${renderHandoffCommand(resolveWorkspaceOrExit("handoff"), rest)}\n`);
+    return;
+  }
+
+  if (command === "panel") {
+    runNodeScript("scripts/cco-panel.js", rest, { cwd: resolveWorkspaceOrExit("panel") });
+    return;
+  }
+
+  if (command === "activate") {
+    renderActivation(rest);
+    return;
+  }
+
+  if (command === "first-value" || command === "first_value") {
+    renderFirstValue(resolveWorkspaceOrExit("first-value"), rest);
+    return;
+  }
+
+  if (command === "alpha-readiness" || command === "alpha-readiness-gate") {
+    renderAlphaReadinessGate(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "feedback" && rest[0] === "insights") {
+    renderFeedbackInsights(resolveWorkspaceOrExit(command), rest.slice(1));
+    return;
+  }
+
+  if (command === "feedback") {
+    renderFeedbackCommand(resolveWorkspaceOrExit("feedback"), rest);
+    return;
+  }
+
+  if (command === "support-bundle" || command === "support_bundle") {
+    renderSupportBundle(resolveWorkspaceOrExit("support-bundle"), rest);
+    return;
+  }
+
+  if (command === "token-efficiency" || command === "token-evidence" || command === "token_efficiency") {
+    renderTokenEfficiency(resolveWorkspaceOrExit("token-efficiency"), rest);
+    return;
+  }
+
+  if (command === "repo-map" || command === "repo_map") {
+    renderRepoMap(resolveWorkspaceOrExit("repo-map"), rest);
+    return;
+  }
+
+  if (command === "context-plan" || command === "context_plan") {
+    renderContextPlan(resolveWorkspaceOrExit("context-plan"), rest);
+    return;
+  }
+
+  if (command === "cache-readiness" || command === "cache_readiness") {
+    renderCacheReadiness(resolveWorkspaceOrExit("cache-readiness"), rest);
+    return;
+  }
+
+  if (command === "doctor") {
+    if (rest.includes("--orchestration")) {
+      process.stdout.write(`${renderOrchestrationStatusCommand(resolveWorkspaceOrExit("doctor"), rest.includes("--deep") ? ["--refresh", "--deep"] : [])}\n`);
+      return;
+    }
+    renderDoctor(resolveWorkspaceOrExit("doctor"), rest);
+    return;
+  }
+
+  if (command === "summary") {
+    runNodeScript("scripts/wuz-post-run.js", rest, { cwd: resolveWorkspaceOrExit("summary") });
+    return;
+  }
+
+  if (command === "prompt") {
+    renderPrompt(resolveWorkspaceOrExit("prompt"), rest);
+    return;
+  }
+
+  if (command === "visual-qa") {
+    renderVisualQa(resolveWorkspaceOrExit("visual-qa"), rest);
+    return;
+  }
+
+  if (command === "capabilities" || command === "packs") {
+    renderCapabilities(resolveWorkspaceOrExit("capabilities"), rest);
+    return;
+  }
+
+  if (command === "guard") {
+    renderGuard(resolveWorkspaceOrExit("guard"), rest);
+    return;
+  }
+
+  if (command === "init") {
+    if (rest.includes("--print")) {
+      process.stdout.write(`${PUBLIC_INIT_COMMAND}\n`);
+      return;
+    }
+    runNodeScript("scripts/cco-init.js", rest, { cwd: resolveWorkspaceOrExit("init") });
+    return;
+  }
+
+  if (command === "verify") {
+    if (rest[0] && fs.existsSync(rest[0])) {
+      await runVerify(rest[0]);
+      return;
+    }
+    process.stdout.write(`${renderOrchestrationVerifyCommand(resolveWorkspaceOrExit("verify"), rest)}\n`);
+    return;
+  }
+
+  if (command === "proof") {
+    process.stdout.write(`${renderProofCommand(resolveWorkspaceOrExit("proof"), rest)}\n`);
+    return;
+  }
+
+  if (command === "intake" || command === "install-intake") {
+    renderIntake(resolveWorkspaceOrExit("intake"), rest);
+    return;
+  }
+
+  if (command === "work-control" || command === "receipt") {
+    renderWorkControl(resolveWorkspaceOrExit("work-control"), rest);
+    return;
+  }
+
+  if (command === "brain-pack" || command === "brain_pack") {
+    renderBrainPack(resolveWorkspaceOrExit("brain-pack"), rest);
+    return;
+  }
+
+  if (command === "session-context" || command === "session-start") {
+    renderSessionContext(resolveWorkspaceOrExit("session-context"), rest);
+    return;
+  }
+
+  if (command === "workspace-map") {
+    renderWorkspaceMap(resolveWorkspaceOrExit("workspace-map"), rest);
+    return;
+  }
+
+  if (command === "workspace-registry" || command === "assets" || command === "registry") {
+    renderWorkspaceRegistry(resolveWorkspaceOrExit("workspace-registry"), rest);
+    return;
+  }
+
+  if (command === "workspace-hygiene" || command === "hygiene" || command === "ai-workspace") {
+    renderWorkspaceHygiene(resolveWorkspaceOrExit("workspace-hygiene"), rest);
+    return;
+  }
+
+  if (command === "skills") {
+    runNodeScript("scripts/avorelo-skills.js", rest, { cwd: resolveWorkspaceOrExit("skills") });
+    return;
+  }
+
+  if (command === "workspace") {
+    renderWorkspace(rest);
+    return;
+  }
+
+  if (command === "operating-value" || command === "value" || command === "savings") {
+    renderOperatingValue(resolveWorkspaceOrExit("operating-value"), rest);
+    return;
+  }
+
+  if (command === "pricing") {
+    renderPricing(resolveWorkspaceOrExit("pricing"), rest);
+    return;
+  }
+
+  if (command === "token-evidence") {
+    renderTokenEvidence(resolveWorkspaceOrExit("token-evidence"), rest);
+    return;
+  }
+
+  if (command === "session-timing") {
+    renderSessionTiming(resolveWorkspaceOrExit("session-timing"), rest);
+    return;
+  }
+
+  if (command === "cost-evidence") {
+    renderCostEvidence(resolveWorkspaceOrExit("cost-evidence"), rest);
+    return;
+  }
+
+  if (command === "context" || command === "context-pack") {
+    renderContextPack(resolveWorkspaceOrExit("context"), rest);
+    return;
+  }
+
+  if (command === "readiness" || command === "install-check") {
+    renderLaunchReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "outcome" || command === "reality-gate") {
+    renderOutcome(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "orchestrate" || command === "work-plan" || command === "plan-work") {
+    renderOrchestrate(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "ledger" || command === "work-ledger") {
+    renderLedger(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "company-loop" || command === "loop" || command === "learn") {
+    renderCompanyLoop(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "project-profile" || command === "profile") {
+    renderProjectProfile(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "execution-packet" || command === "packet") {
+    renderExecutionPacket(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "work-panel" || command === "panel-preview") {
+    renderWorkPanel(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "smart-route" || command === "work-route") {
+    renderSmartRoute(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "hooks" || command === "hook-baseline" || command === "hook-readiness" || command === "hook-preview") {
+    const cwd = resolveWorkspaceOrExit(command);
+    // hook-preview is an alias for hooks preview
+    if (command === "hook-preview") {
+      renderHooksCommand(cwd, ["preview", ...rest]);
+    } else {
+      renderHooksCommand(cwd, rest);
+    }
+    return;
+  }
+
+  if (command === "adapter-readiness") {
+    renderAdapterReadinessCommand(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "lifecycle-hook") {
+    renderLifecycleHookCommand(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "worker-handoff") {
+    const cwd = resolveWorkspaceOrExit(command);
+    const wantJson = rest.includes("--json");
+    const { buildSmartRouteSurface } = require("./smart-work-routing");
+    const surface = buildSmartRouteSurface(cwd);
+    const fs2 = require("fs");
+    const path2 = require("path");
+    const handoffPath = path2.join(cwd, surface.latestHandoffPath || ".claude/cco/orchestration/worker-handoff/latest-handoff.json");
+    if (fs2.existsSync(handoffPath)) {
+      try {
+        const data = JSON.parse(fs2.readFileSync(handoffPath, "utf8"));
+        process.stdout.write(`${wantJson ? JSON.stringify(data, null, 2) : `Worker handoff: ${data.handoffId || "available"}\nTarget: ${data.targetWorker || "unknown"}\nNext: ${data.safeNextAction || "Review handoff receipt."}`}\n`);
+      } catch {
+        process.stdout.write("Worker handoff receipt unavailable. Run avorelo smart-route \"<task>\" first.\n");
+      }
+    } else {
+      process.stdout.write("No worker handoff receipt found. Run avorelo smart-route \"<task>\" first.\n");
+    }
+    return;
+  }
+
+  if (command === "artifacts") {
+    renderArtifactsCommand(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "launch-hardening" || command === "launch_hardening") {
+    renderLaunchHardening(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "install-ai" || command === "ai-install" || command === "install-prompt") {
+    renderInstallAi(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "prelaunch-readiness" || command === "prelaunch_readiness") {
+    renderPrelaunchReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "first-value-check" || command === "first_value_check") {
+    renderFirstValueCheck(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "prelaunch-intelligence" || command === "intelligence") {
+    renderPrelaunchIntelligence(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "token-cost" || command === "cost-intelligence") {
+    renderTokenCostIntelligence(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "install-journey") {
+    renderInstallJourneyIntelligence(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "mcp" || command === "tools") {
+    renderMcpCommand(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "full-readiness" || command === "rc-gate") {
+    renderFullReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+  if (command === "readiness-delta") {
+    renderReadinessDelta(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+  if (command === "readiness-closure") {
+    renderReadinessClosure(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+  if (command === "known-limitations") {
+    renderKnownLimitations(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+  if (command === "external-user-sim") {
+    renderExternalUserSim(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+  if (command === "release-candidate-bundle") {
+    renderReleaseCandidateBundle(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "activation-distribution" || command === "readiness-activation") {
+    renderActivationDistributionReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "public-distribution" || command === "distribution-truth") {
+    renderPublicDistribution(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "package-audit" || command === "npm-readiness") {
+    renderPackageAudit(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "package-smoke") {
+    renderPackageSmoke(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "install-claims") {
+    renderInstallClaims(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "publish-readiness") {
+    renderPublishReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "host-matrix") {
+    renderHostMatrix(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "cross-host-install") {
+    renderCrossHostInstall(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "cross-host-value") {
+    renderCrossHostValue(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "adapter-safety") {
+    renderAdapterSafety(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "host-support") {
+    renderHostSupport(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "browser-preflight") {
+    renderBrowserPreflight(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  if (command === "adapter-readiness-technical") {
+    renderAdapterTechnicalReadiness(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  // ── adapter <subcommand> — unified adapter/host routing (PR #163) ─────────
+  if (command === "adapter" || command === "hosts" || command === "adapters") {
+    const sub = rest[0] || "";
+    const subRest = rest.slice(1);
+    const cwd = resolveWorkspaceOrExit(command);
+    if (sub === "matrix" || sub === "host-matrix") {
+      renderHostMatrix(cwd, subRest);
+    } else if (sub === "readiness") {
+      renderAdapterReadinessCommand(cwd, subRest);
+    } else if (sub === "technical" || sub === "readiness-technical") {
+      renderAdapterTechnicalReadiness(cwd, subRest);
+    } else if (sub === "install-plan") {
+      renderCrossHostInstallPlan(cwd, subRest);
+    } else if (sub === "install") {
+      renderCrossHostInstall(cwd, subRest);
+    } else if (sub === "value-flow" || sub === "value") {
+      renderCrossHostValue(cwd, subRest);
+    } else if (sub === "safety") {
+      renderAdapterSafety(cwd, subRest);
+    } else if (sub === "support" || sub === "host-support") {
+      renderHostSupport(cwd, subRest);
+    } else if (sub === "browser-preflight" || sub === "preflight") {
+      renderBrowserPreflight(cwd, subRest);
+    } else {
+      // Default: show adapter readiness
+      renderAdapterReadinessCommand(cwd, rest);
+    }
+    return;
+  }
+
+  // ── run-improvements — next-run preparation based on last-run evidence ──
+  if (command === "run-improvements" || command === "next-run-prep") {
+    renderRunImprovements(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  // ── learning — evidence-backed learning memory ──────────────────────────
+  if (command === "learning") {
+    renderLearning(resolveWorkspaceOrExit(command), rest);
+    return;
+  }
+
+  // ── browser-proof <subcommand> — browser proof preflight alias (PR #163) ──
+  if (command === "browser-proof") {
+    const sub = rest[0] || "";
+    const subRest = rest.slice(1);
+    const cwd = resolveWorkspaceOrExit(command);
+    if (sub === "preflight") {
+      renderBrowserPreflight(cwd, subRest);
+    } else {
+      renderBrowserPreflight(cwd, rest);
+    }
+    return;
+  }
+
+  console.error(`[${CLI_NAME}] Unknown command: ${command}`);
+  console.error(`Run ${CLI_NAME} --help to see the supported commands.`);
+  process.exit(1);
+}
+
+// ── Pre-Launch Intelligence CLI (PR #147) ─────────────────────────────────────
+
+function renderPrelaunchIntelligence(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+  const refresh = forwardedArgs.includes("--refresh");
+
+  const {
+    buildPrelaunchIntelligence,
+    writePrelaunchIntelligence,
+    formatPrelaunchIntelligenceText,
+  } = require("./prelaunch-intelligence");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const intel = buildPrelaunchIntelligence(cwd, { refresh });
+  writePrelaunchIntelligence(cwd, intel);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "prelaunch_intelligence_run",
+      category: "prelaunch_intelligence",
+      status: intel.status,
+      score: intel.score,
+    });
+  } catch {}
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(intel, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(formatPrelaunchIntelligenceText(intel, { debug: wantDebug }) + "\n");
+}
+
+function renderFeedbackInsights(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildFeedbackIntelligence,
+    writeFeedbackIntelligence,
+    formatFeedbackIntelligenceText,
+  } = require("./feedback-intelligence");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const intel = buildFeedbackIntelligence(cwd);
+  writeFeedbackIntelligence(cwd, intel);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "feedback_intelligence_built",
+      category: "prelaunch_intelligence",
+      status: intel.status,
+      topFriction: intel.topFriction,
+    });
+  } catch {}
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(intel, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(formatFeedbackIntelligenceText(intel, { debug: wantDebug }) + "\n");
+}
+
+function renderTokenCostIntelligence(cwd, forwardedArgs = []) {
+  const subcommand = forwardedArgs.find((a) => !a.startsWith("-")) || null;
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildTokenCostRollup,
+    writeTokenCostIntelligence,
+    formatTokenCostIntelligenceText,
+  } = require("./token-cost-intelligence");
+  const {
+    buildRealUsageTokenCostCapture,
+    writeRealUsageTokenCostCapture,
+  } = require("./token-cost-capture");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+  const {
+    importTokenCostEvidence,
+    validateTokenCostEvidence,
+    buildTokenCostEvidenceSummary,
+    writeTokenCostEvidenceSummary,
+  } = require("./prelaunch-evidence-store");
+
+  if (subcommand === "validate") {
+    const file = readFlagValue(forwardedArgs, "--file");
+    if (!file) {
+      const message = { ok: false, error: "--file is required", redacted: true };
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(message, null, 2)}\n`);
+        return;
+      }
+      process.stderr.write("Token-cost validate error: --file is required\n");
+      process.exit(1);
+    }
+    const receipt = validateTokenCostEvidence(cwd, file);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Token-cost validation: ${receipt.acceptedCount} accepted, ${receipt.rejectedCount} rejected.\n`);
+    return;
+  }
+
+  if (subcommand === "import") {
+    const file = readFlagValue(forwardedArgs, "--file");
+    if (!file) {
+      const message = { ok: false, error: "--file is required", redacted: true };
+      if (wantJson) {
+        process.stdout.write(`${JSON.stringify(message, null, 2)}\n`);
+        return;
+      }
+      process.stderr.write("Token-cost import error: --file is required\n");
+      process.exit(1);
+    }
+    const receipt = importTokenCostEvidence(cwd, file);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Token-cost import: ${receipt.acceptedCount} accepted, ${receipt.rejectedCount} rejected.\n`);
+    return;
+  }
+
+  if (subcommand === "capture") {
+    const capture = buildRealUsageTokenCostCapture(cwd);
+    const receipt = writeRealUsageTokenCostCapture(cwd, capture);
+    const summary = writeTokenCostEvidenceSummary(cwd, buildTokenCostEvidenceSummary(cwd));
+    const output = Object.assign({}, receipt, { summary });
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Token-cost capture: ${receipt.status} (${receipt.realUsageSamplesCount} measured sample(s), ${receipt.capturedRowsCount} captured row(s)).\n`);
+    return;
+  }
+
+  if (subcommand === "summary") {
+    const summary = writeTokenCostEvidenceSummary(cwd, buildTokenCostEvidenceSummary(cwd));
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(`Token-cost summary: ${summary.status} (${summary.evidenceMode}, ${summary.realUsageSamplesCount} measured sample(s)).\n`);
+    return;
+  }
+
+  const intel = buildTokenCostRollup(cwd);
+  writeTokenCostIntelligence(cwd, intel);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "token_cost_intelligence_built",
+      category: "prelaunch_intelligence",
+      status: intel.status,
+      evidenceLevel: intel.evidenceLevel,
+    });
+  } catch {}
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(intel, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(formatTokenCostIntelligenceText(intel, { debug: wantDebug }) + "\n");
+}
+
+function renderInstallJourneyIntelligence(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const {
+    buildInstallJourneyIntelligence,
+    writeInstallJourneyIntelligence,
+    formatInstallJourneyText,
+  } = require("./install-journey-intelligence");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  const intel = buildInstallJourneyIntelligence(cwd);
+  writeInstallJourneyIntelligence(cwd, intel);
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "install_journey_intelligence_built",
+      category: "prelaunch_intelligence",
+      status: intel.status,
+      stepsComplete: intel.stepsComplete,
+      stepsTotal: intel.stepsTotal,
+    });
+  } catch {}
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify(intel, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(formatInstallJourneyText(intel, { debug: wantDebug }) + "\n");
+}
+
+// ── MCP Tool Governance CLI ───────────────────────────────────────────────────
+
+function renderMcpCommand(cwd, forwardedArgs = []) {
+  const subcommand = forwardedArgs[0] || "doctor";
+  const rest = forwardedArgs.slice(1);
+  const wantJson = forwardedArgs.includes("--json");
+  const wantDebug = forwardedArgs.includes("--debug");
+
+  const { buildMcpToolInventory, writeMcpToolInventory, buildMcpToolInventorySurface, formatMcpToolInventoryText } = require("./mcp-tool-inventory");
+  const { buildMcpToolRiskReport, writeMcpToolRiskReport, formatMcpToolRiskText } = require("./mcp-tool-risk");
+  const { buildMcpLeastPrivilegePolicy, writeMcpPolicy, buildMcpPolicyPreview, writeMcpPolicyPreview, formatMcpPolicyText } = require("./mcp-least-privilege-policy");
+  const { appendProductLearningEvent } = require("./product-learning-events");
+
+  if (subcommand === "inventory" || subcommand === "inv") {
+    const inventory = buildMcpToolInventory(cwd);
+    writeMcpToolInventory(cwd, inventory);
+    try {
+      appendProductLearningEvent(cwd, {
+        eventName: "mcp_tool_inventory_scanned",
+        payload: { status: inventory.status, serverCount: inventory.servers.length, configFiles: inventory.configFiles.length, redacted: true },
+      });
+    } catch {}
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(inventory, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(formatMcpToolInventoryText(inventory, { debug: wantDebug }) + "\n");
+    return;
+  }
+
+  if (subcommand === "risk") {
+    const inventory = buildMcpToolInventory(cwd);
+    writeMcpToolInventory(cwd, inventory);
+    const riskReport = buildMcpToolRiskReport(cwd, inventory);
+    writeMcpToolRiskReport(cwd, riskReport);
+    try {
+      appendProductLearningEvent(cwd, {
+        eventName: "mcp_tool_risk_classified",
+        payload: { status: riskReport.status, serverCount: riskReport.summary.serverCount, highCritical: riskReport.summary.highCriticalTools, unknownServers: riskReport.summary.unknownServers, redacted: true },
+      });
+      if (riskReport.summary.unknownServers > 0) {
+        appendProductLearningEvent(cwd, { eventName: "mcp_unknown_tool_detected", payload: { count: riskReport.summary.unknownServers, redacted: true } });
+      }
+    } catch {}
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(riskReport, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(formatMcpToolRiskText(riskReport, { debug: wantDebug }) + "\n");
+    return;
+  }
+
+  if (subcommand === "policy") {
+    const inventory = buildMcpToolInventory(cwd);
+    const riskReport = buildMcpToolRiskReport(cwd, inventory);
+    const policy = buildMcpLeastPrivilegePolicy(cwd, riskReport);
+    writeMcpPolicy(cwd, policy);
+    try {
+      appendProductLearningEvent(cwd, {
+        eventName: "mcp_policy_preview_generated",
+        payload: { status: policy.status, approvalRequired: policy.summary.approvalRequired, blocked: policy.summary.blocked, redacted: true },
+      });
+      if (policy.summary.blocked > 0) {
+        appendProductLearningEvent(cwd, { eventName: "mcp_tool_blocked", payload: { count: policy.summary.blocked, redacted: true } });
+      }
+      if (policy.summary.approvalRequired > 0) {
+        appendProductLearningEvent(cwd, { eventName: "mcp_tool_approval_required", payload: { count: policy.summary.approvalRequired, redacted: true } });
+      }
+    } catch {}
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(policy, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write(formatMcpPolicyText(policy, { debug: wantDebug }) + "\n");
+    return;
+  }
+
+  if (subcommand === "preview") {
+    const inventory = buildMcpToolInventory(cwd);
+    const riskReport = buildMcpToolRiskReport(cwd, inventory);
+    const policy = buildMcpLeastPrivilegePolicy(cwd, riskReport);
+    const preview = buildMcpPolicyPreview(cwd, policy);
+    writeMcpPolicyPreview(cwd, preview);
+    if (wantJson) {
+      process.stdout.write(`${JSON.stringify(preview, null, 2)}\n`);
+      return;
+    }
+    process.stdout.write([
+      `MCP Policy Preview [${preview.status}]`,
+      `Preview only — config not modified.`,
+      `Allow: ${preview.summary?.allow || 0} · Warn: ${preview.summary?.warn || 0} · Approval: ${preview.summary?.approvalRequired || 0} · Blocked: ${preview.summary?.blocked || 0}`,
+      preview.topDecisions && preview.topDecisions.length > 0 ? `Top issues:\n${preview.topDecisions.map((d) => `  ${d.name} → ${d.decision} [${d.riskLevel}]`).join("\n")}` : "No high/critical issues.",
+      `Next: Run \`avorelo mcp doctor\` for full governance status.`,
+    ].join("\n") + "\n");
+    return;
+  }
+
+  // Default: doctor (full governance status)
+  const inventory = buildMcpToolInventory(cwd);
+  writeMcpToolInventory(cwd, inventory);
+  const riskReport = buildMcpToolRiskReport(cwd, inventory);
+  writeMcpToolRiskReport(cwd, riskReport);
+  const policy = buildMcpLeastPrivilegePolicy(cwd, riskReport);
+  writeMcpPolicy(cwd, policy);
+
+  if (wantJson) {
+    process.stdout.write(`${JSON.stringify({
+      inventory: { status: inventory.status, servers: inventory.servers.length, tools: inventory.tools.length },
+      risk: { status: riskReport.status, unknownServers: riskReport.summary.unknownServers, highCritical: riskReport.summary.highCriticalTools },
+      policy: { status: policy.status, allow: policy.summary.allow, warn: policy.summary.warn, approvalRequired: policy.summary.approvalRequired, blocked: policy.summary.blocked },
+      note: "Avorelo does not execute MCP servers during inventory. Preview only — config not modified.",
+      redacted: true,
+    }, null, 2)}\n`);
+    return;
+  }
+
+  const lines = [
+    `MCP Tool Governance: ${policy.status}`,
+    ``,
+    `Found: ${inventory.servers.length} server(s) · ${inventory.tools.length} tool surface(s)`,
+    `Unknown servers: ${riskReport.summary.unknownServers}`,
+    `Approval-gated: ${policy.summary.approvalRequired}`,
+    `Blocked: ${policy.summary.blocked}`,
+    ``,
+    `Protected: Secrets/prod/destructive actions remain blocked.`,
+    `Preview only: No MCP config modified.`,
+    ``,
+    `Next: Run \`avorelo mcp policy --debug\` for per-tool decisions.`,
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+
+
+// PR #148: Full Readiness / Release Candidate Gate CLI
+
+function renderFullReadiness(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var wantDebug = args.indexOf("--debug") !== -1;
+  var frg = require("./full-readiness-gate");
+  var kll = require("./known-limitations");
+  var rec = require("./readiness-evidence-closure");
+  var eus = require("./external-user-simulation");
+  var ple = require("./product-learning-events");
+  var closure = rec.runReadinessEvidenceClosure(cwd, {});
+  rec.writeEvidenceClosure(cwd, closure);
+  var signals = frg.collectFullReadinessSignals(cwd, {});
+  var limitations = kll.buildKnownLimitations(cwd, signals, {});
+  kll.writeKnownLimitations(cwd, limitations);
+  var sim = eus.runExternalUserSimulation(cwd, {});
+  eus.writeExternalUserSimulation(cwd, sim);
+  var gate = frg.runFullReadinessGate(cwd, { knownLimitations: limitations });
+  frg.writeFullReadinessGate(cwd, gate);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "full_readiness_gate_run", category: "full_readiness", status: gate.status, score: gate.score, blockerCount: (gate.blockers || []).length }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(gate, null, 2) + "\n"); return; }
+  process.stdout.write(frg.formatFullReadinessText(gate, { debug: wantDebug }) + "\n");
+}
+
+function renderReadinessDelta(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var rd = require("./readiness-delta");
+  var delta = rd.buildReadinessDelta(cwd, {});
+  rd.writeReadinessDelta(cwd, delta);
+  if (wantJson) { process.stdout.write(JSON.stringify(delta, null, 2) + "\n"); return; }
+  process.stdout.write(rd.formatReadinessDeltaText(delta) + "\n");
+}
+
+function renderReadinessClosure(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var rec = require("./readiness-evidence-closure");
+  var ple = require("./product-learning-events");
+  var closure = rec.runReadinessEvidenceClosure(cwd, {});
+  rec.writeEvidenceClosure(cwd, closure);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "readiness_evidence_closure_run", category: "full_readiness", status: closure.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(closure, null, 2) + "\n"); return; }
+  process.stdout.write(rec.formatEvidenceClosureText(closure) + "\n");
+}
+
+function renderKnownLimitations(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var frg = require("./full-readiness-gate");
+  var kll = require("./known-limitations");
+  var ple = require("./product-learning-events");
+  var signals = frg.collectFullReadinessSignals(cwd, {});
+  var limitations = kll.buildKnownLimitations(cwd, signals, {});
+  kll.writeKnownLimitations(cwd, limitations);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "known_limitations_built", category: "full_readiness", totalLimitations: limitations.totalLimitations }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(limitations, null, 2) + "\n"); return; }
+  process.stdout.write(kll.formatKnownLimitationsText(limitations) + "\n");
+}
+
+function renderExternalUserSim(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var eus = require("./external-user-simulation");
+  var ple = require("./product-learning-events");
+  var sim = eus.runExternalUserSimulation(cwd, {});
+  eus.writeExternalUserSimulation(cwd, sim);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "external_user_simulation_run", category: "full_readiness", status: sim.status, passed: sim.passed }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(sim, null, 2) + "\n"); return; }
+  process.stdout.write(eus.formatExternalUserSimulationText(sim) + "\n");
+}
+
+function renderReleaseCandidateBundle(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var rcb = require("./release-candidate-bundle");
+  var ple = require("./product-learning-events");
+  var bundle = rcb.buildReleaseCandidateBundle(cwd, {});
+  rcb.writeReleaseCandidateBundle(cwd, bundle);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "release_candidate_bundle_built", category: "full_readiness", status: bundle.status, releaseCandidateStatus: bundle.releaseCandidateStatus }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(bundle, null, 2) + "\n"); return; }
+  process.stdout.write(rcb.formatReleaseCandidateBundleText(bundle) + "\n");
+}
+
+function renderActivationDistributionReadiness(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var debug = args.indexOf("--debug") !== -1;
+  var adr = require("./activation-distribution-readiness");
+  var ple = require("./product-learning-events");
+  var result = adr.runActivationDistributionReadiness(cwd, {});
+  adr.writeActivationDistributionReadiness(cwd, result);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "activation_distribution_readiness_run", category: "activation_distribution", status: result.status, score: result.score }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(result, null, 2) + "\n"); return; }
+  process.stdout.write(adr.formatActivationDistributionText(result, { debug: debug }) + "\n");
+}
+
+// ── Public Distribution Truth CLI (PR #148) ───────────────────────────────────
+
+function renderPublicDistribution(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var wantDebug = args.indexOf("--debug") !== -1;
+  var pag = require("./public-activation-distribution-gate");
+  var ple = require("./product-learning-events");
+  var gate = pag.runPublicActivationDistributionGate(cwd, {});
+  pag.writePublicActivationDistributionGate(cwd, gate);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "public_activation_distribution_gate_run", category: "public_distribution", status: gate.status, score: gate.score }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(gate, null, 2) + "\n"); return; }
+  process.stdout.write(pag.formatPublicActivationDistributionText(gate, { debug: wantDebug }) + "\n");
+}
+
+function renderPackageAudit(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var pca = require("./package-content-audit");
+  var ple = require("./product-learning-events");
+  var audit = pca.buildPackageContentAudit(cwd, {});
+  pca.writePackageContentAudit(cwd, audit);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "package_content_audit_run", category: "public_distribution", status: audit.status, fileCount: audit.fileCount }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(audit, null, 2) + "\n"); return; }
+  process.stdout.write(pca.formatPackageContentAuditText(audit) + "\n");
+}
+
+function renderPackageSmoke(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var lps = require("./local-package-smoke");
+  var ple = require("./product-learning-events");
+  var smoke = lps.runLocalPackageSmoke(cwd, {});
+  lps.writeLocalPackageSmoke(cwd, smoke);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "local_package_smoke_run", category: "public_distribution", status: smoke.status, tarballCreated: smoke.tarballCreated }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(smoke, null, 2) + "\n"); return; }
+  process.stdout.write(lps.formatLocalPackageSmokeText(smoke) + "\n");
+}
+
+function renderInstallClaims(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var picc = require("./public-install-claim-checker");
+  var ple = require("./product-learning-events");
+  var report = picc.validateInstallClaims(cwd, {});
+  picc.writePublicInstallClaimCheck(cwd, report);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "public_install_claim_check_run", category: "public_distribution", status: report.status, blockedCount: (report.blockedClaims || []).length }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(report, null, 2) + "\n"); return; }
+  process.stdout.write(picc.formatPublicInstallClaimText(report) + "\n");
+}
+
+function renderPublishReadiness(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var ppr = require("./publish-provenance-readiness");
+  var ple = require("./product-learning-events");
+  var readiness = ppr.buildPublishProvenanceReadiness(cwd, {});
+  ppr.writePublishProvenanceReadiness(cwd, readiness);
+  try { ple.appendProductLearningEvent(cwd, { eventName: "publish_provenance_readiness_run", category: "public_distribution", status: readiness.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(readiness, null, 2) + "\n"); return; }
+  process.stdout.write(ppr.formatPublishProvenanceText(readiness) + "\n");
+}
+
+// ── Adapter Technical Readiness CLI (PR #162) ─────────────────────────────────
+
+function renderHostMatrix(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./host-capability-matrix");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildHostCapabilityMatrixSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "host_matrix_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildHostCapabilityMatrix(cwd, {});
+  process.stdout.write(mod.formatHostCapabilityMatrixText(full) + "\n");
+}
+
+function renderCrossHostInstall(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./cross-host-install-readiness");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildCrossHostInstallSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "cross_host_install_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildCrossHostInstallReadiness(cwd, {});
+  process.stdout.write(mod.formatCrossHostInstallText(full) + "\n");
+}
+
+function renderCrossHostInstallPlan(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var wantDebug = args.indexOf("--debug") !== -1;
+  var mod = require("./cross-host-install-plan");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildCrossHostInstallSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "cross_host_install_plan_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) {
+    var full = mod.buildAllHostInstallPlans(cwd, {});
+    process.stdout.write(JSON.stringify(full, null, 2) + "\n");
+    return;
+  }
+  var full2 = mod.buildAllHostInstallPlans(cwd, {});
+  process.stdout.write(mod.formatCrossHostInstallText(full2, { debug: wantDebug }) + "\n");
+}
+
+function renderCrossHostValue(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./cross-host-value-flow");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildCrossHostValueFlowSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "cross_host_value_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildCrossHostValueFlow(cwd, {});
+  process.stdout.write(mod.formatCrossHostValueFlowText(full) + "\n");
+}
+
+function renderAdapterSafety(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./adapter-safety-boundaries");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildAdapterSafetyBoundariesSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "adapter_safety_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildAdapterSafetyBoundaries(cwd, {});
+  process.stdout.write(mod.formatAdapterSafetyBoundariesText(full) + "\n");
+}
+
+function renderHostSupport(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./host-support-context");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildHostSupportContextSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "host_support_run", category: "adapter_readiness", status: surface.status }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildHostSupportContext(cwd, {});
+  process.stdout.write(mod.formatHostSupportContextText(full) + "\n");
+}
+
+function renderBrowserPreflight(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./browser-proof-preflight");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildBrowserProofPreflightSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "browser_preflight_run", category: "adapter_readiness", status: surface.status, noBrowserLaunch: true }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildBrowserProofPreflight(cwd, {});
+  process.stdout.write(mod.formatBrowserProofPreflightText(full) + "\n");
+}
+
+function renderAdapterTechnicalReadiness(cwd, args) {
+  args = args || [];
+  var wantJson = args.indexOf("--json") !== -1;
+  var mod = require("./adapter-technical-readiness-gate");
+  var ple = require("./product-learning-events");
+  var surface = mod.buildAdapterTechnicalReadinessSurface(cwd, {});
+  try { ple.appendProductLearningEvent(cwd, { eventName: "adapter_technical_readiness_run", category: "adapter_readiness", status: surface.status, score: surface.score, verdict: surface.verdict }); } catch (e) {}
+  if (wantJson) { process.stdout.write(JSON.stringify(surface, null, 2) + "\n"); return; }
+  var full = mod.buildAdapterTechnicalReadinessGate(cwd, {});
+  process.stdout.write(mod.formatAdapterTechnicalReadinessText(full) + "\n");
+}
+
+// ── Run Improvements CLI (Add Run Improvements E2E) ──────────────────────────
+
+function renderRunImprovements(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const forceGenerate = forwardedArgs.includes("--generate");
+  const wantConsume = forwardedArgs.includes("--consume");
+  const wantApply = forwardedArgs.includes("--apply");
+
+  const {
+    generateRunImprovementsArtifact,
+    loadRunImprovements,
+    formatRunImprovementsText,
+    formatRunImprovementsStatusLine,
+  } = require("./run-improvements");
+
+  // --apply: inject next-run context artifact and mark lifecycle applied
+  // This is the real application path — creates bounded next-run-context artifact
+  // and sets applied receipt with surface = "next_run_context".
+  if (wantApply) {
+    const { injectNextRunContext } = require("./run-improvements-lifecycle");
+    const result = injectNextRunContext(cwd);
+    if (wantJson) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    } else if (result.success) {
+      process.stdout.write(`Run Improvements: applied via next-run context.\n`);
+      process.stdout.write(`  Artifact: ${result.artifactPath || ".claude/cco/state/next-run-context.json"}\n`);
+      process.stdout.write(`  Defaults: ${result.defaultsCount || 0} · Decisions: ${result.decisionsCount || 0} · Risks: ${result.risksCount || 0}\n`);
+      process.stdout.write(`  Surface: ${result.surface || "next_run_context"}\n`);
+      process.stdout.write(`  Applied at: ${result.receipt?.appliedAt || "n/a"}\n`);
+      if (result.reason === "already_applied") {
+        process.stdout.write(`  (Already applied for this fingerprint — idempotent.)\n`);
+      }
+    } else {
+      process.stdout.write(`Run Improvements: apply failed — ${result.reason}\n`);
+      if (result.error) process.stdout.write(`  Error: ${result.error}\n`);
+    }
+    return;
+  }
+
+  // --consume: mark defaults as consumed by a supported surface
+  if (wantConsume) {
+    const { consumeRunImprovements } = require("./run-improvements-lifecycle");
+    const receipt = consumeRunImprovements(cwd, "cli");
+    if (wantJson) {
+      process.stdout.write(JSON.stringify(receipt || { status: "no_artifact" }, null, 2) + "\n");
+    } else if (receipt) {
+      process.stdout.write(`Run Improvements: consumed.\n`);
+      process.stdout.write(`  Fingerprint: ${receipt.sourceRunFingerprint}\n`);
+      process.stdout.write(`  Consumed at: ${receipt.consumedAt}\n`);
+    } else {
+      process.stdout.write(`Run Improvements: consume failed — no prepared artifact found.\n`);
+    }
+    return;
+  }
+
+  if (forceGenerate) {
+    const { artifact, written, reason } = generateRunImprovementsArtifact(cwd, { mode: "prepare" });
+    if (wantJson) {
+      process.stdout.write(JSON.stringify({ written, reason, artifact }, null, 2) + "\n");
+    } else {
+      const text = formatRunImprovementsText(cwd) || artifact.publicSummary;
+      process.stdout.write(text + "\n");
+      if (written) {
+        process.stdout.write(`  Generated: ${artifact.topImprovements.length} improvement(s).\n`);
+      } else {
+        process.stdout.write(`  Skipped (same fingerprint, not expired).\n`);
+      }
+    }
+    return;
+  }
+
+  const existing = loadRunImprovements(cwd);
+  if (wantJson) {
+    process.stdout.write(JSON.stringify(existing || { status: "not_available" }, null, 2) + "\n");
+    return;
+  }
+
+  if (!existing || existing.status === "not_available") {
+    process.stdout.write(
+      "Run Improvements: not available.\n" +
+        "No prior run evidence found. Run an Avorelo session first, or use --generate to check now.\n"
+    );
+    return;
+  }
+
+  const line = formatRunImprovementsStatusLine(cwd);
+  const text = formatRunImprovementsText(cwd);
+  process.stdout.write((line || text || existing.publicSummary) + "\n");
+
+  if (
+    (existing.status === "prepared" || existing.status === "applied") &&
+    existing.nextRunDefaults.length > 0
+  ) {
+    process.stdout.write("\nNext-run defaults:\n");
+    existing.nextRunDefaults.forEach((d, i) => {
+      process.stdout.write(`  ${i + 1}. ${d.text}\n`);
+    });
+  }
+
+  // Show next-run context status if applied
+  if (existing.status === "applied") {
+    try {
+      const { buildNextRunContextSurface } = require("./next-run-context");
+      const nrcSurface = buildNextRunContextSurface(cwd);
+      if (nrcSurface.showInStatus && nrcSurface.statusLine) {
+        process.stdout.write(`\n${nrcSurface.statusLine}\n`);
+      }
+    } catch {}
+  }
+
+  if (existing.limitations && existing.limitations.length > 0) {
+    process.stdout.write("\nLimitations:\n");
+    existing.limitations.forEach((l) => process.stdout.write(`  - ${l}\n`));
+  }
+}
+
+// ── Learning CLI ──────────────────────────────────────────────────────────────
+
+function renderLearning(cwd, forwardedArgs = []) {
+  const wantJson = forwardedArgs.includes("--json");
+  const wantGenerate = forwardedArgs.includes("--generate");
+  const wantSummary = forwardedArgs.includes("--summary") || !wantGenerate;
+
+  const {
+    generateLearningArtifacts,
+    loadLearningSummary,
+    formatLearningSummaryText,
+  } = require("./learning-memory");
+
+  if (wantGenerate) {
+    const result = generateLearningArtifacts(cwd);
+    if (wantJson) {
+      process.stdout.write(JSON.stringify(result.summary, null, 2) + "\n");
+    } else {
+      const text = formatLearningSummaryText(cwd);
+      process.stdout.write((text || "Learning: generated.") + "\n");
+      process.stdout.write(`  Decisions: ${result.summary.activeDecisionCount}\n`);
+      process.stdout.write(`  Risks: ${result.summary.activeRiskCount}\n`);
+      process.stdout.write(`  Capabilities: ${result.summary.capabilityCount}\n`);
+    }
+    return;
+  }
+
+  if (wantSummary) {
+    const summary = loadLearningSummary(cwd);
+    if (wantJson) {
+      process.stdout.write(JSON.stringify(summary || { status: "not_available" }, null, 2) + "\n");
+      return;
+    }
+    if (!summary) {
+      process.stdout.write(
+        "Learning: not available.\nNo learning summary found. Run --generate to build learning artifacts.\n"
+      );
+      return;
+    }
+    const text = formatLearningSummaryText(cwd);
+    process.stdout.write((text || "Learning: available.") + "\n");
+    if (summary.nextRunInfluence.length > 0) {
+      process.stdout.write("\nNext-run influence:\n");
+      summary.nextRunInfluence.forEach((inf) => {
+        process.stdout.write(`  - ${inf.text}\n`);
+      });
+    }
+  }
+}
+
+module.exports = {
+  main,
+  printHelp,
+};