avorelo 0.1.0

package/scripts/lib/activation-distribution-readiness.js

@@ -0,0 +1,507 @@
+"use strict";
+
+// ── Activation Distribution Readiness ────────────────────────────────────────
+// Contract: avorelo.activationDistributionReadiness.v1
+// Answers: "Can a first external user install, activate, see first value,
+// understand limitations, and recover safely without founder hand-holding?"
+// Does NOT claim public launch readiness. Honest about missing evidence.
+
+const fs = require("fs");
+const path = require("path");
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+
+const CONTRACT = "avorelo.activationDistributionReadiness.v1";
+const SCHEMA_VERSION = 1;
+const ARTIFACT_DIR_REL = ".claude/cco/orchestration/activation-distribution";
+const ARTIFACT_REL = ARTIFACT_DIR_REL + "/latest-activation-distribution-readiness.json";
+
+const SCORE_READY = 85;
+const SCORE_WARN = 70;
+
+const CHECK_WEIGHTS = {
+  install_command_available:        8,
+  install_docs_current:             5,
+  activation_entrypoint_available:  8,
+  doctor_available:                 5,
+  first_value_surface_available:    8,
+  clear_next_action_available:      6,
+  recovery_path_available:          7,
+  support_bundle_available:         6,
+  known_limitations_visible:        5,
+  release_candidate_bundle_safe:    6,
+  evidence_closure_complete:        6,
+  external_user_simulation_covered: 6,
+  token_cost_honest:                7,
+  feedback_intelligence_honest:     7,
+  no_public_launch_claim:           8,
+  safe_next_action_exists:          6,
+};
+
+const TOTAL_WEIGHT = Object.values(CHECK_WEIGHTS).reduce(function(a, b) { return a + b; }, 0);
+
+function safeReadJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
+  } catch { return null; }
+}
+
+function pass(id, label, evidence, detail) {
+  return { id: id, label: label, status: "pass", evidence: evidence || null, detail: detail || null, safeNextAction: null };
+}
+function warn(id, label, safeNextAction, evidence, detail) {
+  return { id: id, label: label, status: "warn", evidence: evidence || null, detail: detail || null, safeNextAction: safeNextAction || "Run readiness closure to identify missing evidence." };
+}
+function blocked(id, label, safeNextAction, evidence, detail) {
+  return { id: id, label: label, status: "blocked", evidence: evidence || null, detail: detail || null, safeNextAction: safeNextAction || "Fix blocker before proceeding." };
+}
+function info(id, label, detail) {
+  return { id: id, label: label, status: "info", evidence: null, detail: detail || null, safeNextAction: null };
+}
+
+function checkInstallCommandAvailable(cwd) {
+  const binPath = path.join(cwd, "bin", "avorelo");
+  const hasBin = fs.existsSync(binPath);
+  const pkgPath = path.join(cwd, "package.json");
+  const pkg = safeReadJson(pkgPath);
+  const hasBinField = pkg && pkg.bin && (typeof pkg.bin === "string" || Object.keys(pkg.bin).length > 0);
+  if (!hasBin && !hasBinField) {
+    return blocked("install_command_available", "Install command available",
+      "Create bin/avorelo entry point. Add bin field to package.json.",
+      null, "No bin/avorelo and no bin field in package.json.");
+  }
+  return pass("install_command_available", "Install command available",
+    { binExists: hasBin, pkgBinField: !!hasBinField }, null);
+}
+
+function checkInstallDocsCurrent(cwd) {
+  const docsDir = path.join(cwd, "docs");
+  if (!fs.existsSync(docsDir)) {
+    return warn("install_docs_current", "Install docs current",
+      "Create docs/ directory with install instructions.",
+      null, "No docs directory found.");
+  }
+  const docFiles = fs.readdirSync(docsDir).filter(function(f) {
+    return f.toLowerCase().includes("install") || f.toLowerCase().includes("activation") || f.toLowerCase().includes("readiness");
+  });
+  if (docFiles.length === 0) {
+    return warn("install_docs_current", "Install docs current",
+      "Add install/activation documentation to docs/ directory.",
+      null, "No install or activation docs found in docs/.");
+  }
+  return pass("install_docs_current", "Install docs current",
+    { docCount: docFiles.length, examples: docFiles.slice(0, 3) }, null);
+}
+
+function checkActivationEntrypointAvailable(cwd) {
+  const cliPath = path.join(cwd, "scripts", "lib", "public-cli.js");
+  if (!fs.existsSync(cliPath)) {
+    return blocked("activation_entrypoint_available", "Activation entrypoint available",
+      "Create scripts/lib/public-cli.js with activate command.",
+      null, "public-cli.js not found.");
+  }
+  const content = fs.readFileSync(cliPath, "utf8");
+  const hasActivate = content.includes('"activate"') || content.includes("'activate'");
+  const hasInstallAi = content.includes('"install-ai"') || content.includes("'install-ai'");
+  if (!hasActivate && !hasInstallAi) {
+    return warn("activation_entrypoint_available", "Activation entrypoint available",
+      "Add activate or install-ai command to public-cli.js.",
+      null, "No activate or install-ai command found in public-cli.js.");
+  }
+  return pass("activation_entrypoint_available", "Activation entrypoint available",
+    { hasActivate: hasActivate, hasInstallAi: hasInstallAi }, null);
+}
+
+function checkDoctorAvailable(cwd) {
+  const cliPath = path.join(cwd, "scripts", "lib", "public-cli.js");
+  if (!fs.existsSync(cliPath)) {
+    return warn("doctor_available", "Doctor/readiness check available",
+      "Add doctor command to public-cli.js.",
+      null, "public-cli.js not found.");
+  }
+  const content = fs.readFileSync(cliPath, "utf8");
+  const hasDoctor = content.includes('"doctor"') || content.includes("'doctor'");
+  const hasReadiness = content.includes('"readiness"') || content.includes("'readiness'");
+  const hasPrelaunhReadiness = content.includes('"prelaunch-readiness"') || content.includes("'prelaunch-readiness'");
+  if (!hasDoctor && !hasReadiness && !hasPrelaunhReadiness) {
+    return warn("doctor_available", "Doctor/readiness check available",
+      "Add a doctor or readiness command so users can self-diagnose setup issues.",
+      null, "No doctor or readiness command found.");
+  }
+  return pass("doctor_available", "Doctor/readiness check available",
+    { hasDoctor: hasDoctor, hasReadiness: hasReadiness }, null);
+}
+
+function checkFirstValueSurfaceAvailable(cwd) {
+  const firstValueArtifact = safeReadJson(path.join(cwd, ".claude/cco/orchestration/prelaunch-readiness/latest-activation-readiness.json"));
+  const valueSummary = safeReadJson(path.join(cwd, ".claude/cco/orchestration/seamless-outcome/latest-value-summary.json"));
+  const cliPath = path.join(cwd, "scripts", "lib", "public-cli.js");
+  const hasFirstValueCmd = fs.existsSync(cliPath) &&
+    (fs.readFileSync(cliPath, "utf8").includes("first-value") || fs.readFileSync(cliPath, "utf8").includes("first_value"));
+  if (!firstValueArtifact && !valueSummary && !hasFirstValueCmd) {
+    return warn("first_value_surface_available", "First value surface available",
+      "Run: node bin/avorelo first-value-check --json to generate first value surface.",
+      null, "No first-value artifact or command found.");
+  }
+  return pass("first_value_surface_available", "First value surface available",
+    { hasActivationArtifact: !!firstValueArtifact, hasValueSummary: !!valueSummary, hasCliCommand: hasFirstValueCmd }, null);
+}
+
+function checkClearNextActionAvailable(cwd) {
+  const gate = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-gate.json"));
+  if (!gate) {
+    return warn("clear_next_action_available", "Clear next action available",
+      "Run: node bin/avorelo full-readiness --json to generate gate with safeNextAction.",
+      null, "Full readiness gate artifact not found.");
+  }
+  if (!gate.safeNextAction || gate.safeNextAction.length < 10) {
+    return warn("clear_next_action_available", "Clear next action available",
+      "Re-run full-readiness gate. safeNextAction should be specific and actionable.",
+      gate, "Gate has no safeNextAction or it is too vague.");
+  }
+  return pass("clear_next_action_available", "Clear next action available",
+    { safeNextAction: gate.safeNextAction.slice(0, 80) }, null);
+}
+
+function checkRecoveryPathAvailable(cwd) {
+  const hardening = safeReadJson(path.join(cwd, ".claude/cco/orchestration/launch-hardening/latest-gate.json"));
+  const failureRecovery = safeReadJson(path.join(cwd, ".claude/cco/orchestration/launch-hardening/latest-failure-recovery.json"));
+  const cliPath = path.join(cwd, "scripts", "lib", "public-cli.js");
+  const hasRecoveryCmd = fs.existsSync(cliPath) &&
+    (fs.readFileSync(cliPath, "utf8").includes("recovery") || fs.readFileSync(cliPath, "utf8").includes("resume"));
+  if (!hardening && !failureRecovery && !hasRecoveryCmd) {
+    return warn("recovery_path_available", "Failure/recovery path available",
+      "Run: node bin/avorelo launch-hardening --json to verify recovery gates.",
+      null, "No hardening or failure recovery artifact found.");
+  }
+  return pass("recovery_path_available", "Failure/recovery path available",
+    { hasHardening: !!hardening, hasFailureRecovery: !!failureRecovery, hasCli: hasRecoveryCmd }, null);
+}
+
+function checkSupportBundleAvailable(cwd) {
+  const bundle = safeReadJson(path.join(cwd, ".claude/cco/support/latest-support-bundle.json"));
+  if (!bundle) {
+    return warn("support_bundle_available", "Support bundle available",
+      "Run: node bin/avorelo support-bundle --json to generate a redacted support bundle.",
+      null, "Support bundle artifact not found.");
+  }
+  if (bundle.redacted !== true) {
+    return blocked("support_bundle_available", "Support bundle available",
+      "Regenerate support bundle with redacted: true.",
+      null, "Support bundle exists but redacted is not true — safety violation.");
+  }
+  return pass("support_bundle_available", "Support bundle available",
+    { redacted: bundle.redacted }, null);
+}
+
+function checkKnownLimitationsVisible(cwd) {
+  const kl = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-known-limitations.json"));
+  if (!kl) {
+    return warn("known_limitations_visible", "Known limitations visible",
+      "Run: node bin/avorelo known-limitations --json to generate limitations register.",
+      null, "Known limitations artifact not found.");
+  }
+  if (!kl.limitations || kl.limitations.length === 0) {
+    return warn("known_limitations_visible", "Known limitations visible",
+      "Known limitations register is empty — must document real limitations.",
+      null, "Empty limitations register.");
+  }
+  const blockers = kl.limitations.filter(function(l) { return l.severity === "blocker" && l.status === "needs_fix"; });
+  if (blockers.length > 0) {
+    return blocked("known_limitations_visible", "Known limitations visible",
+      "Resolve blocker limitations before proceeding with distribution.",
+      { blockerIds: blockers.map(function(b) { return b.id; }) },
+      blockers.length + " blocker limitation(s) unresolved.");
+  }
+  return pass("known_limitations_visible", "Known limitations visible",
+    { totalLimitations: kl.limitations.length, blockers: 0 }, null);
+}
+
+function checkReleaseCandidateBundleSafe(cwd) {
+  const rcb = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-release-candidate-bundle.json"));
+  if (!rcb) {
+    return warn("release_candidate_bundle_safe", "Release candidate bundle safe",
+      "Run: node bin/avorelo release-candidate-bundle --json",
+      null, "Release candidate bundle not found.");
+  }
+  if (rcb.rawContentExcluded !== true) {
+    return blocked("release_candidate_bundle_safe", "Release candidate bundle safe",
+      "Regenerate release candidate bundle. rawContentExcluded must be true.",
+      null, "rawContentExcluded is not true — raw content may be exposed.");
+  }
+  return pass("release_candidate_bundle_safe", "Release candidate bundle safe",
+    { rawContentExcluded: rcb.rawContentExcluded, redacted: rcb.redacted }, null);
+}
+
+function checkEvidenceClosureComplete(cwd) {
+  const ec = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-evidence-closure.json"));
+  if (!ec) {
+    return warn("evidence_closure_complete", "Evidence closure complete",
+      "Run: node bin/avorelo readiness-closure --json",
+      null, "Evidence closure artifact not found.");
+  }
+  if (ec.status === "complete") {
+    return pass("evidence_closure_complete", "Evidence closure complete",
+      { evidencePresentCount: ec.evidencePresentCount, totalChecked: ec.totalChecked }, null);
+  }
+  if (ec.evidenceMissingCount > 0) {
+    return warn("evidence_closure_complete", "Evidence closure complete",
+      ec.nextAction || "Follow recoverCommand for each missing artifact.",
+      { presentCount: ec.evidencePresentCount, missingCount: ec.evidenceMissingCount },
+      ec.evidenceMissingCount + " artifact(s) still missing.");
+  }
+  return pass("evidence_closure_complete", "Evidence closure complete",
+    { status: ec.status }, null);
+}
+
+function checkExternalUserSimulationCovered(cwd) {
+  const sim = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-external-user-simulation.json"));
+  if (!sim) {
+    return warn("external_user_simulation_covered", "External user simulation covered",
+      "Run: node bin/avorelo external-user-sim --json",
+      null, "External user simulation not run.");
+  }
+  if (sim.blocked > 0) {
+    return blocked("external_user_simulation_covered", "External user simulation covered",
+      "Fix blocked scenarios. Run: node bin/avorelo external-user-sim --json",
+      { blockedCount: sim.blocked },
+      sim.blocked + " scenario(s) blocked in external user simulation.");
+  }
+  return pass("external_user_simulation_covered", "External user simulation covered",
+    { passed: sim.passed, warned: sim.warned, total: sim.totalScenarios }, null);
+}
+
+function checkTokenCostHonest(cwd) {
+  const tc = safeReadJson(path.join(cwd, ".claude/cco/orchestration/prelaunch-intelligence/latest-token-cost-intelligence.json"));
+  if (!tc) {
+    return warn("token_cost_honest", "Token cost evidence honest",
+      "Run: node bin/avorelo token-cost --json. Status not_available is acceptable.",
+      null, "Token cost intelligence artifact not found.");
+  }
+  if (tc.noExactSavingsClaim !== true) {
+    return blocked("token_cost_honest", "Token cost evidence honest",
+      "Ensure noExactSavingsClaim=true in token cost intelligence.",
+      null, "noExactSavingsClaim is not true — exact savings claim may be made.");
+  }
+  return pass("token_cost_honest", "Token cost evidence honest",
+    { status: tc.status, evidenceLevel: tc.evidenceLevel, noExactSavingsClaim: tc.noExactSavingsClaim }, null);
+}
+
+function checkFeedbackIntelligenceHonest(cwd) {
+  const fi = safeReadJson(path.join(cwd, ".claude/cco/orchestration/prelaunch-intelligence/latest-feedback-intelligence.json"));
+  if (!fi) {
+    return warn("feedback_intelligence_honest", "Feedback intelligence honest",
+      "Run: node bin/avorelo feedback insights --json. Insufficient is acceptable; missing is not.",
+      null, "Feedback intelligence artifact not found.");
+  }
+  // As long as the artifact exists and represents the truth, it passes — even if insufficient
+  return pass("feedback_intelligence_honest", "Feedback intelligence honest",
+    { status: fi.status, sessionsAnalyzed: fi.sessionsAnalyzed, redacted: fi.redacted }, null);
+}
+
+function checkNoPublicLaunchClaim(cwd) {
+  const gate = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-gate.json"));
+  const rcb = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-release-candidate-bundle.json"));
+  var violations = [];
+  if (gate && gate.noPublicLaunchClaim !== true) violations.push("full-readiness gate");
+  if (rcb && rcb.noPublicLaunchClaim !== true) violations.push("release-candidate-bundle");
+  if (violations.length > 0) {
+    return blocked("no_public_launch_claim", "No public launch claim on outputs",
+      "Set noPublicLaunchClaim: true on all output artifacts.",
+      null, "Violations: " + violations.join(", "));
+  }
+  return pass("no_public_launch_claim", "No public launch claim on outputs",
+    { verified: ["full-readiness gate", "release-candidate-bundle"] }, null);
+}
+
+function checkSafeNextActionExists(cwd) {
+  const gate = safeReadJson(path.join(cwd, ".claude/cco/orchestration/full-readiness/latest-gate.json"));
+  if (!gate) {
+    return warn("safe_next_action_exists", "Safe next action for every blocker/warning",
+      "Run: node bin/avorelo full-readiness --json to generate gate.",
+      null, "Gate artifact not found.");
+  }
+  const blockers = gate.blockers || [];
+  const missingSnA = blockers.filter(function(b) { return !b.safeNextAction || b.safeNextAction.length < 5; });
+  if (missingSnA.length > 0) {
+    return blocked("safe_next_action_exists", "Safe next action for every blocker/warning",
+      "Add safeNextAction to all blockers in full-readiness-gate.js.",
+      { missingIds: missingSnA.map(function(b) { return b.id; }) },
+      "Blockers without safeNextAction: " + missingSnA.map(function(b) { return b.id; }).join(", "));
+  }
+  if (!gate.safeNextAction) {
+    return warn("safe_next_action_exists", "Safe next action for every blocker/warning",
+      "Add top-level safeNextAction to full-readiness gate.",
+      null, "Gate has no top-level safeNextAction.");
+  }
+  return pass("safe_next_action_exists", "Safe next action for every blocker/warning",
+    { blockerCount: blockers.length, allHaveSafeNextAction: true }, null);
+}
+
+function collectActivationDistributionSignals(cwd) {
+  function read(rel) { return safeReadJson(path.join(cwd, rel)); }
+  return {
+    gate: read(".claude/cco/orchestration/full-readiness/latest-gate.json"),
+    evidenceClosure: read(".claude/cco/orchestration/full-readiness/latest-evidence-closure.json"),
+    knownLimitations: read(".claude/cco/orchestration/full-readiness/latest-known-limitations.json"),
+    externalUserSim: read(".claude/cco/orchestration/full-readiness/latest-external-user-simulation.json"),
+    releaseCandidateBundle: read(".claude/cco/orchestration/full-readiness/latest-release-candidate-bundle.json"),
+    supportBundle: read(".claude/cco/support/latest-support-bundle.json"),
+    tokenCost: read(".claude/cco/orchestration/prelaunch-intelligence/latest-token-cost-intelligence.json"),
+    feedbackIntelligence: read(".claude/cco/orchestration/prelaunch-intelligence/latest-feedback-intelligence.json"),
+    prelaunchReadiness: read(".claude/cco/orchestration/prelaunch-readiness/latest-activation-readiness.json"),
+    valueSummary: read(".claude/cco/orchestration/seamless-outcome/latest-value-summary.json"),
+    hardening: read(".claude/cco/orchestration/launch-hardening/latest-gate.json"),
+  };
+}
+
+function scoreActivationDistributionReadiness(checks) {
+  var totalEarned = 0;
+  checks.forEach(function(c) {
+    var weight = CHECK_WEIGHTS[c.id] || 0;
+    if (c.status === "pass" || c.status === "info") totalEarned += weight;
+    else if (c.status === "warn") totalEarned += Math.floor(weight * 0.5);
+  });
+  return Math.round((totalEarned / TOTAL_WEIGHT) * 100);
+}
+
+function runActivationDistributionReadiness(cwd, options) {
+  options = options || {};
+  var checks = [
+    checkInstallCommandAvailable(cwd),
+    checkInstallDocsCurrent(cwd),
+    checkActivationEntrypointAvailable(cwd),
+    checkDoctorAvailable(cwd),
+    checkFirstValueSurfaceAvailable(cwd),
+    checkClearNextActionAvailable(cwd),
+    checkRecoveryPathAvailable(cwd),
+    checkSupportBundleAvailable(cwd),
+    checkKnownLimitationsVisible(cwd),
+    checkReleaseCandidateBundleSafe(cwd),
+    checkEvidenceClosureComplete(cwd),
+    checkExternalUserSimulationCovered(cwd),
+    checkTokenCostHonest(cwd),
+    checkFeedbackIntelligenceHonest(cwd),
+    checkNoPublicLaunchClaim(cwd),
+    checkSafeNextActionExists(cwd),
+  ];
+
+  var blockers = checks.filter(function(c) { return c.status === "blocked"; });
+  var warnings = checks.filter(function(c) { return c.status === "warn"; });
+  var passes = checks.filter(function(c) { return c.status === "pass"; });
+  var score = scoreActivationDistributionReadiness(checks);
+
+  var status;
+  if (blockers.length > 0) status = "blocked";
+  else if (score >= SCORE_READY) status = "ready";
+  else if (score >= SCORE_WARN) status = "warn";
+  else status = "insufficient_data";
+
+  var safeNextActions = [];
+  blockers.forEach(function(b) { if (b.safeNextAction) safeNextActions.push(b.safeNextAction); });
+  warnings.slice(0, 3).forEach(function(w) { if (w.safeNextAction) safeNextActions.push(w.safeNextAction); });
+  if (safeNextActions.length === 0) safeNextActions.push("Run: node bin/avorelo readiness-closure --json to identify missing evidence.");
+
+  var releaseCandidateStatus = (status === "ready") ? "candidate_ready" : (status === "warn") ? "candidate_warn" : "candidate_blocked";
+
+  var result = {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: nowIso(),
+    status: status,
+    releaseCandidateStatus: releaseCandidateStatus,
+    score: score,
+    checks: checks,
+    blockers: blockers,
+    warnings: warnings,
+    passes: passes,
+    safeNextActions: safeNextActions,
+    noPublicLaunchClaim: true,
+    noReleaseReadyClaimUnlessPassed: true,
+    redacted: true,
+  };
+
+  try { appendProductLearningEvent(cwd, { eventName: "activation_distribution_readiness_run", category: "activation_distribution", status: status, score: score, blockerCount: blockers.length, warnCount: warnings.length }); } catch (e) {}
+  return result;
+}
+
+function writeActivationDistributionReadiness(cwd, result) {
+  var dir = path.join(cwd, ARTIFACT_DIR_REL);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(cwd, ARTIFACT_REL), JSON.stringify(result, null, 2));
+  return result;
+}
+
+function buildActivationDistributionSurface(cwd, options) {
+  options = options || {};
+  var artifact = safeReadJson(path.join(cwd, ARTIFACT_REL));
+  if (!artifact) return { status: "not_available", contract: CONTRACT };
+  return {
+    contract: artifact.contract,
+    status: artifact.status,
+    releaseCandidateStatus: artifact.releaseCandidateStatus,
+    score: artifact.score,
+    blockerCount: (artifact.blockers || []).length,
+    warningCount: (artifact.warnings || []).length,
+    safeNextActions: (artifact.safeNextActions || []).slice(0, 3),
+    noPublicLaunchClaim: artifact.noPublicLaunchClaim,
+    redacted: artifact.redacted,
+  };
+}
+
+function formatActivationDistributionText(result, options) {
+  options = options || {};
+  var lines = [];
+  lines.push("Activation distribution readiness: " + result.status + " (score: " + result.score + "/100)");
+  if (result.blockers && result.blockers.length > 0) {
+    lines.push("Blockers: " + result.blockers.length);
+    result.blockers.forEach(function(b) { lines.push("  [blocked] " + b.label + " — " + (b.safeNextAction || "")); });
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    lines.push("Warnings: " + result.warnings.length);
+    if (options.debug) result.warnings.forEach(function(w) { lines.push("  [warn] " + w.label + " — " + (w.safeNextAction || "")); });
+  }
+  if (result.safeNextActions && result.safeNextActions.length > 0) {
+    lines.push("Next: " + result.safeNextActions[0]);
+  }
+  lines.push("No public launch claim. Redacted.");
+  if (options.debug) {
+    lines.push("");
+    lines.push("Checks:");
+    (result.checks || []).forEach(function(c) { lines.push("  [" + c.status + "] " + c.id + (c.detail ? " — " + c.detail : "")); });
+  }
+  return lines.join("\n");
+}
+
+module.exports = {
+  CONTRACT,
+  SCHEMA_VERSION,
+  ARTIFACT_REL,
+  SCORE_READY,
+  SCORE_WARN,
+  CHECK_WEIGHTS,
+  collectActivationDistributionSignals,
+  scoreActivationDistributionReadiness,
+  runActivationDistributionReadiness,
+  writeActivationDistributionReadiness,
+  buildActivationDistributionSurface,
+  formatActivationDistributionText,
+  // Individual checks exported for testing
+  checkInstallCommandAvailable,
+  checkInstallDocsCurrent,
+  checkActivationEntrypointAvailable,
+  checkDoctorAvailable,
+  checkFirstValueSurfaceAvailable,
+  checkClearNextActionAvailable,
+  checkRecoveryPathAvailable,
+  checkSupportBundleAvailable,
+  checkKnownLimitationsVisible,
+  checkReleaseCandidateBundleSafe,
+  checkEvidenceClosureComplete,
+  checkExternalUserSimulationCovered,
+  checkTokenCostHonest,
+  checkFeedbackIntelligenceHonest,
+  checkNoPublicLaunchClaim,
+  checkSafeNextActionExists,
+};

package/scripts/lib/adapter-conformance.js

@@ -0,0 +1,176 @@
+"use strict";
+
+const { HOOK_EVENT_NAMES } = require("./hook-contracts");
+
+const CAPABILITY_MAP = {
+  claude: {
+    platform: "claude",
+    supportsHooks: [...HOOK_EVENT_NAMES],
+    supportsToolOutputReplacement: true,
+    supportsPermissionDecision: true,
+    supportsPanelLaunch: true,
+    supportsRules: false,
+    supportsMCPConfig: true,
+    supportsExtensionBridge: false,
+    supportsPermissionControl: true,
+    partialSupportNotes: [],
+  },
+  cursor: {
+    platform: "cursor",
+    supportsHooks: ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "SessionEnd"],
+    supportsToolOutputReplacement: false,
+    supportsPermissionDecision: false,
+    supportsPanelLaunch: true,
+    supportsRules: true,
+    supportsMCPConfig: true,
+    supportsExtensionBridge: true,
+    supportsPermissionControl: false,
+    partialSupportNotes: [
+      "Cursor does not provide Claude-equivalent hook lifecycle for all 18 events.",
+      "Permission decisions are advisory via rules/extension workflow.",
+      "Tool output replacement is not directly supported; recommendations are post-action.",
+    ],
+  },
+  windsurf: {
+    platform: "windsurf",
+    supportsHooks: [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PreToolUse",
+      "PostToolUse",
+      "PostToolUseFailure",
+      "Notification",
+      "Stop",
+      "TaskCompleted",
+      "SubagentStart",
+      "SubagentStop",
+      "ConfigChange",
+      "SessionEnd",
+    ],
+    supportsToolOutputReplacement: false,
+    supportsPermissionDecision: true,
+    supportsPanelLaunch: true,
+    supportsRules: false,
+    supportsMCPConfig: true,
+    supportsExtensionBridge: false,
+    supportsPermissionControl: true,
+    partialSupportNotes: [
+      "Tool output replacement is host-limited; optimizer uses post-action recommendations instead.",
+      "Hook names differ by host; mapped through adapter contract.",
+    ],
+  },
+  "copilot-coding-agent": {
+    platform: "copilot-coding-agent",
+    supportsHooks: ["SessionStart", "PreToolUse", "PostToolUse", "Stop", "TaskCompleted", "SessionEnd"],
+    supportsToolOutputReplacement: false,
+    supportsPermissionDecision: false,
+    supportsPanelLaunch: true,
+    supportsRules: true,
+    supportsMCPConfig: false,
+    supportsExtensionBridge: false,
+    supportsPermissionControl: false,
+    partialSupportNotes: [
+      "No first-class permission decision hook parity; guardrails run in advisory mode.",
+      "Notification and teammate events are synthesized from available telemetry.",
+    ],
+  },
+  continue: {
+    platform: "continue",
+    supportsHooks: ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "SessionEnd"],
+    supportsToolOutputReplacement: false,
+    supportsPermissionDecision: false,
+    supportsPanelLaunch: true,
+    supportsRules: true,
+    supportsMCPConfig: true,
+    supportsExtensionBridge: false,
+    supportsPermissionControl: false,
+    partialSupportNotes: [
+      "Permission decisions are advisory due to host capabilities.",
+      "Subagent and worktree lifecycle events are approximated when unavailable.",
+    ],
+  },
+  codex: {
+    platform: "codex",
+    supportsHooks: ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop", "SessionEnd"],
+    supportsToolOutputReplacement: false,
+    supportsPermissionDecision: true,
+    supportsPanelLaunch: true,
+    supportsRules: false,
+    supportsMCPConfig: true,
+    supportsExtensionBridge: false,
+    supportsPermissionControl: true,
+    partialSupportNotes: ["Hook/event mapping relies on adapter routing and may not expose all Claude-native lifecycle events."],
+  },
+};
+
+function normalizePlatform(platform) {
+  const p = String(platform || "claude").toLowerCase();
+  if (p === "copilot" || p === "github-copilot" || p === "github-copilot-coding-agent") return "copilot-coding-agent";
+  return CAPABILITY_MAP[p] ? p : "claude";
+}
+
+function getAdapterCapabilityMap(platform) {
+  const key = normalizePlatform(platform);
+  return CAPABILITY_MAP[key];
+}
+
+function normalizeDashboardForPlatform(platform, dashboard) {
+  const capabilityMap = getAdapterCapabilityMap(platform);
+  const unsupportedHooks = HOOK_EVENT_NAMES.filter((evt) => !capabilityMap.supportsHooks.includes(evt));
+
+  return {
+    platform: capabilityMap.platform,
+    capabilityMap,
+    partialSupport: unsupportedHooks.length > 0,
+    partialSupportNotes: [...capabilityMap.partialSupportNotes],
+    unsupportedHooks,
+    statusDashboardVersion: dashboard.statusDashboardVersion,
+    tier: dashboard.tier,
+    dashboardFraming: dashboard.dashboardFraming,
+    benefitSummary: dashboard.benefitSummary,
+    memorySummary: dashboard.memorySummary,
+    contextBudgetPlan: dashboard.contextBudgetPlan,
+    recommendationTraces: dashboard.recommendationTraces || [],
+    recommendationDecision: dashboard.recommendationDecision || null,
+    nextBestAction: dashboard.nextBestAction,
+    nextBestPrompt: dashboard.nextBestPrompt,
+    simplifyModeStatus: dashboard.simplifyModeStatus,
+    teamUnifiedView: dashboard.teamUnifiedView,
+    pricingMeter: dashboard.pricingMeter,
+    cloudSync: dashboard.cloudSync,
+  };
+}
+
+function hasNormalizedDashboardShape(payload) {
+  return Boolean(
+    payload &&
+      typeof payload === "object" &&
+      typeof payload.platform === "string" &&
+      payload.capabilityMap &&
+      Array.isArray(payload.capabilityMap.supportsHooks) &&
+      typeof payload.capabilityMap.supportsToolOutputReplacement === "boolean" &&
+      typeof payload.capabilityMap.supportsPermissionDecision === "boolean" &&
+      typeof payload.capabilityMap.supportsPanelLaunch === "boolean" &&
+      typeof payload.capabilityMap.supportsRules === "boolean" &&
+      typeof payload.capabilityMap.supportsMCPConfig === "boolean" &&
+      typeof payload.capabilityMap.supportsExtensionBridge === "boolean" &&
+      Array.isArray(payload.partialSupportNotes) &&
+      payload.benefitSummary &&
+      payload.memorySummary &&
+      payload.contextBudgetPlan &&
+      typeof payload.nextBestAction === "string" &&
+      typeof payload.nextBestPrompt === "string" &&
+      payload.simplifyModeStatus &&
+      payload.pricingMeter &&
+      payload.teamUnifiedView &&
+      payload.cloudSync
+  );
+}
+
+module.exports = {
+  CAPABILITY_MAP,
+  normalizePlatform,
+  getAdapterCapabilityMap,
+  normalizeDashboardForPlatform,
+  hasNormalizedDashboardShape,
+};