avorelo 0.1.0 → 0.3.0

package/scripts/lib/full-readiness-gate.js

@@ -1,451 +0,0 @@
-"use strict";
-
-// ── Full Readiness / Release Candidate Gate ───────────────────────────────────
-// Contract: avorelo.fullReadinessGate.v1
-// Consumes all existing signals and makes a formal go/no-go release candidate
-// determination. Local-only. Redacted. No public launch claim.
-
-const fs = require("fs");
-const path = require("path");
-const { nowIso } = require("./fsx");
-const { appendProductLearningEvent } = require("./product-learning-events");
-
-const CONTRACT = "avorelo.fullReadinessGate.v1";
-const SCHEMA_VERSION = 1;
-const GATE_DIR_REL = ".claude/cco/orchestration/full-readiness";
-const ARTIFACT_REL = GATE_DIR_REL + "/latest-gate.json";
-const SCORE_READY = 85;
-const SCORE_WARN = 70;
-
-function safeReadJson(absPath) {
-  try {
-    if (!fs.existsSync(absPath)) return null;
-    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
-  } catch { return null; }
-}
-
-function collectFullReadinessSignals(cwd, options) {
-  options = options || {};
-  function read(rel) { return safeReadJson(path.join(cwd, rel)); }
-  var proofOutcomeEvidence = null;
-  var installAiReadiness = null;
-  var failureRecoveryReadiness = null;
-  var hookSafetyBoundaryReadiness = null;
-  try {
-    var poe = require("./proof-outcome-evidence");
-    proofOutcomeEvidence = poe.buildProofOutcomeEvidence(cwd);
-    poe.writeProofOutcomeEvidence(cwd, proofOutcomeEvidence);
-  } catch (e) {}
-  try { installAiReadiness = require("./install-ai-readiness").buildInstallAiReadiness(cwd); } catch (e) {}
-  try { failureRecoveryReadiness = require("./failure-recovery-readiness").buildFailureRecoveryReadiness(cwd); } catch (e) {}
-  try { hookSafetyBoundaryReadiness = require("./hook-safety-boundary-readiness").buildHookSafetyBoundaryReadiness(cwd); } catch (e) {}
-  return {
-    prelaunchIntelligence: read(".claude/cco/orchestration/prelaunch-intelligence/latest-intelligence.json"),
-    feedbackIntelligence: read(".claude/cco/orchestration/prelaunch-intelligence/latest-feedback-intelligence.json"),
-    tokenCostIntelligence: read(".claude/cco/orchestration/prelaunch-intelligence/latest-token-cost-intelligence.json"),
-    installJourneyIntelligence: read(".claude/cco/orchestration/prelaunch-intelligence/latest-install-journey.json"),
-    installPrompt: read(".claude/cco/orchestration/ai-install/latest-prompt.json"),
-    installAiReadiness: installAiReadiness,
-    prelaunchReadiness: read(".claude/cco/orchestration/prelaunch-readiness/latest-activation-readiness.json"),
-    activation: read(".claude/cco/orchestration/activation/latest-activation.json"),
-    alphaReadiness: read(".claude/cco/orchestration/alpha-readiness/latest-gate.json"),
-    launchHardening: read(".claude/cco/orchestration/launch-hardening/latest-gate.json"),
-    failureRecovery: read(".claude/cco/orchestration/failure-recovery/latest-recovery.json"),
-    failureRecoveryReadiness: failureRecoveryReadiness,
-    artifactHealth: read(".claude/cco/orchestration/artifact-health/latest-health.json"),
-    tokenEfficiency: read(".claude/cco/orchestration/token-efficiency/latest-evidence.json"),
-    tokenQualityGate: read(".claude/cco/orchestration/token-efficiency/latest-quality-gate.json"),
-    mcpInventory: read(".claude/cco/orchestration/mcp-tool-governance/latest-inventory.json"),
-    mcpRisk: read(".claude/cco/orchestration/mcp-tool-governance/latest-risk.json"),
-    mcpPolicy: read(".claude/cco/orchestration/mcp-tool-governance/latest-policy.json"),
-    hookDoctor: read(".claude/cco/orchestration/hook-apply/latest-doctor.json"),
-    hookSafetyBoundaryReadiness: hookSafetyBoundaryReadiness,
-    supportBundle: read(".claude/cco/support/latest-support-bundle.json"),
-    valueSummary: read(".claude/cco/orchestration/seamless-outcome/latest-value-summary.json"),
-    realityGate: read(".claude/cco/orchestration/seamless-outcome/latest-reality-gate.json"),
-    proofOutcomeEvidence: proofOutcomeEvidence,
-    companyLoop: read(".claude/cco/orchestration/company-loop/latest-report.json"),
-    activationDistribution: (function() { try { var adr = require("./activation-distribution-readiness"); return adr.buildActivationDistributionSurface(cwd, {}); } catch(e) { return null; } })(),
-    publicDistributionGate: (function() {
-      try { return safeReadJson(path.join(cwd, ".claude/cco/orchestration/public-distribution/latest-gate.json")); } catch(e) { return null; }
-    })(),
-    adapterTechnicalReadiness: (function() {
-      try { return safeReadJson(path.join(cwd, ".claude/cco/orchestration/adapter-readiness/latest-technical-gate.json")); } catch(e) { return null; }
-    })(),
-  };
-}
-
-function checkInstallAi(signals) {
-  var readiness = signals.installAiReadiness;
-  if (readiness) {
-    if (readiness.status === "pass") return { id: "install_ai", status: "pass", message: "AI install path present with explicit approval boundaries" };
-    return {
-      id: "install_ai",
-      status: "warn",
-      message: "AI install path exists but still has internal readiness gaps",
-      safeNextAction: (readiness.safeNextActions && readiness.safeNextActions[0]) || "Run: node bin/avorelo install-ai --json",
-    };
-  }
-  var s = signals.installPrompt;
-  if (!s) return { id: "install_ai", status: "warn", message: "AI install prompt not generated", safeNextAction: "Run: node bin/avorelo install-ai --json" };
-  var ok = s.activationAvailable === true && s.prelaunchAvailable === true && Array.isArray(s.approvalBoundaries) && s.approvalBoundaries.length > 0;
-  if (!ok) return { id: "install_ai", status: "warn", message: "AI install prompt exists but approval boundaries unclear", safeNextAction: "Run: node bin/avorelo install-ai --json" };
-  return { id: "install_ai", status: "pass", message: "AI install prompt present with approval boundaries" };
-}
-
-function checkFirstValue(signals) {
-  var s = signals.prelaunchReadiness;
-  if (!s) return { id: "first_value", status: "warn", message: "First value check not run", safeNextAction: "Run: node bin/avorelo first-value-check --json" };
-  var fv = s.firstValuePath || s.firstValue || s.firstValueJourney;
-  if (!fv) return { id: "first_value", status: "warn", message: "First value path not confirmed", safeNextAction: "Run: node bin/avorelo first-value-check --json" };
-  return { id: "first_value", status: "pass", message: "First value path confirmed" };
-}
-
-function checkPrelaunchActivation(signals) {
-  var s = signals.prelaunchReadiness;
-  if (!s) return { id: "prelaunch_activation", status: "warn", message: "Prelaunch activation readiness not run", safeNextAction: "Run: node bin/avorelo prelaunch-readiness --json" };
-  if (s.status !== "ready" && s.status !== "warn" && s.status !== "pass") return { id: "prelaunch_activation", status: "blocked", message: "Prelaunch readiness status: " + (s.status || "unknown"), safeNextAction: "Run: node bin/avorelo prelaunch-readiness --json and resolve blockers" };
-  return { id: "prelaunch_activation", status: (s.status === "ready" || s.status === "pass") ? "pass" : "warn", message: "Prelaunch readiness: " + s.status };
-}
-
-function checkPrelaunchIntelligence(signals) {
-  var s = signals.prelaunchIntelligence;
-  if (!s) return { id: "prelaunch_intelligence", status: "warn", message: "Prelaunch intelligence not run", safeNextAction: "Run: node bin/avorelo prelaunch-intelligence --json" };
-  var score = s.score || 0;
-  if ((s.missingEvidence || []).length > 0) {
-    return {
-      id: "prelaunch_intelligence",
-      status: "warn",
-      message: "Prelaunch intelligence has unresolved evidence gaps",
-      safeNextAction: (s.safeNextActions && s.safeNextActions[0]) || "Run: node bin/avorelo prelaunch-intelligence --json",
-    };
-  }
-  if (score >= SCORE_READY) return { id: "prelaunch_intelligence", status: "pass", message: "Intelligence score: " + score };
-  return { id: "prelaunch_intelligence", status: "warn", message: "Intelligence score: " + score + " (below " + SCORE_READY + " ready threshold)", safeNextAction: "Run dogfood feedback pass then rerun prelaunch-intelligence" };
-}
-
-function checkLaunchHardening(signals) {
-  var s = signals.launchHardening;
-  if (!s) return { id: "launch_hardening", status: "warn", message: "Launch hardening gate not run", safeNextAction: "Run: node bin/avorelo launch-hardening --json" };
-  if ((s.summary && s.summary.fail || 0) > 0) return { id: "launch_hardening", status: "blocked", message: "Launch hardening has " + s.summary.fail + " failures", safeNextAction: "Run: node bin/avorelo launch-hardening --json and resolve failures" };
-  return { id: "launch_hardening", status: "pass", message: "Launch hardening pass: " + (s.summary && s.summary.pass || 0) + ", warn: " + (s.summary && s.summary.warn || 0) };
-}
-
-function checkFailureRecovery(signals) {
-  var readiness = signals.failureRecoveryReadiness;
-  if (readiness) {
-    if (readiness.status === "pass") return { id: "failure_recovery", status: "pass", message: "Failure recovery path and support surfaces are internally ready" };
-    return {
-      id: "failure_recovery",
-      status: "warn",
-      message: "Failure recovery path still has internal readiness gaps",
-      safeNextAction: (readiness.safeNextActions && readiness.safeNextActions[0]) || "Run: node bin/avorelo launch-hardening --json",
-    };
-  }
-  var s = signals.failureRecovery;
-  if (!s) return { id: "failure_recovery", status: "warn", message: "Failure recovery plan not generated", safeNextAction: "Run: node bin/avorelo launch-hardening --json" };
-  return { id: "failure_recovery", status: "pass", message: "Failure recovery plan present" };
-}
-
-function checkTokenContextQuality(signals) {
-  var s = signals.tokenQualityGate;
-  var e = signals.tokenEfficiency;
-  if (!s && !e) return { id: "token_context_quality", status: "warn", message: "Token/context quality gate not run", safeNextAction: "Run: node bin/avorelo token-efficiency --json" };
-  if (s && s.summary && s.summary.fail > 0) return { id: "token_context_quality", status: "blocked", message: "Token quality gate has " + s.summary.fail + " failures", safeNextAction: "Run: node bin/avorelo token-efficiency --json and resolve failures" };
-  return { id: "token_context_quality", status: "pass", message: "Token/context quality checks passing" };
-}
-
-function checkTokenCostDiscipline(signals) {
-  var s = signals.tokenCostIntelligence;
-  if (!s) return { id: "token_cost_discipline", status: "warn", message: "Token/cost intelligence not available", safeNextAction: "Run: node bin/avorelo token-cost --json" };
-  if (s.noExactSavingsClaim === false) return { id: "token_cost_discipline", status: "blocked", message: "Exact savings claimed without verified source", safeNextAction: "Remove exact savings claims" };
-  if ((s.realUsageSamplesCount || 0) === 0) {
-    return {
-      id: "token_cost_discipline",
-      status: "warn",
-      message: "Token/cost evidence is " + (s.evidenceMode || s.evidenceLevel || "missing") + " and still lacks measured real usage samples",
-      safeNextAction: (s.safeNextActions && s.safeNextActions[0]) || "Run: node bin/avorelo token-cost import --file <redacted-json-or-jsonl> --json",
-      evidenceLevel: s.evidenceLevel || "not_available",
-    };
-  }
-  if (s.status === "not_available" || s.evidenceLevel === "not_available") return { id: "token_cost_discipline", status: "warn", message: "Token/cost evidence not_available — acceptable if caveated", evidenceLevel: "not_available" };
-  return { id: "token_cost_discipline", status: "pass", message: "Token/cost evidence: " + (s.evidenceLevel || s.status) };
-}
-
-function checkMcpToolGovernance(signals) {
-  var inv = signals.mcpInventory;
-  var risk = signals.mcpRisk;
-  var policy = signals.mcpPolicy;
-  if (!inv && !risk && !policy) return { id: "mcp_tool_governance", status: "warn", message: "MCP governance not run", safeNextAction: "Run: node bin/avorelo mcp doctor --json" };
-  if (risk && (risk.highCritical || 0) > 0) return { id: "mcp_tool_governance", status: "blocked", message: "MCP has " + risk.highCritical + " high/critical risk tools", safeNextAction: "Run: node bin/avorelo mcp doctor --json and resolve high/critical risks" };
-  return { id: "mcp_tool_governance", status: "pass", message: "MCP governance active. Risk: " + (risk && risk.status || "pass") };
-}
-
-function checkHookSafetyBoundaries(signals) {
-  var readiness = signals.hookSafetyBoundaryReadiness;
-  if (readiness) {
-    if (readiness.status === "pass") return { id: "hook_safety_boundaries", status: "pass", message: "Hook safety boundaries are enforced and explicit" };
-    return {
-      id: "hook_safety_boundaries",
-      status: "warn",
-      message: "Hook safety boundaries still need internal verification",
-      safeNextAction: (readiness.safeNextActions && readiness.safeNextActions[0]) || "Run: node bin/avorelo hooks doctor --json",
-    };
-  }
-  var s = signals.hookDoctor;
-  if (!s) return { id: "hook_safety_boundaries", status: "warn", message: "Hook doctor not run — hooks require explicit approval", safeNextAction: "Run: node bin/avorelo hooks doctor --json" };
-  if (s.summary && s.summary.fail > 0) return { id: "hook_safety_boundaries", status: "blocked", message: "Hook safety boundary check failed", safeNextAction: "Run: node bin/avorelo hooks doctor --json and resolve failures" };
-  return { id: "hook_safety_boundaries", status: "pass", message: "Hook safety boundaries enforced — hooks require explicit approval" };
-}
-
-function checkSupportBundleRedaction(signals) {
-  var s = signals.supportBundle;
-  if (!s) return { id: "support_bundle_redaction", status: "warn", message: "Support bundle not generated", safeNextAction: "Run: node bin/avorelo support-bundle --json" };
-  if (s.redacted !== true) return { id: "support_bundle_redaction", status: "blocked", message: "Support bundle is not marked redacted", safeNextAction: "Run: node bin/avorelo support-bundle --json" };
-  return { id: "support_bundle_redaction", status: "pass", message: "Support bundle present and redacted" };
-}
-
-function checkProofOutcomeEvidence(signals) {
-  var s = signals.proofOutcomeEvidence;
-  if (!s || s.latestProofAvailable !== true) {
-    return {
-      id: "proof_outcome_evidence",
-      status: "warn",
-      message: "No proof/value summary generated from a completed real task",
-      safeNextAction: (s && s.safeNextActions && s.safeNextActions[0]) || "Run: node bin/avorelo proof after completing a real task",
-      redacted: true,
-    };
-  }
-  if (s.status !== "pass") {
-    return {
-      id: "proof_outcome_evidence",
-      status: "warn",
-      message: "Proof/value summary exists but readiness evidence is still incomplete",
-      safeNextAction: (s.safeNextActions && s.safeNextActions[0]) || "Run: node bin/avorelo outcome --gate --json",
-      redacted: true,
-    };
-  }
-  return {
-    id: "proof_outcome_evidence",
-    status: "pass",
-    message: "Proof/value summary present and evidence-backed",
-    redacted: true,
-  };
-}
-
-function checkFeedbackIntelligence(signals) {
-  var s = signals.feedbackIntelligence;
-  if (!s) return { id: "feedback_intelligence", status: "warn", message: "Feedback intelligence not run", safeNextAction: "Run: node bin/avorelo feedback intake-pack --json" };
-  if ((s.qualifiedFeedbackItemsCount || 0) === 0 || s.status === "insufficient_data") {
-    return {
-      id: "feedback_intelligence",
-      status: "warn",
-      message: "Feedback insufficient — no qualified redacted feedback evidence exists",
-      safeNextAction: (s.safeNextActions && s.safeNextActions[0]) || "Run: node bin/avorelo feedback intake-pack --json",
-      evidenceLevel: "insufficient_data",
-    };
-  }
-  if (s.hasBlockerSeverity === true) return { id: "feedback_intelligence", status: "warn", message: "Feedback has blocker-severity friction", safeNextAction: "Address feedback blockers then rerun" };
-  return { id: "feedback_intelligence", status: "pass", message: "Feedback clusters: " + (s.clustersFound || 0) };
-}
-
-function checkCompanyLoopRecommendation(signals) {
-  var s = signals.companyLoop;
-  if (!s) return { id: "company_loop_recommendation", status: "warn", message: "Company loop not run", safeNextAction: "Run: node bin/avorelo company-loop --json" };
-  var rec = (s.nextPrRecommendation && s.nextPrRecommendation.recommendedNextPr) || s.recommendedNextPr;
-  return { id: "company_loop_recommendation", status: "pass", message: "Company loop recommendation: " + (rec || "present"), recommendation: rec || null };
-}
-
-function checkKnownLimitations(signals, options) {
-  options = options || {};
-  var limitations = options.knownLimitations || null;
-  if (!limitations) return { id: "known_limitations", status: "warn", message: "Known limitations register not yet built", safeNextAction: "Run: node bin/avorelo known-limitations --json" };
-  var blockerLimits = (limitations.limitations || []).filter(function(l) { return l.severity === "blocker" && l.status !== "accepted"; });
-  if (blockerLimits.length > 0) return { id: "known_limitations", status: "blocked", message: blockerLimits.length + " unmitigated blocker limitations", safeNextAction: "Resolve blocker limitations before release candidate", blockerCount: blockerLimits.length };
-  return { id: "known_limitations", status: "pass", message: "Known limitations documented: " + (limitations.limitations || []).length, count: (limitations.limitations || []).length };
-}
-
-function checkNoFalseClaims(signals) {
-  var tci = signals.tokenCostIntelligence;
-  var intel = signals.prelaunchIntelligence;
-  var pi = signals.prelaunchReadiness;
-  if ((tci && tci.noExactSavingsClaim === false) || (intel && intel.noExactSavingsClaim === false) || (pi && pi.noExactSavingsClaim === false)) {
-    return { id: "no_false_claims", status: "blocked", message: "Exact savings claimed without verified billing source", safeNextAction: "Remove exact savings claims" };
-  }
-  if ((intel && intel.noPublicLaunchClaim === false) || (pi && pi.noPublicLaunchClaim === false)) {
-    return { id: "no_false_claims", status: "blocked", message: "Public launch ready claimed before gate passes", safeNextAction: "Remove public launch claim" };
-  }
-  return { id: "no_false_claims", status: "pass", message: "No false claims detected" };
-}
-
-
-function checkAdapterTechnicalReadiness(signals) {
-  var id = "adapter_technical_readiness";
-  var s = signals.adapterTechnicalReadiness;
-  if (!s) return { id: id, status: "warn", message: "Adapter technical readiness gate not yet run.", safeNextAction: "Run: node bin/avorelo adapter-readiness-technical --json" };
-  if (s.status === "blocked") return { id: id, status: "blocked", message: "Adapter technical readiness blocked (" + (s.blockerCount || s.totalBlockers || 0) + " blockers).", safeNextAction: s.safeNextAction || "Run: node bin/avorelo adapter-readiness-technical --json and fix blockers." };
-  if (s.verdict === "adapter_ready") return { id: id, status: "pass", message: "Adapter technical readiness: ready (score " + s.score + "/100).", safeNextAction: null };
-  return { id: id, status: "warn", message: "Adapter technical readiness: " + s.status + " (score " + (s.score || "?") + "/100).", safeNextAction: s.safeNextAction || "Run: node bin/avorelo adapter-readiness-technical --json" };
-}
-
-function checkActivationDistributionReadiness(signals) {
-  var id = "activation_distribution_readiness";
-  var s = signals.activationDistribution;
-  if (!s) return { id: id, status: "warn", message: "Activation distribution readiness not yet run.", safeNextAction: "Run: node bin/avorelo activation-distribution --json" };
-  if (s.status === "blocked") return { id: id, status: "blocked", message: "Activation distribution readiness is blocked (" + (s.blockerCount || 0) + " blockers).", safeNextAction: s.safeNextActions && s.safeNextActions[0] || "Run: node bin/avorelo activation-distribution --json and fix blockers." };
-  if (s.status === "ready") return { id: id, status: "pass", message: "Activation distribution readiness: ready (score " + s.score + ").", safeNextAction: null };
-  return { id: id, status: "warn", message: "Activation distribution readiness: " + s.status + " (score " + (s.score || "?") + ").", safeNextAction: s.safeNextActions && s.safeNextActions[0] || "Run: node bin/avorelo activation-distribution --json" };
-}
-
-function checkPublicDistributionGate(signals) {
-  var id = "public_distribution_gate";
-  var s = signals.publicDistributionGate;
-  if (!s) return { id: id, status: "warn", message: "Public distribution truth gate not yet run.", safeNextAction: "Run: node bin/avorelo public-distribution --json" };
-  // Only block full readiness if distribution gate is truly blocked (false install claims, forbidden files, broken bin)
-  if (s.status === "blocked") return { id: id, status: "blocked", message: "Public distribution gate blocked (" + (s.blockers || []).length + " blockers).", safeNextAction: s.safeNextAction || "Run: node bin/avorelo public-distribution --json and fix blockers." };
-  // local_only, warn, or pending are all acceptable — package is not yet public
-  if (s.status === "local_only" || s.status === "pending") return { id: id, status: "pass", message: "Public distribution: " + s.status + " (private package, local install verified).", safeNextAction: null };
-  if (s.status === "ready") return { id: id, status: "pass", message: "Public distribution gate: ready (score " + s.score + ").", safeNextAction: null };
-  return { id: id, status: "warn", message: "Public distribution: " + s.status + " (score " + (s.score || "?") + ").", safeNextAction: s.safeNextAction || "Run: node bin/avorelo public-distribution --json" };
-}
-
-var CHECK_WEIGHTS = { install_ai: 10, first_value: 8, prelaunch_activation: 10, prelaunch_intelligence: 12, launch_hardening: 10, failure_recovery: 5, token_context_quality: 8, token_cost_discipline: 5, mcp_tool_governance: 8, hook_safety_boundaries: 8, support_bundle_redaction: 5, proof_outcome_evidence: 5, feedback_intelligence: 3, company_loop_recommendation: 2, known_limitations: 5, no_false_claims: 10, activation_distribution_readiness: 8, public_distribution_gate: 5, adapter_technical_readiness: 5 };
-var TOTAL_WEIGHT = Object.values(CHECK_WEIGHTS).reduce(function(a, b) { return a + b; }, 0);
-
-function scoreFullReadiness(checks) {
-  var earned = 0;
-  for (var i = 0; i < checks.length; i++) {
-    var w = CHECK_WEIGHTS[checks[i].id] || 0;
-    if (checks[i].status === "pass") earned += w;
-    else if (checks[i].status === "warn") earned += w * 0.6;
-  }
-  return Math.round((earned / TOTAL_WEIGHT) * 100);
-}
-
-function runFullReadinessGate(cwd, options) {
-  options = options || {};
-  var signals = collectFullReadinessSignals(cwd, options);
-  var knownLimitations = options.knownLimitations || null;
-  var checks = [
-    checkInstallAi(signals), checkFirstValue(signals), checkPrelaunchActivation(signals),
-    checkPrelaunchIntelligence(signals), checkLaunchHardening(signals), checkFailureRecovery(signals),
-    checkTokenContextQuality(signals), checkTokenCostDiscipline(signals), checkMcpToolGovernance(signals),
-    checkHookSafetyBoundaries(signals), checkSupportBundleRedaction(signals), checkProofOutcomeEvidence(signals),
-    checkFeedbackIntelligence(signals), checkCompanyLoopRecommendation(signals),
-    checkKnownLimitations(signals, { knownLimitations: knownLimitations }), checkNoFalseClaims(signals),
-    checkActivationDistributionReadiness(signals), checkPublicDistributionGate(signals),
-    checkAdapterTechnicalReadiness(signals),
-  ].map(function(check) { return Object.assign({ redacted: true }, check); });
-  var score = scoreFullReadiness(checks);
-  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 evidenceRefs = [
-    ".claude/cco/orchestration/prelaunch-intelligence/latest-intelligence.json",
-    ".claude/cco/orchestration/prelaunch-readiness/latest-activation-readiness.json",
-    ".claude/cco/orchestration/launch-hardening/latest-gate.json",
-    ".claude/cco/orchestration/mcp-tool-governance/latest-policy.json",
-    ".claude/cco/orchestration/token-efficiency/latest-evidence.json",
-    ".claude/cco/support/latest-support-bundle.json",
-    ".claude/cco/orchestration/seamless-outcome/latest-value-summary.json",
-    ".claude/cco/orchestration/company-loop/latest-report.json",
-  ].filter(function(r) { return fs.existsSync(path.join(cwd, r)); });
-
-  var status, releaseCandidateStatus;
-  if (blockers.length > 0) { status = "blocked"; releaseCandidateStatus = "candidate_blocked"; }
-  else if (score >= SCORE_READY) {
-    var hasSparse = signals.feedbackIntelligence && signals.feedbackIntelligence.status === "insufficient_data" &&
-      (signals.tokenCostIntelligence && (signals.tokenCostIntelligence.status === "not_available" || signals.tokenCostIntelligence.evidenceLevel === "not_available"));
-    if (hasSparse) { status = "warn"; releaseCandidateStatus = "candidate_warn"; }
-    else { status = "ready"; releaseCandidateStatus = "candidate_ready"; }
-  } else if (score >= SCORE_WARN) { status = "warn"; releaseCandidateStatus = "candidate_warn"; }
-  else { status = "insufficient_data"; releaseCandidateStatus = "insufficient_data"; }
-
-  var decision;
-  if (status === "ready") decision = "Release candidate criteria met. Evidence supports proceeding to distribution readiness.";
-  else if (status === "warn") decision = "Not release-candidate ready yet. Incomplete evidence but no hard blockers.";
-  else if (status === "blocked") decision = "Blocked by " + blockers.length + " hard blocker(s). Resolve before proceeding.";
-  else decision = "Insufficient evidence to make a release candidate determination.";
-
-  var recommendedNextPr;
-  var evidenceOnlyWarnings = ["feedback_intelligence", "token_cost_discipline", "proof_outcome_evidence", "prelaunch_intelligence"];
-  var nonEvidenceWarnings = warnings.filter(function(w) { return evidenceOnlyWarnings.indexOf(w.id) === -1; });
-  if (status !== "blocked" && blockers.length === 0 && warnings.length > 0 && nonEvidenceWarnings.length === 0) recommendedNextPr = "GrowthBook Provider + Exposure Events";
-  else if (warnings.some(function(w) { return w.id === "feedback_intelligence"; })) recommendedNextPr = "Operational: Import real design-partner feedback";
-  else if (warnings.some(function(w) { return w.id === "token_cost_discipline"; })) recommendedNextPr = "Operational: Capture/import real token-cost evidence";
-  else if (warnings.some(function(w) { return w.id === "proof_outcome_evidence"; })) recommendedNextPr = "Operational: Run proof after a real bounded task";
-  else if (status === "ready" || (status === "warn" && blockers.length === 0)) recommendedNextPr = "Activation Distribution Readiness v1";
-  else if (blockers.some(function(b) { return b.id === "mcp_tool_governance" || b.id === "hook_safety_boundaries"; })) recommendedNextPr = "Repair: MCP/Hook safety";
-  else recommendedNextPr = "Dogfood / Feedback Collection pass";
-
-  var firstBlocker = blockers[0];
-  var firstWarning = warnings[0];
-  var safeNextAction = (firstBlocker && firstBlocker.safeNextAction) || (firstWarning && firstWarning.safeNextAction) || "Run: node bin/avorelo release-candidate-bundle --json for full summary";
-
-  var gate = {
-    contract: CONTRACT, schemaVersion: SCHEMA_VERSION, createdAt: nowIso(),
-    status: status, releaseCandidateStatus: releaseCandidateStatus, score: score, decision: decision,
-    checks: checks, blockers: blockers, warnings: warnings, passes: passes.map(function(p) { return p.id; }),
-    evidenceRefs: evidenceRefs,
-    knownLimitationsRef: ".claude/cco/orchestration/full-readiness/latest-known-limitations.json",
-    recommendedNextPr: recommendedNextPr, safeNextAction: safeNextAction,
-    knownLimitationsCount: knownLimitations ? (knownLimitations.limitations || []).length : 0,
-    noPublicLaunchClaim: true, noReleaseReadyClaimUnlessPassed: true, redacted: true,
-  };
-
-  try { appendProductLearningEvent(cwd, { eventName: "full_readiness_gate_run", category: "full_readiness", status: status, score: score, blockerCount: blockers.length, warningCount: warnings.length }); } catch (e) {}
-  return gate;
-}
-
-function writeFullReadinessGate(cwd, gate) {
-  var dir = path.join(cwd, GATE_DIR_REL);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(cwd, ARTIFACT_REL), JSON.stringify(gate, null, 2));
-  return gate;
-}
-
-function buildFullReadinessSurface(cwd, options) {
-  options = options || {};
-  var gate = safeReadJson(path.join(cwd, ARTIFACT_REL));
-  if (!gate) return { status: "not_available", score: null, releaseCandidateStatus: "insufficient_data", blockerCount: 0, warningCount: 0, knownLimitationsCount: 0, recommendedNextPr: null };
-  return { status: gate.status, score: gate.score, releaseCandidateStatus: gate.releaseCandidateStatus, blockerCount: (gate.blockers || []).length, warningCount: (gate.warnings || []).length, knownLimitationsCount: gate.knownLimitationsCount || 0, recommendedNextPr: gate.recommendedNextPr, blockers: gate.blockers, noPublicLaunchClaim: true };
-}
-
-function formatFullReadinessText(gate, options) {
-  options = options || {};
-  var debug = options.debug === true;
-  var lines = [];
-  lines.push("Full readiness: " + gate.status);
-  lines.push("Score: " + gate.score);
-  lines.push("");
-  lines.push("Decision:");
-  lines.push("  " + gate.decision);
-  if (gate.blockers.length > 0) {
-    lines.push(""); lines.push("Blockers:");
-    gate.blockers.forEach(function(b) { lines.push("  - " + b.message); if (b.safeNextAction) lines.push("    Next: " + b.safeNextAction); });
-  } else { lines.push(""); lines.push("Blockers:"); lines.push("  none"); }
-  if (gate.warnings.length > 0) {
-    lines.push(""); lines.push("Warnings:");
-    gate.warnings.forEach(function(w) { lines.push("  - " + w.message); });
-  }
-  if (debug) {
-    lines.push(""); lines.push("Checks:");
-    gate.checks.forEach(function(c) { lines.push("  " + c.status.padEnd(8) + " " + c.id + ": " + c.message); });
-    lines.push(""); lines.push("Evidence refs: " + gate.evidenceRefs.length);
-    lines.push("Release candidate status: " + gate.releaseCandidateStatus);
-  }
-  lines.push(""); lines.push("Next:"); lines.push("  " + gate.safeNextAction); lines.push(""); lines.push("No public launch claim.");
-  return lines.join("\n");
-}
-
-module.exports = {
-  CONTRACT, SCHEMA_VERSION, ARTIFACT_REL, GATE_DIR_REL, SCORE_READY, SCORE_WARN,
-  runFullReadinessGate, collectFullReadinessSignals, scoreFullReadiness,
-  writeFullReadinessGate, buildFullReadinessSurface, formatFullReadinessText,
-  checkInstallAi, checkFirstValue, checkPrelaunchActivation, checkPrelaunchIntelligence,
-  checkLaunchHardening, checkFailureRecovery, checkTokenContextQuality, checkTokenCostDiscipline,
-  checkMcpToolGovernance, checkHookSafetyBoundaries, checkSupportBundleRedaction,
-  checkProofOutcomeEvidence, checkFeedbackIntelligence, checkCompanyLoopRecommendation,
-  checkKnownLimitations, checkNoFalseClaims, checkActivationDistributionReadiness,
-  checkAdapterTechnicalReadiness, checkPublicDistributionGate,
-};

package/scripts/lib/guidance-builder.js

@@ -1,174 +0,0 @@
-"use strict";
-
-const { formatNextBoundedAction } = require("./proof-canonical");
-
-function extractContinueField(text, label) {
-  const pattern = new RegExp(`^${label}:\\s*(.+)$`, "mi");
-  const match = String(text || "").match(pattern);
-  return match ? String(match[1]).trim() : "";
-}
-
-function parseContinueNote(text) {
-  if (!String(text || "").trim()) return null;
-
-  const whatHappened = extractContinueField(text, "What happened");
-  const nextAction = extractContinueField(text, "Next");
-  const preservedState = extractContinueField(text, "Preserved");
-  const artifactPath = extractContinueField(text, "Artifact");
-
-  if (!whatHappened && !nextAction && !preservedState && !artifactPath) {
-    return null;
-  }
-
-  return {
-    whatHappened,
-    nextAction,
-    preservedState,
-    artifactPath: artifactPath || null,
-  };
-}
-
-function buildFreshStartGuidance(onboardingReady) {
-  const lines = ["## Avorelo Session Guidance", ""];
-
-  if (onboardingReady) {
-    lines.push("Fresh start.");
-    lines.push("");
-    lines.push("Run /avorelo-init, then avorelo status.");
-    lines.push("Avorelo should stay quiet unless it needs to intervene or guide recovery.");
-    return { text: lines.join("\n"), hasResume: false };
-  }
-
-  lines.push("Fresh start.");
-  lines.push("");
-  lines.push("Continue working normally.");
-  lines.push("Use avorelo status if you want a quick check before the next step.");
-  lines.push("Avorelo should stay quiet unless it needs to intervene or guide recovery.");
-  return { text: lines.join("\n"), hasResume: false };
-}
-
-function buildCanonicalReentryGuidance(input = {}, parsedContinueNote = null) {
-  const canonicalReentry =
-    input.canonicalReentry && input.canonicalReentry.is_canonical_truth_available
-      ? input.canonicalReentry
-      : null;
-  if (!canonicalReentry) return null;
-
-  const carryForward = input.carryForward || null;
-  const reentryState = input.reentryState || null;
-  const lines = ["## Avorelo Session Guidance", "", "**Current bounded state**"];
-  const nextAction =
-    canonicalReentry.next_bounded_action_text ||
-    formatNextBoundedAction(canonicalReentry.next_bounded_action) ||
-    parsedContinueNote?.nextAction ||
-    reentryState?.nextAction ||
-    "Run avorelo status to inspect the current bounded state.";
-  const preservedState =
-    parsedContinueNote?.preservedState ||
-    (carryForward?.toolHistory?.toolNames?.length
-      ? `Recent tool context was preserved: ${carryForward.toolHistory.toolNames.join(", ")}.`
-      : null);
-  const artifactPath =
-    canonicalReentry.state_source ||
-    parsedContinueNote?.artifactPath ||
-    reentryState?.primaryArtifactPath ||
-    null;
-
-  if (canonicalReentry.where_am_i_now) {
-    lines.push(`- Where am I now: ${canonicalReentry.where_am_i_now}`);
-  }
-  if (canonicalReentry.what_can_i_honestly_claim) {
-    lines.push(`- Honest claim: ${canonicalReentry.what_can_i_honestly_claim}`);
-  }
-  if (canonicalReentry.reentry_status) {
-    lines.push(`- Re-entry: ${canonicalReentry.reentry_status}`);
-  }
-  lines.push(`- Next: ${nextAction}`);
-  if (canonicalReentry.latest_trustworthy_run_id) {
-    lines.push(`- Trustworthy run: ${canonicalReentry.latest_trustworthy_run_id}`);
-  }
-  if (canonicalReentry.readiness_state) {
-    lines.push(`- Readiness: ${canonicalReentry.readiness_state}`);
-  }
-  if (canonicalReentry.rollback_available === true) {
-    const rollbackSuffix = canonicalReentry.rollback_trigger ? ` (${canonicalReentry.rollback_trigger})` : "";
-    lines.push(`- Rollback: available${rollbackSuffix}.`);
-  }
-  if (preservedState) {
-    lines.push(`- Preserved: ${preservedState}`);
-  }
-  if (artifactPath) {
-    lines.push(`- Artifact: ${artifactPath}`);
-  }
-  if (reentryState?.unresolvedRisk) {
-    lines.push("- Risk: unresolved review still needs attention before the next unsafe step.");
-  }
-  lines.push("");
-  lines.push("Avorelo is active. Continue with the next bounded step.");
-
-  return {
-    text: lines.join("\n"),
-    hasResume: true,
-    usedCanonicalTruth: true,
-  };
-}
-
-function buildStartGuidance(input = {}) {
-  const carryForward = input.carryForward || null;
-  const reentryState = input.reentryState || null;
-  const continueNote = parseContinueNote(input.continueNoteText || "");
-  const onboardingReady = input.onboardingReady === true;
-  const canonicalGuidance = buildCanonicalReentryGuidance(input, continueNote);
-  if (canonicalGuidance) {
-    return canonicalGuidance;
-  }
-
-  const lines = ["## Avorelo Session Guidance", ""];
-
-  const hasResume = Boolean(continueNote || reentryState || carryForward);
-  if (!hasResume) {
-    return buildFreshStartGuidance(onboardingReady);
-  }
-
-  const whatHappened =
-    continueNote?.whatHappened ||
-    (reentryState?.lastInterventionType && reentryState.lastInterventionType !== "none"
-      ? `The last session ended after ${reentryState.lastInterventionType.replace(/_/g, " ")}.`
-      : "The last session left a bounded continuation cue.");
-  const nextAction =
-    continueNote?.nextAction ||
-    reentryState?.nextAction ||
-    "Run avorelo status to continue.";
-  const preservedState =
-    continueNote?.preservedState ||
-    (carryForward?.toolHistory?.toolNames?.length
-      ? `Recent tool context was preserved: ${carryForward.toolHistory.toolNames.join(", ")}.`
-      : "Bounded local evidence from the last session was preserved.");
-  const artifactPath =
-    continueNote?.artifactPath ||
-    reentryState?.primaryArtifactPath ||
-    null;
-
-  lines.push("**Resume cue**");
-  lines.push(`- What happened: ${whatHappened}`);
-  lines.push(`- Next: ${nextAction}`);
-  lines.push(`- Preserved: ${preservedState}`);
-  if (artifactPath) {
-    lines.push(`- Artifact: ${artifactPath}`);
-  }
-  if (reentryState?.unresolvedRisk) {
-    lines.push("- Risk: unresolved risk still needs review before the next unsafe step.");
-  }
-  lines.push("");
-  lines.push("Avorelo is active. Continue with the next bounded step.");
-
-  return {
-    text: lines.join("\n"),
-    hasResume: true,
-  };
-}
-
-module.exports = {
-  buildStartGuidance,
-  parseContinueNote,
-};