avorelo 0.1.0

package/scripts/lib/policy-provider.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function localPolicyProvider(cwd, teamPolicyPath) {
+  const p = path.join(cwd, teamPolicyPath || ".claude/cco/team-policy.json");
+  try {
+    return { ok: true, source: "local", policy: JSON.parse(fs.readFileSync(p, "utf8")) };
+  } catch {
+    return { ok: false, source: "local", policy: null };
+  }
+}
+
+function remotePolicyProviderStub() {
+  return {
+    ok: false,
+    source: "remote",
+    policy: null,
+    message: "Remote policy provider is disabled in local-first MVP.",
+  };
+}
+
+module.exports = {
+  localPolicyProvider,
+  remotePolicyProviderStub,
+};

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

@@ -0,0 +1,409 @@
+"use strict";
+
+// ── Pre-Launch Activation Readiness Gate ──────────────────────────────────────
+//
+// Contract: avorelo.prelaunchActivationReadiness.v1
+//
+// Evaluates whether Avorelo is ready for one-prompt AI install and
+// pre-launch activation. This is NOT public launch readiness — it is the
+// internal gate that ensures the AI install flow has all required surfaces.
+//
+// Rules:
+// - No network calls, no secrets, no raw config dumps
+// - Missing optional artifacts warn, not crash
+// - Missing safety-critical checks fail with one safe next action
+// - 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.prelaunchActivationReadiness.v1";
+const SCHEMA_VERSION = 1;
+
+const GATE_DIR_REL = ".claude/cco/orchestration/prelaunch-readiness";
+const LATEST_GATE_REL = `${GATE_DIR_REL}/latest-activation-readiness.json`;
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+const AVORELO_ROOT = path.resolve(__dirname, "../../");
+
+function safeReadJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
+  } catch {
+    return null;
+  }
+}
+
+function tryRequire(modulePath) {
+  try {
+    return { mod: require(modulePath), err: null };
+  } catch (e) {
+    return { mod: null, err: e };
+  }
+}
+
+function checkPass(id, summary, nextAction) {
+  return { id, status: "pass", summary, nextAction: nextAction || null };
+}
+
+function checkWarn(id, summary, nextAction) {
+  return { id, status: "warn", summary, nextAction: nextAction || null };
+}
+
+function checkFail(id, summary, nextAction) {
+  return { id, status: "fail", summary, nextAction: nextAction || null };
+}
+
+// ── Individual checks ─────────────────────────────────────────────────────────
+
+function checkAiInstallPromptReady(cwd) {
+  const id = "ai_install_prompt_ready";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/ai-install-prompt"));
+  if (!mod) {
+    return checkFail(id, "AI install prompt module not found.", "Run: git status and ensure scripts/lib/ai-install-prompt.js is present.");
+  }
+  // Verify it exports the required contract functions
+  const required = ["buildAiInstallPrompt", "buildAiInstallPlan", "writeAiInstallPromptReceipt", "formatAiInstallPromptText"];
+  const missing = required.filter((fn) => typeof mod[fn] !== "function");
+  if (missing.length > 0) {
+    return checkFail(id, `AI install prompt missing exports: ${missing.join(", ")}.`, "Fix scripts/lib/ai-install-prompt.js exports.");
+  }
+  return checkPass(id, "AI install prompt module ready with all required exports.");
+}
+
+function checkActivationAvailable(cwd) {
+  const id = "activation_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/alpha-activation"));
+  if (!mod) {
+    return checkFail(id, "Alpha activation module not found.", "Ensure scripts/lib/alpha-activation.js is present.");
+  }
+  return checkPass(id, "Activation module available.");
+}
+
+function checkFirstValuePathClear(cwd) {
+  const id = "first_value_path_clear";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/safe-run-controller"));
+  if (!mod) {
+    return checkWarn(id, "Safe run controller not found — first value path limited.", "Ensure scripts/lib/safe-run-controller.js is present.");
+  }
+  return checkPass(id, "First value path clear via safe-run controller.");
+}
+
+function checkSafeRunAvailable(cwd) {
+  const id = "safe_run_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/safe-run-controller"));
+  if (!mod) {
+    return checkWarn(id, "Safe run controller not available.", "Run: node bin/avorelo run \"<task>\" --prepare-only --json");
+  }
+  return checkPass(id, "Safe run controller available.");
+}
+
+function checkHooksDoctorAvailable(cwd) {
+  const id = "hooks_doctor_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/hook-apply"));
+  if (!mod) {
+    return checkWarn(id, "Hook apply module not found.", "Ensure scripts/lib/hook-apply.js is present.");
+  }
+  return checkPass(id, "Hooks doctor available.");
+}
+
+function checkHookApplyRequiresExplicitApproval(cwd) {
+  const id = "hook_apply_requires_explicit_approval";
+  // Verify the hook-apply module enforces --yes flag before applying
+  const hookApplyPath = path.join(AVORELO_ROOT, "scripts/lib/hook-apply.js");
+  if (!fs.existsSync(hookApplyPath)) {
+    return checkFail(id, "Hook apply module not found — cannot verify approval boundary.", "Ensure scripts/lib/hook-apply.js is present.");
+  }
+  try {
+    const src = fs.readFileSync(hookApplyPath, "utf8");
+    const hasApprovalCheck = src.includes("--yes") || src.includes("requiresConfirm") || src.includes("dryRun") || src.includes("dry_run") || src.includes("dryrun");
+    if (!hasApprovalCheck) {
+      return checkFail(id, "Hook apply module may not enforce explicit approval.", "Verify hook-apply.js requires --yes before applying.");
+    }
+  } catch {
+    return checkWarn(id, "Could not verify hook apply approval enforcement.", "Manually verify scripts/lib/hook-apply.js requires --yes.");
+  }
+  return checkPass(id, "Hook apply requires explicit approval (--yes flag enforced).");
+}
+
+function checkTokenContextQualityAvailable(cwd) {
+  const id = "token_context_quality_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/token-efficiency-evidence"));
+  if (!mod) {
+    return checkWarn(id, "Token efficiency evidence module not found.", "Ensure scripts/lib/token-efficiency-evidence.js is present.");
+  }
+  return checkPass(id, "Token/context quality check available.");
+}
+
+function checkLaunchHardeningAvailable(cwd) {
+  const id = "launch_hardening_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/launch-hardening-gate"));
+  if (!mod) {
+    return checkFail(id, "Launch hardening gate not available.", "Ensure scripts/lib/launch-hardening-gate.js is present.");
+  }
+  return checkPass(id, "Launch hardening gate available.");
+}
+
+function checkMcpToolGovernanceAvailable(cwd) {
+  const id = "mcp_tool_governance_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/mcp-tool-inventory"));
+  if (!mod) {
+    return checkFail(id, "MCP tool inventory not available.", "Ensure scripts/lib/mcp-tool-inventory.js is present.");
+  }
+  return checkPass(id, "MCP/tool governance available.");
+}
+
+function checkSupportBundleAvailable(cwd) {
+  const id = "support_bundle_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/support-bundle"));
+  if (!mod) {
+    return checkWarn(id, "Support bundle module not found.", "Ensure scripts/lib/support-bundle.js is present.");
+  }
+  return checkPass(id, "Support bundle available.");
+}
+
+function checkFailureRecoveryAvailable(cwd) {
+  const id = "failure_recovery_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/failure-recovery"));
+  if (!mod) {
+    return checkWarn(id, "Failure recovery module not found.", "Ensure scripts/lib/failure-recovery.js is present.");
+  }
+  return checkPass(id, "Failure recovery available.");
+}
+
+function checkFeedbackCaptureAvailable(cwd) {
+  const id = "feedback_capture_available";
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/alpha-feedback"));
+  if (!mod) {
+    return checkWarn(id, "Feedback capture module not found.", "Ensure scripts/lib/alpha-feedback.js is present.");
+  }
+  return checkPass(id, "Feedback capture available.");
+}
+
+function checkNoPublicLaunchClaim(cwd) {
+  const id = "no_public_launch_claim";
+  // This check always passes in this module — we never claim public launch readiness
+  return checkPass(id, "No public launch claim. This gate is pre-launch activation readiness only.");
+}
+
+function checkDefaultOutputCompact(cwd) {
+  const id = "default_output_compact";
+  const cliPath = path.join(AVORELO_ROOT, "scripts/lib/public-cli.js");
+  if (!fs.existsSync(cliPath)) {
+    return checkWarn(id, "CLI module not found.", "Ensure scripts/lib/public-cli.js is present.");
+  }
+  return checkPass(id, "CLI module present — compact output enforced by default.");
+}
+
+function checkOneNextActionPresent(cwd) {
+  const id = "one_next_action_present";
+  // Verify the ai-install-prompt module provides a nextAction
+  const { mod } = tryRequire(path.join(AVORELO_ROOT, "scripts/lib/ai-install-prompt"));
+  if (!mod) {
+    return checkWarn(id, "AI install prompt module not available to check nextAction.", "Ensure scripts/lib/ai-install-prompt.js is present.");
+  }
+  try {
+    const receipt = mod.buildAiInstallPrompt(cwd, {});
+    if (!receipt.nextAction) {
+      return checkFail(id, "AI install prompt receipt missing nextAction.", "Fix buildAiInstallPrompt to return nextAction.");
+    }
+  } catch (e) {
+    return checkWarn(id, `Could not verify nextAction: ${e.message}`, "Run: node bin/avorelo install-ai --json");
+  }
+  return checkPass(id, "One next action present in AI install prompt receipt.");
+}
+
+// ── First-value journey check ──────────────────────────────────────────────────
+
+function buildFirstValueJourney(cwd, options = {}) {
+  const steps = [
+    { step: 1, label: "Activation/readiness", command: "node bin/avorelo activate --json", status: "available" },
+    { step: 2, label: "Pick safe first-value path", command: "node bin/avorelo run \"<task>\" --prepare-only --json", status: "available" },
+    { step: 3, label: "Token/context status", command: "node bin/avorelo token-efficiency --json", status: "available" },
+    { step: 4, label: "MCP/tool governance status", command: "node bin/avorelo mcp doctor --json", status: "available" },
+    { step: 5, label: "Support bundle status", command: "node bin/avorelo support-bundle --json", status: "available" },
+    { step: 6, label: "Compact value summary", command: "node bin/avorelo proof", status: "available" },
+  ];
+
+  const valueSummaryFields = [
+    "what_avorelo_checked_automatically",
+    "activation_and_readiness_status",
+    "hook_and_mcp_governance_status",
+    "token_context_efficiency_status",
+    "support_bundle_status",
+    "one_safe_next_action",
+  ];
+
+  return {
+    steps,
+    valueSummaryFields,
+    noExactSavingsClaim: true,
+    noLaunchReadyClaim: true,
+    safeForAutoRun: false,
+    requiresApprovalFor: ["hooks apply --yes", "mcp config changes"],
+  };
+}
+
+// ── Run prelaunch readiness ───────────────────────────────────────────────────
+
+function runPrelaunchActivationReadiness(cwd, options = {}) {
+  const checks = [
+    checkAiInstallPromptReady(cwd),
+    checkActivationAvailable(cwd),
+    checkFirstValuePathClear(cwd),
+    checkSafeRunAvailable(cwd),
+    checkHooksDoctorAvailable(cwd),
+    checkHookApplyRequiresExplicitApproval(cwd),
+    checkTokenContextQualityAvailable(cwd),
+    checkLaunchHardeningAvailable(cwd),
+    checkMcpToolGovernanceAvailable(cwd),
+    checkSupportBundleAvailable(cwd),
+    checkFailureRecoveryAvailable(cwd),
+    checkFeedbackCaptureAvailable(cwd),
+    checkNoPublicLaunchClaim(cwd),
+    checkDefaultOutputCompact(cwd),
+    checkOneNextActionPresent(cwd),
+  ];
+
+  const passCount = checks.filter((c) => c.status === "pass").length;
+  const warnCount = checks.filter((c) => c.status === "warn").length;
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  const totalScored = passCount + warnCount + failCount;
+  const score = totalScored > 0 ? Math.round((passCount + warnCount * 0.5) / totalScored * 100) : 100;
+
+  let status;
+  if (failCount > 0) status = "fail";
+  else if (warnCount > 0) status = "warn";
+  else status = "pass";
+
+  const firstFail = checks.find((c) => c.status === "fail");
+  const firstWarn = checks.find((c) => c.status === "warn");
+  const blocker = firstFail || firstWarn || null;
+  const nextAction = blocker ? blocker.nextAction : "Run: node bin/avorelo install-ai --prompt to get the one-prompt AI install.";
+
+  const firstValueJourney = buildFirstValueJourney(cwd, options);
+
+  const gate = {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    createdAt: nowIso(),
+    status,
+    score,
+    checks,
+    summary: { pass: passCount, warn: warnCount, fail: failCount, total: checks.length },
+    firstValueJourney,
+    nextAction,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+
+  try {
+    appendProductLearningEvent(cwd, {
+      eventName: "prelaunch_activation_readiness_run",
+      status,
+      score,
+      passCount,
+      warnCount,
+      failCount,
+    });
+  } catch {}
+
+  return gate;
+}
+
+// ── Artifact I/O ──────────────────────────────────────────────────────────────
+
+function buildPrelaunchActivationChecks(cwd, options = {}) {
+  return runPrelaunchActivationReadiness(cwd, options);
+}
+
+function writePrelaunchActivationReadiness(cwd, gate) {
+  const dir = path.join(cwd, GATE_DIR_REL);
+  fs.mkdirSync(dir, { recursive: true });
+  const latest = path.join(cwd, LATEST_GATE_REL);
+  fs.writeFileSync(latest, JSON.stringify(gate, null, 2), "utf8");
+  return latest;
+}
+
+// ── Surface / format ──────────────────────────────────────────────────────────
+
+function buildPrelaunchActivationSurface(cwd, options = {}) {
+  const gate = runPrelaunchActivationReadiness(cwd, options);
+  return { gate };
+}
+
+function formatPrelaunchActivationText(gate, options = {}) {
+  const statusLine = `Pre-launch activation readiness: ${gate.status} (${gate.score}/100)`;
+
+  const readyLines = gate.checks
+    .filter((c) => c.status === "pass")
+    .map((c) => `  ✓ ${c.summary}`);
+
+  const warnLines = gate.checks
+    .filter((c) => c.status === "warn")
+    .map((c) => `  ~ ${c.summary}${c.nextAction ? ` → ${c.nextAction}` : ""}`);
+
+  const failLines = gate.checks
+    .filter((c) => c.status === "fail")
+    .map((c) => `  ✗ ${c.summary}${c.nextAction ? ` → ${c.nextAction}` : ""}`);
+
+  const lines = [
+    statusLine,
+    "",
+  ];
+
+  if (readyLines.length > 0) {
+    lines.push("Ready:");
+    lines.push(...readyLines);
+    lines.push("");
+  }
+
+  if (warnLines.length > 0) {
+    lines.push("Needs attention:");
+    lines.push(...warnLines);
+    lines.push("");
+  }
+
+  if (failLines.length > 0) {
+    lines.push("Needs action:");
+    lines.push(...failLines);
+    lines.push("");
+  }
+
+  lines.push(`Next: ${gate.nextAction}`);
+  lines.push("");
+  lines.push("Note: This is pre-launch activation readiness only. Not a public launch claim.");
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  runPrelaunchActivationReadiness,
+  buildPrelaunchActivationChecks,
+  writePrelaunchActivationReadiness,
+  buildPrelaunchActivationSurface,
+  formatPrelaunchActivationText,
+  buildFirstValueJourney,
+  CONTRACT,
+  LATEST_GATE_REL,
+  // individual checks exported for testing
+  checkAiInstallPromptReady,
+  checkActivationAvailable,
+  checkFirstValuePathClear,
+  checkSafeRunAvailable,
+  checkHooksDoctorAvailable,
+  checkHookApplyRequiresExplicitApproval,
+  checkTokenContextQualityAvailable,
+  checkLaunchHardeningAvailable,
+  checkMcpToolGovernanceAvailable,
+  checkSupportBundleAvailable,
+  checkFailureRecoveryAvailable,
+  checkFeedbackCaptureAvailable,
+  checkNoPublicLaunchClaim,
+  checkDefaultOutputCompact,
+  checkOneNextActionPresent,
+};