avorelo 0.1.0

package/scripts/lib/cross-host-value-flow.js

@@ -0,0 +1,268 @@
+"use strict";
+
+// ── Cross-Host Value Flow ─────────────────────────────────────────────────────
+// Contract: avorelo.crossHostValueFlow.v1
+// Answers: "Are proof outcomes, work ledger entries, token savings, and telemetry
+// captured and reachable across detected hosts?"
+// Reads existing artifacts. Does NOT generate new evidence.
+
+const fs = require("fs");
+const path = require("path");
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+
+const CONTRACT = "avorelo.crossHostValueFlow.v1";
+const SCHEMA_VERSION = 1;
+const ARTIFACT_DIR_REL = ".claude/cco/orchestration/adapter-readiness";
+const ARTIFACT_REL = ARTIFACT_DIR_REL + "/latest-cross-host-value-flow.json";
+
+function safeReadJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
+  } catch { return null; }
+}
+
+function countJsonlLines(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return 0;
+    const content = fs.readFileSync(absPath, "utf8");
+    return content.split("\n").filter(function(l) { return l.trim().length > 0; }).length;
+  } catch { return 0; }
+}
+
+function pass(id, label, evidence, detail) {
+  return { id, label, status: "pass", evidence: evidence || null, detail: detail || null, safeNextAction: null };
+}
+function warn(id, label, safeNextAction, evidence, detail) {
+  return { id, label, status: "warn", evidence: evidence || null, detail: detail || null, safeNextAction: safeNextAction || "Review and resolve." };
+}
+function blocked(id, label, safeNextAction, evidence, detail) {
+  return { id, label, status: "blocked", evidence: evidence || null, detail: detail || null, safeNextAction: safeNextAction || "Fix blocker before proceeding." };
+}
+function info(id, label, evidence, detail) {
+  return { id, label, status: "info", evidence: evidence || null, detail: detail || null, safeNextAction: null };
+}
+
+// ── Value Flow Checks ─────────────────────────────────────────────────────────
+
+function checkProofOutcomeEvidence(cwd) {
+  const proofPath = path.join(cwd, ".claude/cco/orchestration/proof-outcome/latest-proof-outcome.json");
+  const artifact = safeReadJson(proofPath);
+  if (!artifact) {
+    return warn("proof_outcome_evidence", "No proof outcome evidence found",
+      "Run a bounded task with outcome tracking enabled. Run: node bin/avorelo proof-receipt --json",
+      null, "latest-proof-outcome.json not found.");
+  }
+  if (artifact.status === "no_proof" || artifact.status === "empty") {
+    return warn("proof_outcome_evidence", "Proof outcome artifact is empty",
+      "Complete a real task with proof tracking to populate evidence.",
+      { status: artifact.status });
+  }
+  return pass("proof_outcome_evidence", "Proof outcome evidence present",
+    { status: artifact.status, path: ".claude/cco/orchestration/proof-outcome/latest-proof-outcome.json" });
+}
+
+function checkWorkLedgerEntries(cwd) {
+  const ledgerPath = path.join(cwd, ".claude/cco/orchestration/work-ledger/latest-ledger.json");
+  const artifact = safeReadJson(ledgerPath);
+  if (!artifact) {
+    return warn("work_ledger_entries", "Work ledger not yet populated",
+      "Complete a bounded task to generate work ledger entries.",
+      null, "latest-ledger.json not found.");
+  }
+  const entries = artifact.entries || [];
+  if (entries.length === 0) {
+    return warn("work_ledger_entries", "Work ledger has no entries",
+      "Complete a bounded task to generate work ledger entries.",
+      { entryCount: 0 });
+  }
+  return pass("work_ledger_entries", "Work ledger has entries",
+    { entryCount: entries.length });
+}
+
+function checkTokenCostEvidence(cwd) {
+  const tokenPath = path.join(cwd, ".claude/cco/orchestration/token-cost/latest-token-cost-evidence.json");
+  const artifact = safeReadJson(tokenPath);
+  if (!artifact) {
+    return warn("token_cost_evidence", "Token cost evidence not found",
+      "Run: node bin/avorelo token-cost capture --json to record token cost baseline.",
+      null, "latest-token-cost-evidence.json not found.");
+  }
+  if (artifact.status === "no_data" || !artifact.samples || artifact.samples.length === 0) {
+    return warn("token_cost_evidence", "Token cost evidence has no samples",
+      "Run real tasks with token tracking enabled.",
+      { status: artifact.status });
+  }
+  return pass("token_cost_evidence", "Token cost evidence has samples",
+    { sampleCount: (artifact.samples || []).length });
+}
+
+function checkProductLearningEvents(cwd) {
+  const eventsPath = path.join(cwd, ".claude/cco/events/product-learning.jsonl");
+  const count = countJsonlLines(eventsPath);
+  if (count === 0) {
+    return warn("product_learning_events", "No product learning events found",
+      "Run avorelo commands to generate product learning events.",
+      { count: 0 });
+  }
+  return pass("product_learning_events", "Product learning events present",
+    { count });
+}
+
+function checkFeedbackFlow(cwd) {
+  const feedbackPath = path.join(cwd, ".claude/cco/orchestration/prelaunch-intelligence/latest-feedback-intelligence.json");
+  const artifact = safeReadJson(feedbackPath);
+  if (!artifact) {
+    return info("feedback_flow", "Feedback intelligence artifact not found",
+      null, "Not required for value flow verification.");
+  }
+  if (artifact.status === "insufficient_data") {
+    return warn("feedback_flow", "Feedback intelligence has insufficient data",
+      "Import real design-partner or alpha feedback sessions.",
+      { status: artifact.status });
+  }
+  return pass("feedback_flow", "Feedback intelligence populated",
+    { status: artifact.status });
+}
+
+function checkSupportBundleValueFlow(cwd) {
+  const bundlePath = path.join(cwd, ".claude/cco/support/latest-support-bundle.json");
+  const artifact = safeReadJson(bundlePath);
+  if (!artifact) {
+    return warn("support_bundle_value_flow", "Support bundle not generated",
+      "Run: node bin/avorelo support-bundle --json to generate support bundle.",
+      null, "latest-support-bundle.json not found.");
+  }
+  if (artifact.redacted !== true) {
+    return blocked("support_bundle_value_flow", "Support bundle is not redacted",
+      "Run support bundle generation with redaction enabled.",
+      { redacted: artifact.redacted });
+  }
+  return pass("support_bundle_value_flow", "Support bundle present and redacted",
+    { redacted: true });
+}
+
+// ── Build Cross-Host Value Flow ────────────────────────────────────────────────
+
+function buildCrossHostValueFlow(cwd, options) {
+  const checks = [
+    checkProofOutcomeEvidence(cwd),
+    checkWorkLedgerEntries(cwd),
+    checkTokenCostEvidence(cwd),
+    checkProductLearningEvents(cwd),
+    checkFeedbackFlow(cwd),
+    checkSupportBundleValueFlow(cwd),
+  ];
+
+  const blockers = checks.filter(function(c) { return c.status === "blocked"; });
+  const warnings = checks.filter(function(c) { return c.status === "warn"; });
+  const passes = checks.filter(function(c) { return c.status === "pass"; });
+
+  var status;
+  if (blockers.length > 0) {
+    status = "blocked";
+  } else if (warnings.length > 0) {
+    status = "warn";
+  } else {
+    status = "pass";
+  }
+
+  const valueSignals = {
+    proofOutcome: checks.find(function(c) { return c.id === "proof_outcome_evidence"; }).status,
+    workLedger: checks.find(function(c) { return c.id === "work_ledger_entries"; }).status,
+    tokenCost: checks.find(function(c) { return c.id === "token_cost_evidence"; }).status,
+    productEvents: checks.find(function(c) { return c.id === "product_learning_events"; }).status,
+    feedback: checks.find(function(c) { return c.id === "feedback_flow"; }).status,
+    supportBundle: checks.find(function(c) { return c.id === "support_bundle_value_flow"; }).status,
+  };
+
+  const safeNextAction = blockers.length > 0
+    ? "Fix value flow blockers. Check support bundle redaction."
+    : warnings.length > 0
+    ? "Run bounded tasks to generate proof outcomes, work ledger entries, and token cost evidence."
+    : "All value flow signals present. Proceed to adapter safety boundary check.";
+
+  return {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: nowIso(),
+    status,
+    checks,
+    valueSignals,
+    blockerCount: blockers.length,
+    warningCount: warnings.length,
+    passCount: passes.length,
+    safeNextAction,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+}
+
+// ── Write ─────────────────────────────────────────────────────────────────────
+
+function writeCrossHostValueFlow(cwd, flow) {
+  const dir = path.join(cwd, ARTIFACT_DIR_REL);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(cwd, ARTIFACT_REL), JSON.stringify(flow, null, 2));
+}
+
+// ── Surface ───────────────────────────────────────────────────────────────────
+
+function buildCrossHostValueFlowSurface(cwd, options) {
+  const flow = buildCrossHostValueFlow(cwd, options);
+  writeCrossHostValueFlow(cwd, flow);
+  try {
+    appendProductLearningEvent(cwd, {
+      event: "cross_host_value_flow_built",
+      contract: CONTRACT,
+      status: flow.status,
+      blockerCount: flow.blockerCount,
+    });
+  } catch { /* non-fatal */ }
+  return {
+    status: flow.status,
+    valueSignals: flow.valueSignals,
+    blockerCount: flow.blockerCount,
+    warningCount: flow.warningCount,
+    noPublicLaunchClaim: true,
+  };
+}
+
+// ── Format ────────────────────────────────────────────────────────────────────
+
+function formatCrossHostValueFlowText(flow) {
+  var lines = [
+    "Cross-Host Value Flow [" + (flow.status || "?").toUpperCase() + "]",
+  ];
+  if (flow.valueSignals) {
+    lines.push("  Proof outcome: " + flow.valueSignals.proofOutcome);
+    lines.push("  Work ledger: " + flow.valueSignals.workLedger);
+    lines.push("  Token cost: " + flow.valueSignals.tokenCost);
+    lines.push("  Product events: " + flow.valueSignals.productEvents);
+    lines.push("  Feedback: " + flow.valueSignals.feedback);
+    lines.push("  Support bundle: " + flow.valueSignals.supportBundle);
+  }
+  lines.push(
+    "  Blockers: " + (flow.blockerCount || 0),
+    "  Warnings: " + (flow.warningCount || 0),
+    "  Next: " + (flow.safeNextAction || "Review value flow.")
+  );
+  return lines.join("\n");
+}
+
+module.exports = {
+  CONTRACT,
+  SCHEMA_VERSION,
+  ARTIFACT_REL,
+  buildCrossHostValueFlow,
+  writeCrossHostValueFlow,
+  buildCrossHostValueFlowSurface,
+  formatCrossHostValueFlowText,
+  checkProofOutcomeEvidence,
+  checkWorkLedgerEntries,
+  checkTokenCostEvidence,
+  checkProductLearningEvents,
+  checkFeedbackFlow,
+  checkSupportBundleValueFlow,
+};