avorelo 0.1.0 → 0.2.0

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

@@ -1,507 +0,0 @@
-"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

@@ -1,176 +0,0 @@
-"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,
-};