avorelo 0.1.0

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

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

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