avorelo 0.1.0

package/scripts/lib/host-capability-matrix.js

@@ -0,0 +1,351 @@
+"use strict";
+
+// ── Host Capability Matrix ─────────────────────────────────────────────────────
+// Contract: avorelo.hostCapabilityMatrix.v1
+// Answers: "Which hosts are detected, which capabilities are proven vs theoretical,
+// and what are the capability gaps for each host?"
+// Builds on existing adapter-conformance.js + activation/detect-hosts.js data.
+// Does NOT auto-configure. Does NOT write hook configs. Read-only.
+
+const fs = require("fs");
+const path = require("path");
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+
+const CONTRACT = "avorelo.hostCapabilityMatrix.v1";
+const SCHEMA_VERSION = 1;
+const ARTIFACT_DIR_REL = ".claude/cco/orchestration/adapter-readiness";
+const ARTIFACT_REL = ARTIFACT_DIR_REL + "/latest-host-capability-matrix.json";
+
+function safeReadJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
+  } catch { return null; }
+}
+
+function pass(id, label, evidence, detail) {
+  return { id, 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 };
+}
+
+// Host definitions — expanded set beyond adapter-readiness.js
+const HOST_DEFS = [
+  {
+    id: "claude_code",
+    label: "Claude Code",
+    markers: [".claude"],
+    hookConfigPath: ".claude/settings.json",
+    hooksDepth: "deep",
+    mcpSupported: true,
+    installAiSupported: true,
+    proofSupported: true,
+    valueFlowTier: "full",
+    notes: "Primary host. Full hook lifecycle, MCP, install-ai, proof. All value flows verified.",
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    markers: [".cursor", ".cursor/rules"],
+    hookConfigPath: ".cursor/settings.json",
+    hooksDepth: "partial",
+    mcpSupported: true,
+    installAiSupported: true,
+    proofSupported: true,
+    valueFlowTier: "partial",
+    notes: "Hook lifecycle is partial. Tool output replacement advisory only. Value flow via rules+MCP.",
+  },
+  {
+    id: "windsurf",
+    label: "Windsurf",
+    markers: [".codeium", ".windsurf"],
+    hookConfigPath: ".windsurf/settings.json",
+    hooksDepth: "partial",
+    mcpSupported: true,
+    installAiSupported: true,
+    proofSupported: true,
+    valueFlowTier: "partial",
+    notes: "Hook subset available. Permission decision supported. MCP supported.",
+  },
+  {
+    id: "codex",
+    label: "Codex CLI",
+    markers: ["codex.yaml", ".codex"],
+    hookConfigPath: null,
+    hooksDepth: "partial",
+    mcpSupported: true,
+    installAiSupported: true,
+    proofSupported: true,
+    valueFlowTier: "partial",
+    notes: "Partial hook support via adapter routing. MCP supported.",
+  },
+  {
+    id: "vscode",
+    label: "VS Code",
+    markers: [".vscode", ".vscode/extensions.json"],
+    hookConfigPath: ".vscode/settings.json",
+    hooksDepth: "extension",
+    mcpSupported: false,
+    installAiSupported: true,
+    proofSupported: false,
+    valueFlowTier: "limited",
+    notes: "Extension-bridge only. No native MCP. Proof requires extension wrapper.",
+  },
+  {
+    id: "github_agent",
+    label: "GitHub Copilot Agent",
+    markers: [".github/copilot-instructions.md", ".github/copilot-workspace"],
+    hookConfigPath: null,
+    hooksDepth: "limited",
+    mcpSupported: false,
+    installAiSupported: false,
+    proofSupported: false,
+    valueFlowTier: "limited",
+    notes: "Advisory mode only. No hook parity. No MCP. Value via instructions/rules.",
+  },
+];
+
+function detectHost(cwd, hostDef) {
+  const detected = hostDef.markers.some(function(m) {
+    return fs.existsSync(path.join(cwd, m));
+  });
+  return detected;
+}
+
+function inspectHostCapabilities(cwd, hostDef) {
+  const detected = detectHost(cwd, hostDef);
+  const checks = [];
+
+  // host_detected
+  if (detected) {
+    checks.push(pass("host_detected", hostDef.label + " host detected",
+      { id: hostDef.id, markers: hostDef.markers }));
+  } else {
+    checks.push(info("host_detected", hostDef.label + " host not detected",
+      { id: hostDef.id }, "Host markers not present in cwd."));
+  }
+
+  // hook_depth
+  if (hostDef.hooksDepth === "deep") {
+    checks.push(pass("hook_depth_" + hostDef.id, "Hook depth: full lifecycle",
+      { depth: hostDef.hooksDepth }));
+  } else if (hostDef.hooksDepth === "partial") {
+    checks.push(warn("hook_depth_" + hostDef.id, "Hook depth: partial lifecycle",
+      "Review which hooks are unavailable for this host. Use advisory mode for unsupported hooks.",
+      { depth: hostDef.hooksDepth }));
+  } else {
+    checks.push(warn("hook_depth_" + hostDef.id, "Hook depth: " + hostDef.hooksDepth,
+      "Extension-bridge or limited hook support only. Value via adapter routing.",
+      { depth: hostDef.hooksDepth }));
+  }
+
+  // mcp_supported
+  if (hostDef.mcpSupported) {
+    checks.push(pass("mcp_" + hostDef.id, "MCP supported on " + hostDef.label,
+      { mcpSupported: true }));
+  } else {
+    checks.push(warn("mcp_" + hostDef.id, "MCP not supported on " + hostDef.label,
+      "Use extension-bridge or advisory-only mode. MCP-dependent capabilities unavailable.",
+      { mcpSupported: false }));
+  }
+
+  // install_ai_supported
+  if (hostDef.installAiSupported) {
+    checks.push(pass("install_ai_" + hostDef.id, "install-ai supported on " + hostDef.label,
+      { installAiSupported: true }));
+  } else {
+    checks.push(warn("install_ai_" + hostDef.id, "install-ai not supported on " + hostDef.label,
+      "Manual installation path required. Document fallback.",
+      { installAiSupported: false }));
+  }
+
+  // proof_supported
+  if (hostDef.proofSupported) {
+    checks.push(pass("proof_" + hostDef.id, "Proof outcome supported on " + hostDef.label,
+      { proofSupported: true }));
+  } else {
+    checks.push(warn("proof_" + hostDef.id, "Proof outcome not supported on " + hostDef.label,
+      "Proof requires hook lifecycle. Document manual proof path for this host.",
+      { proofSupported: false }));
+  }
+
+  // hook_config_exists (only for detected hosts with known config path)
+  if (detected && hostDef.hookConfigPath) {
+    const configAbs = path.join(cwd, hostDef.hookConfigPath);
+    if (fs.existsSync(configAbs)) {
+      checks.push(pass("hook_config_" + hostDef.id, "Hook config present for " + hostDef.label,
+        { path: hostDef.hookConfigPath }));
+    } else {
+      checks.push(warn("hook_config_" + hostDef.id, "Hook config absent for " + hostDef.label,
+        "Run hook preview/apply for " + hostDef.label + " to generate config.",
+        { path: hostDef.hookConfigPath }));
+    }
+  }
+
+  const status = checks.some(function(c) { return c.status === "blocked"; }) ? "blocked"
+    : checks.every(function(c) { return c.status === "pass" || c.status === "info"; }) ? "pass"
+    : "warn";
+
+  return {
+    id: hostDef.id,
+    label: hostDef.label,
+    detected,
+    hooksDepth: hostDef.hooksDepth,
+    mcpSupported: hostDef.mcpSupported,
+    installAiSupported: hostDef.installAiSupported,
+    proofSupported: hostDef.proofSupported,
+    valueFlowTier: hostDef.valueFlowTier,
+    notes: hostDef.notes,
+    status,
+    checks,
+  };
+}
+
+// ── Build Matrix ──────────────────────────────────────────────────────────────
+
+function buildHostCapabilityMatrix(cwd, options) {
+  const hosts = HOST_DEFS.map(function(def) {
+    return inspectHostCapabilities(cwd, def);
+  });
+
+  const detectedHosts = hosts.filter(function(h) { return h.detected; });
+  const detectedCount = detectedHosts.length;
+  const fullValueHosts = hosts.filter(function(h) { return h.detected && h.valueFlowTier === "full"; });
+  const partialValueHosts = hosts.filter(function(h) { return h.detected && h.valueFlowTier === "partial"; });
+  const limitedValueHosts = hosts.filter(function(h) { return h.detected && h.valueFlowTier === "limited"; });
+
+  const allChecks = hosts.reduce(function(acc, h) { return acc.concat(h.checks); }, []);
+  const blockers = allChecks.filter(function(c) { return c.status === "blocked"; });
+  const warnings = allChecks.filter(function(c) { return c.status === "warn"; });
+
+  var status;
+  if (detectedCount === 0) {
+    status = "warn"; // No hosts detected — generic CLI fallback
+  } else if (blockers.length > 0) {
+    status = "blocked";
+  } else if (warnings.length > 0) {
+    status = "warn";
+  } else {
+    status = "pass";
+  }
+
+  const safeNextAction = detectedCount === 0
+    ? "No hosts detected. Run from a project directory where a supported AI coding host is configured."
+    : blockers.length > 0
+    ? "Fix blocking capability gaps before proceeding."
+    : warnings.length > 0
+    ? "Review capability warnings. Partial-support hosts use advisory mode — this is expected."
+    : "All detected hosts have adequate capability coverage.";
+
+  return {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: nowIso(),
+    status,
+    detectedCount,
+    primaryHost: detectedHosts.length > 0 ? detectedHosts[0].id : "none",
+    hosts,
+    detectedHosts: detectedHosts.map(function(h) { return { id: h.id, label: h.label, valueFlowTier: h.valueFlowTier }; }),
+    fullValueHosts: fullValueHosts.map(function(h) { return h.id; }),
+    partialValueHosts: partialValueHosts.map(function(h) { return h.id; }),
+    limitedValueHosts: limitedValueHosts.map(function(h) { return h.id; }),
+    blockerCount: blockers.length,
+    warningCount: warnings.length,
+    safeNextAction,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+}
+
+// ── Write ──────────────────────────────────────────────────────────────────────
+
+function writeHostCapabilityMatrix(cwd, matrix) {
+  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(matrix, null, 2));
+}
+
+// ── Surface ───────────────────────────────────────────────────────────────────
+
+function buildHostCapabilityMatrixSurface(cwd, options) {
+  const matrix = buildHostCapabilityMatrix(cwd, options);
+  writeHostCapabilityMatrix(cwd, matrix);
+  try {
+    appendProductLearningEvent(cwd, {
+      event: "host_capability_matrix_built",
+      contract: CONTRACT,
+      status: matrix.status,
+      detectedCount: matrix.detectedCount,
+      blockerCount: matrix.blockerCount,
+    });
+  } catch { /* non-fatal */ }
+  return {
+    status: matrix.status,
+    detectedCount: matrix.detectedCount,
+    primaryHost: matrix.primaryHost,
+    detectedHosts: matrix.detectedHosts,
+    blockerCount: matrix.blockerCount,
+    warningCount: matrix.warningCount,
+    noPublicLaunchClaim: true,
+  };
+}
+
+// ── Format ────────────────────────────────────────────────────────────────────
+
+function formatHostCapabilityMatrixText(matrix) {
+  var lines = [
+    "Host Capability Matrix [" + (matrix.status || "?").toUpperCase() + "]",
+    "  Detected hosts: " + (matrix.detectedCount || 0),
+    "  Primary host: " + (matrix.primaryHost || "none"),
+  ];
+  if (matrix.detectedHosts && matrix.detectedHosts.length > 0) {
+    lines.push("  Detected:");
+    matrix.detectedHosts.forEach(function(h) {
+      lines.push("    - " + h.label + " (" + h.valueFlowTier + " value flow)");
+    });
+  }
+  if (matrix.fullValueHosts && matrix.fullValueHosts.length > 0) {
+    lines.push("  Full value flow: " + matrix.fullValueHosts.join(", "));
+  }
+  if (matrix.partialValueHosts && matrix.partialValueHosts.length > 0) {
+    lines.push("  Partial value flow: " + matrix.partialValueHosts.join(", "));
+  }
+  lines.push(
+    "  Blockers: " + (matrix.blockerCount || 0),
+    "  Warnings: " + (matrix.warningCount || 0),
+    "  Next: " + (matrix.safeNextAction || "Review host capability matrix.")
+  );
+  return lines.join("\n");
+}
+
+// ── Classify Host Support ─────────────────────────────────────────────────────
+// Returns: "full" | "partial" | "limited" | "unsupported"
+
+function classifyHostSupport(hostDef, inspected) {
+  if (!inspected.detected) return "unsupported";
+  if (hostDef.valueFlowTier === "full") return "full";
+  if (hostDef.valueFlowTier === "partial") return "partial";
+  return "limited";
+}
+
+module.exports = {
+  CONTRACT,
+  SCHEMA_VERSION,
+  ARTIFACT_REL,
+  HOST_DEFS,
+  buildHostCapabilityMatrix,
+  writeHostCapabilityMatrix,
+  buildHostCapabilityMatrixSurface,
+  formatHostCapabilityMatrixText,
+  inspectHostCapabilities,
+  detectHost,
+  classifyHostSupport,
+};

package/scripts/lib/host-support-context.js

@@ -0,0 +1,254 @@
+"use strict";
+
+// ── Host Support Context ──────────────────────────────────────────────────────
+// Contract: avorelo.hostSupportContext.v1
+// Answers: "Is the support bundle, proof evidence, and work ledger enriched with
+// host context? Can support diagnose per-host issues?"
+// Reads existing artifacts. Does NOT generate new support bundles.
+
+const fs = require("fs");
+const path = require("path");
+const { nowIso } = require("./fsx");
+const { appendProductLearningEvent } = require("./product-learning-events");
+
+const CONTRACT = "avorelo.hostSupportContext.v1";
+const SCHEMA_VERSION = 1;
+const ARTIFACT_DIR_REL = ".claude/cco/orchestration/adapter-readiness";
+const ARTIFACT_REL = ARTIFACT_DIR_REL + "/latest-host-support-context.json";
+
+function safeReadJson(absPath) {
+  try {
+    if (!fs.existsSync(absPath)) return null;
+    return JSON.parse(fs.readFileSync(absPath, "utf8").replace(/^/, ""));
+  } catch { return null; }
+}
+
+function pass(id, label, evidence, detail) {
+  return { id, 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 };
+}
+
+// ── Host Context Checks ───────────────────────────────────────────────────────
+
+function detectActiveHost(cwd) {
+  // Detect the current host from env, state, or markers
+  var host = null;
+  var source = "undetected";
+
+  // Check env variable first (most reliable for current session)
+  if (process.env.AVORELO_HOST) {
+    host = process.env.AVORELO_HOST;
+    source = "env";
+  } else if (fs.existsSync(path.join(cwd, ".claude"))) {
+    host = "claude_code";
+    source = "marker";
+  } else if (fs.existsSync(path.join(cwd, ".cursor"))) {
+    host = "cursor";
+    source = "marker";
+  } else if (fs.existsSync(path.join(cwd, ".codeium"))) {
+    host = "windsurf";
+    source = "marker";
+  } else if (fs.existsSync(path.join(cwd, "codex.yaml")) || fs.existsSync(path.join(cwd, ".codex"))) {
+    host = "codex";
+    source = "marker";
+  } else if (fs.existsSync(path.join(cwd, ".vscode"))) {
+    host = "vscode";
+    source = "marker";
+  }
+
+  return { host, source };
+}
+
+function checkSupportBundleHasHostContext(cwd) {
+  const bundlePath = path.join(cwd, ".claude/cco/support/latest-support-bundle.json");
+  const bundle = safeReadJson(bundlePath);
+  if (!bundle) {
+    return warn("support_bundle_host_context", "Support bundle not generated",
+      "Run: node bin/avorelo support-bundle --json to generate with host context.",
+      null);
+  }
+  if (!bundle.platform) {
+    return warn("support_bundle_host_context", "Support bundle missing platform/host context",
+      "Regenerate support bundle to include host context in platform field.",
+      { hasPlatform: false });
+  }
+  return pass("support_bundle_host_context", "Support bundle includes platform context",
+    { platform: bundle.platform, redacted: bundle.redacted });
+}
+
+function checkProofEvidenceHasHostContext(cwd) {
+  const proofPath = path.join(cwd, ".claude/cco/orchestration/proof-outcome/latest-proof-outcome.json");
+  const proof = safeReadJson(proofPath);
+  if (!proof) {
+    return warn("proof_evidence_host_context", "Proof outcome artifact not found",
+      "Run a bounded task with proof tracking to generate proof evidence.",
+      null);
+  }
+  // Proof evidence having a session ID or host is good enough
+  if (proof.sessionId || proof.host || proof.platform) {
+    return pass("proof_evidence_host_context", "Proof evidence has session/host context",
+      { hasSessionId: Boolean(proof.sessionId), hasHost: Boolean(proof.host || proof.platform) });
+  }
+  return info("proof_evidence_host_context", "Proof evidence lacks explicit host context",
+    { proofStatus: proof.status }, "Host context optional in proof evidence.");
+}
+
+function checkWorkLedgerHasHostContext(cwd) {
+  const ledgerPath = path.join(cwd, ".claude/cco/orchestration/work-ledger/latest-ledger.json");
+  const ledger = safeReadJson(ledgerPath);
+  if (!ledger) {
+    return warn("work_ledger_host_context", "Work ledger not found",
+      "Complete a bounded task to populate work ledger.",
+      null);
+  }
+  const entries = ledger.entries || [];
+  if (entries.length === 0) {
+    return warn("work_ledger_host_context", "Work ledger has no entries",
+      "Complete a bounded task to populate work ledger.",
+      { entryCount: 0 });
+  }
+  return pass("work_ledger_host_context", "Work ledger has entries",
+    { entryCount: entries.length });
+}
+
+function checkHostStateFilesPresent(cwd) {
+  const hostsDir = path.join(cwd, ".claude/cco/state/hosts");
+  if (!fs.existsSync(hostsDir)) {
+    return info("host_state_files_present", "Host state directory not yet created",
+      null, "Will be created on first per-host activation.");
+  }
+  let files = [];
+  try { files = fs.readdirSync(hostsDir).filter(function(f) { return f.endsWith(".json"); }); } catch { /* ignore */ }
+  if (files.length === 0) {
+    return info("host_state_files_present", "No host state files yet",
+      null, "Will be created on first activation per host.");
+  }
+  return pass("host_state_files_present", "Host state files present",
+    { count: files.length, files: files });
+}
+
+function checkAdapterReadinessSurfacePresent(cwd) {
+  const artifactPath = path.join(cwd, ".claude/cco/orchestration/adapter-readiness/latest-readiness.json");
+  const artifact = safeReadJson(artifactPath);
+  if (!artifact) {
+    return warn("adapter_readiness_surface_present", "Adapter readiness artifact not found",
+      "Run: node bin/avorelo adapter-readiness to generate adapter readiness surface.",
+      null);
+  }
+  return pass("adapter_readiness_surface_present", "Adapter readiness surface present",
+    { status: artifact.status });
+}
+
+// ── Build Host Support Context ─────────────────────────────────────────────────
+
+function buildHostSupportContext(cwd, options) {
+  const { host: activeHost, source: hostSource } = detectActiveHost(cwd);
+
+  const checks = [
+    checkSupportBundleHasHostContext(cwd),
+    checkProofEvidenceHasHostContext(cwd),
+    checkWorkLedgerHasHostContext(cwd),
+    checkHostStateFilesPresent(cwd),
+    checkAdapterReadinessSurfacePresent(cwd),
+  ];
+
+  const blockers = checks.filter(function(c) { return c.status === "blocked"; });
+  const warnings = checks.filter(function(c) { return c.status === "warn"; });
+
+  var status;
+  if (blockers.length > 0) {
+    status = "blocked";
+  } else if (warnings.length > 0) {
+    status = "warn";
+  } else {
+    status = "pass";
+  }
+
+  const safeNextAction = blockers.length > 0
+    ? "Fix support context blockers."
+    : warnings.length > 0
+    ? "Run support bundle and complete a task to populate proof/ledger with host context."
+    : "Host support context complete. All signals have adequate host context.";
+
+  return {
+    contract: CONTRACT,
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: nowIso(),
+    status,
+    activeHost: activeHost || "undetected",
+    hostSource,
+    checks,
+    blockerCount: blockers.length,
+    warningCount: warnings.length,
+    safeNextAction,
+    noPublicLaunchClaim: true,
+    redacted: true,
+  };
+}
+
+// ── Write ─────────────────────────────────────────────────────────────────────
+
+function writeHostSupportContext(cwd, ctx) {
+  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(ctx, null, 2));
+}
+
+// ── Surface ───────────────────────────────────────────────────────────────────
+
+function buildHostSupportContextSurface(cwd, options) {
+  const ctx = buildHostSupportContext(cwd, options);
+  writeHostSupportContext(cwd, ctx);
+  try {
+    appendProductLearningEvent(cwd, {
+      event: "host_support_context_built",
+      contract: CONTRACT,
+      status: ctx.status,
+      activeHost: ctx.activeHost,
+    });
+  } catch { /* non-fatal */ }
+  return {
+    status: ctx.status,
+    activeHost: ctx.activeHost,
+    blockerCount: ctx.blockerCount,
+    warningCount: ctx.warningCount,
+    noPublicLaunchClaim: true,
+  };
+}
+
+// ── Format ────────────────────────────────────────────────────────────────────
+
+function formatHostSupportContextText(ctx) {
+  var lines = [
+    "Host Support Context [" + (ctx.status || "?").toUpperCase() + "]",
+    "  Active host: " + (ctx.activeHost || "undetected") + " (source: " + (ctx.hostSource || "?") + ")",
+    "  Blockers: " + (ctx.blockerCount || 0),
+    "  Warnings: " + (ctx.warningCount || 0),
+    "  Next: " + (ctx.safeNextAction || "Review host support context."),
+  ];
+  return lines.join("\n");
+}
+
+module.exports = {
+  CONTRACT,
+  SCHEMA_VERSION,
+  ARTIFACT_REL,
+  buildHostSupportContext,
+  writeHostSupportContext,
+  buildHostSupportContextSurface,
+  formatHostSupportContextText,
+  detectActiveHost,
+  checkSupportBundleHasHostContext,
+  checkProofEvidenceHasHostContext,
+  checkWorkLedgerHasHostContext,
+  checkHostStateFilesPresent,
+  checkAdapterReadinessSurfacePresent,
+};